LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movb $0x1, -0x29(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x8c038
movq -0x18(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0xcbc0
movq -0xc0(%rbp), %rsi
movq -0xb8(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x27820
jmp 0x8bebd
leaq -0x50(%rbp), %rdi
leaq 0x1b614(%rip), %rsi     # 0xa74dc
callq 0x25b80
movb %al, -0xc1(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xc3e0
leaq -0x51(%rbp), %rdi
callq 0xc730
movb -0xc1(%rbp), %al
testb $0x1, %al
jne 0x8bef4
jmp 0x8bfa5
jmp 0x8bef6
jmp 0x8bef8
movq -0xb0(%rbp), %rsi
movq -0x18(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0x88(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x8c210
movq -0xe0(%rbp), %rdi
callq 0xc260
movq -0xd8(%rbp), %rdi
movq %rax, %rdx
leaq 0x1c4d4(%rip), %rsi     # 0xa840e
xorl %eax, %eax
callq 0x47060
movq %rax, -0xd0(%rbp)
jmp 0x8bf4a
movq -0xd0(%rbp), %rax
cmpq $0x1, %rax
sete %al
andb $0x1, %al
movb %al, -0x29(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xc3e0
jmp 0x8c036
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x51(%rbp), %rdi
callq 0xc730
jmp 0x8c046
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xc3e0
jmp 0x8c046
jmp 0x8bfa7
jmp 0x8bfa9
movq -0xb0(%rbp), %rsi
movq -0x18(%rbp), %rax
movq %rax, -0xf0(%rbp)
leaq -0xa8(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x8c210
movq -0xf8(%rbp), %rdi
callq 0xc260
movq -0xf0(%rbp), %rdi
movq %rax, %rdx
leaq 0x1c6e1(%rip), %rsi     # 0xa86cc
xorl %eax, %eax
callq 0x47060
movq %rax, -0xe8(%rbp)
jmp 0x8bffb
movq -0xe8(%rbp), %rax
cmpq $0x1, %rax
sete %al
andb $0x1, %al
movb %al, -0x29(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0xc3e0
jmp 0x8c036
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0xc3e0
jmp 0x8c046
jmp 0x8c038
movb -0x29(%rbp), %al
andb $0x1, %al
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0xcba0
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movb $0x1, -0x29(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x8c110
jmp 0x8c088
jmp 0x8c08a
movq -0x68(%rbp), %rsi
movq -0x20(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x8c210
movq -0x88(%rbp), %rdi
callq 0xc260
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc260
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rdx
movq %rax, %rcx
leaq 0x1c3c6(%rip), %rsi     # 0xa8497
xorl %eax, %eax
callq 0x47200
movq %rax, -0x70(%rbp)
jmp 0x8c0de
movq -0x70(%rbp), %rax
cmpq $0x1, %rax
sete %al
andb $0x1, %al
movb %al, -0x29(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xc3e0
jmp 0x8c110
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xc3e0
jmp 0x8c11e
movb -0x29(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0xcba0
nopw (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_jobrun_relay.cc
// Function: scdc_dataprov_jobrun_relay::close(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov_jobrun_relay::close(scdc_result &result)
{
  SCDC_TRACE("close:");

  bool ret = scdc_dataprov_relay::close(result);

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

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x8d1ea
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5e090
andb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0x8d1fe
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x8d231
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0xc270
movq -0x68(%rbp), %rdi
leaq 0x1934f(%rip), %rsi     # 0xa65a4
callq 0x25b80
movb %al, -0x59(%rbp)
jmp 0x8d25f
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x8d283
jmp 0x8d268
movq -0x58(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x8d340
movb %al, -0x69(%rbp)
jmp 0x8d27a
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x8d283
jmp 0x8d2dc
jmp 0x8d285
jmp 0x8d287
jmp 0x8d289
movl $0x40, %edi
callq 0xc690
movq %rax, -0x78(%rbp)
jmp 0x8d299
movq -0x58(%rbp), %rsi
movq -0x78(%rbp), %rdi
callq 0x90fb0
jmp 0x8d2a8
movq -0x78(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x8d301
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x8d32b
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
movl $0x40, %esi
callq 0xc6a0
jmp 0x8d32b
jmp 0x8d2de
jmp 0x8d2e0
jmp 0x8d2e2
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x32c00
movq %rax, -0x80(%rbp)
jmp 0x8d2f9
movq -0x80(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x8d303
jmp 0x8d305
jmp 0x8d307
movq -0x20(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xc3e0
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0xc3e0
movq -0x48(%rbp), %rdi
callq 0xcba0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x8d3be
movb $0x0, -0x19(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x8d3d5
callq 0xc770
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rax), %rdi
leaq 0x45f91(%rip), %rsi     # 0xd3378
callq 0x60040
testb $0x1, %al
jne 0x8d3f2
jmp 0x8d414
jmp 0x8d3f4
jmp 0x8d3f6
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x8d40e
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movb $0x1, -0x19(%rbp)
jmp 0x8d42e
jmp 0x8d416
jmp 0x8d418
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x33240
andb $0x1, %al
movb %al, -0x19(%rbp)
jmp 0x8d430
jmp 0x8d432
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd0(%rbp)
jmp 0x8d95c
leaq -0x48(%rbp), %rdi
callq 0xc960
movq -0xd0(%rbp), %rdi
addq $0xf8, %rdi
callq 0x34950
movq %rax, -0x50(%rbp)
movq -0xd0(%rbp), %rdi
addq $0xf8, %rdi
callq 0x349b0
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x34980
testb $0x1, %al
jne 0x8d9a9
jmp 0x8daba
leaq -0x50(%rbp), %rdi
callq 0x349e0
movq %rax, %rsi
leaq 0x1b9e5(%rip), %rdx     # 0xa93a1
leaq -0xb8(%rbp), %rdi
callq 0x31740
jmp 0x8d9ca
leaq -0x50(%rbp), %rdi
callq 0x349e0
movq %rax, %rdx
addq $0x20, %rdx
leaq -0x98(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x34a30
jmp 0x8d9ef
leaq 0x18e73(%rip), %rdx     # 0xa6869
leaq -0x78(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x2eef0
jmp 0x8da08
leaq -0x48(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xc8a0
jmp 0x8da17
leaq -0x78(%rbp), %rdi
callq 0xc3e0
leaq -0x98(%rbp), %rdi
callq 0xc3e0
leaq -0xb8(%rbp), %rdi
callq 0xc3e0
leaq -0x50(%rbp), %rdi
callq 0x34a80
jmp 0x8d97c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x8db14
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x8daac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x8daa0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xc3e0
leaq -0x98(%rbp), %rdi
callq 0xc3e0
leaq -0xb8(%rbp), %rdi
callq 0xc3e0
jmp 0x8db14
leaq -0x48(%rbp), %rdi
callq 0xc460
cmpq $0x0, %rax
jbe 0x8daef
leaq -0x48(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0xc460
movq -0xd8(%rbp), %rdi
movq %rax, %rsi
decq %rsi
callq 0xc940
jmp 0x8daed
jmp 0x8daef
movq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xc070
jmp 0x8dafe
leaq -0x48(%rbp), %rdi
callq 0xc3e0
movb $0x1, %al
andb $0x1, %al
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x48(%rbp), %rdi
callq 0xc3e0
movq -0xc0(%rbp), %rdi
callq 0xcba0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1e8(%rbp)
jmp 0x8db5c
leaq -0x1b0(%rbp), %rdi
callq 0xc470
movq -0x1e8(%rbp), %rdi
leaq -0x1a0(%rbp), %rax
movq %rax, -0x1f8(%rbp)
addq $0xf8, %rdi
callq 0x34f40
movq -0x1f8(%rbp), %rdi
movq %rax, %rsi
callq 0xc120
movq %rax, -0x1f0(%rbp)
jmp 0x8dba1
movq -0x1f0(%rbp), %rdi
leaq 0x1b7fc(%rip), %rsi     # 0xa93ab
callq 0xc670
jmp 0x8dbb6
leaq -0x1e0(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
callq 0xc650
jmp 0x8dbcb
movq -0x28(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
callq 0xc850
leaq -0x1e0(%rbp), %rdi
callq 0xc3e0
leaq -0x1b0(%rbp), %rdi
callq 0xc4b0
movb $0x1, %al
andb $0x1, %al
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0xc4b0
movq -0x1b8(%rbp), %rdi
callq 0xcba0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0xf8, %rdi
movq -0x18(%rbp), %rsi
callq 0x34e40
movq -0x38(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0xf8, %rdi
callq 0x349b0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x34ab0
testb $0x1, %al
jne 0x8e047
jmp 0x8e04d
movb $0x0, -0x1(%rbp)
jmp 0x8e06a
leaq -0x28(%rbp), %rdi
callq 0x349e0
movq %rax, %rsi
addq $0x20, %rsi
movq -0x20(%rbp), %rdi
callq 0xc070
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x8ef10
movq -0xb8(%rbp), %rsi
addq $0x18, %rsi
leaq -0x50(%rbp), %rdi
callq 0x316b0
testb $0x1, %al
jne 0x91ec1
jmp 0x91ed1
movb $0x1, -0x1(%rbp)
movl $0x1, -0x54(%rbp)
jmp 0x9203e
movq -0xb8(%rbp), %rdi
callq 0x91700
jmp 0x91edf
leaq -0x89(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0xcbc0
movq -0xc0(%rbp), %rdx
leaq 0x146a4(%rip), %rsi     # 0xa65a4
leaq -0x88(%rbp), %rdi
callq 0x27820
jmp 0x91f0e
movq -0xb8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x42e20
jmp 0x91f23
leaq -0x88(%rbp), %rdi
callq 0xc3e0
leaq -0x89(%rbp), %rdi
callq 0xc730
leaq -0x50(%rbp), %rdi
callq 0xc460
cmpq $0x0, %rax
jne 0x91fa2
movb $0x1, -0x1(%rbp)
movl $0x1, -0x54(%rbp)
jmp 0x9203e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x92055
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x91f91
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xc3e0
leaq -0x89(%rbp), %rdi
callq 0xc730
jmp 0x92055
leaq -0xb0(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xc270
jmp 0x91fb4
movq -0xb8(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
movl $0x1, %edx
callq 0x913a0
movb %al, -0xc1(%rbp)
jmp 0x91fd4
movb -0xc1(%rbp), %al
xorb $-0x1, %al
movb %al, -0xc2(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0xc3e0
movb -0xc2(%rbp), %al
testb $0x1, %al
jne 0x91ffa
jmp 0x92021
movb $0x0, -0x1(%rbp)
movl $0x1, -0x54(%rbp)
jmp 0x9203e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0xc3e0
jmp 0x92055
movq -0xb8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x42e20
jmp 0x92033
movb $0x1, -0x1(%rbp)
movl $0x1, -0x54(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xc3e0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
leaq -0x50(%rbp), %rdi
callq 0xc3e0
movq -0x60(%rbp), %rdi
callq 0xcba0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
jmp 0x92d86
movq -0x20(%rbp), %rdi
callq 0xc8f0
movq -0x18(%rbp), %rdi
movl $0x4, %esi
leaq -0x28(%rbp), %rdx
xorl %ecx, %ecx
callq 0x4d6c0
cmpq $0x0, %rax
jne 0x92e35
jmp 0x92daf
leaq 0x418f2(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e8e0
cmpq $0x0, %rax
je 0x92e2d
leaq 0x418dd(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e900
leaq 0x418ce(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e8e0
movq %rax, %rdi
leaq 0x136bc(%rip), %rsi     # 0xa64a8
callq 0xc670
movq %rax, %rdi
leaq 0x16894(%rip), %rsi     # 0xa968f
callq 0xc670
movq %rax, %rdi
leaq 0x16897(%rip), %rsi     # 0xa96a1
callq 0xc670
movq %rax, %rdi
movq 0x411a7(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x41883(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e920
jmp 0x92e2f
movb $0x0, -0x1(%rbp)
jmp 0x92e48
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
callq 0xc920
jmp 0x92e44
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/node/node_direct.cc
// Function: scdc_nodeport_direct::supported(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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x92e72
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xcbc0
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x27820
jmp 0x92e9a
leaq 0x134bf(%rip), %rcx     # 0xa6360
xorl %eax, %eax
movl %eax, %esi
leaq -0x38(%rbp), %rdi
movl $0x5, %edx
callq 0xc910
movl %eax, -0x64(%rbp)
jmp 0x92eb8
movl -0x64(%rbp), %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x65(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xc3e0
leaq -0x39(%rbp), %rdi
callq 0xc730
movb -0x65(%rbp), %al
andb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0x92ee0
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x92f0e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xc3e0
leaq -0x39(%rbp), %rdi
callq 0xc730
movq -0x48(%rbp), %rdi
callq 0xcba0
// File: mh0fm4[P]SCDC/src/components/node/node_direct.cc
// Function: scdc_nodeport_direct::open(char const*, scdc_args*)
bool scdc_nodeport_direct::open(const char *conf, scdc_args *args)
{
  const char *s;

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

  id = s;

  return scdc_nodeport::open(conf, args);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movl $0x4, %esi
leaq -0x28(%rbp), %rdx
xorl %ecx, %ecx
callq 0x4d6c0
cmpq $0x0, %rax
jne 0x93132
jmp 0x930ac
leaq 0x415f5(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e8e0
cmpq $0x0, %rax
je 0x9312a
leaq 0x415e0(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e900
leaq 0x415d1(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e8e0
movq %rax, %rdi
leaq 0x133bf(%rip), %rsi     # 0xa64a8
callq 0xc670
movq %rax, %rdi
leaq 0x16597(%rip), %rsi     # 0xa968f
callq 0xc670
movq %rax, %rdi
leaq 0x165b0(%rip), %rsi     # 0xa96b7
callq 0xc670
movq %rax, %rdi
movq 0x40eaa(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x41586(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e920
jmp 0x9312c
movb $0x0, -0x1(%rbp)
jmp 0x9315c
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x90, %rdi
callq 0xc920
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x96810
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movq $0x0, 0x60(%rax)
movq 0x68(%rax), %rdi
callq 0x53d60
movq %rax, -0x20(%rbp)
movq -0x90(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x93540
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x54a40
testb $0x1, %al
jne 0x9339d
jmp 0x934ca
leaq -0x20(%rbp), %rdi
callq 0x53d90
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x93570
movq -0xa0(%rbp), %rdi
movb $0x0, -0x81(%rbp)
leaq 0x12e9c(%rip), %rsi     # 0xa6272
callq 0x25b80
movb %al, -0x91(%rbp)
jmp 0x933e3
movb -0x91(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0xa1(%rbp)
jne 0x933f8
jmp 0x93431
movq -0x30(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x935a0
jmp 0x93407
movb $0x1, -0x81(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x25b80
movb %al, -0xa2(%rbp)
jmp 0x93423
movb -0xa2(%rbp), %al
movb %al, -0xa1(%rbp)
jmp 0x93431
movb -0xa1(%rbp), %al
movb %al, -0xa3(%rbp)
testb $0x1, -0x81(%rbp)
jne 0x93448
jmp 0x93451
leaq -0x80(%rbp), %rdi
callq 0xc3e0
leaq -0x50(%rbp), %rdi
callq 0xc3e0
movb -0xa3(%rbp), %al
testb $0x1, %al
jne 0x93466
jmp 0x934ba
movq -0x30(%rbp), %rdi
callq 0x935e0
movq %rax, %rcx
movq -0x90(%rbp), %rax
movq %rcx, 0x60(%rax)
jmp 0x934ca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x934af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
testb $0x1, -0x81(%rbp)
jne 0x934a4
jmp 0x934ad
leaq -0x80(%rbp), %rdi
callq 0xc3e0
jmp 0x934af
leaq -0x50(%rbp), %rdi
callq 0xc3e0
jmp 0x93501
jmp 0x934bc
leaq -0x20(%rbp), %rdi
callq 0x93600
jmp 0x93373
movq -0x90(%rbp), %rax
cmpq $0x0, 0x60(%rax)
jne 0x934de
movb $0x0, -0x1(%rbp)
jmp 0x934f3
movq -0x90(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x95e60
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0xcba0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
leaq 0x139d8(%rip), %rsi     # 0xa7063
movl $0x1, %edx
callq 0x95f90
movq -0x30(%rbp), %rax
leaq 0x3fdf8(%rip), %rcx     # 0xd3498
movq %rcx, (%rax)
movl $0x48, %edi
callq 0xc690
movq %rax, -0x28(%rbp)
jmp 0x936b3
movq -0x28(%rbp), %rdi
callq 0x9a870
jmp 0x936be
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x90(%rax)
movl $0x30, %edi
callq 0xc690
movq %rax, -0x38(%rbp)
jmp 0x936dd
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x90(%rax), %rsi
callq 0x9d760
jmp 0x936f3
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x90(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x93a30
jmp 0x93711
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x30(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x93767
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x48, %esi
callq 0xc6a0
jmp 0x93767
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x30, %esi
callq 0xc6a0
movq -0x30(%rbp), %rdi
callq 0x96070
movq -0x10(%rbp), %rdi
callq 0xcba0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x18(%rbp), %rsi
callq 0x96b50
testb $0x1, %al
jne 0x9389e
movb $0x0, -0x1(%rbp)
jmp 0x93929
movq -0x30(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x938c6
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq 0x48(%rax), %rsi
movq 0x50(%rax), %rdx
callq 0x93a50
cmpq $0x1, -0x18(%rbp)
jne 0x938f0
movq -0x30(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x938f0
movq -0x30(%rbp), %rax
movq 0x90(%rax), %rdi
movq 0x58(%rax), %rsi
movq 0x60(%rax), %rdx
callq 0x93a80
movq -0x30(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq 0x406c2(%rip), %rax     # 0xd3fd0
movq (%rax), %rdx
movq 0x40698(%rip), %rax     # 0xd3fb0
movq (%rax), %rcx
movq (%rdi), %rax
callq *0xf8(%rax)
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x90(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x9398b
movq -0x20(%rbp), %rax
movq 0x90(%rax), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x93a80
movq -0x20(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x939b2
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x93a50
movq -0x20(%rbp), %rdi
callq 0x96bc0
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x93da2
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xcbc0
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x27820
jmp 0x93dca
leaq 0x159a5(%rip), %rcx     # 0xa9776
xorl %eax, %eax
movl %eax, %esi
leaq -0x38(%rbp), %rdi
movl $0x9, %edx
callq 0xc910
movl %eax, -0x64(%rbp)
jmp 0x93de8
movl -0x64(%rbp), %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x65(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xc3e0
leaq -0x39(%rbp), %rdi
callq 0xc730
movb -0x65(%rbp), %al
andb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0x93e10
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x93e3e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xc3e0
leaq -0x39(%rbp), %rdi
callq 0xc730
movq -0x48(%rbp), %rdi
callq 0xcba0
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
leaq 0x13b94(%rip), %rsi     # 0xa79ff
movl $0x5, %edx
callq 0x95f90
movq -0x30(%rbp), %rdi
leaq 0x3f680(%rip), %rax     # 0xd3500
movq %rax, (%rdi)
addq $0x98, %rdi
movq %rdi, -0x38(%rbp)
callq 0xc960
movq -0x30(%rbp), %rax
movl $0x5cdc, 0xb8(%rax)     # imm = 0x5CDC
movl $0x48, %edi
callq 0xc690
movq %rax, -0x28(%rbp)
jmp 0x93eb1
movq -0x28(%rbp), %rdi
callq 0x9b360
jmp 0x93ebc
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x90(%rax)
movl $0x30, %edi
callq 0xc690
movq %rax, -0x40(%rbp)
jmp 0x93edb
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x90(%rax), %rsi
callq 0x9d760
jmp 0x93ef1
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x90(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x93a30
jmp 0x93f0f
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x30(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x93f65
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x48, %esi
callq 0xc6a0
jmp 0x93f65
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x30, %esi
callq 0xc6a0
movq -0x38(%rbp), %rdi
callq 0xc3e0
movq -0x30(%rbp), %rdi
callq 0x96070
movq -0x10(%rbp), %rdi
callq 0xcba0
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x9426e
movq -0x30(%rbp), %rdi
movb $0x1, -0x19(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x96810
testb $0x1, %al
jne 0x94316
jmp 0x9428d
leaq 0x40414(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
cmpq $0x0, %rax
je 0x9430b
leaq 0x403ff(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25800
leaq 0x403f0(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
movq %rax, %rdi
leaq 0x11ee6(%rip), %rsi     # 0xa61b0
callq 0xc670
movq %rax, %rdi
leaq 0x15434(%rip), %rsi     # 0xa970d
callq 0xc670
movq %rax, %rdi
leaq 0x1381d(%rip), %rsi     # 0xa7b05
callq 0xc670
movq %rax, %rdi
movq 0x3fcc9(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x403a5(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25820
jmp 0x9430d
movb $0x0, -0x19(%rbp)
jmp 0x943fc
movq -0x30(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x94327
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x98, %rdi
callq 0xc260
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movq -0x30(%rbp), %rax
movl 0xb8(%rax), %edx
movq (%rdi), %rax
callq *0xf8(%rax)
testb $0x1, %al
jne 0x943e9
jmp 0x94363
leaq 0x4033e(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
cmpq $0x0, %rax
je 0x943e1
leaq 0x40329(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25800
leaq 0x4031a(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
movq %rax, %rdi
leaq 0x11e10(%rip), %rsi     # 0xa61b0
callq 0xc670
movq %rax, %rdi
leaq 0x1535e(%rip), %rsi     # 0xa970d
callq 0xc670
movq %rax, %rdi
leaq 0x15403(%rip), %rsi     # 0xa97c1
callq 0xc670
movq %rax, %rdi
movq 0x3fbf3(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x402cf(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25820
jmp 0x943e3
movb $0x0, -0x19(%rbp)
jmp 0x943eb
jmp 0x943eb
testb $0x1, -0x19(%rbp)
jne 0x943fa
movq -0x30(%rbp), %rdi
callq 0x96b20
jmp 0x943fc
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/node/node_tcp.cc
// Function: scdc_nodeport_tcp::close()
void scdc_nodeport_tcp::close()
{
  SCDC_TRACE("open: close");

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

  transport_tcp->close();

  scdc_nodeport::close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x94426
movq -0x18(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x18(%rbp), %rdi
callq 0x96b20
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x18(%rbp), %rsi
callq 0x96b50
testb $0x1, %al
jne 0x9447e
movb $0x0, -0x1(%rbp)
jmp 0x94511
movq -0x30(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x944a6
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq 0x48(%rax), %rsi
movq 0x50(%rax), %rdx
callq 0x93a50
cmpq $0x1, -0x18(%rbp)
jne 0x944d0
movq -0x30(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x944d0
movq -0x30(%rbp), %rax
movq 0x90(%rax), %rdi
movq 0x58(%rax), %rsi
movq 0x60(%rax), %rdx
callq 0x93a80
movq -0x30(%rbp), %rax
cmpq $0x0, 0x68(%rax)
jl 0x944ef
movq -0x30(%rbp), %rax
movq 0x90(%rax), %rdi
movq 0x68(%rax), %rsi
callq 0x94b50
movq -0x30(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
callq *0x20(%rax)
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
leaq 0x133d4(%rip), %rsi     # 0xa79ff
callq 0x95d50
movq -0x30(%rbp), %rax
leaq 0x3ef15(%rip), %rcx     # 0xd3550
movq %rcx, (%rax)
movl $0x48, %edi
callq 0xc690
movq %rax, -0x28(%rbp)
jmp 0x9464e
movq -0x28(%rbp), %rdi
callq 0x9b360
jmp 0x94659
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x68(%rax)
movl $0x30, %edi
callq 0xc690
movq %rax, -0x38(%rbp)
jmp 0x94675
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x68(%rax), %rsi
callq 0x9d760
jmp 0x94688
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x68(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x93a30
jmp 0x946a3
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x60(%rax)
movq $0x0, 0x70(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x94701
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x48, %esi
callq 0xc6a0
jmp 0x94701
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x30, %esi
callq 0xc6a0
movq -0x30(%rbp), %rdi
callq 0x95e10
movq -0x10(%rbp), %rdi
callq 0xcba0
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/node/node_tcp.cc
// Function: scdc_nodeconn_tcp::close()
void scdc_nodeconn_tcp::close()
{
  SCDC_TRACE("close:");

  scdc_nodeconn::close();

  transport->disconnect(transport_connection);

  transport_connection = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x94ab6
movq -0x10(%rbp), %rdi
callq 0x95ea0
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdi
movq 0x70(%rax), %rsi
movq (%rdi), %rax
callq *0x70(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x70(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/node/node_uds.cc
// Function: scdc_nodeport_uds::authority(char const*, scdc_args*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_nodeport_uds::authority(const char *conf, scdc_args *args, std::string &auth)
{
  SCDC_TRACE("authority: conf: '" << conf << "'");

  auth.clear();

  const char *socketname;

  if (!args->get<const char *>(SCDC_ARGS_TYPE_CSTR, &socketname))
  {
    SCDC_FAIL("authority: failed to get socket name parameter!");
    return false;
  }

  auth = socketname;

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

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
jmp 0x94c46
movq -0x20(%rbp), %rdi
callq 0xc8f0
movq -0x18(%rbp), %rdi
movl $0x4, %esi
leaq -0x28(%rbp), %rdx
xorl %ecx, %ecx
callq 0x4d6c0
cmpq $0x0, %rax
jne 0x94cf5
jmp 0x94c6f
leaq 0x3fa32(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
cmpq $0x0, %rax
je 0x94ced
leaq 0x3fa1d(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25800
leaq 0x3fa0e(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
movq %rax, %rdi
leaq 0x11504(%rip), %rsi     # 0xa61b0
callq 0xc670
movq %rax, %rdi
leaq 0x14b7b(%rip), %rsi     # 0xa9836
callq 0xc670
movq %rax, %rdi
leaq 0x14b7b(%rip), %rsi     # 0xa9845
callq 0xc670
movq %rax, %rdi
movq 0x3f2e7(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x3f9c3(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25820
jmp 0x94cef
movb $0x0, -0x1(%rbp)
jmp 0x94d08
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
callq 0xc920
jmp 0x94d04
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/node/node_uds.cc
// Function: scdc_nodeport_uds::supported(char const*, scdc_args*)
bool scdc_nodeport_uds::supported(const char *uri, scdc_args *args)
{
  SCDC_TRACE("supported: uri: '" << uri << "'");

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

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

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x94d32
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xcbc0
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x27820
jmp 0x94d5a
leaq 0x14b14(%rip), %rcx     # 0xa9875
xorl %eax, %eax
movl %eax, %esi
leaq -0x38(%rbp), %rdi
movl $0x9, %edx
callq 0xc910
movl %eax, -0x64(%rbp)
jmp 0x94d78
movl -0x64(%rbp), %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x65(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xc3e0
leaq -0x39(%rbp), %rdi
callq 0xc730
movb -0x65(%rbp), %al
andb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0x94da0
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x94dce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xc3e0
leaq -0x39(%rbp), %rdi
callq 0xc730
movq -0x48(%rbp), %rdi
callq 0xcba0
// File: mh0fm4[P]SCDC/src/components/node/node_uds.cc
// Function: scdc_nodeport_uds::scdc_nodeport_uds()
scdc_nodeport_uds::scdc_nodeport_uds()
  :scdc_nodeport("uds", SCDC_NODEPORT_START_LOOP_UNTIL_CANCEL|SCDC_NODEPORT_START_ASYNC_UNTIL_CANCEL)
{
  transport = new scdc_transport_uds();

  scdc_compcoup_transport *compcoup_transport = new scdc_compcoup_transport(transport);

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

  socketfile = make_uds_socketfile(NODE_UDS_SOCKETNAME_DEFAULT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
leaq 0x12c0d(%rip), %rsi     # 0xa7a08
movl $0x5, %edx
callq 0x95f90
movq -0x58(%rbp), %rdi
leaq 0x3e7a8(%rip), %rax     # 0xd35b8
movq %rax, (%rdi)
addq $0x98, %rdi
movq %rdi, -0x50(%rbp)
callq 0xc960
movl $0x48, %edi
callq 0xc690
movq %rax, -0x48(%rbp)
jmp 0x94e33
movq -0x48(%rbp), %rdi
callq 0x9c3c0
jmp 0x94e3e
movq -0x58(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x90(%rax)
movl $0x30, %edi
callq 0xc690
movq %rax, -0x60(%rbp)
jmp 0x94e5d
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rax
movq 0x90(%rax), %rsi
callq 0x9d760
jmp 0x94e73
movq -0x58(%rbp), %rax
movq -0x60(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x90(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x93a30
jmp 0x94e91
movq -0x58(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x30(%rax)
leaq 0x14338(%rip), %rsi     # 0xa91dc
leaq -0x40(%rbp), %rdi
callq 0x94b70
jmp 0x94eaf
movq -0x58(%rbp), %rdi
addq $0x98, %rdi
leaq -0x40(%rbp), %rsi
callq 0xc850
leaq -0x40(%rbp), %rdi
callq 0xc3e0
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x94f16
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x48, %esi
callq 0xc6a0
jmp 0x94f16
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x30, %esi
callq 0xc6a0
movq -0x50(%rbp), %rdi
callq 0xc3e0
movq -0x58(%rbp), %rdi
callq 0x96070
movq -0x10(%rbp), %rdi
callq 0xcba0
nopw %cs:(%rax,%rax)