LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xb53f(%rip), %rsi      # 0x529d7
pushq $0x5
popq %rdx
callq 0x486e8
leaq 0x2d069(%rip), %rax     # 0x74510
movq %rax, (%rbx)
leaq 0xa8(%rbx), %rax
movq %rax, 0x98(%rbx)
andq $0x0, 0xa0(%rbx)
movb $0x0, 0xa8(%rbx)
movl $0x5cdc, 0xb8(%rbx)     # imm = 0x5CDC
pushq $0x48
popq %rdi
callq 0xb540
movq %rax, %r15
movq %rax, %rdi
callq 0x4acec
movq %r15, 0x90(%rbx)
pushq $0x30
popq %rdi
callq 0xb540
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x4c0e0
movq 0x90(%rbx), %rax
movq %r12, 0x8(%rax)
movq %r12, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
pushq $0x30
popq %rsi
movq %r12, %rdi
jmp 0x47532
jmp 0x47539
movq %rax, %r14
pushq $0x48
popq %rsi
movq %r15, %rdi
callq 0xb550
jmp 0x4753c
movq %rax, %r14
leaq 0x98(%rbx), %rdi
callq 0xb230
movq %rbx, %rdi
callq 0x4874a
movq %r14, %rdi
callq 0xb9a0
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/node/node_tcp.cc
// Function: scdc_nodeport_tcp::open_config_conf(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, scdc_args*, bool&)
bool scdc_nodeport_tcp::open_config_conf(const std::string &conf, scdc_args *args, bool &done)
{
  done = true;
  bool ret = true;

  if (conf == "address")
  {
    const char *a;

    if (args->get<const char *>(SCDC_ARGS_TYPE_CSTR, &a) == SCDC_ARG_REF_NULL)
    {
      SCDC_ERROR("open_config_conf: getting address");
      ret = false;

    } else
    {
      SCDC_TRACE("open_config_conf: address: '" << address << "'");
      address = a;
    }

  } else if (conf == "port")
  {
    if (args->get<int>(SCDC_ARGS_TYPE_INT, &port) == SCDC_ARG_REF_NULL)
    {
      SCDC_ERROR("open_config_conf: getting port");
      ret = false;

    } else
    {
      SCDC_TRACE("open_config_conf: port: " << port);
    }

  } else
  {
    done = false;
    ret = scdc_nodeport::open_config_conf(conf, args, done);
  }

  return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movb $0x1, (%rcx)
leaq 0xd16e(%rip), %rsi      # 0x5474e
movq %r12, %rdi
callq 0x19be0
testb %al, %al
je 0x47627
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x476b0
movq (%r14), %rdi
pushq $0x4
popq %rsi
movq %rsp, %rdx
callq *%rax
testq %rax, %rax
je 0x476b0
movq (%rsp), %rsi
addq $0x98, %rbx
movq %rbx, %rdi
callq 0xba40
movb $0x1, %al
jmp 0x47711
leaq 0xd142(%rip), %rsi      # 0x54770
movq %r12, %rdi
callq 0x19be0
testb %al, %al
je 0x4771d
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x47667
addq $0xb8, %rbx
movq (%r14), %rdi
pushq $0x1
popq %rsi
movq %rbx, %rdx
callq *%rax
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x47711
leaq 0x2df12(%rip), %rbx     # 0x75580
movq (%rbx), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x4770f
addq $0x20, %rdi
callq 0xb800
movq (%rbx), %rax
movq 0x18(%rax), %rdi
leaq 0x9df5(%rip), %rsi      # 0x51488
callq 0xb520
leaq 0xd022(%rip), %rsi      # 0x546c1
movq %rax, %rdi
callq 0xb520
leaq 0xd0a8(%rip), %rsi      # 0x54756
jmp 0x476f3
leaq 0x2dec9(%rip), %rbx     # 0x75580
movq (%rbx), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x4770f
addq $0x20, %rdi
callq 0xb800
movq (%rbx), %rax
movq 0x18(%rax), %rdi
leaq 0x9db0(%rip), %rsi      # 0x51488
callq 0xb520
leaq 0xcfdd(%rip), %rsi      # 0x546c1
movq %rax, %rdi
callq 0xb520
leaq 0xd041(%rip), %rsi      # 0x54734
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
movq (%rbx), %rdi
addq $0x20, %rdi
callq 0xb3e0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movb $0x0, (%r15)
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r15, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x48786
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x48b8c
testb %al, %al
je 0x477e4
movq 0x90(%rbx), %rdi
movq 0x98(%rbx), %rsi
movl 0xb8(%rbx), %edx
movq (%rdi), %rax
callq *0xf8(%rax)
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x47845
leaq 0x2ddfe(%rip), %r14     # 0x75580
movq (%r14), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x477da
addq $0x20, %rdi
callq 0xb800
movq (%r14), %rax
movq 0x8(%rax), %rdi
leaq 0x99e5(%rip), %rsi      # 0x51188
callq 0xb520
leaq 0xcf12(%rip), %rsi      # 0x546c1
movq %rax, %rdi
callq 0xb520
leaq 0xcfb7(%rip), %rsi      # 0x54775
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
movq (%r14), %rdi
addq $0x20, %rdi
callq 0xb3e0
movq %rbx, %rdi
callq 0x48cdc
jmp 0x47843
leaq 0x2dd95(%rip), %rbx     # 0x75580
movq (%rbx), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x47843
addq $0x20, %rdi
callq 0xb800
movq (%rbx), %rax
movq 0x8(%rax), %rdi
leaq 0x997c(%rip), %rsi      # 0x51188
callq 0xb520
leaq 0xcea9(%rip), %rsi      # 0x546c1
movq %rax, %rdi
callq 0xb520
leaq 0xb2b6(%rip), %rsi      # 0x52add
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
movq (%rbx), %rdi
addq $0x20, %rdi
callq 0xb3e0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/node/node_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 0x48ce2
testb %al, %al
je 0x478dd
movq 0x48(%r14), %rax
testq %rax, %rax
je 0x47894
movq 0x30(%r14), %rcx
movq 0x50(%r14), %rdx
movq %rax, 0x20(%rcx)
movq %rdx, 0x28(%rcx)
cmpq $0x1, %rbx
jne 0x478b6
movq 0x58(%r14), %rax
testq %rax, %rax
je 0x478b6
movq 0x60(%r14), %rcx
movq 0x90(%r14), %rdx
movq %rax, 0x10(%rdx)
movq %rcx, 0x18(%rdx)
movq 0x68(%r14), %rax
movq 0x90(%r14), %rdi
testq %rax, %rax
js 0x478ca
movq %rax, 0x20(%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
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4790e
movq 0x90(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
cmpq $0x0, 0x48(%rbx)
je 0x47920
movq 0x30(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movq %rbx, %rdi
popq %rbx
jmp 0x48d0a
nop
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/node/node_tcp.cc
// Function: scdc_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 0xb073(%rip), %rsi      # 0x529d7
callq 0x48604
leaq 0x2cbf0(%rip), %rax     # 0x74560
movq %rax, (%rbx)
pushq $0x48
popq %rdi
callq 0xb540
movq %rax, %r14
movq %rax, %rdi
callq 0x4acec
movq %r14, 0x68(%rbx)
pushq $0x30
popq %rdi
callq 0xb540
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x4c0e0
movq 0x68(%rbx), %rax
movq %r12, 0x8(%rax)
movq %r12, 0x60(%rbx)
andq $0x0, 0x70(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
pushq $0x30
popq %rsi
movq %r12, %rdi
jmp 0x479d3
jmp 0x479da
movq %rax, %r15
pushq $0x48
popq %rsi
movq %r14, %rdi
callq 0xb550
jmp 0x479dd
movq %rax, %r15
movq %rbx, %rdi
callq 0x48664
movq %r15, %rdi
callq 0xb9a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/node/node_tcp.cc
// Function: scdc_nodeconn_tcp::open(char const*)
bool scdc_nodeconn_tcp::open(const char *authority)
{
  SCDC_TRACE("open: connect to '" << authority << "'");

  stringlist sl(':', authority);

  string host = sl.front_pop();
  if (host.size() <= 0) host = NODE_TCP_HOST_DEFAULT;

  int port = NODE_TCP_PORT_DEFAULT;

  if (sl.size() >= 1)
  {
    sscanf(sl.front_pop().c_str(), "%d", &port);
  }

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

  transport_connection = transport_tcp->connect(host.c_str(), port);

  if (!transport_connection)
  {
    SCDC_FAIL("open: connect failed!");
    return false;
  }

  transport_connection->on_idle_handler = scdc_nodeconn_on_idle_close_handler;
  transport_connection->on_idle_data = this;

  return scdc_nodeconn::open(authority);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x30(%rsp), %r15
pushq $0x3a
popq %rsi
pushq $-0x1
popq %rcx
movq %r15, %rdi
movq %rbx, %rdx
callq 0x19b64
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x19ba0
cmpq $0x0, 0x18(%rsp)
jne 0x47a91
leaq 0xcd0a(%rip), %rsi      # 0x54791
leaq 0x10(%rsp), %rdi
callq 0xba40
movl $0x5cdc, 0xc(%rsp)      # imm = 0x5CDC
cmpq $0x0, 0x40(%rsp)
je 0x47adc
leaq 0x58(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x19ba0
leaq 0x58(%rsp), %r15
movq (%r15), %rdi
leaq 0xcc68(%rip), %rsi      # 0x54727
leaq 0xc(%rsp), %r12
movq %r12, %rdx
xorl %eax, %eax
callq 0xb510
movq %r15, %rdi
callq 0xb230
movl (%r12), %edx
jmp 0x47ae1
movl $0x5cdc, %edx           # imm = 0x5CDC
movq 0x68(%r14), %rdi
movq 0x10(%rsp), %rsi
movq (%rdi), %rax
callq *0x100(%rax)
movq %rax, 0x70(%r14)
testq %rax, %rax
je 0x47b1a
leaq 0xba5(%rip), %rcx       # 0x486a8
movq %rcx, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4868a
movl %eax, %ebx
jmp 0x47b7b
leaq 0x2da5f(%rip), %rbx     # 0x75580
movq (%rbx), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x47b79
addq $0x20, %rdi
callq 0xb800
movq (%rbx), %rax
movq 0x8(%rax), %rdi
leaq 0x9646(%rip), %rsi      # 0x51188
callq 0xb520
leaq 0xcb73(%rip), %rsi      # 0x546c1
movq %rax, %rdi
callq 0xb520
leaq 0xcc3e(%rip), %rsi      # 0x5479b
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
movq (%rbx), %rdi
addq $0x20, %rdi
callq 0xb3e0
xorl %ebx, %ebx
leaq 0x10(%rsp), %rdi
callq 0xb230
leaq 0x30(%rsp), %rdi
callq 0x19ef4
movl %ebx, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x47ba6
jmp 0x47ba6
movq %rax, %rbx
jmp 0x47bb3
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xb230
leaq 0x30(%rsp), %rdi
callq 0x19ef4
movq %rbx, %rdi
callq 0xb9a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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>>&)
void scdc_nodeport_uds::close()
{
  SCDC_TRACE("open: close");

  scdc_transport_uds *transport_uds = static_cast<scdc_transport_uds *>(transport);

  transport_uds->close();

  scdc_nodeport::close();
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
andq $0x0, 0x8(%rdx)
movq (%rdx), %rax
movb $0x0, (%rax)
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x47c79
movq %rdx, %rbx
movq (%rsi), %rdi
pushq $0x4
popq %rsi
leaq 0x8(%rsp), %rdx
callq *%rax
testq %rax, %rax
je 0x47c79
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xba40
movb $0x1, %al
jmp 0x47cda
leaq 0x2d900(%rip), %rbx     # 0x75580
movq (%rbx), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x47cd8
addq $0x20, %rdi
callq 0xb800
movq (%rbx), %rax
movq 0x8(%rax), %rdi
leaq 0x94e7(%rip), %rsi      # 0x51188
callq 0xb520
leaq 0xcb3d(%rip), %rsi      # 0x547ea
movq %rax, %rdi
callq 0xb520
leaq 0xcb3d(%rip), %rsi      # 0x547f9
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
movq (%rbx), %rdi
addq $0x20, %rdi
callq 0xb3e0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x30, %rsp
movq %rdi, %rsi
leaq 0x10(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x1a132
leaq 0xcb28(%rip), %rcx      # 0x54829
pushq $0x9
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xb730
testl %eax, %eax
sete %bl
leaq 0x10(%rsp), %rdi
callq 0xb230
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0xac8f(%rip), %rsi      # 0x529e0
pushq $0x5
popq %rdx
callq 0x486e8
leaq 0x2c868(%rip), %rax     # 0x745c8
movq %rax, (%rbx)
leaq 0x98(%rbx), %r14
leaq 0xa8(%rbx), %rax
movq %rax, 0x98(%rbx)
andq $0x0, 0xa0(%rbx)
movb $0x0, 0xa8(%rbx)
pushq $0x48
popq %rdi
callq 0xb540
movq %rax, %r12
movq %rax, %rdi
callq 0x4b634
movq %r12, 0x90(%rbx)
pushq $0x30
popq %rdi
callq 0xb540
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
callq 0x4c0e0
movq 0x90(%rbx), %rax
movq %r13, 0x8(%rax)
movq %r13, 0x30(%rbx)
leaq 0xc417(%rip), %rsi      # 0x541e4
movq %rsp, %rdi
callq 0x47bf0
movq %rsp, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb690
movq %rbx, %rdi
callq 0xb230
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x47e18
movq %rax, %r15
pushq $0x30
popq %rsi
movq %r13, %rdi
jmp 0x47e11
jmp 0x47e18
movq %rax, %r15
pushq $0x48
popq %rsi
movq %r12, %rdi
callq 0xb550
jmp 0x47e1b
movq %rax, %r15
movq %r14, %rdi
callq 0xb230
movq %rbx, %rdi
callq 0x4874a
movq %r15, %rdi
callq 0xb9a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/node/node_uds.cc
// Function: scdc_nodeport_uds::open_config_conf(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, scdc_args*, bool&)
bool scdc_nodeport_uds::open_config_conf(const std::string &conf, scdc_args *args, bool &done)
{
  done = true;
  bool ret = true;

  if (conf == "socketname")
  {
    const char *s;

    if (args->get<const char *>(SCDC_ARGS_TYPE_CSTR, &s) == SCDC_ARG_REF_NULL)
    {
      SCDC_ERROR("open_config_conf: getting socket name");
      ret = false;

    } else
    {
      SCDC_TRACE("open_config_conf: socketname: '" << s << "'");
      socketfile = make_uds_socketfile(s);
    }

  } else if (conf == "socketfile")
  {
    const char *s;

    if (args->get<const char *>(SCDC_ARGS_TYPE_CSTR, &s) == SCDC_ARG_REF_NULL)
    {
      SCDC_ERROR("open_config_conf: getting socket file");
      ret = false;

    } else
    {
      SCDC_TRACE("open_config_conf: socketfile: '" << s << "'");
      socketfile = s;
    }

  } else
  {
    done = false;
    ret = scdc_nodeport::open_config_conf(conf, args, done);
  }

  return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movb $0x1, (%rcx)
leaq 0xc974(%rip), %rsi      # 0x54833
movq %r12, %rdi
callq 0x19be0
testb %al, %al
je 0x47f19
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x47f6e
movq (%r14), %rdi
pushq $0x4
popq %rsi
movq %rsp, %rdx
callq *%rax
testq %rax, %rax
je 0x47f6e
movq (%rsp), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x47bf0
addq $0x98, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb690
movq %r14, %rdi
callq 0xb230
jmp 0x47f67
leaq 0xc944(%rip), %rsi      # 0x54864
movq %r12, %rdi
callq 0x19be0
testb %al, %al
je 0x47fb7
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x47fd7
movq (%r14), %rdi
pushq $0x4
popq %rsi
leaq 0x8(%rsp), %rdx
callq *%rax
testq %rax, %rax
je 0x47fd7
movq 0x8(%rsp), %rsi
addq $0x98, %rbx
movq %rbx, %rdi
callq 0xba40
movb $0x1, %al
jmp 0x48038
leaq 0x2d60b(%rip), %rbx     # 0x75580
movq (%rbx), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x48036
addq $0x20, %rdi
callq 0xb800
movq (%rbx), %rax
movq 0x18(%rax), %rdi
leaq 0x94ee(%rip), %rsi      # 0x51488
callq 0xb520
leaq 0xc844(%rip), %rsi      # 0x547ea
movq %rax, %rdi
callq 0xb520
leaq 0xc889(%rip), %rsi      # 0x5483e
jmp 0x4801a
movb $0x0, (%r15)
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r15, %rcx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x48786
leaq 0x2d5a2(%rip), %rbx     # 0x75580
movq (%rbx), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x48036
addq $0x20, %rdi
callq 0xb800
movq (%rbx), %rax
movq 0x18(%rax), %rdi
leaq 0x9489(%rip), %rsi      # 0x51488
callq 0xb520
leaq 0xc7df(%rip), %rsi      # 0x547ea
movq %rax, %rdi
callq 0xb520
leaq 0xc855(%rip), %rsi      # 0x5486f
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
movq (%rbx), %rdi
addq $0x20, %rdi
callq 0xb3e0
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/node/node_uds.cc
// Function: scdc_nodeport_uds::open(char const*, scdc_args*)
bool scdc_nodeport_uds::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_uds *transport_uds = static_cast<scdc_transport_uds *>(transport);

    SCDC_TRACE("open: socketfile: '" << socketfile << "'");

    if (!transport_uds->open(socketfile.c_str()))
    {
      SCDC_FAIL("open: opening UDS transport");
      ret = false;
      goto do_close;
    }

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

  return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x48b8c
testb %al, %al
je 0x480e4
movq 0x90(%rbx), %rdi
movq 0x98(%rbx), %rsi
movq (%rdi), %rax
callq *0xf8(%rax)
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x48145
leaq 0x2d4fe(%rip), %r14     # 0x75580
movq (%r14), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x480da
addq $0x20, %rdi
callq 0xb800
movq (%r14), %rax
movq 0x8(%rax), %rdi
leaq 0x90e5(%rip), %rsi      # 0x51188
callq 0xb520
leaq 0xc73b(%rip), %rsi      # 0x547ea
movq %rax, %rdi
callq 0xb520
leaq 0xc7d7(%rip), %rsi      # 0x54895
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
movq (%r14), %rdi
addq $0x20, %rdi
callq 0xb3e0
movq %rbx, %rdi
callq 0x48cdc
jmp 0x48143
leaq 0x2d495(%rip), %rbx     # 0x75580
movq (%rbx), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x48143
addq $0x20, %rdi
callq 0xb800
movq (%rbx), %rax
movq 0x8(%rax), %rdi
leaq 0x907c(%rip), %rsi      # 0x51188
callq 0xb520
leaq 0xc6d2(%rip), %rsi      # 0x547ea
movq %rax, %rdi
callq 0xb520
leaq 0xa9b6(%rip), %rsi      # 0x52add
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
movq (%rbx), %rdi
addq $0x20, %rdi
callq 0xb3e0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/node/node_uds.cc
// Function: scdc_nodeport_uds::start(long long)
bool scdc_nodeport_uds::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_uds *transport_uds = static_cast<scdc_transport_uds *>(transport);

  return transport_uds->start(mode);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x48ce2
testb %al, %al
je 0x481dd
movq 0x48(%r14), %rax
testq %rax, %rax
je 0x48194
movq 0x30(%r14), %rcx
movq 0x50(%r14), %rdx
movq %rax, 0x20(%rcx)
movq %rdx, 0x28(%rcx)
cmpq $0x1, %rbx
jne 0x481b6
movq 0x58(%r14), %rax
testq %rax, %rax
je 0x481b6
movq 0x60(%r14), %rcx
movq 0x90(%r14), %rdx
movq %rax, 0x10(%rdx)
movq %rcx, 0x18(%rdx)
movq 0x68(%r14), %rax
movq 0x90(%r14), %rdi
testq %rax, %rax
js 0x481ca
movq %rax, 0x20(%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
nop
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/node/node_uds.cc
// Function: scdc_nodeport_uds::stop()
bool scdc_nodeport_uds::stop()
{
  scdc_transport_uds *transport_uds = static_cast<scdc_transport_uds *>(transport);

  transport_uds->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 0x4820e
movq 0x90(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
cmpq $0x0, 0x48(%rbx)
je 0x48220
movq 0x30(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movq %rbx, %rdi
popq %rbx
jmp 0x48d0a
nop
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/node/node_uds.cc
// Function: scdc_nodeconn_uds::scdc_nodeconn_uds()
scdc_nodeconn_uds::scdc_nodeconn_uds()
  :scdc_nodeconn("uds")
{
  transport = new scdc_transport_uds();

  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 0xa77c(%rip), %rsi      # 0x529e0
callq 0x48604
leaq 0x2c3a8(%rip), %rax     # 0x74618
movq %rax, (%rbx)
pushq $0x48
popq %rdi
callq 0xb540
movq %rax, %r14
movq %rax, %rdi
callq 0x4b634
movq %r14, 0x68(%rbx)
pushq $0x30
popq %rdi
callq 0xb540
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x4c0e0
movq 0x68(%rbx), %rax
movq %r12, 0x8(%rax)
movq %r12, 0x60(%rbx)
andq $0x0, 0x70(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
pushq $0x30
popq %rsi
movq %r12, %rdi
jmp 0x482d3
jmp 0x482da
movq %rax, %r15
pushq $0x48
popq %rsi
movq %r14, %rdi
callq 0xb550
jmp 0x482dd
movq %rax, %r15
movq %rbx, %rdi
callq 0x48664
movq %r15, %rdi
callq 0xb9a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/node/nodeconn.cc
// Function: scdc_nodeconn_on_idle_close_handler(void*)
scdcint_t scdc_nodeconn_on_idle_close_handler(void *data)
{
  scdc_nodeconn *nodeconn = static_cast<scdc_nodeconn *>(data);

  SCDC_TRACE("scdc_nodeconn_on_idle_close_handler: close_on_idle: '" << nodeconn->close_on_idle << "'");

  if (nodeconn->close_on_idle > 0)
  {
    --nodeconn->close_on_idle;

    nodeconn->nodeconn_pool->close(nodeconn);
  }

  return SCDC_SUCCESS;
}

// Assembly:
movq 0x30(%rdi), %rax
testq %rax, %rax
jle 0x486c9
pushq %rax
movq %rdi, %rsi
decq %rax
movq %rax, 0x30(%rdi)
movq 0x38(%rdi), %rdi
callq 0x2b2da
addq $0x8, %rsp
pushq $0x1
popq %rax
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/node/nodeport.cc
// Function: scdc_nodeport::scdc_nodeport(char const*, long long)
scdc_nodeport::scdc_nodeport(const char *type_, scdcint_t supported_modes_)
  :type(type_), supported_modes(supported_modes_), compcoup(0), open_args(0), open_args_refcount(0)
{
  cmd_handler_args.handler = 0;
  cmd_handler_args.data = 0;

  loop_handler_dummy_args.handler = 0;
  loop_handler_dummy_args.data = 0;

  max_connections = -1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x2bfcf(%rip), %rax     # 0x746c8
movq %rax, (%rdi)
addq $0x8, %rdi
leaq 0x7(%rsp), %rdx
callq 0x1a132
movq %rbx, 0x28(%r14)
leaq 0x80(%r14), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%r14)
andq $0x0, 0x40(%r14)
movq %rax, 0x70(%r14)
andq $0x0, 0x78(%r14)
movb $0x0, 0x80(%r14)
movups %xmm0, 0x48(%r14)
movups %xmm0, 0x58(%r14)
orq $-0x1, 0x68(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/node/nodeport.cc
// Function: scdc_nodeport::open_config_conf(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, scdc_args*, bool&)
bool scdc_nodeport::open_config_conf(const std::string &conf, scdc_args *args, bool &done)
{
  done = true;
  bool ret = true;

  if (conf == "cmd_handler")
  {
    if (args->get<scdc_nodeport_cmd_handler_args_t>(SCDC_ARGS_TYPE_NODEPORT_CMD_HANDLER, &cmd_handler_args, true) == SCDC_ARG_REF_NULL)
    {
      SCDC_ERROR("open_config_conf: getting command handler");
      ret = false;

    } else
    {
      SCDC_TRACE("open_config_conf: cmd_handler: " << reinterpret_cast<void *>(cmd_handler_args.handler) << " / " << static_cast<void *>(cmd_handler_args.data));
    }

  } else if (conf == "max_connections")
  {
    if (args->get<scdcint_t>(SCDC_ARGS_TYPE_SCDCINT, &max_connections) == SCDC_ARG_REF_NULL)
    {
      SCDC_ERROR("open_config_conf: getting max. connections");
      ret = false;

    } else
    {
      SCDC_TRACE("open_config_conf: max_connections: " << max_connections);
    }

  } else if (conf.compare(0, 4, "zlib") == 0)
  {
    SCDC_TRACE("open_config_conf: cfg_compression: '" << cfg_compression << "'");
    cfg_compression = conf;

  } else done = false;

  return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movb $0x1, (%rcx)
leaq 0xc161(%rip), %rsi      # 0x54905
movq %r14, %rdi
callq 0x19be0
testb %al, %al
je 0x4881f
addq $0x48, %rbx
pushq $0x12
popq %rsi
pushq $0x1
popq %rcx
movq %r12, %rdi
movq %rbx, %rdx
callq 0x48d12
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x488f0
leaq 0x2cda6(%rip), %rbx     # 0x75580
movq (%rbx), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x488bd
addq $0x20, %rdi
callq 0xb800
movq (%rbx), %rax
movq 0x18(%rax), %rdi
leaq 0x8c89(%rip), %rsi      # 0x51488
callq 0xb520
leaq 0xc106(%rip), %rsi      # 0x54911
movq %rax, %rdi
callq 0xb520
leaq 0xc102(%rip), %rsi      # 0x5491c
jmp 0x488a1
leaq 0xc120(%rip), %rsi      # 0x54946
movq %r14, %rdi
callq 0x19be0
testb %al, %al
je 0x488c1
movq 0x8(%r12), %rax
testq %rax, %rax
je 0x4885e
addq $0x68, %rbx
movq (%r12), %rdi
pushq $0x2
popq %rsi
movq %rbx, %rdx
callq *%rax
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x488f0
leaq 0x2cd1b(%rip), %rbx     # 0x75580
movq (%rbx), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x488bd
addq $0x20, %rdi
callq 0xb800
movq (%rbx), %rax
movq 0x18(%rax), %rdi
leaq 0x8c02(%rip), %rsi      # 0x51488
callq 0xb520
leaq 0xc07f(%rip), %rsi      # 0x54911
movq %rax, %rdi
callq 0xb520
leaq 0xc0b5(%rip), %rsi      # 0x54956
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
movq (%rbx), %rdi
addq $0x20, %rdi
callq 0xb3e0
xorl %eax, %eax
jmp 0x488f0
leaq 0xc0b9(%rip), %rcx      # 0x54981
pushq $0x4
popq %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0xb730
testl %eax, %eax
je 0x488df
movb $0x0, (%r15)
jmp 0x488ee
addq $0x70, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb2e0
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/node/nodeport.cc
// Function: scdc_nodeport::open(char const*, scdc_args*)
bool scdc_nodeport::open(const char *conf, scdc_args *args)
{
  SCDC_TRACE("open: conf: '" << conf << "'");

  bool ret = true;

  args = open_args_init(args);

  string confs(conf);

  if (conf && !open_config(confs, args))
  {
    SCDC_FAIL("open: processing configuration failed");
    ret = false;
    goto do_quit;
  }

  if (args->get<scdc_nodeport_loop_handler_args_t>(SCDC_ARGS_TYPE_NODEPORT_LOOP_HANDLER_DUMMY, &loop_handler_dummy_args, true) == SCDC_ARG_REF_NULL)
  {
    SCDC_ERROR("open: getting loop handler dummy");
    ret = false;
    goto do_quit;

  } else
  {
    SCDC_TRACE("open_config_conf: loop_handler_dummy: " << reinterpret_cast<void *>(loop_handler_dummy_args.handler) << " / " << static_cast<void *>(loop_handler_dummy_args.data));
  }

  open_args_clear();

do_quit:
  if (!ret) open_args_release();

  return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, %rsi
callq 0x2c94c
movq %rax, %r14
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %r15, %rsi
callq 0x1a132
testq %r15, %r15
je 0x48bd1
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x488fc
testb %al, %al
je 0x48bf7
leaq 0x58(%rbx), %rdx
pushq $0x15
popq %rsi
pushq $0x1
popq %rcx
movq %r14, %rdi
callq 0x48d6e
testq %rax, %rax
je 0x48c40
movq 0x38(%rbx), %rax
andq $0x0, (%rax)
movb $0x1, %bl
jmp 0x48cb0
leaq 0x2c982(%rip), %r14     # 0x75580
movq (%r14), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x48ca6
addq $0x20, %rdi
callq 0xb800
movq (%r14), %rax
movq 0x8(%rax), %rdi
leaq 0x8565(%rip), %rsi      # 0x51188
callq 0xb520
leaq 0xbce2(%rip), %rsi      # 0x54911
movq %rax, %rdi
callq 0xb520
leaq 0xa043(%rip), %rsi      # 0x52c81
jmp 0x48c83
leaq 0x2c939(%rip), %r14     # 0x75580
movq (%r14), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x48ca6
addq $0x20, %rdi
callq 0xb800
movq (%r14), %rax
movq 0x18(%rax), %rdi
leaq 0x8820(%rip), %rsi      # 0x51488
callq 0xb520
leaq 0xbc9d(%rip), %rsi      # 0x54911
movq %rax, %rdi
callq 0xb520
leaq 0xbd03(%rip), %rsi      # 0x54986
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
leaq 0x2c8e6(%rip), %rax     # 0x75580
movq (%rax), %rdi
addq $0x20, %rdi
callq 0xb3e0
movq %rbx, %rdi
callq 0x2c9fa
xorl %ebx, %ebx
leaq 0x10(%rsp), %rdi
callq 0xb230
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/node/nodeport.cc
// Function: scdc_nodeport::start(long long)
bool scdc_nodeport::start(scdcint_t mode)
{
  if (!(supported_modes & mode))
  {
    SCDC_TRACE("start: mode '" << mode << "' not supported");
    return false;
  }

  if (compcoup) compcoup->set_compression(cfg_compression.c_str());

  SCDC_TRACE("cfg_compression: '" << cfg_compression << "'");

  return true;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
andq 0x28(%rdi), %rbx
je 0x48d02
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x48d02
movq 0x70(%rdi), %rsi
movq (%rax), %rcx
movq %rax, %rdi
callq *0x48(%rcx)
testq %rbx, %rbx
setne %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/posix_fs_handler.cc
// Function: scdc_posix_fs_handler::open_conf(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, scdc_args*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_posix_fs_handler::open_conf(std::string &conf, scdc_args *args, scdc_result &result)
{
  SCDC_TRACE_F("conf: '" << conf << "'");

  bool ret = false;

  const char *r;
  if (!args->get<const char *>(SCDC_ARGS_TYPE_CSTR, &r))
  {
    result = "getting root directory failed";
    SCDC_ERROR_F(result);
    goto do_return;
  }

  root_dir = r;
  if (*root_dir.rbegin() != '/') root_dir += '/';

  ret = true;

do_return:
  SCDC_TRACE_F("return: " << ret << ", result: '" << result << "'");

  return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq 0x8(%rdx), %rax
testq %rax, %rax
je 0x48e25
movq %rdi, %r14
movq (%rdx), %rdi
pushq $0x4
popq %rsi
movq %rsp, %rdx
callq *%rax
testq %rax, %rax
je 0x48e25
movq (%rsp), %rsi
movq %r14, %rdi
callq 0xba40
movq (%r14), %rax
movq 0x8(%r14), %rcx
movb $0x1, %bl
cmpb $0x2f, -0x1(%rax,%rcx)
je 0x48eaf
pushq $0x2f
popq %rsi
movq %r14, %rdi
callq 0xb450
jmp 0x48eaf
leaq 0xbb8b(%rip), %rsi      # 0x549b7
movq %rbx, %rdi
callq 0xba40
leaq 0x2c745(%rip), %r14     # 0x75580
movq (%r14), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x48ead
addq $0x20, %rdi
callq 0xb800
movq (%r14), %rax
movq 0x18(%rax), %rdi
leaq 0x862c(%rip), %rsi      # 0x51488
callq 0xb520
leaq 0xbb6d(%rip), %rsi      # 0x549d5
movq %rax, %rdi
callq 0xb520
leaq 0xbb71(%rip), %rsi      # 0x549e8
movq %rax, %rdi
callq 0xb520
leaq 0xbc1d(%rip), %rsi      # 0x54aa3
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
movq %rbx, %rsi
callq 0xb490
movq %rax, %rdi
callq 0xb270
movq (%r14), %rdi
addq $0x20, %rdi
callq 0xb3e0
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/posix_fs_handler.cc
// Function: scdc_posix_fs_handler::open(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_posix_fs_handler::open(scdc_result &result)
{
  SCDC_TRACE_F("");

  bool ret = false;

  if (!dir_exists(""))
  {
    result = "root directory '" + root_dir + "' does not exist or is not a directory";
    SCDC_ERROR_F(result);
    goto do_return;
  }

  ret = true;

do_return:
  SCDC_TRACE_F("return: " << ret << ", result: '" << result << "'");

  return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x95eb(%rip), %rsi      # 0x524bd
callq 0x48fca
movl %eax, %ebx
testb %al, %al
jne 0x48fa7
leaq 0xa3af(%rip), %rsi      # 0x53297
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rdx
callq 0x19ae2
leaq 0xbaf3(%rip), %rdx      # 0x549f2
leaq 0x28(%rsp), %rdi
movq %r12, %rsi
callq 0x1cb18
leaq 0x28(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0xb690
movq %r15, %rdi
callq 0xb230
leaq 0x8(%rsp), %rdi
callq 0xb230
leaq 0x2c64b(%rip), %r15     # 0x75580
movq (%r15), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x48fa7
addq $0x20, %rdi
callq 0xb800
movq (%r15), %rax
movq 0x18(%rax), %rdi
leaq 0x8532(%rip), %rsi      # 0x51488
callq 0xb520
leaq 0xba73(%rip), %rsi      # 0x549d5
movq %rax, %rdi
callq 0xb520
leaq 0x7418(%rip), %rsi      # 0x50389
movq %rax, %rdi
callq 0xb520
leaq 0xbb23(%rip), %rsi      # 0x54aa3
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
movq %r14, %rsi
callq 0xb490
movq %rax, %rdi
callq 0xb270
movq (%r15), %rdi
addq $0x20, %rdi
callq 0xb3e0
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/posix_fs_handler.cc
// Function: scdc_posix_fs_handler::dir_count_entries(__dirstream*)
scdcint_t scdc_posix_fs_handler::dir_count_entries(dir_t dir)
{
  SCDC_TRACE_F("dir: " << dir);

  scdcint_t n = 0;
  struct dirent *ent;
  while ((ent = ::readdir(dir)) != NULL)
  {
    if (dirent_is_dir(ent) || dirent_is_file(ent)) ++n;
  }

  return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
xorl %ebx, %ebx
movq %r14, %rdi
callq 0xb870
testq %rax, %rax
je 0x49156
movq %rax, %r15
movq %rax, %rdi
callq 0x4915f
testb %al, %al
jne 0x49151
cmpb $0x8, 0x12(%r15)
jne 0x4912e
incq %rbx
jmp 0x4912e
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/posix_fs_handler.cc
// Function: scdc_posix_fs_handler::dir_count_dirs(__dirstream*)
scdcint_t scdc_posix_fs_handler::dir_count_dirs(dir_t dir)
{
  SCDC_TRACE_F("dir: " << dir);

  scdcint_t n = 0;
  struct dirent *ent;
  while ((ent = ::readdir(dir)) != NULL)
  {
    if (dirent_is_dir(ent)) ++n;
  }

  return n;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
xorl %ebx, %ebx
movq %r14, %rdi
callq 0xb870
testq %rax, %rax
je 0x491aa
movq %rax, %rdi
callq 0x4915f
movzbl %al, %eax
addq %rax, %rbx
jmp 0x4918d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/posix_fs_handler.cc
// Function: scdc_posix_fs_handler::dir_list_dirs(__dirstream*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
bool scdc_posix_fs_handler::dir_list_dirs(dir_t dir, std::vector<std::string> &dirs)
{
  SCDC_TRACE_F("dir: " << dir);

  struct dirent *ent;
  while ((ent = ::readdir(dir)) != NULL)
  {
    if (dirent_is_dir(ent)) dirs.push_back(ent->d_name);
  }

  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %r12
movq %r14, %rdi
callq 0xb870
testq %rax, %rax
je 0x49216
movq %rax, %r13
movq %rax, %rdi
callq 0x4915f
testb %al, %al
je 0x491d3
addq $0x13, %r13
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x1a132
movq %rbx, %rdi
movq %r15, %rsi
callq 0x49464
movq %r15, %rdi
callq 0xb230
jmp 0x491d3
movb $0x1, %al
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/posix_fs_handler.cc
// Function: scdc_posix_fs_handler::dir_count_files(__dirstream*)
scdcint_t scdc_posix_fs_handler::dir_count_files(dir_t dir)
{
  SCDC_TRACE_F("dir: " << dir);

  scdcint_t n = 0;
  struct dirent *ent;
  while ((ent = ::readdir(dir)) != NULL)
  {
    if (dirent_is_file(ent)) ++n;
  }

  return n;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
xorl %ebx, %ebx
movq %r14, %rdi
callq 0xb870
testq %rax, %rax
je 0x49260
xorl %ecx, %ecx
cmpb $0x8, 0x12(%rax)
sete %cl
addq %rcx, %rbx
jmp 0x49245
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/posix_fs_handler.cc
// Function: scdc_posix_fs_handler::dir_list_files(__dirstream*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
bool scdc_posix_fs_handler::dir_list_files(dir_t dir, std::vector<std::string> &files)
{
  SCDC_TRACE_F("dir: " << dir);

  struct dirent *ent;
  while ((ent = ::readdir(dir)) != NULL)
  {
    if (dirent_is_file(ent)) files.push_back(ent->d_name);
  }

  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x8(%rsp), %r15
leaq 0x7(%rsp), %r12
movq %r14, %rdi
callq 0xb870
testq %rax, %rax
je 0x492c1
cmpb $0x8, 0x12(%rax)
jne 0x49287
addq $0x13, %rax
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x1a132
movq %rbx, %rdi
movq %r15, %rsi
callq 0x49464
movq %r15, %rdi
callq 0xb230
jmp 0x49287
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/posix_fs_handler.cc
// Function: scdc_posix_fs_handler::file_reopen(char const*, int, int, char const*)
scdc_posix_fs_handler::file_t scdc_posix_fs_handler::file_reopen(const char *path, int flags, file_t file, const char *old_path)
{
  std::string p = root_dir + path;
  SCDC_TRACE_F("path: '" << path << "' -> '" << p << "', flags: " << flags << ", old_path: '" << old_path << "'");

  /* FIXME: check whether path == old_path and flags == old_flags (determine with fnctl and F_GETFL) to prevent unnecessary close and open */
  if (::close(file) != 0) return file_null;

  return ::open(p.c_str(), flags);
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movl %edx, %ebx
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x8(%rsp), %rdi
callq 0x1d867
movl %ebp, %edi
callq 0xbaa0
testl %eax, %eax
je 0x493f4
pushq $-0x1
popq %rbx
jmp 0x49404
movq 0x8(%rsp), %rdi
movl %ebx, %esi
xorl %eax, %eax
callq 0xb3b0
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0xb230
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/transport/transport.cc
// Function: scdc_transport_connection_t::release()
void scdc_transport_connection_t::release()
{
  SCDC_TRACE("release: idle: '" << idle << "'");

  SCDC_ASSERT(!idle);

  idle = true;
  
  if (on_idle_handler) on_idle_handler(on_idle_data);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, 0x9(%rdi)
jne 0x49601
leaq 0x2c000(%rip), %r14     # 0x75580
movq (%r14), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x49601
addq $0x20, %rdi
callq 0xb800
movq (%r14), %rax
movq 0x18(%rax), %rdi
leaq 0x7fa8(%rip), %rsi      # 0x51549
callq 0xb520
leaq 0xb47f(%rip), %rsi      # 0x54a2c
movq %rax, %rdi
callq 0xb520
leaq 0x7d88(%rip), %rsi      # 0x51344
movq %rax, %rdi
callq 0xb520
pushq $0x3d
popq %rsi
movq %rax, %rdi
callq 0xb990
leaq 0xb46d(%rip), %rsi      # 0x54a43
movq %rax, %rdi
callq 0xb520
leaq 0x98ab(%rip), %rsi      # 0x52e90
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
movq (%r14), %rdi
addq $0x20, %rdi
callq 0xb3e0
movb $0x1, 0x9(%rbx)
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x4961b
movq 0x18(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/transport/transport.cc
// Function: scdc_transport_connection_pool::scdc_transport_connection_pool(long long, scdc_transport*)
scdc_transport_connection_pool::scdc_transport_connection_pool(scdcint_t max_connections_, scdc_transport *transport_)
  :max_connections(max_connections_), transport(transport_)
{
#if THREAD_POOLING
  SCDC_TRACE("scdc_transport_connection_pool: max. " << max_connections << " connections, with thread pooling");
#else
  SCDC_TRACE("scdc_transport_connection_pool: max. " << max_connections << " connections, without thread pooling");
#endif

  pool = new scdc_transport_connection_pool_t();

  pool->run = true;
  pool->naquired_entries = 0;

  pthread_mutex_init(&pool->lock, NULL);
  pthread_cond_init(&pool->cond, NULL);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
movl $0xb0, %edi
callq 0xb540
movq %rax, %r14
movl $0xb0, %edx
movq %rax, %rdi
xorl %esi, %esi
callq 0xb2f0
movq %r14, %rdi
callq 0x4a566
movq %r14, 0x10(%rbx)
movb $0x1, 0x58(%r14)
andq $0x0, 0x78(%r14)
movq %r14, %rdi
xorl %esi, %esi
callq 0xb810
movq 0x10(%rbx), %rdi
addq $0x28, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb680
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/transport/transport.cc
// Function: scdc_transport_connection_pool::~scdc_transport_connection_pool()
scdc_transport_connection_pool::~scdc_transport_connection_pool()
{
  pthread_cond_destroy(&pool->cond);
  pthread_mutex_destroy(&pool->lock);

  delete pool; pool = 0;

  transport = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
addq $0x28, %rdi
callq 0xba60
movq 0x10(%rbx), %rdi
callq 0xb640
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0x496b6
movq %r14, %rdi
callq 0x4a5b2
movl $0xb0, %esi
movq %r14, %rdi
callq 0xb550
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/transport/transport.cc
// Function: scdc_transport_connection_pool::insert(scdc_transport_connection_t*)
void scdc_transport_connection_pool::insert(scdc_transport_connection_t *conn)
{
  SCDC_TRACE("insert: conn: '" << conn << "'");

  bool async = (max_connections > 1);

  scdc_transport_connection_pool_entry_t *entry = acquire_entry(async);

  if (!entry)
  {
    SCDC_TRACE("insert: aquire entry failed: closing connection '" << conn << "'");
    transport->close(conn);
    return;
  }

  if (async)
  {
    SCDC_TRACE("insert: run async in thread");

    pthread_mutex_lock(&entry->lock);
    entry->conn = conn;
    pthread_mutex_unlock(&entry->lock);

    pthread_cond_signal(&entry->cond);

  } else
  {
    SCDC_TRACE("insert: run direct in function");

    entry->conn = conn;

    run_entry(entry);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %r12
xorl %esi, %esi
cmpq $0x2, %r12
setge %sil
callq 0x49764
testq %rax, %rax
je 0x4972f
movq %rax, %r14
cmpq $0x2, %r12
jl 0x4974a
leaq 0x8(%r14), %r15
movq %r15, %rdi
callq 0xb800
movq %rbx, 0x70(%r14)
movq %r15, %rdi
callq 0xb3e0
addq $0x30, %r14
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xb030
movq 0x8(%r15), %rdi
movq (%rdi), %rax
movq 0x60(%rax), %rax
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
movq %rbx, 0x70(%r14)
movq %r15, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4980a