LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun.cc
// Function: scdc_dataset_jobrun::do_cmd_ls(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_ls(const std::string &params, scdc_dataset_input_t *input, scdc_dataset_output_t *output, scdc_result &result)
    {
      if (!has_jobid() && dataprov_jobrun()->do_cmd_ls(params, input, output, result)) return true;

      string jobid;
      string p = params;

      if (!select_job(p, true, true, jobid))
      {
        result = "selecting job '" + jobid + "' failed";
        SCDC_FAIL("do_cmd_ls: " << result);
        return false;
      }

      bool ret = do_cmd_ls_inout(p, input, output, result);

      undo_select_job();

      return ret;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r8, %rbx
movq %rdi, %r14
cmpq $0x0, 0x20(%rdi)
je 0x40469
movq %rcx, %r15
movq %rdx, %r12
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x8(%rsp), %rdi
callq 0xb750
leaq 0x8(%rsp), %rsi
pushq $0x1
popq %rcx
leaq 0x28(%rsp), %r8
movq %r14, %rdi
movl %ecx, %edx
callq 0x41480
testb %al, %al
je 0x4047c
movq (%r14), %rax
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movq %r12, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq *0x48(%rax)
movl %eax, %ebx
movq %r14, %rdi
callq 0x41594
jmp 0x40536
movq 0x8(%r14), %rdi
movq %rbx, %r8
callq 0x3d3fe
movb $0x1, %bl
jmp 0x4054a
leaq 0x13cc9(%rip), %rsi     # 0x5414c
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x19ae2
leaq 0x129f7(%rip), %rdx     # 0x52e90
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x1cb18
leaq 0x68(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb690
movq %r14, %rdi
callq 0xb230
leaq 0x48(%rsp), %rdi
callq 0xb230
leaq 0x350af(%rip), %r14     # 0x75580
movq (%r14), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x40534
addq $0x20, %rdi
callq 0xb800
movq (%r14), %rax
movq 0x8(%rax), %rdi
leaq 0x10c96(%rip), %rsi     # 0x51188
callq 0xb520
leaq 0x13c5e(%rip), %rsi     # 0x5415c
movq %rax, %rdi
callq 0xb520
leaq 0x13c60(%rip), %rsi     # 0x5416d
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
movq %rbx, %rsi
callq 0xb490
movq %rax, %rdi
callq 0xb270
movq (%r14), %rdi
addq $0x20, %rdi
callq 0xb3e0
xorl %ebx, %ebx
leaq 0x8(%rsp), %rdi
callq 0xb230
leaq 0x28(%rsp), %rdi
callq 0xb230
movl %ebx, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xb230
jmp 0x40576
jmp 0x40573
jmp 0x40573
movq %rax, %rbx
jmp 0x40580
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xb230
leaq 0x28(%rsp), %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14
movl %ecx, 0xc(%rsp)
movl %edx, %ebp
movq %rsi, %r13
movq %rdi, %r12
leaq 0x18(%rdi), %r15
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb750
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb690
movq %rbx, %rdi
callq 0xb230
cmpq $0x0, 0x20(%r12)
setne %al
movb $0x1, %bl
testb %bpl, %al
jne 0x4156d
leaq 0x30(%rsp), %rbp
leaq 0x40(%rsp), %rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x20(%rax)
movaps %xmm0, -0x30(%rax)
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x10(%rsp), %rcx
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x415d4
cmpq $0x0, 0x8(%r14)
je 0x4155c
movq 0x8(%r12), %rdi
movq %r14, %rsi
callq 0x3db40
testb %al, %al
je 0x41563
leaq 0x58(%rsp), %rdi
movq %r15, %rsi
callq 0xb750
addq $0x38, %r12
leaq 0x58(%rsp), %rbx
movq %r12, %rdi
movq %rbx, %rsi
callq 0xb690
movq %rbx, %rdi
callq 0xb230
movb $0x1, %bl
movq %r15, %rdi
movq %r14, %rsi
callq 0xb2e0
jmp 0x41565
cmpb $0x0, 0xc(%rsp)
je 0x41524
xorl %ebx, %ebx
movq %rbp, %rdi
callq 0xb230
movl %ebx, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x41580
movq %rax, %rbx
movq %rbp, %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x38(%rdi), %rbx
cmpq $0x0, 0x40(%rdi)
je 0x415b6
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x3db40
testb %al, %al
je 0x415c9
addq $0x18, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb2e0
movb $0x1, %al
jmp 0x415cb
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun.cc
// Function: scdc_dataset_jobrun::create_job(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, scdc_dataprov_jobrun_job_params_proc_t&)
bool create_job(const string &jobid, scdc_dataprov_jobrun_job_params_t &job_params)
    {
      SCDC_TRACE(__func__ << ": jobid: '" << jobid << "', nt: " << job_params.nt_min << "-" << job_params.nt_max << "', np: " << job_params.np_min << "-" << job_params.np_max);

      bool ret = true;

      ret = ret && create_job_inout(jobid, job_params);

      ret = ret && dataprov_jobrun()->job_create(jobid, job_params);

      return ret;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x41afc
movq 0x8(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x3dc6a
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun.cc
// Function: scdc_dataset_jobrun::update_job(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, scdc_dataprov_jobrun_job_params_proc_t&)
bool update_job(const string &jobid, scdc_dataprov_jobrun_job_params_t &job_params)
    {
      SCDC_TRACE(__func__ << ": jobid: '" << jobid << "', nt: " << job_params.nt_min << "-" << job_params.nt_max << "', np: " << job_params.np_min << "-" << job_params.np_max);

      bool ret = true;

      ret = ret && update_job_inout(jobid, job_params);

      ret = ret && dataprov_jobrun()->job_update(jobid, job_params);

      return ret;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rax
callq *0x40(%rax)
testb %al, %al
je 0x41b30
movq 0x8(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x3ddfe
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun.cc
// Function: scdc_dataset_jobrun::destroy_job(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool destroy_job(const string &jobid)
    {
      SCDC_TRACE(__func__ << ": jobid: '" << jobid << "'");

      bool ret = true;

      ret = ret && dataprov_jobrun()->job_destroy(jobid);

      ret = ret && destroy_job_inout();

      return ret;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x3dd64
testb %al, %al
je 0x41b53
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
jmpq *0x38(%rax)
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x48(%rsp), %r14
movq %r14, %rdi
callq 0xb750
leaq 0x20(%rsp), %rdi
pushq $0x20
popq %rsi
movq %r14, %rdx
callq 0x2f05c
leaq 0x48(%rsp), %rdi
callq 0xb230
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x19ba0
leaq 0x125e9(%rip), %rsi     # 0x541e4
movq %rsp, %rdi
callq 0x19be0
testb %al, %al
jne 0x41c1a
leaq 0x11e83(%rip), %rsi     # 0x53a91
movq %rsp, %rdi
callq 0x19be0
testb %al, %al
je 0x41c46
andq $0x0, 0x38(%rbx)
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x41d98
movq %rsp, %rdi
callq 0xb230
leaq 0x20(%rsp), %rdi
callq 0x19ef4
addq $0x68, %rsp
popq %rbx
popq %r14
retq
leaq 0x1259f(%rip), %rsi     # 0x541ec
movq %rsp, %rdi
callq 0x19be0
testb %al, %al
je 0x41c2c
movq $0x1, 0x38(%rbx)
jmp 0x41c2c
movq %rax, %rbx
movq %rsp, %rdi
callq 0xb230
jmp 0x41c73
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x19ef4
jmp 0x41c8c
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x19ba0
movq 0x30(%rbx), %rdi
leaq 0x20(%rsp), %rdx
movq %r14, %rsi
callq 0x3d74a
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x1d83e
movq 0x20(%rsp), %rcx
testb %al, %al
je 0x41de3
movq %rcx, %rax
subq 0x20(%rbx), %rax
addq %rax, 0x28(%rbx)
movq %rcx, 0x20(%rbx)
jmp 0x41df6
movq %rcx, 0x28(%rbx)
movq %rcx, 0x20(%rbx)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xb2e0
movq %rsp, %rdi
callq 0xb230
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %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 0xb2e0
movq 0x30(%r15), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x3dc2c
movq 0x28(%r15), %r12
movq (%r14), %r13
imulq 0x10(%r14), %r13
cmpq %r13, %r12
jl 0x41eb6
movl $0x228, %edi            # imm = 0x228
addq 0x30(%r15), %rdi
callq 0x41ede
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rsp, %rdi
movq %r15, %rsi
callq 0xb2e0
movq 0x10(%r14), %rax
movq %rsp, %rsi
movq %rax, 0x20(%rsi)
movq (%r14), %rax
movq %rax, 0x28(%rsi)
movq %rbx, %rdi
callq 0x4039e
movq %rsp, %rdi
callq 0xb230
cmpq %r13, %r12
setge %al
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun.cc
// Function: scdc_dataset_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 do_cmd_info(const std::string &params, scdc_dataset_input_t *input, scdc_dataset_output_t *output, scdc_result &result)
    {
      if (!has_jobid() && dataprov_jobrun()->do_cmd_info(params, input, output, result)) return true;

      string jobid;
      string p = params;

      if (!select_job(p, true, true, jobid))
      {
        result = "selecting job '" + jobid + "' failed";
        SCDC_FAIL("do_cmd_info: " << result);
        return false;
      }

      dataprov_jobrun()->get_job_state(jobid, result);

      undo_select_job();

      return true;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %r8, %r14
movq %rdi, %r15
cmpq $0x0, 0x20(%rdi)
je 0x43459
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x40(%rsp), %rdi
callq 0xb750
leaq 0x40(%rsp), %rsi
pushq $0x1
popq %rcx
movq %rsp, %r8
movq %r15, %rdi
movl %ecx, %edx
callq 0x41480
movl %eax, %ebx
testb %al, %al
je 0x4346c
movq 0x8(%r15), %rdi
movq %rsp, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x3d5ae
movq %r15, %rdi
callq 0x41594
jmp 0x43522
movq 0x8(%r15), %rdi
movq %r14, %r8
callq 0x3d666
movb $0x1, %bl
jmp 0x43534
leaq 0x10cd9(%rip), %rsi     # 0x5414c
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x19ae2
leaq 0xfa09(%rip), %rdx      # 0x52e90
leaq 0x60(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x1cb18
leaq 0x60(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xb690
movq %r15, %rdi
callq 0xb230
leaq 0x20(%rsp), %rdi
callq 0xb230
leaq 0x320c1(%rip), %r15     # 0x75580
movq (%r15), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x43522
addq $0x20, %rdi
callq 0xb800
movq (%r15), %rax
movq 0x8(%rax), %rdi
leaq 0xdca8(%rip), %rsi      # 0x51188
callq 0xb520
leaq 0x10c70(%rip), %rsi     # 0x5415c
movq %rax, %rdi
callq 0xb520
leaq 0x10d43(%rip), %rsi     # 0x5423e
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
movq %r14, %rsi
callq 0xb490
movq %rax, %rdi
callq 0xb270
movq (%r15), %rdi
addq $0x20, %rdi
callq 0xb3e0
leaq 0x40(%rsp), %rdi
callq 0xb230
movq %rsp, %rdi
callq 0xb230
movl %ebx, %eax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xb230
jmp 0x4355c
jmp 0x43559
movq %rax, %rbx
jmp 0x43566
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xb230
movq %rsp, %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun.cc
// Function: scdc_dataset_jobrun::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;
      string p = params;

      if (!select_job(p, false, false, jobid))
      {
        result = "selecting job '" + jobid + "' failed";
        SCDC_FAIL("do_cmd_cd: " << result);
        return false;
      }

      return true;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %r8, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x40(%rsp), %rdi
callq 0xb750
leaq 0x40(%rsp), %rsi
movq %rsp, %r8
movq %rbx, %rdi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x41480
movl %eax, %ebx
testb %al, %al
jne 0x43677
leaq 0x10b84(%rip), %rsi     # 0x5414c
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0x19ae2
leaq 0xf8b4(%rip), %rdx      # 0x52e90
leaq 0x60(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x1cb18
leaq 0x60(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xb690
movq %r15, %rdi
callq 0xb230
leaq 0x20(%rsp), %rdi
callq 0xb230
leaq 0x31f6c(%rip), %r15     # 0x75580
movq (%r15), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x43677
addq $0x20, %rdi
callq 0xb800
movq (%r15), %rax
movq 0x8(%rax), %rdi
leaq 0xdb53(%rip), %rsi      # 0x51188
callq 0xb520
leaq 0x10b1b(%rip), %rsi     # 0x5415c
movq %rax, %rdi
callq 0xb520
leaq 0x10bfc(%rip), %rsi     # 0x5424c
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
movq %r14, %rsi
callq 0xb490
movq %rax, %rdi
callq 0xb270
movq (%r15), %rdi
addq $0x20, %rdi
callq 0xb3e0
leaq 0x40(%rsp), %rdi
callq 0xb230
movq %rsp, %rdi
callq 0xb230
movl %ebx, %eax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xb230
jmp 0x436b1
jmp 0x436ae
movq %rax, %rbx
jmp 0x436bb
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xb230
movq %rsp, %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x439d0
movq (%rbx), %rdi
callq 0x2da96
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xb230
testq %rbx, %rbx
jne 0x43765
leaq 0x31e73(%rip), %r14     # 0x75580
movq (%r14), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x43765
addq $0x20, %rdi
callq 0xb800
movq (%r14), %rax
movq 0x8(%rax), %rdi
leaq 0xda5a(%rip), %rsi      # 0x51188
callq 0xb520
leaq 0x10672(%rip), %rsi     # 0x53dac
movq %rax, %rdi
callq 0xb520
leaq 0x10b0f(%rip), %rsi     # 0x54258
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
movq (%r14), %rdi
addq $0x20, %rdi
callq 0xb3e0
testq %rbx, %rbx
setne %al
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rsi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x439e2
movq (%rbx), %rdi
callq 0x2db42
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xb230
testq %rbx, %rbx
jne 0x43818
leaq 0x31dc0(%rip), %r14     # 0x75580
movq (%r14), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x43818
addq $0x20, %rdi
callq 0xb800
movq (%r14), %rax
movq 0x8(%rax), %rdi
leaq 0xd9a7(%rip), %rsi      # 0x51188
callq 0xb520
leaq 0x105bf(%rip), %rsi     # 0x53dac
movq %rax, %rdi
callq 0xb520
leaq 0x10a89(%rip), %rsi     # 0x54285
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
movq (%r14), %rdi
addq $0x20, %rdi
callq 0xb3e0
testq %rbx, %rbx
setne %al
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_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 %rbx
subq $0x28, %rsp
testq %rdx, %rdx
je 0x4390c
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
leaq 0x7(%rsp), %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1a132
leaq 0xebe6(%rip), %rsi      # 0x524b5
movq %r15, %rdi
callq 0x19be0
movl %eax, %ebp
movq %r15, %rdi
callq 0xb230
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
testb %bpl, %bpl
je 0x43910
callq 0x439e2
movq (%r15), %rdx
leaq 0xfa9e(%rip), %rsi      # 0x5339e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x273af
jmp 0x43929
movb $0x1, %bl
jmp 0x4393a
callq 0x439e2
movq (%r15), %rdx
leaq 0xfd3d(%rip), %rsi      # 0x5365c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x273af
cmpq $0x1, %rax
sete %bl
leaq 0x8(%rsp), %rdi
callq 0xb230
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x43949
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_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 0x439a8
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x439e2
movq (%r15), %rdx
movq (%r14), %rcx
leaq 0xfa9a(%rip), %rsi      # 0x53427
movq %rbx, %rdi
xorl %eax, %eax
callq 0x274da
cmpq $0x1, %rax
sete %bl
movq %rsp, %rdi
callq 0xb230
jmp 0x439aa
movb $0x1, %bl
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xb750
leaq 0xe2af(%rip), %rsi      # 0x524bd
movq %r12, %rdi
callq 0x19be0
testb %al, %al
jne 0x4422b
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x442a4
testb %al, %al
je 0x44265
pushq $0x40
popq %rdi
callq 0xb540
movq %rax, %r14
movq %rbx, 0x8(%rax)
xorl %eax, %eax
movb %al, 0x10(%r14)
movq %r14, %rcx
addq $0x28, %rcx
movq %rcx, 0x18(%r14)
andq $0x0, 0x20(%r14)
movb %al, 0x28(%r14)
leaq 0x30155(%rip), %rax     # 0x743b0
movq %rax, (%r14)
andq $0x0, 0x38(%r14)
jmp 0x44276
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1de8e
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0xb230
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
testq %rsi, %rsi
je 0x44312
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq (%rsi), %rax
movq -0x8(%rax), %rdi
leaq 0x300a3(%rip), %rsi     # 0x74388
callq 0x2f09a
testb %al, %al
je 0x442ff
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x1e1e8
callq 0xb5e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun_relay.cc
// Function: scdc_dataprov_jobrun_relay::do_cmd_ls(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_ls(const std::string &params, scdc_dataset_input_t *input, scdc_dataset_output_t *output, scdc_result &result)
{
  SCDC_TRACE("do_cmd_ls: params: '" << params << "'");

  string s;

  for (sched_jobs_t::iterator i = sched_jobs.begin(); i != sched_jobs.end(); ++i)
  {
    s += i->first + ":unknown:" + i->second + ",";
  }

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

  result = s;

  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r8, (%rsp)
movq %rdi, %r14
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x110(%rdi), %r12
addq $0x100, %r14            # imm = 0x100
leaq 0x28(%rsp), %r13
leaq 0x48(%rsp), %rbp
leaq 0x68(%rsp), %r15
leaq 0x8(%rsp), %rbx
cmpq %r14, %r12
je 0x4465e
leaq 0x20(%r12), %rsi
movq %r13, %rdi
leaq 0xfd4e(%rip), %rdx      # 0x54355
callq 0x1d867
leaq 0x40(%r12), %rdx
movq %rbp, %rdi
movq %r13, %rsi
callq 0x1eeb2
movq %r15, %rdi
movq %rbp, %rsi
leaq 0xd21d(%rip), %rdx      # 0x51846
callq 0x1cb18
movq %rbx, %rdi
movq %r15, %rsi
callq 0xba90
movq %r15, %rdi
callq 0xb230
movq %rbp, %rdi
callq 0xb230
movq %r13, %rdi
callq 0xb230
movq %r12, %rdi
callq 0xb380
movq %rax, %r12
jmp 0x445f3
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x44675
decq %rsi
leaq 0x8(%rsp), %rdi
callq 0xb760
leaq 0x8(%rsp), %rsi
movq (%rsp), %rdi
callq 0xb2e0
leaq 0x8(%rsp), %rdi
callq 0xb230
movb $0x1, %al
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x446a3
movq %rax, %rbx
jmp 0x446d3
movq %rax, %rbx
jmp 0x446c9
movq %rax, %rbx
jmp 0x446bf
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xb230
leaq 0x48(%rsp), %rdi
callq 0xb230
leaq 0x28(%rsp), %rdi
callq 0xb230
leaq 0x8(%rsp), %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_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 0xb390
leaq 0x30(%rsp), %rdi
movq 0x120(%r14), %rsi
callq 0xb360
leaq 0xfc47(%rip), %rsi      # 0x5435f
movq %rax, %rdi
callq 0xb520
leaq 0x38(%rsp), %rsi
movq %rsp, %rdi
callq 0xb8d0
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb690
movq %r14, %rdi
callq 0xb230
leaq 0x20(%rsp), %rdi
callq 0xb3d0
movb $0x1, %al
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
jmp 0x4475c
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xb3d0
movq %rbx, %rdi
callq 0xb9a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xd0(%rdi), %r15
movq 0x130(%rdi), %rsi
cmpq %r15, %rsi
je 0x447c8
movq 0x138(%rbx), %rax
cmpq 0x40(%rsi), %rax
jl 0x447c8
leaq 0x130(%rbx), %rdi
callq 0x46196
andq $0x0, 0x138(%rbx)
movq 0x130(%rbx), %rsi
cmpq %r15, %rsi
jne 0x447e3
movq 0xe0(%rbx), %rsi
movq %rsi, 0x130(%rbx)
andq $0x0, 0x138(%rbx)
cmpq %r15, %rsi
je 0x44857
leaq 0x98(%rbx), %rdi
addq $0x20, %rsi
callq 0x1f19c
leaq 0xa0(%rbx), %rcx
cmpq %rcx, %rax
je 0x44857
incq 0x138(%rbx)
addq $0x40, %rax
movq %rsp, %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0xb750
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x461aa
addq $0xf8, %rbx
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x1f212
movl %edx, %ebx
leaq 0x20(%rsp), %rdi
callq 0x1eff8
movq %rsp, %rdi
callq 0xb230
jmp 0x44859
xorl %ebx, %ebx
andb $0x1, %bl
movl %ebx, %eax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x1eff8
jmp 0x4487a
movq %rax, %rbx
movq %rsp, %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1f19c
movq %rax, %r15
addq $0x100, %rbx            # imm = 0x100
cmpq %rbx, %rax
je 0x448d2
leaq 0x40(%r15), %rsi
movq %r14, %rdi
callq 0xb2e0
cmpq %rbx, %r15
setne %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun_relay.cc
// Function: scdc_dataprov_jobrun_relay::relay_rm(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool scdc_dataprov_jobrun_relay::relay_rm(const std::string &path)
{
  SCDC_TRACE("relay_rm: path: '" << path << "'");

  bool ret = scdc_dataprov_relay::relay_rm(path);

  sched_t::iterator i = sched.find(path);

  if (ret && i != sched.end())
  {
    max_parallel_jobs -= i->second.max_parallel_jobs;

    if (sched_last == i)
    {
      ++sched_last;
      sched_last_jobs = 0;
    }

    sched.erase(i);

    SCDC_TRACE("relay_put: max_parallel_jobs: " << max_parallel_jobs);
    SCDC_INFO("removing relay for path '" << path << "' (total max. parallel jobs: " << max_parallel_jobs << ")");
  }

  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %r14
callq 0x1ec2c
movl %eax, %ebx
leaq 0xc8(%r14), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x46b50
movq %rax, %r13
leaq 0xd0(%r14), %rax
cmpq %rax, %r13
setne %al
andb %bl, %al
cmpb $0x1, %al
jne 0x44faf
movq 0x40(%r13), %rax
subq %rax, 0x128(%r14)
cmpq %r13, 0x130(%r14)
jne 0x44ee1
leaq 0x130(%r14), %rdi
callq 0x46196
andq $0x0, 0x138(%r14)
movq %r12, %rdi
movq %r13, %rsi
callq 0x46bc6
leaq 0x3068d(%rip), %rbp     # 0x75580
movq (%rbp), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x44faf
addq $0x20, %rdi
callq 0xb800
movq (%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0xcfce(%rip), %rsi      # 0x51ee8
callq 0xb520
movq %rax, %r12
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x44df9
movq %r12, %rdi
movq %r13, %rsi
callq 0xb490
leaq 0xf3cb(%rip), %rsi      # 0x5430c
movq %rax, %rdi
callq 0xb520
leaq 0xf4e9(%rip), %rsi      # 0x54439
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
movq %r15, %rsi
callq 0xb490
leaq 0xf4e9(%rip), %rsi      # 0x54453
movq %rax, %rdi
callq 0xb520
movq 0x128(%r14), %rsi
movq %rax, %rdi
callq 0xb1d0
leaq 0xd967(%rip), %rsi      # 0x528ef
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
leaq 0x8(%rsp), %rdi
callq 0xb230
movq (%rbp), %rdi
addq $0x20, %rdi
callq 0xb3e0
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun_relay.cc
// Function: scdc_dataset_jobrun_relay::remote_dataset_open(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
bool remote_dataset_open(string jobid, bool cd)
    {
      string remote;

      if (!dataprov_jobrun_relay()->sched_job_get_relay(jobid, remote))
      {
        SCDC_ERROR("remote_dataset_open: getting relay address of job '" << jobid << "' failed");
        return false;
      }

      if (cd) remote += "/" + jobid;

      remote_dataset = scdc_dataset_open(remote.c_str());

      if (remote_dataset == SCDC_DATASET_NULL)
      {
        SCDC_FAIL("remote_dataset_open: opening remote dataset '" << remote << "' failed");
        return false;
      }

      return true;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rsi, %r14
movq %rdi, %r15
movb $0x0, (%rax)
movq 0x8(%rdi), %rdi
leaq 0x8(%rsp), %rbx
movq %rbx, %rdx
callq 0x448a0
testb %al, %al
je 0x46306
testb %bpl, %bpl
je 0x46296
leaq 0xb0dd(%rip), %rsi      # 0x5134d
leaq 0x28(%rsp), %rdi
movq %r14, %rdx
callq 0x19ae2
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xba90
leaq 0x28(%rsp), %rdi
callq 0xb230
movq 0x8(%rsp), %rdi
xorl %eax, %eax
callq 0x187db
movq %rax, 0x38(%r15)
movb $0x1, %bpl
testq %rax, %rax
jne 0x46388
leaq 0x2f2c7(%rip), %r14     # 0x75580
movq (%r14), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x46386
addq $0x20, %rdi
callq 0xb800
movq (%r14), %rax
movq 0x8(%rax), %rdi
leaq 0xaeaa(%rip), %rsi      # 0x51188
callq 0xb520
leaq 0xe1a3(%rip), %rsi      # 0x5448d
movq %rax, %rdi
callq 0xb520
leaq 0xe21b(%rip), %rsi      # 0x54514
movq %rax, %rdi
callq 0xb520
movq %rbx, %r14
jmp 0x46351
leaq 0x2f273(%rip), %rbx     # 0x75580
movq (%rbx), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x46386
addq $0x20, %rdi
callq 0xb800
movq (%rbx), %rax
movq 0x18(%rax), %rdi
leaq 0xb15a(%rip), %rsi      # 0x51488
callq 0xb520
leaq 0xe153(%rip), %rsi      # 0x5448d
movq %rax, %rdi
callq 0xb520
leaq 0xe197(%rip), %rsi      # 0x544e0
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
movq %r14, %rsi
callq 0xb490
leaq 0xcb2d(%rip), %rsi      # 0x52e90
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
leaq 0x2f206(%rip), %rax     # 0x75580
movq (%rax), %rdi
addq $0x20, %rdi
callq 0xb3e0
xorl %ebp, %ebp
leaq 0x8(%rsp), %rdi
callq 0xb230
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xb230
jmp 0x463b3
jmp 0x463b0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_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, %r15
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x44fd5
leaq 0x18(%r15), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d83e
movb $0x1, %bl
testb %al, %al
jne 0x4689b
movq %r15, %rdi
callq 0x463c6
leaq 0xbc91(%rip), %rsi      # 0x524bd
leaq 0x48(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x1a132
leaq 0x48(%rsp), %rsi
movq %r14, %rdi
callq 0xb2e0
leaq 0x48(%rsp), %rdi
callq 0xb230
cmpq $0x0, 0x10(%rsp)
je 0x4689b
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xb750
leaq 0x28(%rsp), %rsi
pushq $0x1
popq %rdx
movq %r15, %rdi
callq 0x46228
movl %eax, %ebp
leaq 0x28(%rsp), %rdi
callq 0xb230
testb %bpl, %bpl
je 0x46899
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0xb2e0
jmp 0x4689b
xorl %ebx, %ebx
leaq 0x8(%rsp), %rdi
callq 0xb230
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x468c4
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xb230
jmp 0x468d0
jmp 0x468cd
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x8(%rdx), %rax
testq %rax, %rax
je 0x46e36
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdx), %rdi
pushq $0x4
popq %rsi
leaq 0x8(%rsp), %rdx
callq *%rax
testq %rax, %rax
je 0x46e36
movq 0x8(%rsp), %rsi
leaq 0x90(%r15), %rdi
callq 0xba40
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x48b8c
jmp 0x46e97
leaq 0x2e743(%rip), %rbx     # 0x75580
movq (%rbx), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x46e95
addq $0x20, %rdi
callq 0xb800
movq (%rbx), %rax
movq 0x18(%rax), %rdi
leaq 0xa62a(%rip), %rsi      # 0x51488
callq 0xb520
leaq 0xd7d9(%rip), %rsi      # 0x54643
movq %rax, %rdi
callq 0xb520
leaq 0xd7f2(%rip), %rsi      # 0x5466b
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
movq (%rbx), %rdi
addq $0x20, %rdi
callq 0xb3e0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x58, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, %r14
andq $0x0, 0x60(%rdi)
movq 0x68(%rdi), %rax
movq 0x18(%rax), %rbp
leaq 0x18(%rsp), %r15
leaq 0xa2af(%rip), %rbx      # 0x5124a
leaq 0x38(%rsp), %r13
addq $0x8, %rax
cmpq %rax, %rbp
je 0x4701c
movq 0x20(%rbp), %r12
leaq 0x8(%r12), %rsi
movq %r15, %rdi
callq 0xb750
movq %r15, %rdi
movq %rbx, %rsi
callq 0x19be0
testb %al, %al
je 0x47003
leaq 0x90(%r12), %rsi
movq %r13, %rdi
callq 0xb750
movq %r13, %rdi
movq 0x10(%rsp), %rsi
callq 0x19be0
movb %al, 0xf(%rsp)
movq %r13, %rdi
callq 0xb230
movq %r15, %rdi
callq 0xb230
cmpb $0x0, 0xf(%rsp)
je 0x4700b
jmp 0x47022
movq %r15, %rdi
callq 0xb230
movq %rbp, %rdi
callq 0xb620
movq %rax, %rbp
movq 0x68(%r14), %rax
jmp 0x46fa0
movq 0x60(%r14), %rax
jmp 0x4702b
movq 0x30(%r12), %rax
movq %rax, 0x60(%r14)
testq %rax, %rax
je 0x4703f
movq %r14, %rdi
movq 0x10(%rsp), %rsi
callq 0x4868a
jmp 0x47041
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xafb6(%rip), %rsi      # 0x5203c
pushq $0x1
popq %rdx
callq 0x486e8
leaq 0x2d413(%rip), %rax     # 0x744a8
movq %rax, (%rbx)
pushq $0x48
popq %rdi
callq 0xb540
movq %rax, %r14
movq %rax, %rdi
callq 0x4a76c
movq %r14, 0x90(%rbx)
pushq $0x30
popq %rdi
callq 0xb540
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x4c0e0
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
pushq $0x30
popq %rsi
movq %r12, %rdi
jmp 0x470f9
jmp 0x47100
movq %rax, %r15
pushq $0x48
popq %rsi
movq %r14, %rdi
callq 0xb550
jmp 0x47103
movq %rax, %r15
movq %rbx, %rdi
callq 0x4874a
movq %r15, %rdi
callq 0xb9a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x48ce2
testb %al, %al
je 0x471f7
movq 0x48(%r14), %rax
testq %rax, %rax
je 0x471a4
movq 0x30(%r14), %rcx
movq 0x50(%r14), %rdx
movq %rax, 0x20(%rcx)
movq %rdx, 0x28(%rcx)
cmpq $0x1, %rbx
jne 0x471c6
movq 0x58(%r14), %rax
testq %rax, %rax
je 0x471c6
movq 0x60(%r14), %rcx
movq 0x90(%r14), %rdx
movq %rax, 0x10(%rdx)
movq %rcx, 0x18(%rdx)
movq 0x90(%r14), %rdi
movq 0x2ddfc(%rip), %rax     # 0x74fd0
movq (%rax), %rdx
movq 0x2ddda(%rip), %rax     # 0x74fb8
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
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/node/node_stream.cc
// Function: scdc_nodeport_stream::stop()
bool scdc_nodeport_stream::stop()
{
  scdc_transport_stream *transport_stream = static_cast<scdc_transport_stream *>(transport);

  transport_stream->stop();

  if (loop_handler_dummy_args.handler)
  {
    transport->set_loop_handler(0, 0);
  }

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

  return scdc_nodeport::stop();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x90(%rdi), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
cmpq $0x0, 0x58(%rbx)
je 0x47228
movq 0x90(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
cmpq $0x0, 0x48(%rbx)
je 0x4723a
movq 0x30(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movq %rbx, %rdi
popq %rbx
jmp 0x48d0a
nop
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/node/node_tcp.cc
// Function: scdc_nodeport_tcp::supported(char const*, scdc_args*)
bool scdc_nodeport_tcp::supported(const char *uri, scdc_args *args)
{
  SCDC_TRACE("supported: uri: '" << uri << "'");

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

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

  return ret;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rsi
leaq 0x10(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x1a132
leaq 0xd2dd(%rip), %rcx      # 0x5472a
pushq $0x9
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xb730
testl %eax, %eax
sete %bl
leaq 0x10(%rsp), %rdi
callq 0xb230
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0