LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun.cc
// Function: scdc_dataprov_jobrun::job_create(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, scdc_dataprov_jobrun_job_params_proc_t&)
bool scdc_dataprov_jobrun::job_create(const std::string &jobid, scdc_dataprov_jobrun_job_params_t &job_params)
{
  scdc_dataprov_jobrun_job_t job;

  bool ret = set_job_params(job, job_params);

  if (ret)
  {
    pthread_mutex_lock(&sched_lock);
    ret = add_job(jobid, job);
    pthread_mutex_unlock(&sched_lock);
  }

  if (!ret)
  {
    SCDC_FAIL("job_create: adding job failed");
    return false;
  }

  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x30(%rsp), %r12
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%r12)
movaps %xmm0, -0x30(%r12)
movq %r12, -0x10(%r12)
xorl %eax, %eax
movq %rax, -0x8(%r12)
movb %al, (%r12)
leaq 0x50(%rsp), %r13
movq %r13, -0x10(%r13)
movq %rax, -0x8(%r13)
movb %al, (%r13)
movb $0x1, 0x10(%r13)
movq %rsp, %rsi
callq 0x4ed2c
leaq 0x190(%r14), %r15
movq %r15, %rdi
callq 0xb7d0
movq %rsp, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4e866
movl %eax, %ebx
movq %r15, %rdi
callq 0xb3b0
testb %bl, %bl
jne 0x4ef50
leaq 0x3d6a9(%rip), %r15     # 0x8c570
movq (%r15), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x4ef50
addq $0x20, %rdi
callq 0xb7d0
movq (%r15), %rax
movq 0x8(%rax), %r14
leaq 0x1b2c0(%rip), %rsi     # 0x6a1a8
movl $0xb, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x1dbe0(%rip), %rsi     # 0x6cadc
movl $0x11, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x1de5c(%rip), %rsi     # 0x6cd6c
movl $0x1d, %edx
movq %r14, %rdi
callq 0xb5f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %r14, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq (%r15), %rdi
addq $0x20, %rdi
callq 0xb3b0
movq 0x40(%rsp), %rdi
cmpq %r13, %rdi
je 0x4ef67
movq 0x50(%rsp), %rsi
incq %rsi
callq 0xb510
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x4ef7e
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xb510
movl %ebx, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x53ffe
movq %rbx, %rdi
callq 0xb9c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun.cc
// Function: scdc_dataprov_jobrun::job_destroy(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool scdc_dataprov_jobrun::job_destroy(const std::string &jobid)
{
  pthread_mutex_lock(&sched_lock);
  bool ret = del_job(jobid);
  pthread_mutex_unlock(&sched_lock);

  if (!ret)
  {
    SCDC_FAIL("job_destroy: deleting job failed");
    return false;
  }

  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x190(%rdi), %r15
movq %r15, %rdi
callq 0xb7d0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4eabc
movl %eax, %ebx
movq %r15, %rdi
callq 0xb3b0
testb %bl, %bl
jne 0x4f069
leaq 0x3d590(%rip), %r15     # 0x8c570
movq (%r15), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x4f069
addq $0x20, %rdi
callq 0xb7d0
movq (%r15), %rax
movq 0x8(%rax), %r14
leaq 0x1b1a7(%rip), %rsi     # 0x6a1a8
movl $0xb, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x1dac7(%rip), %rsi     # 0x6cadc
movl $0x11, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x1dd61(%rip), %rsi     # 0x6cd8a
movl $0x20, %edx
movq %r14, %rdi
callq 0xb5f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %r14, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq (%r15), %rdi
addq $0x20, %rdi
callq 0xb3b0
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun.cc
// Function: scdc_dataprov_jobrun::job_update(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, scdc_dataprov_jobrun_job_params_proc_t&)
bool scdc_dataprov_jobrun::job_update(const std::string &jobid, scdc_dataprov_jobrun_job_params_t &job_params)
{
  pthread_mutex_lock(&sched_lock);
  bool ret = set_job_params(jobid, job_params);
  pthread_mutex_unlock(&sched_lock);

  if (!ret)
  {
    SCDC_FAIL("job_update: updating job failed");
    return false;
  }

  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x190(%rdi), %r12
movq %r12, %rdi
callq 0xb7d0
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4ed90
movl %eax, %ebx
movq %r12, %rdi
callq 0xb3b0
testb %bl, %bl
jne 0x4f142
leaq 0x3d4b7(%rip), %r15     # 0x8c570
movq (%r15), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x4f142
addq $0x20, %rdi
callq 0xb7d0
movq (%r15), %rax
movq 0x8(%rax), %r14
leaq 0x1b0ce(%rip), %rsi     # 0x6a1a8
movl $0xb, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x1d9ee(%rip), %rsi     # 0x6cadc
movl $0x11, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x1dca9(%rip), %rsi     # 0x6cdab
movl $0x1f, %edx
movq %r14, %rdi
callq 0xb5f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %r14, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq (%r15), %rdi
addq $0x20, %rdi
callq 0xb3b0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun.cc
// Function: scdc_dataprov_jobrun::job_wait_finished(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool scdc_dataprov_jobrun::job_wait_finished(const std::string &jobid)
{
  SCDC_TRACE(__func__ << ": jobid: '" << jobid << "'");

  scdc_dataprov_jobrun_job_t job;

  pthread_mutex_lock(&sched_lock);
  get_job(jobid, job);
  while (job.waiting)
  {
    pthread_cond_wait(&sched_cond_finished, &sched_lock);
    get_job(jobid, job);
  }
  pthread_mutex_unlock(&sched_lock);

  job_wait_running(jobid);

  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x30(%rsp), %rcx
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rcx)
movaps %xmm0, -0x30(%rcx)
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x50(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq %rax, -0x8(%rbp)
movb %al, (%rbp)
movb $0x1, 0x10(%rbp)
leaq 0x190(%rdi), %r15
movq %r15, %rdi
callq 0xb7d0
movq %rsp, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4edce
leaq 0x1e8(%r14), %r12
movq %rsp, %r13
cmpb $0x1, 0x60(%rsp)
jne 0x4f7b5
movq %r12, %rdi
movq %r15, %rsi
callq 0xb840
movq %r14, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x4edce
jmp 0x4f793
movq %r15, %rdi
callq 0xb3b0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4f822
movq 0x40(%rsp), %rdi
cmpq %rbp, %rdi
je 0x4f7df
movq 0x50(%rsp), %rsi
incq %rsi
callq 0xb510
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x4f7fb
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xb510
movb $0x1, %al
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4f80e
movq %rax, %rbx
movq %rsp, %rdi
callq 0x53ffe
movq %rbx, %rdi
callq 0xb9c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun.cc
// Function: scdc_dataprov_jobrun::job_wait_running(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool scdc_dataprov_jobrun::job_wait_running(const std::string &jobid)
{
  SCDC_TRACE(__func__ << ": jobid: '" << jobid << "'");

  bool wait = false;
  pthread_t thread;

  pthread_mutex_lock(&sched_lock);
  sched_jobs_run_t::iterator i = sched_jobs_run.find(jobid);
  if (i != sched_jobs_run.end())
  {
    wait = true;
    thread = i->second;
  }
  pthread_mutex_unlock(&sched_lock);

  SCDC_TRACE(__func__ << ": wait: '" << wait << "'");

  if (!wait) return false;

  pthread_join(thread, NULL);

  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x190(%rdi), %r15
movq %r15, %rdi
callq 0xb7d0
leaq 0x240(%rbx), %rdi
movq %r14, %rsi
callq 0x56490
movq %rax, %r14
addq $0x248, %rbx            # imm = 0x248
cmpq %rbx, %rax
je 0x4f875
movq 0x40(%r14), %r12
movq %r15, %rdi
callq 0xb3b0
movq %r12, %rdi
xorl %esi, %esi
callq 0xb460
jmp 0x4f87d
movq %r15, %rdi
callq 0xb3b0
cmpq %rbx, %r14
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun.cc
// Function: scdc_dataprov_jobrun_handler::open(char const*, scdc_args*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov_jobrun_handler::open(const char *conf, scdc_args *args, scdc_result &result)
{
  SCDC_TRACE(__func__ << ": '" << conf << "'");

  bool ret = true;

  args = open_args_init(args);

  if (args->get<scdc_dataprov_jobrun_handler_args_t>(SCDC_ARGS_TYPE_DATAPROV_JOBRUN_HANDLER, &handler_args, true) == SCDC_ARG_REF_NULL)
  {
    SCDC_ERROR("open: getting parameter for jobrun handler");
    ret = false;
    goto do_quit;
  }

  if (!scdc_dataprov_jobrun::open(conf, args, result))
  {
    SCDC_FAIL("open: opening base");
    ret = false;
  }

  SCDC_TRACE(__func__ << ": handler: '" << handler_args.handler << "', handler_data: '" << handler_args.data << "'");

  open_args_clear();

do_quit:
  if (!ret) open_args_release();

  return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, %rsi
callq 0x25168
movq %rax, %r12
leaq 0x270(%rbx), %rdx
movl $0x10, %esi
movq %rax, %rdi
movl $0x1, %ecx
callq 0x54036
testq %rax, %rax
je 0x51bc7
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x4cb58
testb %al, %al
je 0x51c60
movq 0x58(%rbx), %rax
movq $0x0, (%rax)
movb $0x1, %al
jmp 0x51d05
leaq 0x3a9a2(%rip), %r15     # 0x8c570
movq (%r15), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x51cfb
addq $0x20, %rdi
callq 0xb7d0
movq (%r15), %rax
movq 0x18(%rax), %r14
leaq 0x188b5(%rip), %rsi     # 0x6a4a8
movl $0xc, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x1b53f(%rip), %rsi     # 0x6d146
movl $0x19, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x1b545(%rip), %rsi     # 0x6d160
movl $0x2a, %edx
movq %r14, %rdi
callq 0xb5f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %r14, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq (%r15), %rdi
addq $0x20, %rdi
callq 0xb3b0
jmp 0x51cfb
leaq 0x3a909(%rip), %r15     # 0x8c570
movq (%r15), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x51cf0
addq $0x20, %rdi
callq 0xb7d0
movq (%r15), %rax
movq 0x8(%rax), %r14
leaq 0x18520(%rip), %rsi     # 0x6a1a8
movl $0xb, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x1b4aa(%rip), %rsi     # 0x6d146
movl $0x19, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x19e9d(%rip), %rsi     # 0x6bb4d
movl $0x12, %edx
movq %r14, %rdi
callq 0xb5f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %r14, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq (%r15), %rdi
addq $0x20, %rdi
callq 0xb3b0
movq 0x58(%rbx), %rax
movq $0x0, (%rax)
movq %rbx, %rdi
callq 0x2675c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun.cc
// Function: scdc_dataprov_jobrun_handler::close(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov_jobrun_handler::close(scdc_result &result)
{
  SCDC_TRACE(__func__ << ":");

  bool ret = scdc_dataprov_jobrun::close(result);

  open_args_release();

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

  return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4ceca
movq %r14, %rdi
movq %rbx, %rsi
callq 0x35f70
movl %eax, %ebx
movq %r14, %rdi
callq 0x2675c
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun.cc
// Function: sched_job_routine(void*)
static void *sched_job_routine(void *arg)
{
  sched_job_arg_t *sched_job_arg = static_cast<sched_job_arg_t *>(arg);

  SCDC_TRACE(__func__ << ": jobid: '" << sched_job_arg->jobid << "'");

  sched_job_arg->dataprov_jobrun->job_run(sched_job_arg->jobid, sched_job_arg->jobcmds.c_str(), sched_job_arg->jobres);

  pthread_mutex_lock(&sched_job_arg->dataprov_jobrun->sched_lock);
  sched_job_arg->dataprov_jobrun->sched_jobs_run.erase(sched_job_arg->jobid);
  sched_job_arg->dataprov_jobrun->sched->job_stopped(sched_job_arg->m, sched_job_arg->jobid, sched_job_arg->jobres);
  pthread_mutex_unlock(&sched_job_arg->dataprov_jobrun->sched_lock);

  pthread_cond_signal(&sched_job_arg->dataprov_jobrun->sched_cond);

  SCDC_TRACE(__func__ << ": return: jobid: '" << sched_job_arg->jobid << "'");

  delete sched_job_arg;

  pthread_exit(NULL);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq (%rdi), %r12
leaq 0x8(%rdi), %r14
movq 0x28(%rdi), %rsi
leaq 0x10(%rsp), %r13
leaq 0xf(%rsp), %rdx
movq %r13, %rdi
callq 0x1bd28
leaq 0x48(%rbx), %r15
movq %r12, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r15, %rcx
callq 0x4f150
leaq 0x10(%rsp), %rdi
callq 0xb210
movl $0x190, %r12d           # imm = 0x190
movq (%rbx), %rdi
addq %r12, %rdi
callq 0xb7d0
movl $0x240, %edi            # imm = 0x240
addq (%rbx), %rdi
movq %r14, %rsi
callq 0x553b2
movq (%rbx), %rax
movq 0x60(%rbx), %rsi
movq 0x180(%rax), %rdi
movq %r14, %rdx
movq %r15, %rcx
callq 0x553dc
addq (%rbx), %r12
movq %r12, %rdi
callq 0xb3b0
movl $0x1b8, %edi            # imm = 0x1B8
addq (%rbx), %rdi
callq 0xb030
movq %rbx, %rdi
callq 0x5540c
movl $0x68, %esi
movq %rbx, %rdi
callq 0xb510
xorl %edi, %edi
callq 0xb9d0
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x526df
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun.cc
// Function: scdc_dataset_jobrun::select_job(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, bool, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool select_job(std::string &params, bool ignore_if_selected, bool fail_if_unselect, string &jobid)
    {
      jobid = get_jobid();

      /* if there is a job selected and should not be unselected */
      if (has_jobid() && ignore_if_selected) return true;

      scdc_dataprov_jobrun_job_params_t job_params;
      read_job_params2(params, jobid, job_params);

      /* if there is no jobid */
      if (jobid.size() == 0)
      {
        /* if unselect is not allowed */
        if (fail_if_unselect) return false;

      } else
      {
        /* if the job does not exist */
        if (!dataprov_jobrun()->is_job(jobid)) return false;
      }

      undo_select_jobid = get_jobid();

      set_jobid(jobid);

      return true;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r8, %rbx
movl %ecx, 0xc(%rsp)
movl %edx, %r13d
movq %rsi, %r15
movq %rdi, %r14
leaq 0x20(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq 0x18(%rdi), %rsi
movq 0x20(%rdi), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0x1d0a0
movq %rbx, %rdi
movq %r12, %rsi
callq 0xb670
movq (%r12), %rdi
cmpq %rbp, %rdi
je 0x54434
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xb510
cmpq $0x0, 0x20(%r14)
setne %al
movb $0x1, %r12b
testb %r13b, %al
jne 0x54521
leaq 0x40(%rsp), %r13
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%r13)
movaps %xmm0, -0x30(%r13)
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
leaq 0x10(%rsp), %rcx
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x545a6
cmpq $0x0, 0x8(%rbx)
je 0x54500
movq 0x8(%r14), %r15
leaq 0x128(%r15), %rdi
movq %rbx, %rsi
callq 0x56418
addq $0x130, %r15            # imm = 0x130
cmpq %r15, %rax
je 0x54507
leaq 0x68(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq 0x18(%r14), %rsi
movq 0x20(%r14), %rdx
addq %rsi, %rdx
leaq 0x58(%rsp), %rdi
callq 0x1d0a0
leaq 0x18(%r14), %r15
addq $0x38, %r14
leaq 0x58(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0xb670
movq (%r12), %rdi
cmpq %rbp, %rdi
je 0x544f0
movq 0x68(%rsp), %rsi
incq %rsi
callq 0xb510
movb $0x1, %r12b
movq %r15, %rdi
movq %rbx, %rsi
callq 0xb2c0
jmp 0x5450a
cmpb $0x0, 0xc(%rsp)
je 0x544a4
xorl %r12d, %r12d
movq 0x30(%rsp), %rdi
cmpq %r13, %rdi
je 0x54521
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xb510
movl %r12d, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x54535
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %r13, %rdi
je 0x5454f
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun.cc
// Function: scdc_dataset_jobrun::undo_select_job()
bool undo_select_job()
    {
      /* if there is a jobid and the job does not exist */
      if (undo_select_jobid.size() > 0 && !dataprov_jobrun()->is_job(undo_select_jobid)) return false;

      set_jobid(undo_select_jobid);

      return true;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x38(%rdi), %rbx
cmpq $0x0, 0x40(%rdi)
je 0x5458a
movq 0x8(%r14), %r15
leaq 0x128(%r15), %rdi
movq %rbx, %rsi
callq 0x56418
addq $0x130, %r15            # imm = 0x130
cmpq %r15, %rax
je 0x5459d
addq $0x18, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb2c0
movb $0x1, %al
jmp 0x5459f
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun.cc
// Function: scdc_dataprov_jobrun_sched::update(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void update(const std::string &conf)
    {
      stringlist sl(' ', conf);

      std::string m = sl.front_pop();

      if (m == "default" || m == "node")
      {
        method = 0;
        node_update(sl);

      } else if (m == "sched")
      {
        method = 1;
      }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x1d0a0
leaq 0x48(%rsp), %rdi
movl $0x20, %esi
movq %r14, %rdx
callq 0x37a30
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x54d04
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb510
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x1b878
leaq 0x1853a(%rip), %rsi     # 0x6d254
leaq 0x8(%rsp), %rdi
callq 0xb110
testl %eax, %eax
je 0x54d5c
leaq 0x17dd2(%rip), %rsi     # 0x6cb01
leaq 0x8(%rsp), %rdi
callq 0xb110
testl %eax, %eax
je 0x54d5c
leaq 0x18518(%rip), %rsi     # 0x6d25c
leaq 0x8(%rsp), %rdi
callq 0xb110
testl %eax, %eax
jne 0x54d71
movq $0x1, 0x38(%rbx)
jmp 0x54d71
movq $0x0, 0x38(%rbx)
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x54fc4
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x54d8c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
leaq 0x48(%rsp), %rdi
callq 0x1bad0
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x54dc3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
jmp 0x54dc3
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x1bad0
jmp 0x54de9
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x54de9
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun.cc
// Function: scdc_dataprov_jobrun_sched::node_update(stringlist&)
void node_update(stringlist &sl)
    {
      std::string nodeid = sl.front_pop();

      /* update node information */
      scdc_dataprov_jobrun_node_t node;
      dataprov_jobrun->get_node(nodeid, node);

      if (nodeid == node_data.id)
      {
        node_data.free_cores += node.cores - node_data.cores;
        node_data.cores = node.cores;

      } else
      {
        node_data.cores = node_data.free_cores = node.cores;

        node_data.id = nodeid;
      }
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x1b878
movq 0x30(%rbx), %rdi
leaq 0x20(%rsp), %rdx
movq %r14, %rsi
callq 0x4e674
movq 0x8(%rsp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x5500a
testq %rdx, %rdx
je 0x55024
movq (%rbx), %rsi
movq (%rsp), %rdi
callq 0xb520
testl %eax, %eax
je 0x55024
movq 0x20(%rsp), %rax
movq %rax, 0x28(%rbx)
movq %rax, 0x20(%rbx)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xb2c0
jmp 0x55038
movq 0x20(%rsp), %rax
movq %rax, %rcx
subq 0x20(%rbx), %rcx
addq %rcx, 0x28(%rbx)
movq %rax, 0x20(%rbx)
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x55053
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x55079
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun.cc
// Function: scdc_dataprov_jobrun_sched::node_job_get_runable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, scdc_dataprov_jobrun_job_t&, std::vector<scdc_dataprov_jobrun_res_proc_t, std::allocator<scdc_dataprov_jobrun_res_proc_t>>&)
bool node_job_get_runable(string &jobid, scdc_dataprov_jobrun_job_t &job, scdc_dataprov_jobrun_res_t &res)
    {
      jobid = dataprov_jobrun->sched_jobs_wait.front();

      dataprov_jobrun->get_job(jobid, job);

      SCDC_TRACE(__func__ << ": jobid: '" << jobid << "', jobcmds: '" << job.jobcmds << "', np: " << job.params.np_min << "-" << job.params.np_max);
      SCDC_TRACE(__func__ << ": node: '" << node_data.id << "', free cores: " << node_data.free_cores << " of " << node_data.cores);

      if (node_data.free_cores < job.params.np_min * job.params.nt_min) return false;

      dataprov_jobrun->sched_jobs_wait.pop_front();

      scdc_dataprov_jobrun_res_proc_t res_proc;
      res_proc.node = node_data.id;
      res_proc.np = job.params.np_min;
      res_proc.nt = job.params.nt_min;

      res.push_back(res_proc);

      return true;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq 0x30(%rdi), %rax
movq 0x228(%rax), %rsi
addq $0x10, %rsi
movq %r12, %rdi
callq 0xb2c0
movq 0x30(%r15), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x4edce
movq 0x28(%r15), %r12
movq (%r14), %r13
imulq 0x10(%r14), %r13
cmpq %r13, %r12
jl 0x5513f
movq 0x30(%r15), %rdi
movq 0x228(%rdi), %rsi
addq $0x228, %rdi            # imm = 0x228
callq 0x55176
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
movb $0x0, (%rbp)
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0xb2c0
movq 0x10(%r14), %rax
leaq 0x8(%rsp), %rsi
movq %rax, 0x20(%rsi)
movq (%r14), %rax
movq %rax, 0x28(%rsi)
movq %rbx, %rdi
callq 0x5275c
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x5513f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
cmpq %r13, %r12
setge %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x5516e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun.cc
// Function: scdc_dataset_jobrun_system::create_job_inout(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, scdc_dataprov_jobrun_job_params_proc_t&)
bool create_job_inout(const string &jobid, scdc_dataprov_jobrun_job_params_t &job_params)
    {
      if (!z_fs_mkdir(workdir(jobid).c_str()))
      {
        SCDC_FAIL("create_job_inout: creating directory failed!");
        return false;
      }

      return true;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rdx
movq 0x8(%rdi), %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x511a6
movq (%rbx), %rdi
callq 0x358e4
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x56ad1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
testq %rbx, %rbx
jne 0x56b6a
leaq 0x35a8f(%rip), %r15     # 0x8c570
movq (%r15), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x56b6a
addq $0x20, %rdi
callq 0xb7d0
movq (%r15), %rax
movq 0x8(%rax), %r14
leaq 0x136a6(%rip), %rsi     # 0x6a1a8
movl $0xb, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x16306(%rip), %rsi     # 0x6ce1c
movl $0x18, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x1679e(%rip), %rsi     # 0x6d2c8
movl $0x2c, %edx
movq %r14, %rdi
callq 0xb5f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %r14, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq (%r15), %rdi
addq $0x20, %rdi
callq 0xb3b0
testq %rbx, %rbx
setne %al
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x56b98
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun.cc
// Function: scdc_dataset_jobrun_system::destroy_job_inout()
bool destroy_job_inout()
    {
      if (!z_fs_rm_r(workdir().c_str()))
      {
        SCDC_FAIL("destroy_job_inout: deleting directory failed!");
        return false;
      }

      return true;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x56ebe
movq (%rbx), %rdi
callq 0x3599f
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x56bdd
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
testq %rbx, %rbx
jne 0x56c76
leaq 0x35983(%rip), %r15     # 0x8c570
movq (%r15), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x56c76
addq $0x20, %rdi
callq 0xb7d0
movq (%r15), %rax
movq 0x8(%rax), %r14
leaq 0x1359a(%rip), %rsi     # 0x6a1a8
movl $0xb, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x161fa(%rip), %rsi     # 0x6ce1c
movl $0x18, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x166bf(%rip), %rsi     # 0x6d2f5
movl $0x2d, %edx
movq %r14, %rdi
callq 0xb5f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %r14, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq (%r15), %rdi
addq $0x20, %rdi
callq 0xb3b0
testq %rbx, %rbx
setne %al
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x56ca4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun.cc
// Function: scdc_dataset_jobrun_system::do_cmd_put_inout(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_put_inout(const std::string &params, scdc_dataset_input_t *input, scdc_dataset_output_t *output, scdc_result &result)
    {
      bool ret = true;

      if (input)
      {
        if (string(input->format) == "fstar")
        {
          SCDC_TRACE(__func__ << ": input to 'fs' in '" << workdir() << "'");
          ret = (scdc_dataset_input_redirect(input, "to:fs", workdir().c_str()) == SCDC_SUCCESS);

        } else
        {
          SCDC_TRACE(__func__ << ": input to 'file' in '" << workdir() << "'");
          ret = (scdc_dataset_input_redirect(input, "to:file", workdir().c_str()) == SCDC_SUCCESS);
        }
      }

      return ret;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
testq %rdx, %rdx
je 0x56dbb
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rdx, %rdi
callq 0xb200
leaq (%rax,%rbx), %rdx
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1be38
leaq 0x147b1(%rip), %rsi     # 0x6b525
movq %r15, %rdi
callq 0xb110
movl %eax, %ebp
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x56d93
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
testl %ebp, %ebp
je 0x56dbf
callq 0x56ebe
movq (%r15), %rdx
leaq 0x1591d(%rip), %rsi     # 0x6c6cc
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2df76
jmp 0x56dd8
movb $0x1, %bl
jmp 0x56df5
callq 0x56ebe
movq (%r15), %rdx
leaq 0x15640(%rip), %rsi     # 0x6c40e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2df76
cmpq $0x1, %rax
sete %bl
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x56df5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x56e06
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x56e1f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun.cc
// Function: scdc_dataset_jobrun_system::do_cmd_get_inout(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_get_inout(const std::string &params, scdc_dataset_input_t *input, scdc_dataset_output_t *output, scdc_result &result)
    {
      bool ret = true;

      if (output)
      {
        SCDC_TRACE(__func__ << ": output from 'fs' in '" << workdir() << "': '" << params << "'");

        ret = (scdc_dataset_output_redirect(output, "from:fs", workdir().c_str(), params.c_str()) == SCDC_SUCCESS);
      }

      return ret;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
testq %rcx, %rcx
je 0x56e85
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x56ebe
movq (%r15), %rdx
movq (%r14), %rcx
leaq 0x15640(%rip), %rsi     # 0x6c497
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2e106
cmpq $0x1, %rax
sete %bl
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x56e87
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
jmp 0x56e87
movb $0x1, %bl
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x56eb1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun_relay.cc
// Function: scdc_dataprov_jobrun_relay::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_jobrun_relay::dataset_open(std::string &path, scdc_result &result)
{
  SCDC_TRACE("dataset_open: path: '" << path << "'");
  
  scdc_dataset *dataset = 0;

  string jobid = path;

  if (jobid == "" || sched_job_exists(jobid))
  {
    SCDC_TRACE("dataset_open: local dataset");
  
    /* stay local */
    dataset = new scdc_dataset_jobrun_relay(this);

  } else
  {
    SCDC_TRACE("dataset_open: relay dataset");

    dataset = scdc_dataprov_relay::dataset_open(path, result);
  }

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

  return dataset;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %rsp, %r12
movq %r12, %rdi
callq 0x1d0a0
leaq 0x13a46(%rip), %rsi     # 0x6b52d
movq %r12, %rdi
callq 0xb110
testl %eax, %eax
je 0x57b0e
leaq 0xf8(%rbx), %rdi
movq %rsp, %rsi
callq 0x22790
leaq 0x100(%rbx), %rcx
cmpq %rcx, %rax
je 0x57b48
movl $0x40, %edi
callq 0xb500
movq %rax, %r14
movq %rbx, 0x8(%rax)
xorl %eax, %eax
movb %al, 0x10(%r14)
movq %r14, %rcx
addq $0x28, %rcx
movq %rcx, 0x18(%r14)
movq %rax, 0x20(%r14)
movb %al, 0x28(%r14)
leaq 0x33859(%rip), %rcx     # 0x8b398
movq %rcx, (%r14)
movq %rax, 0x38(%r14)
jmp 0x57b59
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x20a00
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x57b6f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
movq %r14, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x57b99
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun_relay.cc
// Function: scdc_dataprov_jobrun_relay::dataset_close(scdc_dataset*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov_jobrun_relay::dataset_close(scdc_dataset *dataset, scdc_result &result)
{
  SCDC_TRACE("dataset_close: dataset: " << dataset);

  bool ret = false;

  if (typeid(*dataset) == typeid(scdc_dataset_jobrun_relay))
  {
    SCDC_TRACE("dataset_close: local dataset");
    delete dataset;
    ret = true;

  } else
  {
    SCDC_TRACE("dataset_close: relay dataset");
    ret = scdc_dataprov_relay::dataset_close(dataset, result);
  }

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

  return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x57c34
movq %rsi, %rbx
movq %rdi, %r15
movq (%rsi), %r12
movq -0x8(%r12), %rax
movq 0x8(%rax), %rdi
leaq 0x15a92(%rip), %rax     # 0x6d67a
cmpq %rax, %rdi
je 0x57c1e
movq %rdx, %r14
cmpb $0x2a, (%rdi)
je 0x57c05
leaq 0x15a7e(%rip), %rsi     # 0x6d67a
callq 0xb770
testl %eax, %eax
je 0x57c1e
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x20f76
movq %rbx, %rdi
callq *0x8(%r12)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0xb5a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun_relay.cc
// Function: scdc_dataprov_jobrun_relay::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_relay::do_cmd_info(const std::string &params, scdc_dataset_input_t *input, scdc_dataset_output_t *output, scdc_result &result)
{
  SCDC_TRACE("do_cmd_info: params: '" << params << "'");

  stringstream ss;

  ss << sched_jobs.size() << ":-1:-1";

  result = ss.str();

  return true;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %r8, %rbx
movq %rdi, %r14
leaq 0x20(%rsp), %rdi
callq 0xb360
leaq 0x30(%rsp), %rdi
movq 0x120(%r14), %rsi
callq 0xb330
leaq 0x15159(%rip), %rsi     # 0x6d3cf
movl $0x6, %edx
movq %rax, %rdi
callq 0xb5f0
leaq 0x38(%rsp), %rsi
movq %rsp, %rdi
callq 0xb8c0
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb670
movq (%r14), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x582b8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
movq 0x33cf1(%rip), %rsi     # 0x8bfb0
leaq 0x20(%rsp), %rdi
callq 0xb390
leaq 0xa0(%rsp), %rdi
callq 0xb180
movb $0x1, %al
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
jmp 0x582e5
movq %rax, %rbx
movq 0x33cc1(%rip), %rsi     # 0x8bfb0
leaq 0x20(%rsp), %rdi
callq 0xb390
leaq 0xa0(%rsp), %rdi
callq 0xb180
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun_relay.cc
// Function: scdc_dataprov_jobrun_relay::sched_job_add(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_jobrun_relay::sched_job_add(const std::string &jobid, scdc_result &result)
{
  /* last sched exists, but execeeds its max. jobs? */
  if (sched_last != sched.end() && sched_last_jobs >= sched_last->second.max_parallel_jobs)
  {
    /* select next relay */
    ++sched_last;
    sched_last_jobs = 0;
  }

  /* last sched does not exist? */
  if (sched_last == sched.end())
  {
    /* restart with first */
    sched_last = sched.begin();
    sched_last_jobs = 0;
  }

  if (sched_last == sched.end()) return false;

  relay_t::iterator i = relay.find(sched_last->first);

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

  ++sched_last_jobs;

  string rel = i->second;

  return sched_jobs.insert(sched_jobs_t::value_type(jobid, rel)).second;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xd0(%rdi), %r15
movq 0x130(%rdi), %rsi
cmpq %r15, %rsi
je 0x58368
movq 0x138(%rbx), %rax
cmpq 0x40(%rsi), %rax
jl 0x58368
movq %rsi, %rdi
callq 0xb350
movq %rax, %rsi
movq %rax, 0x130(%rbx)
movq $0x0, 0x138(%rbx)
cmpq %r15, %rsi
jne 0x58386
movq 0xe0(%rbx), %rsi
movq %rsi, 0x130(%rbx)
movq $0x0, 0x138(%rbx)
cmpq %r15, %rsi
je 0x5844d
leaq 0x98(%rbx), %rdi
addq $0x20, %rsi
callq 0x22790
leaq 0xa0(%rbx), %rcx
cmpq %rcx, %rax
je 0x5844d
incq 0x138(%rbx)
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x40(%rax), %rsi
movq 0x48(%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x1d0a0
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x5ace0
addq $0xf8, %rbx
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x2281a
movl %edx, %ebx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x58419
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xb510
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x58434
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb510
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x5844f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
jmp 0x5844f
xorl %ebx, %ebx
andb $0x1, %bl
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2250a
jmp 0x58472
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x58489
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun_relay.cc
// Function: scdc_dataprov_jobrun_relay::sched_job_get_relay(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_jobrun_relay::sched_job_get_relay(const std::string &jobid, std::string &relay)
{
  sched_jobs_t::iterator i = sched_jobs.find(jobid);

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

  relay = i->second;

  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
addq $0xf8, %rdi
callq 0x22790
movq %rax, %r15
addq $0x100, %rbx            # imm = 0x100
cmpq %rbx, %rax
je 0x58502
leaq 0x40(%r15), %rsi
movq %r14, %rdi
callq 0xb2c0
cmpq %rbx, %r15
setne %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun_relay.cc
// Function: scdc_dataset_jobrun_relay::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 std::string &params, scdc_dataset_input_t *input, scdc_dataset_output_t *output, scdc_result &result)
    {
      string jobid = safe_jobid(params);

      if (jobid == pwd) return true;

      remote_dataset_close();

      set_pwd("");

      if (jobid.size() == 0) return true;

      if (!remote_dataset_open(jobid, true)) return false;

      set_pwd(jobid);

      return true;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x59038
leaq 0x18(%r14), %rbx
movq 0x8(%r15), %rdx
cmpq 0x20(%r14), %rdx
jne 0x5b78b
movb $0x1, %bpl
testq %rdx, %rdx
je 0x5b84c
movq (%rbx), %rsi
movq 0x8(%rsp), %rdi
callq 0xb520
testl %eax, %eax
je 0x5b84c
movq 0x38(%r14), %rdi
testq %rdi, %rdi
je 0x5b7a1
callq 0x19ffb
movq $0x0, 0x38(%r14)
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xfd7c(%rip), %rdx      # 0x6b52d
leaq 0x48(%rsp), %rdi
movq %rdx, %rsi
callq 0x1be38
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0xb2c0
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x5b7e2
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xb510
movq 0x10(%rsp), %rdx
movb $0x1, %bpl
testq %rdx, %rdx
je 0x5b84c
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%rsp), %rsi
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x1d0a0
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
movl $0x1, %edx
callq 0x5ae12
movl %eax, %r14d
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x5b836
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb510
testb %r14b, %r14b
je 0x5b84a
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xb2c0
jmp 0x5b84c
xorl %ebp, %ebp
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5b867
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
movl %ebp, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x5b8a9
movq 0x38(%rsp), %rsi
jmp 0x5b89a
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x5b8a9
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xb510
jmp 0x5b8a9
jmp 0x5b8a6
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5b8c4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/node/node_direct.cc
// Function: scdc_nodeport_direct::open(char const*, scdc_args*)
bool scdc_nodeport_direct::supported(const char *uri, scdc_args *args)
{
  SCDC_TRACE("supported: uri: '" << uri << "'");

  bool ret = (string(uri).compare(0, strlen(SCDC_NODE_DIRECT_SCHEME) + 1, SCDC_NODE_DIRECT_SCHEME ":") == 0);

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

  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdx), %rax
testq %rax, %rax
je 0x5beb3
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdx), %rdi
movq %rsp, %rdx
movl $0x4, %esi
callq *%rax
testq %rax, %rax
je 0x5beb3
movq (%rsp), %r12
leaq 0x90(%r15), %r13
movq 0x98(%r15), %rbp
movq %r12, %rdi
callq 0xb200
movq %r13, %rdi
xorl %esi, %esi
movq %rbp, %rdx
movq %r12, %rcx
movq %rax, %r8
callq 0xb870
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x5e390
jmp 0x5bf45
leaq 0x306b6(%rip), %r14     # 0x8c570
movq (%r14), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x5bf43
addq $0x20, %rdi
callq 0xb7d0
movq (%r14), %rax
movq 0x18(%rax), %rbx
leaq 0xe5cd(%rip), %rsi      # 0x6a4a8
movl $0xc, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x117c4(%rip), %rsi     # 0x6d6b3
movl $0x11, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x117d8(%rip), %rsi     # 0x6d6db
movl $0x10, %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
callq 0xb3b0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/node/node_direct.cc
// Function: scdc_nodeconn_direct::open(char const*)
bool scdc_nodeconn_direct::open(const char *authority)
{
  compcoup = 0;

  for (scdc_nodeport_pool::iterator np = nodeport_pool->begin(); np != nodeport_pool->end(); ++np)
  {
    scdc_nodeport *nodeport = *np;
    if (nodeport->get_type() == "direct" && static_cast<scdc_nodeport_direct *>(nodeport)->get_id() == authority)
    {
      compcoup = nodeport->get_compcoup();
      break;
    }
  }

  if (!compcoup) return false;

  return scdc_nodeconn::open(authority);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, (%rsp)
movq $0x0, 0x60(%rdi)
movq 0x68(%rdi), %rax
movq 0x18(%rax), %r15
addq $0x8, %rax
cmpq %rax, %r15
je 0x5c15e
movq %rdi, %r14
leaq 0x38(%rsp), %r13
leaq 0x8(%rsp), %r12
leaq 0x28(%rsp), %rbp
movq 0x20(%r15), %rbx
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x1d0a0
movq %r12, %rdi
leaq 0xe1c8(%rip), %rsi      # 0x6a26a
callq 0xb110
testl %eax, %eax
je 0x5c0af
xorl %ebp, %ebp
jmp 0x5c0f6
movq %r13, 0x28(%rsp)
movq 0x90(%rbx), %rsi
movq 0x98(%rbx), %rdx
addq %rsi, %rdx
movq %rbp, %rdi
callq 0x1d0a0
movq %rbp, %rdi
movq (%rsp), %rsi
callq 0xb110
testl %eax, %eax
sete %bpl
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x5c0f6
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb510
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x5c112
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
testb %bpl, %bpl
jne 0x5c143
movq %r15, %rdi
callq 0xb600
movq %rax, %r15
movq 0x68(%r14), %rax
addq $0x8, %rax
cmpq %rax, %r15
leaq 0x38(%rsp), %r13
leaq 0x28(%rsp), %rbp
jne 0x5c077
movq 0x60(%r14), %rax
jmp 0x5c14b
movq 0x30(%rbx), %rax
movq %rax, 0x60(%r14)
testq %rax, %rax
je 0x5c15e
movq %r14, %rdi
movq (%rsp), %rsi
callq 0x5dcf6
jmp 0x5c160
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x5c18e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/node/node_stream.cc
// Function: scdc_nodeport_stream::scdc_nodeport_stream()
scdc_nodeport_stream::scdc_nodeport_stream()
  :scdc_nodeport("stream", SCDC_NODEPORT_START_LOOP_UNTIL_CANCEL)
{
  transport = new scdc_transport_stream();

  scdc_compcoup_transport *compcoup_transport = new scdc_compcoup_transport(transport);

  transport->set_compcoup_transport(compcoup_transport);
  compcoup = compcoup_transport;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xeef2(%rip), %rsi      # 0x6b0ac
movl $0x1, %edx
callq 0x5dd58
leaq 0x2f2c5(%rip), %rax     # 0x8b490
movq %rax, (%rbx)
movl $0x48, %edi
callq 0xb500
movq %rax, %r14
movq %rax, %rdi
callq 0x60730
movq %r14, 0x90(%rbx)
movl $0x30, %edi
callq 0xb500
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x62984
movq 0x90(%rbx), %rax
movq %r12, 0x8(%rax)
movq %r12, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
movl $0x30, %esi
movq %r12, %rdi
jmp 0x5c237
jmp 0x5c23e
movq %rax, %r15
movl $0x48, %esi
movq %r14, %rdi
callq 0xb510
jmp 0x5c241
movq %rax, %r15
movq %rbx, %rdi
callq 0x5ddbe
movq %r15, %rdi
callq 0xb9c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/node/node_stream.cc
// Function: scdc_nodeport_stream::start(long long)
bool scdc_nodeport_stream::start(scdcint_t mode)
{
  if (!scdc_nodeport::start(mode)) return false;

  if (cmd_handler_args.handler)
  {
    scdc_compcoup_transport *compcoup_transport = static_cast<scdc_compcoup_transport *>(compcoup);
    compcoup_transport->set_cmd_handler(cmd_handler_args.handler, cmd_handler_args.data);
  }

  if (mode == SCDC_NODEPORT_START_LOOP_UNTIL_CANCEL && loop_handler_dummy_args.handler)
  {
    transport->set_loop_handler(loop_handler_dummy_args.handler, loop_handler_dummy_args.data);
  }

  scdc_transport_stream *transport_stream = static_cast<scdc_transport_stream *>(transport);

#if SCDC_TRANSPORT_STREAM_USE_IOSTREAM
  return transport_stream->start(mode, &cin, &cout);
#else
  return transport_stream->start(mode, stdin, stdout);
#endif
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x5e576
testb %al, %al
je 0x5c33b
movq 0x48(%r14), %rax
testq %rax, %rax
je 0x5c2e8
movq 0x30(%r14), %rcx
movq 0x50(%r14), %rdx
movq %rax, 0x20(%rcx)
movq %rdx, 0x28(%rcx)
cmpq $0x1, %rbx
jne 0x5c30a
movq 0x58(%r14), %rax
testq %rax, %rax
je 0x5c30a
movq 0x60(%r14), %rcx
movq 0x90(%r14), %rdx
movq %rax, 0x10(%rdx)
movq %rcx, 0x18(%rdx)
movq 0x90(%r14), %rdi
movq 0x2fcb8(%rip), %rax     # 0x8bfd0
movq (%rax), %rdx
movq 0x2fc7e(%rip), %rax     # 0x8bfa0
movq (%rax), %rcx
movq (%rdi), %rax
movq 0xf8(%rax), %rax
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop