LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1d19a
movq %rbx, %rdi
movq %r12, %rsi
callq 0xb670
movq (%r12), %rdi
cmpq %rbp, %rdi
je 0x54894
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xb510
cmpq $0x0, 0x20(%r14)
setne %al
movb $0x1, %r12b
testb %r13b, %al
jne 0x54981
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 0x54a06
cmpq $0x0, 0x8(%rbx)
je 0x54960
movq 0x8(%r14), %r15
leaq 0x128(%r15), %rdi
movq %rbx, %rsi
callq 0x5685a
addq $0x130, %r15            # imm = 0x130
cmpq %r15, %rax
je 0x54967
leaq 0x68(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq 0x18(%r14), %rsi
movq 0x20(%r14), %rdx
addq %rsi, %rdx
leaq 0x58(%rsp), %rdi
callq 0x1d19a
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 0x54950
movq 0x68(%rsp), %rsi
incq %rsi
callq 0xb510
movb $0x1, %r12b
movq %r15, %rdi
movq %rbx, %rsi
callq 0xb2c0
jmp 0x5496a
cmpb $0x0, 0xc(%rsp)
je 0x54904
xorl %r12d, %r12d
movq 0x30(%rsp), %rdi
cmpq %r13, %rdi
je 0x54981
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 0x54995
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %r13, %rdi
je 0x549af
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataprov/dataprov_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 0x549ea
movq 0x8(%r14), %r15
leaq 0x128(%r15), %rdi
movq %rbx, %rsi
callq 0x5685a
addq $0x130, %r15            # imm = 0x130
cmpq %r15, %rax
je 0x549fd
addq $0x18, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb2c0
movb $0x1, %al
jmp 0x549ff
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1d19a
leaq 0x48(%rsp), %rdi
movl $0x20, %esi
movq %r14, %rdx
callq 0x37d96
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x55164
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb510
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x1b92c
leaq 0x1806a(%rip), %rsi     # 0x6d1e4
leaq 0x8(%rsp), %rdi
callq 0xb110
testl %eax, %eax
je 0x551bc
leaq 0x17902(%rip), %rsi     # 0x6ca91
leaq 0x8(%rsp), %rdi
callq 0xb110
testl %eax, %eax
je 0x551bc
leaq 0x18048(%rip), %rsi     # 0x6d1ec
leaq 0x8(%rsp), %rdi
callq 0xb110
testl %eax, %eax
jne 0x551d1
movq $0x1, 0x38(%rbx)
jmp 0x551d1
movq $0x0, 0x38(%rbx)
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x553fc
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x551ec
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
leaq 0x48(%rsp), %rdi
callq 0x1bb7e
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 0x55223
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
jmp 0x55223
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x1bb7e
jmp 0x55249
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x55249
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataprov/dataprov_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 0x1b92c
movq 0x30(%rbx), %rdi
leaq 0x20(%rsp), %rdx
movq %r14, %rsi
callq 0x4eaca
movq 0x8(%rsp), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x55442
testq %rdx, %rdx
je 0x5545c
movq (%rbx), %rsi
movq (%rsp), %rdi
callq 0xb520
testl %eax, %eax
je 0x5545c
movq 0x20(%rsp), %rax
movq %rax, 0x28(%rbx)
movq %rax, 0x20(%rbx)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xb2c0
jmp 0x55470
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 0x5548b
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 0x554b1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataprov/dataprov_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 0x4f21e
movq 0x28(%r15), %r12
movq (%r14), %r13
imulq 0x10(%r14), %r13
cmpq %r13, %r12
jl 0x55577
movq 0x30(%r15), %rdi
movq 0x228(%rdi), %rsi
addq $0x228, %rdi            # imm = 0x228
callq 0x555ae
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 0x52bbe
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x55577
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 0x555a6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5160e
movq (%rbx), %rdi
callq 0x35c2e
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x56f13
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
testq %rbx, %rbx
jne 0x56fac
leaq 0x3564d(%rip), %r15     # 0x8c570
movq (%r15), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x56fac
addq $0x20, %rdi
callq 0xb7d0
movq (%r15), %rax
movq 0x8(%rax), %r14
leaq 0x13244(%rip), %rsi     # 0x6a188
movl $0xb, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x15e54(%rip), %rsi     # 0x6cdac
movl $0x18, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x162ec(%rip), %rsi     # 0x6d258
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 0x56fda
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x57300
movq (%rbx), %rdi
callq 0x35cda
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5701f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
testq %rbx, %rbx
jne 0x570b8
leaq 0x35541(%rip), %r15     # 0x8c570
movq (%r15), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x570b8
addq $0x20, %rdi
callq 0xb7d0
movq (%r15), %rax
movq 0x8(%rax), %r14
leaq 0x13138(%rip), %rsi     # 0x6a188
movl $0xb, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x15d48(%rip), %rsi     # 0x6cdac
movl $0x18, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x1620d(%rip), %rsi     # 0x6d285
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 0x570e6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x571fd
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 0x1bee6
leaq 0x1434f(%rip), %rsi     # 0x6b505
movq %r15, %rdi
callq 0xb110
movl %eax, %ebp
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x571d5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
testl %ebp, %ebp
je 0x57201
callq 0x57300
movq (%r15), %rdx
leaq 0x15463(%rip), %rsi     # 0x6c654
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2e213
jmp 0x5721a
movb $0x1, %bl
jmp 0x57237
callq 0x57300
movq (%r15), %rdx
leaq 0x15186(%rip), %rsi     # 0x6c396
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2e213
cmpq $0x1, %rax
sete %bl
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x57237
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 0x57248
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x57261
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataprov/dataprov_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 0x572c7
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %rsi
movq %rsp, %r15
movq %r15, %rdi
callq 0x57300
movq (%r15), %rdx
movq (%r14), %rcx
leaq 0x15186(%rip), %rsi     # 0x6c41f
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2e3a8
cmpq $0x1, %rax
sete %bl
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x572c9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
jmp 0x572c9
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 0x572f3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataprov/dataprov_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 0x1d19a
leaq 0x135e2(%rip), %rsi     # 0x6b50d
movq %r12, %rdi
callq 0xb110
testl %eax, %eax
je 0x57f52
leaq 0xf8(%rbx), %rdi
movq %rsp, %rsi
callq 0x2286e
leaq 0x100(%rbx), %rcx
cmpq %rcx, %rax
je 0x57f8c
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 0x33415(%rip), %rcx     # 0x8b398
movq %rcx, (%r14)
movq %rax, 0x38(%r14)
jmp 0x57f9d
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x20b1c
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x57fb3
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 0x57fdd
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataprov/dataprov_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 0x58078
movq %rsi, %rbx
movq %rdi, %r15
movq (%rsi), %r12
movq -0x8(%r12), %rax
movq 0x8(%rax), %rdi
leaq 0x155de(%rip), %rax     # 0x6d60a
cmpq %rax, %rdi
je 0x58062
movq %rdx, %r14
cmpb $0x2a, (%rdi)
je 0x58049
leaq 0x155ca(%rip), %rsi     # 0x6d60a
callq 0xb770
testl %eax, %eax
je 0x58062
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x210a8
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_O1/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 0x14cc1(%rip), %rsi     # 0x6d35f
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 0x586e0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
movq 0x338c9(%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 0x5870d
movq %rax, %rbx
movq 0x33899(%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_O1/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), %rdi
cmpq %r15, %rdi
je 0x5878a
movq 0x138(%rbx), %rax
cmpq 0x40(%rdi), %rax
jl 0x5878a
callq 0xb350
movq %rax, 0x130(%rbx)
movq $0x0, 0x138(%rbx)
cmpq %r15, 0x130(%rbx)
jne 0x587ac
movq 0xe0(%rbx), %rax
movq %rax, 0x130(%rbx)
movq $0x0, 0x138(%rbx)
movq 0x130(%rbx), %rsi
cmpq %r15, %rsi
je 0x5887a
leaq 0x98(%rbx), %rdi
addq $0x20, %rsi
callq 0x2286e
leaq 0xa0(%rbx), %rcx
cmpq %rcx, %rax
je 0x5887a
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 0x1d19a
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x5b120
addq $0xf8, %rbx
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x228f8
movl %edx, %ebx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x58846
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xb510
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x58861
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb510
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x5887c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
jmp 0x5887c
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 0x225e8
jmp 0x5889f
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x588b6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2286e
movq %rax, %r15
addq $0x100, %rbx            # imm = 0x100
cmpq %rbx, %rax
je 0x5892e
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_O1/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
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x59468
leaq 0x18(%r14), %rbx
movq 0x8(%r15), %rdx
cmpq 0x20(%r14), %rdx
jne 0x5bbc7
movb $0x1, %bpl
testq %rdx, %rdx
je 0x5bc88
movq (%rbx), %rsi
movq 0x8(%rsp), %rdi
callq 0xb520
testl %eax, %eax
je 0x5bc88
movq 0x38(%r14), %rdi
testq %rdi, %rdi
je 0x5bbdd
callq 0x1a09c
movq $0x0, 0x38(%r14)
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xf920(%rip), %rdx      # 0x6b50d
leaq 0x48(%rsp), %rdi
movq %rdx, %rsi
callq 0x1bee6
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0xb2c0
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x5bc1e
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xb510
movq 0x10(%rsp), %rdx
movb $0x1, %bpl
testq %rdx, %rdx
je 0x5bc88
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%rsp), %rsi
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x1d19a
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
movl $0x1, %edx
callq 0x5b252
movl %eax, %r14d
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x5bc72
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb510
testb %r14b, %r14b
je 0x5bc86
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xb2c0
jmp 0x5bc88
xorl %ebp, %ebp
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5bca3
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 0x5bce5
movq 0x38(%rsp), %rsi
jmp 0x5bcd6
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x5bce5
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xb510
jmp 0x5bce5
jmp 0x5bce2
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5bd00
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/node/node_direct.cc
// Function: scdc_nodeport_direct::authority(char const*, scdc_args*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_nodeport_direct::authority(const char *conf, scdc_args *args, std::string &auth)
{
  SCDC_TRACE("authority: conf: '" << conf << "'");

  auth.clear();

  const char *id;

  if (args->get<const char *>(SCDC_ARGS_TYPE_CSTR, &id) == SCDC_ARG_REF_NULL)
  {
    SCDC_ERROR("authority: getting id");
    return false;
  }

  auth = id;

  SCDC_TRACE("authority: return: '" << auth << "'");

  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq $0x0, 0x8(%rdx)
movq (%rdx), %rax
movb $0x0, (%rax)
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x5c037
movq (%rsi), %rdi
movq %rsp, %rdx
movl $0x4, %esi
callq *%rax
testq %rax, %rax
setne %bl
jmp 0x5c039
xorl %ebx, %ebx
testb %bl, %bl
je 0x5c065
movq (%rsp), %r15
movq 0x8(%r14), %r12
movq %r15, %rdi
callq 0xb200
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r15, %rcx
movq %rax, %r8
callq 0xb870
jmp 0x5c0f5
leaq 0x30504(%rip), %r15     # 0x8c570
movq (%r15), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x5c0f5
addq $0x20, %rdi
callq 0xb7d0
movq (%r15), %rax
movq 0x18(%rax), %r14
leaq 0xe3fb(%rip), %rsi      # 0x6a488
movl $0xc, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x115a2(%rip), %rsi     # 0x6d643
movl $0x11, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x115a0(%rip), %rsi     # 0x6d655
movl $0x15, %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
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5c2f5
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdx), %rdi
movq %rsp, %rdx
movl $0x4, %esi
callq *%rax
testq %rax, %rax
je 0x5c2f5
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 0x5e84c
jmp 0x5c387
leaq 0x30274(%rip), %r14     # 0x8c570
movq (%r14), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x5c385
addq $0x20, %rdi
callq 0xb7d0
movq (%r14), %rax
movq 0x18(%rax), %rbx
leaq 0xe16b(%rip), %rsi      # 0x6a488
movl $0xc, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x11312(%rip), %rsi     # 0x6d643
movl $0x11, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x11326(%rip), %rsi     # 0x6d66b
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_O1/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 %rdi, %r14
movq $0x0, 0x60(%rdi)
movq 0x68(%rdi), %rax
movq 0x18(%rax), %r15
addq $0x8, %rax
cmpq %rax, %r15
je 0x5c589
leaq 0x18(%rsp), %rbp
movq 0x20(%r15), %r13
movq %rbp, %r12
movq %rbp, 0x8(%rsp)
movq 0x8(%r13), %rsi
movq 0x10(%r13), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x1d19a
movq %rbx, %rdi
leaq 0xdd6d(%rip), %rsi      # 0x6a24a
callq 0xb110
movl %eax, %ebp
testl %eax, %eax
je 0x5c4ec
xorl %ebx, %ebx
jmp 0x5c525
leaq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x90(%r13), %rsi
movq 0x98(%r13), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x1d19a
movq %rbx, %rdi
movq (%rsp), %rsi
callq 0xb110
testl %eax, %eax
sete %bl
testl %ebp, %ebp
movq %r12, %rbp
jne 0x5c548
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x5c548
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb510
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x5c55f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
testb %bl, %bl
jne 0x5c581
movq %r15, %rdi
callq 0xb600
movq %rax, %r15
movq 0x68(%r14), %rax
addq $0x8, %rax
cmpq %rax, %r15
jne 0x5c4af
jmp 0x5c589
movq 0x30(%r13), %rax
movq %rax, 0x60(%r14)
cmpq $0x0, 0x60(%r14)
je 0x5c59e
movq %r14, %rdi
movq (%rsp), %rsi
callq 0x5e1b2
jmp 0x5c5a0
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x5c5c9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
movq %r14, %rdi
callq 0xb9c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xea96(%rip), %rsi      # 0x6b08c
movl $0x1, %edx
callq 0x5e214
leaq 0x2ee89(%rip), %rax     # 0x8b490
movq %rax, (%rbx)
movl $0x48, %edi
callq 0xb500
movq %rax, %r14
movq %rax, %rdi
callq 0x60c20
movq %r14, 0x90(%rbx)
movl $0x30, %edi
callq 0xb500
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x62e4c
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 0x5c673
jmp 0x5c67a
movq %rax, %r15
movl $0x48, %esi
movq %r14, %rdi
callq 0xb510
jmp 0x5c67d
movq %rax, %r15
movq %rbx, %rdi
callq 0x5e27a
movq %r15, %rdi
callq 0xb9c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5ea44
testb %al, %al
je 0x5c777
movq 0x48(%r14), %rax
testq %rax, %rax
je 0x5c724
movq 0x30(%r14), %rcx
movq 0x50(%r14), %rdx
movq %rax, 0x20(%rcx)
movq %rdx, 0x28(%rcx)
cmpq $0x1, %rbx
jne 0x5c746
movq 0x58(%r14), %rax
testq %rax, %rax
je 0x5c746
movq 0x60(%r14), %rcx
movq 0x90(%r14), %rdx
movq %rax, 0x10(%rdx)
movq %rcx, 0x18(%rdx)
movq 0x90(%r14), %rdi
movq 0x2f87c(%rip), %rax     # 0x8bfd0
movq (%rax), %rdx
movq 0x2f842(%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
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5c7a8
movq 0x90(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
cmpq $0x0, 0x48(%rbx)
je 0x5c7ba
movq 0x30(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movq %rbx, %rdi
popq %rbx
jmp 0x5ea6c
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1bdd6
leaq 0x10cad(%rip), %rcx     # 0x6d72a
movl $0x9, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xb700
movl %eax, %ebx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5caa9
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xb510
testl %ebx, %ebx
sete %al
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5cad2
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/node/node_tcp.cc
// Function: scdc_nodeport_tcp::scdc_nodeport_tcp()
scdc_nodeport_tcp::scdc_nodeport_tcp()
  :scdc_nodeport("tcp", SCDC_NODEPORT_START_LOOP_UNTIL_CANCEL|SCDC_NODEPORT_START_ASYNC_UNTIL_CANCEL), port(NODE_TCP_PORT_DEFAULT)
{
  transport = new scdc_transport_tcp();

  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 %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0xef3a(%rip), %rsi      # 0x6ba27
movl $0x5, %edx
callq 0x5e214
leaq 0x2e9fa(%rip), %rax     # 0x8b4f8
movq %rax, (%rbx)
leaq 0xa8(%rbx), %r13
movq %r13, 0x98(%rbx)
movq $0x0, 0xa0(%rbx)
movb $0x0, 0xa8(%rbx)
movl $0x5cdc, 0xb8(%rbx)     # imm = 0x5CDC
movl $0x48, %edi
callq 0xb500
movq %rax, %r15
movq %rax, %rdi
callq 0x61250
movq %r15, 0x90(%rbx)
movl $0x30, %edi
callq 0xb500
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x62e4c
movq 0x90(%rbx), %rax
movq %r12, 0x8(%rax)
movq %r12, 0x30(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x30, %esi
movq %r12, %rdi
jmp 0x5cb92
jmp 0x5cb99
movq %rax, %r14
movl $0x48, %esi
movq %r15, %rdi
callq 0xb510
jmp 0x5cb9c
movq %rax, %r14
movq 0x98(%rbx), %rdi
cmpq %r13, %rdi
je 0x5cbb4
movq (%r13), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0x5e27a
movq %r14, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/node/node_tcp.cc
// Function: scdc_nodeport_tcp::open(char const*, scdc_args*)
bool scdc_nodeport_tcp::open(const char *conf, scdc_args *args)
{
  SCDC_TRACE("open: conf: '" << conf << "'");

  bool ret = true;

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

  } else
  {
    scdc_transport_tcp *transport_tcp = static_cast<scdc_transport_tcp *>(transport);

    SCDC_TRACE("open: address: '" << address << "', port: '" << port << "'");

    if (!transport_tcp->open(address.c_str(), port))
    {
      SCDC_FAIL("open: opening TCP transport");
      ret = false;
      goto do_close;
    }

do_close:
    if (!ret) scdc_nodeport::close();
  }

  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x5e84c
testb %al, %al
je 0x5cf42
movq 0x90(%rbx), %rdi
movq 0x98(%rbx), %rsi
movl 0xb8(%rbx), %edx
movq (%rdi), %rax
callq *0xf8(%rax)
movl %eax, %ebp
testb %al, %al
jne 0x5cfd4
leaq 0x2f6cd(%rip), %r15     # 0x8c570
movq (%r15), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x5cf2c
addq $0x20, %rdi
callq 0xb7d0
movq (%r15), %rax
movq 0x8(%rax), %r14
leaq 0xd2c4(%rip), %rsi      # 0x6a188
movl $0xb, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x107e9(%rip), %rsi     # 0x6d6c1
movl $0xe, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x10889(%rip), %rsi     # 0x6d775
movl $0x1b, %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
testb %bpl, %bpl
jne 0x5cfd4
movq %rbx, %rdi
callq 0x5ea3e
jmp 0x5cfd4
leaq 0x2f627(%rip), %r14     # 0x8c570
movq (%r14), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x5cfd2
addq $0x20, %rdi
callq 0xb7d0
movq (%r14), %rax
movq 0x8(%rax), %rbx
leaq 0xd21e(%rip), %rsi      # 0x6a188
movl $0xb, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x10743(%rip), %rsi     # 0x6d6c1
movl $0xe, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0xeb9b(%rip), %rsi      # 0x6bb2d
movl $0x12, %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 %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/node/node_tcp.cc
// Function: scdc_nodeport_tcp::start(long long)
bool scdc_nodeport_tcp::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);
  }

  if (max_connections >= 0) transport->set_max_connections(max_connections);

  scdc_transport_tcp *transport_tcp = static_cast<scdc_transport_tcp *>(transport);

  return transport_tcp->start(mode);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x5ea44
testb %al, %al
je 0x5d078
movq 0x48(%r14), %rax
testq %rax, %rax
je 0x5d028
movq 0x30(%r14), %rcx
movq 0x50(%r14), %rdx
movq %rax, 0x20(%rcx)
movq %rdx, 0x28(%rcx)
cmpq $0x1, %rbx
jne 0x5d04a
movq 0x58(%r14), %rax
testq %rax, %rax
je 0x5d04a
movq 0x60(%r14), %rcx
movq 0x90(%r14), %rdx
movq %rax, 0x10(%rdx)
movq %rcx, 0x18(%rdx)
movq 0x68(%r14), %rax
testq %rax, %rax
js 0x5d05e
movq 0x90(%r14), %rcx
movq %rax, 0x20(%rcx)
movq 0x90(%r14), %rdi
movq (%rdi), %rax
movq 0x20(%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
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/node/node_tcp.cc
// Function: scdc_nodeport_tcp::stop()
bool scdc_nodeport_tcp::stop()
{
  scdc_transport_tcp *transport_tcp = static_cast<scdc_transport_tcp *>(transport);

  transport_tcp->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 0x5d0a8
movq 0x90(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
cmpq $0x0, 0x48(%rbx)
je 0x5d0ba
movq 0x30(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movq %rbx, %rdi
popq %rbx
jmp 0x5ea6c
nop
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/node/node_tcp.cc
// Function: scdc_nodeconn_tcp::scdc_nodeconn_tcp()
scdc_nodeconn_tcp::scdc_nodeconn_tcp()
  :scdc_nodeconn("tcp")
{
  transport = new scdc_transport_tcp();

  scdc_compcoup_transport *compcoup_transport = new scdc_compcoup_transport(transport);

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

  transport_connection = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xe929(%rip), %rsi      # 0x6ba27
callq 0x5e0fc
leaq 0x2e43e(%rip), %rax     # 0x8b548
movq %rax, (%rbx)
movl $0x48, %edi
callq 0xb500
movq %rax, %r14
movq %rax, %rdi
callq 0x61250
movq %r14, 0x68(%rbx)
movl $0x30, %edi
callq 0xb500
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x62e4c
movq 0x68(%rbx), %rax
movq %r12, 0x8(%rax)
movq %r12, 0x60(%rbx)
movq $0x0, 0x70(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
movl $0x30, %esi
movq %r12, %rdi
jmp 0x5d178
jmp 0x5d17f
movq %rax, %r15
movl $0x48, %esi
movq %r14, %rdi
callq 0xb510
jmp 0x5d182
movq %rax, %r15
movq %rbx, %rdi
callq 0x5e16e
movq %r15, %rdi
callq 0xb9c0