LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/node/node_stream.cc
// Function: scdc_nodeport_stream::stop()
bool scdc_nodeport_stream::stop()
{
  scdc_transport_stream *transport_stream = static_cast<scdc_transport_stream *>(transport);

  transport_stream->stop();

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

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

  return scdc_nodeport::stop();
}

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

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

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

  return ret;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rsi
leaq 0x10(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x1bd28
leaq 0x1115f(%rip), %rcx     # 0x6d79a
movl $0x9, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xb700
movl %eax, %ebx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5c667
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xb510
testl %ebx, %ebx
sete %al
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5c690
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/node/node_tcp.cc
// Function: scdc_nodeport_tcp::scdc_nodeport_tcp()
scdc_nodeport_tcp::scdc_nodeport_tcp()
  :scdc_nodeport("tcp", SCDC_NODEPORT_START_LOOP_UNTIL_CANCEL|SCDC_NODEPORT_START_ASYNC_UNTIL_CANCEL), port(NODE_TCP_PORT_DEFAULT)
{
  transport = new scdc_transport_tcp();

  scdc_compcoup_transport *compcoup_transport = new scdc_compcoup_transport(transport);

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0xf39c(%rip), %rsi      # 0x6ba47
movl $0x5, %edx
callq 0x5dd58
leaq 0x2ee3c(%rip), %rax     # 0x8b4f8
movq %rax, (%rbx)
leaq 0xa8(%rbx), %r13
movq %r13, 0x98(%rbx)
movq $0x0, 0xa0(%rbx)
movb $0x0, 0xa8(%rbx)
movl $0x5cdc, 0xb8(%rbx)     # imm = 0x5CDC
movl $0x48, %edi
callq 0xb500
movq %rax, %r15
movq %rax, %rdi
callq 0x60d94
movq %r15, 0x90(%rbx)
movl $0x30, %edi
callq 0xb500
movq %rax, %r12
movq %rax, %rdi
movq %r15, %rsi
callq 0x62984
movq 0x90(%rbx), %rax
movq %r12, 0x8(%rax)
movq %r12, 0x30(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x30, %esi
movq %r12, %rdi
jmp 0x5c750
jmp 0x5c757
movq %rax, %r14
movl $0x48, %esi
movq %r15, %rdi
callq 0xb510
jmp 0x5c75a
movq %rax, %r14
movq 0x98(%rbx), %rdi
cmpq %r13, %rdi
je 0x5c772
movq (%r13), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0x5ddbe
movq %r14, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10f9c(%rip), %rsi     # 0x6d7be
movq %r12, %rdi
callq 0xb110
testl %eax, %eax
je 0x5c861
leaq 0x10fab(%rip), %rsi     # 0x6d7e0
movq %r12, %rdi
callq 0xb110
testl %eax, %eax
je 0x5c8b8
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 0x5de1a
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x5c93e
movq (%r14), %rdi
movq %rsp, %rdx
movl $0x4, %esi
callq *%rax
testq %rax, %rax
je 0x5c93e
movq (%rsp), %r14
movq 0xa0(%rbx), %r15
addq $0x98, %rbx
movq %r14, %rdi
callq 0xb200
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0xb870
movb $0x1, %al
jmp 0x5c9d0
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x5c8e3
addq $0xb8, %rbx
movq (%r14), %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq *%rax
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x5c9d0
leaq 0x2fc86(%rip), %r14     # 0x8c570
movq (%r14), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x5c9ce
addq $0x20, %rdi
callq 0xb7d0
movq (%r14), %rax
movq 0x18(%rax), %rbx
leaq 0xdb99(%rip), %rsi      # 0x6a4a8
movl $0xc, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x10e0e(%rip), %rsi     # 0x6d731
movl $0xe, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x10e8f(%rip), %rsi     # 0x6d7c6
movl $0x1e, %edx
jmp 0x5c993
leaq 0x2fc2b(%rip), %r14     # 0x8c570
movq (%r14), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x5c9ce
addq $0x20, %rdi
callq 0xb7d0
movq (%r14), %rax
movq 0x18(%rax), %rbx
leaq 0xdb42(%rip), %rsi      # 0x6a4a8
movl $0xc, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x10db7(%rip), %rsi     # 0x6d731
movl $0xe, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x10e16(%rip), %rsi     # 0x6d7a4
movl $0x21, %edx
movq %rbx, %rdi
callq 0xb5f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq (%r14), %rdi
addq $0x20, %rdi
callq 0xb3b0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x5e390
testb %al, %al
je 0x5cab7
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 0x5cb49
leaq 0x2fb4f(%rip), %r15     # 0x8c570
movq (%r15), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x5caaa
addq $0x20, %rdi
callq 0xb7d0
movq (%r15), %rax
movq 0x8(%rax), %r14
leaq 0xd766(%rip), %rsi      # 0x6a1a8
movl $0xb, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x10cdb(%rip), %rsi     # 0x6d731
movl $0xe, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x10d7b(%rip), %rsi     # 0x6d7e5
movl $0x1b, %edx
movq %r14, %rdi
callq 0xb5f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %r14, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq (%r15), %rdi
addq $0x20, %rdi
callq 0xb3b0
movq %rbx, %rdi
callq 0x5e570
jmp 0x5cb47
leaq 0x2fab2(%rip), %r14     # 0x8c570
movq (%r14), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x5cb47
addq $0x20, %rdi
callq 0xb7d0
movq (%r14), %rax
movq 0x8(%rax), %rbx
leaq 0xd6c9(%rip), %rsi      # 0x6a1a8
movl $0xb, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x10c3e(%rip), %rsi     # 0x6d731
movl $0xe, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0xf046(%rip), %rsi      # 0x6bb4d
movl $0x12, %edx
movq %rbx, %rdi
callq 0xb5f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq (%r14), %rdi
addq $0x20, %rdi
callq 0xb3b0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5e576
testb %al, %al
je 0x5cbdf
movq 0x48(%r14), %rax
testq %rax, %rax
je 0x5cb96
movq 0x30(%r14), %rcx
movq 0x50(%r14), %rdx
movq %rax, 0x20(%rcx)
movq %rdx, 0x28(%rcx)
cmpq $0x1, %rbx
jne 0x5cbb8
movq 0x58(%r14), %rax
testq %rax, %rax
je 0x5cbb8
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 0x5cbcc
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_O3/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 0x5cc10
movq 0x90(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
cmpq $0x0, 0x48(%rbx)
je 0x5cc22
movq 0x30(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movq %rbx, %rdi
popq %rbx
jmp 0x5e59e
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xede1(%rip), %rsi      # 0x6ba47
callq 0x5dc40
leaq 0x2e8d6(%rip), %rax     # 0x8b548
movq %rax, (%rbx)
movl $0x48, %edi
callq 0xb500
movq %rax, %r14
movq %rax, %rdi
callq 0x60d94
movq %r14, 0x68(%rbx)
movl $0x30, %edi
callq 0xb500
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x62984
movq 0x68(%rbx), %rax
movq %r12, 0x8(%rax)
movq %r12, 0x60(%rbx)
movq $0x0, 0x70(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
movl $0x30, %esi
movq %r12, %rdi
jmp 0x5cce0
jmp 0x5cce7
movq %rax, %r15
movl $0x48, %esi
movq %r14, %rdi
callq 0xb510
jmp 0x5ccea
movq %rax, %r15
movq %rbx, %rdi
callq 0x5dcb2
movq %r15, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x70, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movl $0x3a, %esi
movq %rbx, %rdx
movq $-0x1, %rcx
callq 0x1b83e
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x1b878
cmpq $0x0, 0x10(%rsp)
jne 0x5cdb3
leaq 0x10a62(%rip), %rcx     # 0x6d801
leaq 0x8(%rsp), %rdi
movl $0x9, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0xb870
movl $0x5cdc, 0x4(%rsp)      # imm = 0x5CDC
cmpq $0x0, 0x38(%rsp)
je 0x5ce0a
leaq 0x50(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1b878
leaq 0x60(%rsp), %r15
movq -0x10(%r15), %rdi
leaq 0x109b5(%rip), %rsi     # 0x6d797
leaq 0x4(%rsp), %rdx
xorl %eax, %eax
callq 0xb4e0
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0x5ce04
movq 0x60(%rsp), %rsi
incq %rsi
callq 0xb510
movl 0x4(%rsp), %edx
jmp 0x5ce0f
movl $0x5cdc, %edx           # imm = 0x5CDC
movq 0x68(%r14), %rdi
movq 0x8(%rsp), %rsi
movq (%rdi), %rax
callq *0x100(%rax)
movq %rax, 0x70(%r14)
testq %rax, %rax
je 0x5ce4b
leaq 0xee3(%rip), %rcx       # 0x5dd14
movq %rcx, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5dcf6
movl %eax, %ebx
jmp 0x5cedd
leaq 0x2f71e(%rip), %r14     # 0x8c570
movq (%r14), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x5cedb
addq $0x20, %rdi
callq 0xb7d0
movq (%r14), %rax
movq 0x8(%rax), %rbx
leaq 0xd335(%rip), %rsi      # 0x6a1a8
movl $0xb, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x108aa(%rip), %rsi     # 0x6d731
movl $0xe, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x10970(%rip), %rsi     # 0x6d80b
movl $0x15, %edx
movq %rbx, %rdi
callq 0xb5f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq (%r14), %rdi
addq $0x20, %rdi
callq 0xb3b0
xorl %ebx, %ebx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5cef8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
leaq 0x28(%rsp), %rdi
callq 0x1bad0
movl %ebx, %eax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x5cf17
jmp 0x5cf17
movq %rax, %rbx
jmp 0x5cf35
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5cf35
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
leaq 0x28(%rsp), %rdi
callq 0x1bad0
movq %rbx, %rdi
callq 0xb9c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq $0x0, 0x8(%rdx)
movq (%rdx), %rax
movb $0x0, (%rax)
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x5d02c
movq %rdx, %rbx
movq (%rsi), %rdi
leaq 0x8(%rsp), %rdx
movl $0x4, %esi
callq *%rax
testq %rax, %rax
je 0x5d02c
movq 0x8(%rsp), %r14
movq 0x8(%rbx), %r15
movq %r14, %rdi
callq 0xb200
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0xb870
movb $0x1, %al
jmp 0x5d0be
leaq 0x2f53d(%rip), %r14     # 0x8c570
movq (%r14), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x5d0bc
addq $0x20, %rdi
callq 0xb7d0
movq (%r14), %rax
movq 0x8(%rax), %rbx
leaq 0xd154(%rip), %rsi      # 0x6a1a8
movl $0xb, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x107f2(%rip), %rsi     # 0x6d85a
movl $0xe, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x107ed(%rip), %rsi     # 0x6d869
movl $0x2f, %edx
movq %rbx, %rdi
callq 0xb5f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq (%r14), %rdi
addq $0x20, %rdi
callq 0xb3b0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1bd28
leaq 0x107b0(%rip), %rcx     # 0x6d899
movl $0x9, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xb700
movl %eax, %ebx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5d115
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xb510
testl %ebx, %ebx
sete %al
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5d13e
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0xe8f2(%rip), %rsi      # 0x6ba50
movl $0x5, %edx
callq 0x5dd58
leaq 0x2e441(%rip), %rax     # 0x8b5b0
movq %rax, (%rbx)
leaq 0x98(%rbx), %r14
leaq 0xa8(%rbx), %rbp
movq %rbp, 0x98(%rbx)
movq $0x0, 0xa0(%rbx)
movb $0x0, 0xa8(%rbx)
movl $0x48, %edi
callq 0xb500
movq %rax, %r12
movq %rax, %rdi
callq 0x61a94
movq %r12, 0x90(%rbx)
movl $0x30, %edi
callq 0xb500
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
callq 0x62984
movq 0x90(%rbx), %rax
movq %r13, 0x8(%rax)
movq %r13, 0x30(%rbx)
leaq 0x10071(%rip), %rsi     # 0x6d254
leaq 0x8(%rsp), %rdi
callq 0x5cf74
leaq 0x8(%rsp), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb670
movq (%rbx), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x5d217
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5d249
movq %rax, %r15
movl $0x30, %esi
movq %r13, %rdi
jmp 0x5d242
jmp 0x5d249
movq %rax, %r15
movl $0x48, %esi
movq %r12, %rdi
callq 0xb510
jmp 0x5d24c
movq %rax, %r15
movq (%r14), %rdi
cmpq %rbp, %rdi
je 0x5d260
movq (%rbp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0x5ddbe
movq %r15, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x5e390
testb %al, %al
je 0x5d5db
movq 0x90(%rbx), %rdi
movq 0x98(%rbx), %rsi
movq (%rdi), %rax
callq *0xf8(%rax)
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x5d66d
leaq 0x2f02b(%rip), %r15     # 0x8c570
movq (%r15), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x5d5ce
addq $0x20, %rdi
callq 0xb7d0
movq (%r15), %rax
movq 0x8(%rax), %r14
leaq 0xcc42(%rip), %rsi      # 0x6a1a8
movl $0xb, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x102e0(%rip), %rsi     # 0x6d85a
movl $0xe, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x10377(%rip), %rsi     # 0x6d905
movl $0x1b, %edx
movq %r14, %rdi
callq 0xb5f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %r14, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq (%r15), %rdi
addq $0x20, %rdi
callq 0xb3b0
movq %rbx, %rdi
callq 0x5e570
jmp 0x5d66b
leaq 0x2ef8e(%rip), %r14     # 0x8c570
movq (%r14), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x5d66b
addq $0x20, %rdi
callq 0xb7d0
movq (%r14), %rax
movq 0x8(%rax), %rbx
leaq 0xcba5(%rip), %rsi      # 0x6a1a8
movl $0xb, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x10243(%rip), %rsi     # 0x6d85a
movl $0xe, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0xe522(%rip), %rsi      # 0x6bb4d
movl $0x12, %edx
movq %rbx, %rdi
callq 0xb5f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq (%r14), %rdi
addq $0x20, %rdi
callq 0xb3b0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5e576
testb %al, %al
je 0x5d703
movq 0x48(%r14), %rax
testq %rax, %rax
je 0x5d6ba
movq 0x30(%r14), %rcx
movq 0x50(%r14), %rdx
movq %rax, 0x20(%rcx)
movq %rdx, 0x28(%rcx)
cmpq $0x1, %rbx
jne 0x5d6dc
movq 0x58(%r14), %rax
testq %rax, %rax
je 0x5d6dc
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 0x5d6f0
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_O3/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 0x5d734
movq 0x90(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
cmpq $0x0, 0x48(%rbx)
je 0x5d746
movq 0x30(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movq %rbx, %rdi
popq %rbx
jmp 0x5e59e
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe2c6(%rip), %rsi      # 0x6ba50
callq 0x5dc40
leaq 0x2de6a(%rip), %rax     # 0x8b600
movq %rax, (%rbx)
movl $0x48, %edi
callq 0xb500
movq %rax, %r14
movq %rax, %rdi
callq 0x61a94
movq %r14, 0x68(%rbx)
movl $0x30, %edi
callq 0xb500
movq %rax, %r12
movq %rax, %rdi
movq %r14, %rsi
callq 0x62984
movq 0x68(%rbx), %rax
movq %r12, 0x8(%rax)
movq %r12, 0x60(%rbx)
movq $0x0, 0x70(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
movl $0x30, %esi
movq %r12, %rdi
jmp 0x5d804
jmp 0x5d80b
movq %rax, %r15
movl $0x48, %esi
movq %r14, %rdi
callq 0xb510
jmp 0x5d80e
movq %rax, %r15
movq %rbx, %rdi
callq 0x5dcb2
movq %r15, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2d947(%rip), %rax     # 0x8b6b0
movq %rax, (%rdi)
addq $0x8, %rdi
leaq 0x7(%rsp), %rdx
callq 0x1bd28
movq %rbx, 0x28(%r14)
leaq 0x80(%r14), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%r14)
xorl %ecx, %ecx
movq %rcx, 0x40(%r14)
movq %rax, 0x70(%r14)
movq %rcx, 0x78(%r14)
movb $0x0, 0x80(%r14)
movups %xmm0, 0x48(%r14)
movups %xmm0, 0x58(%r14)
movq $-0x1, 0x68(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x34818
movq %rax, %r14
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %r15, %rsi
callq 0x1bd28
testq %r15, %r15
je 0x5e3d5
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x5dfe0
testb %al, %al
je 0x5e406
leaq 0x58(%rbx), %rdx
movl $0x15, %esi
movq %r14, %rdi
movl $0x1, %ecx
callq 0x5e62c
testq %rax, %rax
je 0x5e47d
movq 0x38(%rbx), %rax
movq $0x0, (%rax)
movb $0x1, %bl
jmp 0x5e522
leaq 0x2e163(%rip), %r14     # 0x8c570
movq (%r14), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x5e518
addq $0x20, %rdi
callq 0xb7d0
movq (%r14), %rax
movq 0x8(%rax), %r14
leaq 0xbd76(%rip), %rsi      # 0x6a1a8
movl $0xb, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0xf53b(%rip), %rsi      # 0x6d981
movl $0xa, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0xd897(%rip), %rsi      # 0x6bcf1
movl $0x25, %edx
movq %r14, %rdi
callq 0xb5f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xb4d0
jmp 0x5e4f2
leaq 0x2e0ec(%rip), %r14     # 0x8c570
movq (%r14), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x5e518
addq $0x20, %rdi
callq 0xb7d0
movq (%r14), %rax
movq 0x18(%rax), %r14
leaq 0xbfff(%rip), %rsi      # 0x6a4a8
movl $0xc, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0xf4c4(%rip), %rsi      # 0x6d981
movl $0xa, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0xf525(%rip), %rsi      # 0x6d9f6
movl $0x20, %edx
movq %r14, %rdi
callq 0xb5f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %r14, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
leaq 0x2e064(%rip), %rax     # 0x8c570
movq (%rax), %rdi
addq $0x20, %rdi
callq 0xb3b0
movq %rbx, %rdi
callq 0x348f4
xorl %ebx, %ebx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5e53d
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xb510
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5e567
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5e596
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x5e596
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_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq 0x8(%rdx), %rax
testq %rax, %rax
je 0x5e72d
movq %rdi, %r14
movq (%rdx), %rdi
movq %rsp, %rdx
movl $0x4, %esi
callq *%rax
testq %rax, %rax
je 0x5e72d
movq (%rsp), %rbx
movq 0x8(%r14), %r15
movq %rbx, %rdi
callq 0xb200
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %rbx, %rcx
movq %rax, %r8
callq 0xb870
movq (%r14), %rax
movq 0x8(%r14), %rcx
movb $0x1, %r15b
cmpb $0x2f, -0x1(%rax,%rcx)
je 0x5e80b
movq %r14, %rdi
movl $0x2f, %esi
callq 0xb420
jmp 0x5e80b
movq 0x8(%rbx), %rdx
leaq 0xf2ef(%rip), %rcx      # 0x6da27
xorl %r15d, %r15d
movl $0x1d, %r8d
movq %rbx, %rdi
xorl %esi, %esi
callq 0xb870
leaq 0x2de1e(%rip), %r12     # 0x8c570
movq (%r12), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x5e80b
addq $0x20, %rdi
callq 0xb7d0
movq (%r12), %rax
movq 0x18(%rax), %r14
leaq 0xbd2f(%rip), %rsi      # 0x6a4a8
movl $0xc, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0xf2b8(%rip), %rsi      # 0x6da45
movl $0x12, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0xf2b7(%rip), %rsi      # 0x6da58
movl $0x9, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0xf35e(%rip), %rsi      # 0x6db13
movl $0x2, %edx
movq %r14, %rdi
callq 0xb5f0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0xb5f0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq (%r12), %rdi
addq $0x20, %rdi
callq 0xb3b0
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/dataprov/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 0xccfb(%rip), %rsi      # 0x6b52d
callq 0x5e9e0
movl %eax, %ebx
testb %al, %al
jne 0x5e9ab
leaq 0xdabf(%rip), %rsi      # 0x6c307
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rdx
callq 0x1b7aa
leaq 0xf203(%rip), %rsi      # 0x6da62
movq %r12, %rdi
callq 0xba60
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x5e88f
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x5e897
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
leaq 0x28(%rsp), %r15
movq %rdx, 0x8(%r15)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0xb670
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x5e8d3
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb510
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5e8ee
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
leaq 0x2dc7b(%rip), %r12     # 0x8c570
movq (%r12), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x5e9ab
addq $0x20, %rdi
callq 0xb7d0
movq (%r12), %rax
movq 0x18(%rax), %r15
leaq 0xbb8c(%rip), %rsi      # 0x6a4a8
movl $0xc, %edx
movq %r15, %rdi
callq 0xb5f0
leaq 0xf115(%rip), %rsi      # 0x6da45
movl $0x12, %edx
movq %r15, %rdi
callq 0xb5f0
leaq 0xaa45(%rip), %rsi      # 0x69389
movl $0x4, %edx
movq %r15, %rdi
callq 0xb5f0
leaq 0xf1bb(%rip), %rsi      # 0x6db13
movl $0x2, %edx
movq %r15, %rdi
callq 0xb5f0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0xb5f0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %r14, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq (%r12), %rdi
addq $0x20, %rdi
callq 0xb3b0
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5e9d7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/dataprov/posix_fs_handler.cc
// Function: scdc_posix_fs_handler::dir_rewind(__dirstream*, char const*)
scdc_posix_fs_handler::dir_t scdc_posix_fs_handler::dir_rewind(dir_t dir, const char *path)
{
  std::string p = root_dir + path;
  SCDC_TRACE_F("dir: " << dir << ", path: '" << path << "' -> '" << p << "'");

  ::rewinddir(dir);
  return dir;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x1d0a0
movq %r15, %rdi
movq %r14, %rsi
callq 0xba60
movq %rbx, %rdi
callq 0xb290
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x5ec74
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x5ec9d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/dataprov/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rsi, %rdi
callq 0xb850
xorl %r14d, %r14d
testq %rax, %rax
je 0x5ecf1
movzbl 0x12(%rax), %ecx
cmpl $0x8, %ecx
je 0x5ece4
cmpl $0x4, %ecx
jne 0x5ece7
cmpb $0x2e, 0x13(%rax)
jne 0x5ece4
movzbl 0x14(%rax), %ecx
testl %ecx, %ecx
je 0x5ece7
cmpl $0x2e, %ecx
jne 0x5ece4
cmpb $0x0, 0x15(%rax)
je 0x5ece7
incq %r14
movq %rbx, %rdi
callq 0xb850
jmp 0x5ecb8
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, %rbx
movq %rsi, %rdi
callq 0xb850
xorl %r14d, %r14d
testq %rax, %rax
je 0x5ed43
cmpb $0x4, 0x12(%rax)
jne 0x5ed39
cmpb $0x2e, 0x13(%rax)
jne 0x5ed36
movzbl 0x14(%rax), %ecx
testl %ecx, %ecx
je 0x5ed39
cmpl $0x2e, %ecx
jne 0x5ed36
cmpb $0x1, 0x15(%rax)
sbbq $-0x1, %r14
jmp 0x5ed39
incq %r14
movq %rbx, %rdi
callq 0xb850
jmp 0x5ed0e
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rsi, %rdi
callq 0xb850
testq %rax, %rax
je 0x5edf4
movq %rax, %r12
leaq 0x10(%rsp), %r13
movq %rsp, %r15
cmpb $0x4, 0x12(%r12)
jne 0x5ede4
cmpb $0x2e, 0x13(%r12)
jne 0x5eda4
movzbl 0x14(%r12), %eax
testl %eax, %eax
je 0x5ede4
cmpl $0x2e, %eax
jne 0x5eda4
cmpb $0x0, 0x15(%r12)
je 0x5ede4
addq $0x13, %r12
movq %r13, (%rsp)
movq %r12, %rdi
callq 0xb200
leaq (%rax,%r12), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x1be38
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5f1a6
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x5ede4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
movq %r14, %rdi
callq 0xb850
movq %rax, %r12
testq %rax, %rax
jne 0x5ed7d
movb $0x1, %al
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x5ee1d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/dataprov/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, %rbx
movq %rsi, %rdi
callq 0xb850
xorl %r14d, %r14d
testq %rax, %rax
je 0x5ee53
xorl %ecx, %ecx
cmpb $0x8, 0x12(%rax)
sete %cl
addq %rcx, %r14
movq %rbx, %rdi
callq 0xb850
jmp 0x5ee38
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rsi, %rdi
callq 0xb850
testq %rax, %rax
je 0x5eeeb
movq %rax, %r12
leaq 0x18(%rsp), %rbp
leaq 0x8(%rsp), %r15
cmpb $0x8, 0x12(%r12)
jne 0x5eedb
leaq 0x13(%r12), %r13
movq %rbp, 0x8(%rsp)
movq %r13, %rdi
callq 0xb200
leaq (%r12,%rax), %rdx
addq $0x13, %rdx
movq %r15, %rdi
movq %r13, %rsi
callq 0x1be38
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5f1a6
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x5eedb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
movq %r14, %rdi
callq 0xb850
movq %rax, %r12
testq %rax, %rax
jne 0x5ee8c
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x5ef16
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/dataprov/posix_fs_handler.cc
// Function: scdc_posix_fs_handler::file_open(char const*, int)
scdc_posix_fs_handler::file_t scdc_posix_fs_handler::file_open(const char *path, int flags)
{
  std::string p = root_dir + path;
  SCDC_TRACE_F("path: '" << path << "' -> '" << p << "', flags: " << flags);

  /* file mode: user/group/others can read/write */
  const mode_t mode = S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movq %rsi, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x1d0a0
movq %r15, %rdi
movq %r14, %rsi
callq 0xba60
movq 0x8(%rsp), %rdi
movl %ebx, %esi
movl $0x1b6, %edx            # imm = 0x1B6
xorl %eax, %eax
callq 0xb380
movl %eax, %ebx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x5f098
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x5f0a8
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x5f0c2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/dataprov/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %ecx, %ebp
movl %edx, %ebx
movq %rsi, %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
addq %rsi, %rdx
movq %rsp, %r15
movq %r15, %rdi
callq 0x1d0a0
movq %r15, %rdi
movq %r14, %rsi
callq 0xba60
movl %ebp, %edi
callq 0xbaa0
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0x5f126
movq (%rsp), %rdi
movl %ebx, %esi
xorl %eax, %eax
callq 0xb380
movl %eax, %ebp
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x5f13c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5f14d
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x5f166
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x9(%rdi)
jne 0x5f4a2
leaq 0x2d193(%rip), %r15     # 0x8c570
movq (%r15), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x5f4a2
addq $0x20, %rdi
callq 0xb7d0
movq (%r15), %rax
movq 0x18(%rax), %r14
leaq 0xb167(%rip), %rsi      # 0x6a569
movl $0xd, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0xe686(%rip), %rsi      # 0x6da9c
movl $0x16, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0xaf3a(%rip), %rsi      # 0x6a364
movl $0x1, %edx
movq %r14, %rdi
callq 0xb5f0
movq %r14, %rdi
movl $0x3d, %esi
callq 0xb9a0
movq %rax, %r14
leaq 0xe665(%rip), %rsi      # 0x6dab3
movl $0x8, %edx
movq %rax, %rdi
callq 0xb5f0
leaq 0xca9e(%rip), %rsi      # 0x6bf00
movl $0x8, %edx
movq %r14, %rdi
callq 0xb5f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %r14, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq (%r15), %rdi
addq $0x20, %rdi
callq 0xb3b0
movb $0x1, 0x9(%rbx)
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x5f4ba
movq 0x18(%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
movl $0xb0, %edi
callq 0xb500
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
movaps %xmm0, 0x50(%rax)
leaq 0x60(%rax), %rcx
movq %rcx, 0x68(%rax)
movq %rcx, 0x60(%rax)
xorl %ecx, %ecx
movq %rcx, 0x70(%rax)
leaq 0x80(%rax), %rdx
movq %rdx, 0x88(%rax)
movq %rdx, 0x80(%rax)
movq %rcx, 0x90(%rax)
leaq 0x98(%rax), %rdx
movq %rdx, 0xa0(%rax)
movq %rdx, 0x98(%rax)
movq %rcx, 0xa8(%rax)
movq %rax, 0x10(%rbx)
movb $0x1, 0x58(%rax)
movq %rcx, 0x78(%rax)
movq %rax, %rdi
xorl %esi, %esi
callq 0xb7e0
movq 0x10(%rbx), %rdi
addq $0x28, %rdi
xorl %esi, %esi
popq %rbx
jmp 0xb660
nop