LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x9524e
movq -0x30(%rbp), %rdi
movb $0x1, -0x19(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x96810
testb $0x1, %al
jne 0x952f6
jmp 0x9526d
leaq 0x3f434(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
cmpq $0x0, %rax
je 0x952eb
leaq 0x3f41f(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25800
leaq 0x3f410(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
movq %rax, %rdi
leaq 0x10f06(%rip), %rsi     # 0xa61b0
callq 0xc670
movq %rax, %rdi
leaq 0x1457d(%rip), %rsi     # 0xa9836
callq 0xc670
movq %rax, %rdi
leaq 0x1283d(%rip), %rsi     # 0xa7b05
callq 0xc670
movq %rax, %rdi
movq 0x3ece9(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x3f3c5(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25820
jmp 0x952ed
movb $0x0, -0x19(%rbp)
jmp 0x953d2
movq -0x30(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x95307
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x98, %rdi
callq 0xc260
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0xf8(%rax)
testb $0x1, %al
jne 0x953bf
jmp 0x95339
leaq 0x3f368(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
cmpq $0x0, %rax
je 0x953b7
leaq 0x3f353(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25800
leaq 0x3f344(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
movq %rax, %rdi
leaq 0x10e3a(%rip), %rsi     # 0xa61b0
callq 0xc670
movq %rax, %rdi
leaq 0x144b1(%rip), %rsi     # 0xa9836
callq 0xc670
movq %rax, %rdi
leaq 0x1454d(%rip), %rsi     # 0xa98e1
callq 0xc670
movq %rax, %rdi
movq 0x3ec1d(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x3f2f9(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25820
jmp 0x953b9
movb $0x0, -0x19(%rbp)
jmp 0x953c1
jmp 0x953c1
testb $0x1, -0x19(%rbp)
jne 0x953d0
movq -0x30(%rbp), %rdi
callq 0x96b20
jmp 0x953d2
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: mh0fm4[P]SCDC/src/components/node/node_uds.cc
// Function: scdc_nodeport_uds::close()
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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x953f6
movq -0x18(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x18(%rbp), %rdi
callq 0x96b20
addq $0x20, %rsp
popq %rbp
retq
nop
// File: mh0fm4[P]SCDC/src/components/node/node_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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x18(%rbp), %rsi
callq 0x96b50
testb $0x1, %al
jne 0x9544e
movb $0x0, -0x1(%rbp)
jmp 0x954e1
movq -0x30(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x95476
movq -0x30(%rbp), %rax
movq 0x30(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq 0x48(%rax), %rsi
movq 0x50(%rax), %rdx
callq 0x93a50
cmpq $0x1, -0x18(%rbp)
jne 0x954a0
movq -0x30(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x954a0
movq -0x30(%rbp), %rax
movq 0x90(%rax), %rdi
movq 0x58(%rax), %rsi
movq 0x60(%rax), %rdx
callq 0x93a80
movq -0x30(%rbp), %rax
cmpq $0x0, 0x68(%rax)
jl 0x954bf
movq -0x30(%rbp), %rax
movq 0x90(%rax), %rdi
movq 0x68(%rax), %rsi
callq 0x94b50
movq -0x30(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
callq *0x20(%rax)
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: mh0fm4[P]SCDC/src/components/node/node_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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x90(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x9553b
movq -0x20(%rbp), %rax
movq 0x90(%rax), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x93a80
movq -0x20(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x95562
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x93a50
movq -0x20(%rbp), %rdi
callq 0x96bc0
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/node/node_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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
leaq 0x1240d(%rip), %rsi     # 0xa7a08
callq 0x95d50
movq -0x30(%rbp), %rax
leaq 0x3dffd(%rip), %rcx     # 0xd3608
movq %rcx, (%rax)
movl $0x48, %edi
callq 0xc690
movq %rax, -0x28(%rbp)
jmp 0x9561e
movq -0x28(%rbp), %rdi
callq 0x9c3c0
jmp 0x95629
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x68(%rax)
movl $0x30, %edi
callq 0xc690
movq %rax, -0x38(%rbp)
jmp 0x95645
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
movq 0x68(%rax), %rsi
callq 0x9d760
jmp 0x95658
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq 0x68(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x93a30
jmp 0x95673
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x60(%rax)
movq $0x0, 0x70(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x956d1
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x48, %esi
callq 0xc6a0
jmp 0x956d1
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x30, %esi
callq 0xc6a0
movq -0x30(%rbp), %rdi
callq 0x95e10
movq -0x10(%rbp), %rdi
callq 0xcba0
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/node/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x95ee6
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jle 0x95f12
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x50d50
movl $0x1, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq 0x3d705(%rip), %rcx     # 0xd36b8
movq %rcx, (%rax)
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x19(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0xcbc0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x27820
jmp 0x95fe6
leaq -0x19(%rbp), %rdi
callq 0xc730
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, 0x28(%rdi)
movq $0x0, 0x30(%rdi)
movq $0x0, 0x38(%rdi)
movq $0x0, 0x40(%rdi)
addq $0x70, %rdi
callq 0xc960
movq -0x50(%rbp), %rax
movq $0x0, 0x48(%rax)
movq $0x0, 0x50(%rax)
movq $0x0, 0x58(%rax)
movq $0x0, 0x60(%rax)
movq $-0x1, 0x68(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0xc730
movq -0x28(%rbp), %rdi
callq 0xcba0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x28(%rax), %rax
andq -0x18(%rbp), %rax
cmpq $0x0, %rax
jne 0x96b80
jmp 0x96b78
jmp 0x96b7a
movb $0x0, -0x1(%rbp)
jmp 0x96bb5
movq -0x20(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x96bad
movq -0x20(%rbp), %rdi
movq 0x30(%rdi), %rax
movq %rax, -0x28(%rbp)
addq $0x70, %rdi
callq 0xc260
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x48(%rax)
jmp 0x96baf
jmp 0x96bb1
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: mh0fm4[P]SCDC/src/components/dataprov/posix_fs_handler.cc
// Function: scdc_posix_fs_handler::open_config_conf(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, scdc_args*, bool&)
bool scdc_posix_fs_handler::open_config_conf(const std::string &conf, scdc_args *args, bool &done)
{
  SCDC_TRACE_F("conf: '" << conf << "'");

  bool ret = false;
  done = false;

  SCDC_TRACE_F("return: " << ret << ", done: " << done);

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
jmp 0x96d56
movb $0x0, -0x21(%rbp)
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
jmp 0x96d63
movb -0x21(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x96d92
movb $0x0, -0x21(%rbp)
movq -0x18(%rbp), %rdi
movl $0x4, %esi
leaq -0x30(%rbp), %rdx
xorl %ecx, %ecx
callq 0x4d6c0
cmpq $0x0, %rax
jne 0x96e65
movq -0x20(%rbp), %rdi
leaq 0x12c44(%rip), %rsi     # 0xa9a03
callq 0xc920
leaq 0x3d8dd(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e8e0
cmpq $0x0, %rax
je 0x96e61
leaq 0x3d8c4(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e900
leaq 0x3d8b5(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e8e0
movq %rax, %rdi
leaq 0xf6a3(%rip), %rsi      # 0xa64a8
callq 0xc670
movq %rax, %rdi
leaq 0x12c0d(%rip), %rsi     # 0xa9a21
callq 0xc670
movq %rax, %rdi
leaq 0x12c11(%rip), %rsi     # 0xa9a34
callq 0xc670
movq %rax, %rdi
leaq 0x12cb9(%rip), %rsi     # 0xa9aeb
callq 0xc670
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0xc5b0
movq %rax, %rdi
movq 0x3d173(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x3d84f(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e920
jmp 0x96e63
jmp 0x96ea2
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xc920
movq -0x40(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0xcb90
leaq -0x38(%rbp), %rdi
callq 0x97910
movsbl (%rax), %eax
cmpl $0x2f, %eax
je 0x96e9e
movq -0x40(%rbp), %rdi
movl $0x2f, %esi
callq 0xc3f0
movb $0x1, -0x21(%rbp)
jmp 0x96ea4
jmp 0x96ea6
movb -0x21(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
jmp 0x96edd
movq -0x70(%rbp), %rdi
movb $0x0, -0x11(%rbp)
leaq 0xf6b8(%rip), %rsi      # 0xa65a4
callq 0x97020
testb $0x1, %al
jne 0x97000
movq -0x70(%rbp), %rdx
leaq 0x11403(%rip), %rsi     # 0xa8307
leaq -0x58(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x25900
movq -0x78(%rbp), %rsi
leaq 0x12b22(%rip), %rdx     # 0xa9a3e
leaq -0x38(%rbp), %rdi
callq 0x2eef0
jmp 0x96f27
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xc850
leaq -0x38(%rbp), %rdi
callq 0xc3e0
leaq -0x58(%rbp), %rdi
callq 0xc3e0
leaq 0x3d75b(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e8e0
cmpq $0x0, %rax
je 0x96ffc
leaq 0x3d742(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e900
leaq 0x3d733(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e8e0
movq %rax, %rdi
leaq 0xf521(%rip), %rsi      # 0xa64a8
callq 0xc670
movq %rax, %rdi
leaq 0x12a8b(%rip), %rsi     # 0xa9a21
callq 0xc670
movq %rax, %rdi
leaq 0xe3e4(%rip), %rsi      # 0xa5389
callq 0xc670
movq %rax, %rdi
leaq 0x12b37(%rip), %rsi     # 0xa9aeb
callq 0xc670
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0xc5b0
movq %rax, %rdi
movq 0x3cff1(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x3d6cd(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e920
jmp 0x96ffc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xc3e0
jmp 0x97016
jmp 0x96ffe
jmp 0x97004
movb $0x1, -0x11(%rbp)
jmp 0x97006
jmp 0x97008
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0xcba0
nop
// File: mh0fm4[P]SCDC/src/components/dataprov/posix_fs_handler.cc
// Function: scdc_posix_fs_handler::close(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_posix_fs_handler::close(scdc_result &result)
{
  SCDC_TRACE_F("");

  bool ret = true;

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

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x970ae
movb $0x1, -0x11(%rbp)
jmp 0x970b4
movb -0x11(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x31740
jmp 0x97287
jmp 0x97289
movq -0x10(%rbp), %rdi
callq 0xc310
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xc3e0
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x972c2
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xca60
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x97307
movq -0x20(%rbp), %rdi
callq 0x97320
testb $0x1, %al
jne 0x972f9
movq -0x20(%rbp), %rdi
callq 0x97390
testb $0x1, %al
jne 0x972f9
jmp 0x97305
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x972ca
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x973c2
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xca60
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x973fa
movq -0x20(%rbp), %rdi
callq 0x97320
testb $0x1, %al
jne 0x973ec
jmp 0x973f8
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x973ca
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0x97426
jmp 0x97428
movq -0x10(%rbp), %rdi
callq 0xca60
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x974db
movq -0x20(%rbp), %rdi
callq 0x97320
testb $0x1, %al
jne 0x97451
jmp 0x974d6
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x20(%rbp), %rax
addq $0x13, %rax
movq %rax, -0x68(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xcbc0
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x27820
jmp 0x97485
movq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x97940
jmp 0x97494
leaq -0x40(%rbp), %rdi
callq 0xc3e0
leaq -0x41(%rbp), %rdi
callq 0xc730
jmp 0x974d6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x974cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xc3e0
leaq -0x41(%rbp), %rdi
callq 0xc730
jmp 0x974e5
jmp 0x97428
movb $0x1, %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0xcba0
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x97502
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0xca60
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x9753a
movq -0x20(%rbp), %rdi
callq 0x97390
testb $0x1, %al
jne 0x9752c
jmp 0x97538
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x9750a
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0x97566
jmp 0x97568
movq -0x10(%rbp), %rdi
callq 0xca60
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x9761b
movq -0x20(%rbp), %rdi
callq 0x97390
testb $0x1, %al
jne 0x97591
jmp 0x97616
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x20(%rbp), %rax
addq $0x13, %rax
movq %rax, -0x68(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xcbc0
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x27820
jmp 0x975c5
movq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x97940
jmp 0x975d4
leaq -0x40(%rbp), %rdi
callq 0xc3e0
leaq -0x41(%rbp), %rdi
callq 0xc730
jmp 0x97616
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x9760b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xc3e0
leaq -0x41(%rbp), %rdi
callq 0xc730
jmp 0x97625
jmp 0x97568
movb $0x1, %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0xcba0
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x31740
jmp 0x97746
jmp 0x97748
movl $0x1b6, -0x3c(%rbp)     # imm = 0x1B6
leaq -0x38(%rbp), %rdi
callq 0xc260
movq %rax, %rdi
movl -0x14(%rbp), %esi
xorl %eax, %eax
movl $0x1b6, %edx            # imm = 0x1B6
callq 0xc490
movl %eax, -0x50(%rbp)
jmp 0x9776f
leaq -0x38(%rbp), %rdi
callq 0xc3e0
movl -0x50(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xc3e0
movq -0x48(%rbp), %rdi
callq 0xcba0
nop
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x31740
jmp 0x977cd
jmp 0x977cf
movl -0x20(%rbp), %edi
callq 0xccd0
movl %eax, -0x5c(%rbp)
jmp 0x977dc
movl -0x5c(%rbp), %eax
cmpl $0x0, %eax
je 0x9780b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x58(%rbp)
jmp 0x97833
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xc3e0
jmp 0x97845
leaq -0x48(%rbp), %rdi
callq 0xc260
movq %rax, %rdi
movl -0x1c(%rbp), %esi
xorl %eax, %eax
callq 0xc490
movl %eax, -0x60(%rbp)
jmp 0x97826
movl -0x60(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0x58(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xc3e0
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0xcba0
nop
// File: mh0fm4[P]SCDC/src/components/transport/transport.cc
// Function: scdc_transport_connection_t::acquire()
bool scdc_transport_connection_t::acquire()
{
  SCDC_TRACE("acquire: idle: '" << idle << "'");

  if (!idle) return false;

  idle = false;

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x97ba2
movq -0x18(%rbp), %rax
testb $0x1, 0x9(%rax)
jne 0x97bb2
movb $0x0, -0x1(%rbp)
jmp 0x97bbe
movq -0x18(%rbp), %rax
movb $0x0, 0x9(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x97be6
jmp 0x97be8
movq -0x10(%rbp), %rax
testb $0x1, 0x9(%rax)
je 0x97ca9
jmp 0x97bf8
leaq 0x3caa9(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e8e0
cmpq $0x0, %rax
je 0x97ca5
leaq 0x3ca90(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e900
leaq 0x3ca81(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e8e0
movq %rax, %rdi
leaq 0xe930(%rip), %rsi      # 0xa6569
callq 0xc670
movq %rax, %rdi
leaq 0x11e2c(%rip), %rsi     # 0xa9a74
callq 0xc670
movq %rax, %rdi
leaq 0xe70d(%rip), %rsi      # 0xa6364
callq 0xc670
movq %rax, %rdi
movl $0x3d, %esi
callq 0xcb80
movq %rax, %rdi
leaq 0x11e18(%rip), %rsi     # 0xa9a8b
callq 0xc670
movq %rax, %rdi
leaq 0x1028a(%rip), %rsi     # 0xa7f0c
callq 0xc670
movq %rax, %rdi
movq 0x3c32f(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x3ca0b(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e920
jmp 0x97ca7
jmp 0x97ca9
jmp 0x97cab
movq -0x10(%rbp), %rax
movb $0x1, 0x9(%rax)
cmpq $0x0, 0x10(%rax)
je 0x97cc8
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rax
movq 0x18(%rcx), %rdi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x97d1d
movl $0xb0, %edi
callq 0xc690
movq %rax, %rdi
movq %rdi, -0x28(%rbp)
xorl %esi, %esi
movl $0xb0, %edx
callq 0xc350
movq -0x28(%rbp), %rdi
callq 0x99af0
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rcx
movb $0x1, 0x58(%rcx)
movq 0x10(%rax), %rcx
movq $0x0, 0x78(%rcx)
movq 0x10(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xca00
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
addq $0x28, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xc840
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x10(%rax), %rdi
addq $0x28, %rdi
callq 0xcc90
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xc7f0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x97de7
movq -0x10(%rbp), %rdi
callq 0x99b40
movq -0x10(%rbp), %rdi
movl $0xb0, %esi
callq 0xc6a0
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq $0x0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x97e2a
movq -0x28(%rbp), %rdi
cmpq $0x1, (%rdi)
setg %al
andb $0x1, %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x97ed0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x97e6a
jmp 0x97e54
jmp 0x97e56
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x60(%rax)
jmp 0x97ec6
testb $0x1, -0x11(%rbp)
je 0x97ea9
jmp 0x97e72
jmp 0x97e74
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0xc9f0
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x70(%rax)
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0xc4c0
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
callq 0xc030
jmp 0x97ec6
jmp 0x97eab
jmp 0x97ead
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x70(%rax)
movq -0x20(%rbp), %rsi
callq 0x98060
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: mh0fm4[P]SCDC/src/components/transport/transport.cc
// Function: scdc_transport_connection_pool::run_entry(scdc_transport_connection_pool_entry_t*)
void scdc_transport_connection_pool::run_entry(scdc_transport_connection_pool_entry_t *entry)
{
  SCDC_TRACE("run_entry: entry: '" << entry << "'");

  pthread_mutex_lock(&entry->lock);

  do
  {
    if (entry->conn)
    {
      pthread_mutex_unlock(&entry->lock);

      execute(entry->conn);

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

      release_entry(entry);

#if THREAD_POOLING
      pthread_mutex_lock(&entry->lock);
#else
      SCDC_TRACE("run_entry: return A");
      return;
#endif

    } else
    {
      entry->wait = true;
      pthread_cond_wait(&entry->cond, &entry->lock);
      entry->wait = false;
    }

  } while (entry->run);

  pthread_mutex_unlock(&entry->lock);

  SCDC_TRACE("run_entry: return B");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x9807a
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0xc9f0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x70(%rax)
je 0x980d8
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0xc4c0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rsi
callq 0x98450
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq $0x0, 0x70(%rax)
movq -0x10(%rbp), %rsi
callq 0x983d0
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0xc9f0
jmp 0x980fd
movq -0x10(%rbp), %rax
movb $0x1, 0x6a(%rax)
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0xca50
movq -0x10(%rbp), %rax
movb $0x0, 0x6a(%rax)
jmp 0x980ff
movq -0x10(%rbp), %rax
testb $0x1, 0x69(%rax)
jne 0x98087
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0xc4c0
jmp 0x9811c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/transport/transport.cc
// Function: scdc_transport_connection_pool::finish()
void scdc_transport_connection_pool::finish()
{
  SCDC_TRACE("finish:");

  pthread_mutex_lock(&pool->lock);

  /* wait until all entries have been released */
  while (pool->naquired_entries > 0) pthread_cond_wait(&pool->cond, &pool->lock);

#if THREAD_POOLING
  while (pool->free_entries.size() > 0)
  {
    scdc_transport_connection_pool_entry_t *entry = pool->free_entries.front();
    pool->free_entries.pop_front();
    exit_entry(entry);
    destroy_entry(entry);
  }
#else
  while (pool->dead_entries.size() > 0)
  {
    scdc_transport_connection_pool_entry_t *entry = pool->dead_entries.front();
    pool->dead_entries.pop_front();
    destroy_entry(entry);
  }
#endif

  pthread_mutex_unlock(&pool->lock);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x98146
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xc9f0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, 0x78(%rax)
jle 0x98179
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
addq $0x28, %rdi
movq 0x10(%rax), %rsi
callq 0xca50
jmp 0x98153
jmp 0x9817b
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
addq $0x98, %rdi
callq 0x99b90
cmpq $0x0, %rax
jbe 0x981e3
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
addq $0x98, %rdi
callq 0x99bc0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, -0x10(%rbp)
movq 0x10(%rax), %rdi
addq $0x98, %rdi
callq 0x99bf0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x98200
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x98250
jmp 0x9817b
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xc4c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/transport/transport.cc
// Function: scdc_transport_connection_pool::exit_entry(scdc_transport_connection_pool_entry_t*)
void scdc_transport_connection_pool::exit_entry(scdc_transport_connection_pool_entry_t *entry)
{
  SCDC_TRACE("exit_entry: entry: '" << entry << "'");

  pthread_mutex_lock(&entry->lock);
  entry->run = false;
  pthread_mutex_unlock(&entry->lock);

  pthread_cond_signal(&entry->cond);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x98212
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0xc9f0
movq -0x10(%rbp), %rax
movb $0x0, 0x69(%rax)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0xc4c0
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0xc030
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/transport/transport.cc
// Function: scdc_transport_connection_pool::destroy_entry(scdc_transport_connection_pool_entry_t*)
void scdc_transport_connection_pool::destroy_entry(scdc_transport_connection_pool_entry_t *entry)
{
  SCDC_TRACE("destroy_entry: entry: '" << entry << "'");

  if (entry->async)
  {
    SCDC_TRACE("destroy_entry: joining thread with id: '" << entry->thread << "'");
    pthread_join(entry->thread, NULL);
  }

  pthread_cond_destroy(&entry->cond);
  pthread_mutex_destroy(&entry->lock);

  delete entry;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x98262
movq -0x10(%rbp), %rax
testb $0x1, 0x68(%rax)
je 0x98281
jmp 0x9826e
jmp 0x98270
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xc5c0
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0xcc90
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0xc7f0
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x982b7
movq -0x18(%rbp), %rdi
movl $0x78, %esi
callq 0xc6a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: mh0fm4[P]SCDC/src/components/transport/transport.cc
// Function: scdc_transport_connection_pool::create_entry(bool)
scdc_transport_connection_pool_entry_t *scdc_transport_connection_pool::create_entry(bool async)
{
  SCDC_TRACE("create_entry: async: '" << async << "'");

  scdc_transport_connection_pool_entry_t *entry = new scdc_transport_connection_pool_entry_t();

  entry->pool = this;

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

  entry->async = async;
  entry->run = async;
  entry->wait = false;
  entry->conn = 0;

  if (entry->async)
  {
    SCDC_TRACE("acquire_entry: creating thread");
    pthread_create(&entry->thread, NULL, entry_thread_run, entry);
    SCDC_TRACE("acquire_entry: id: '" << entry->thread << "'");
  }

  return entry;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x982de
movl $0x78, %edi
callq 0xc690
movq %rax, %rdi
movq %rdi, -0x28(%rbp)
xorl %esi, %esi
movl $0x78, %edx
callq 0xc350
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xca00
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xc840
movb -0x9(%rbp), %cl
movq -0x18(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x68(%rax)
movb -0x9(%rbp), %cl
movq -0x18(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x69(%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0x6a(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x70(%rax)
movq -0x18(%rbp), %rax
testb $0x1, 0x68(%rax)
je 0x9838c
jmp 0x9836a
jmp 0x9836c
movq -0x18(%rbp), %rdi
addq $0x60, %rdi
movq -0x18(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
leaq 0x1d(%rip), %rdx        # 0x983a0
callq 0xcc20
jmp 0x9838a
jmp 0x9838c
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/transport/transport.cc
// Function: scdc_transport_connection_pool::release_entry(scdc_transport_connection_pool_entry_t*)
void scdc_transport_connection_pool::release_entry(scdc_transport_connection_pool_entry_t *entry)
{
  SCDC_TRACE("release_entry: entry: '" << entry << "'");

  pthread_mutex_lock(&pool->lock);

#if THREAD_POOLING
  pool->free_entries.push_back(entry);
#else
  pool->total_entries.erase(std::find(pool->total_entries.begin(), pool->total_entries.end(), entry));
  exit_entry(entry);
  pool->dead_entries.push_back(entry);
#endif

  --pool->naquired_entries;

  pthread_mutex_unlock(&pool->lock);

  pthread_cond_signal(&pool->cond);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x983ea
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xc9f0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
addq $0x98, %rdi
leaq -0x10(%rbp), %rsi
callq 0x99c20
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq 0x78(%rcx), %rdx
addq $-0x1, %rdx
movq %rdx, 0x78(%rcx)
movq 0x10(%rax), %rdi
callq 0xc4c0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
addq $0x28, %rdi
callq 0xc030
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/transport/transport.cc
// Function: scdc_transport_connection_pool::execute(scdc_transport_connection_t*)
void scdc_transport_connection_pool::execute(scdc_transport_connection_t *conn)
{
  SCDC_TRACE("execute: conn: '" << conn << "'");

  SCDC_TRACE("connection: " << conn << ": execute: serve");

  transport->serve(conn);

  SCDC_TRACE("connection: " << conn << ": execute: close");

  transport->close(conn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x9846a
jmp 0x9846c
jmp 0x9846e
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x58(%rax)
jmp 0x98482
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x60(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/transport/transport.cc
// Function: scdc_transport_connection_pool::shutdown(bool)
void scdc_transport_connection_pool::shutdown(bool interrupt)
{
  SCDC_TRACE("shutdown:");

  pthread_mutex_lock(&pool->lock);

  for (std::list<scdc_transport_connection_pool_entry_t *>::iterator i = pool->total_entries.begin(); i != pool->total_entries.end(); ++i)
  {
    scdc_transport_connection_pool_entry_t *entry = *i;

    pthread_mutex_lock(&entry->lock);
    
    if (entry->conn) transport->shutdown(entry->conn, interrupt);

    pthread_mutex_unlock(&entry->lock);
  }

  pool->run = false;

  pthread_mutex_unlock(&pool->lock);

  pthread_cond_signal(&pool->cond);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x984be
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xc9f0
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
addq $0x80, %rdi
callq 0x99c60
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
addq $0x80, %rdi
callq 0x99cc0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x99c90
testb $0x1, %al
jne 0x9850e
jmp 0x98570
leaq -0x18(%rbp), %rdi
callq 0x99cf0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0xc9f0
movq -0x28(%rbp), %rax
cmpq $0x0, 0x70(%rax)
je 0x98555
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x70(%rax), %rsi
movb -0x9(%rbp), %cl
movq (%rdi), %rax
andb $0x1, %cl
movzbl %cl, %edx
callq *0x50(%rax)
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0xc4c0
leaq -0x18(%rbp), %rdi
callq 0x99d10
jmp 0x984e3
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rcx
movb $0x0, 0x58(%rcx)
movq 0x10(%rax), %rdi
callq 0xc4c0
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
addq $0x28, %rdi
callq 0xc030
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: mh0fm4[P]SCDC/src/components/transport/transport.cc
// Function: scdc_transport::stop()
bool scdc_transport::stop()
{
  SCDC_TRACE("stop: running: '" << running << "', canceled: '" << canceled << "'");

  if (!running && !canceled)
  {
    SCDC_FAIL("stop: not running");
    return false;
  }

  if (!canceled) cancel(true);

  if (async)
  {
    pthread_join(server->thread, NULL);
    async = false;
  }

  /* wait for all connections of the connection pool to be finished */
  if (server_connections) server_connections->finish();

  compcoup_transport->stop();

  delete server_connections; server_connections = 0;
  delete server; server = 0;

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x98906
movq -0x18(%rbp), %rax
testb $0x1, 0x29(%rax)
jne 0x989ad
movq -0x18(%rbp), %rax
testb $0x1, 0x2b(%rax)
jne 0x989ad
jmp 0x98924
leaq 0x3bd7d(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
cmpq $0x0, %rax
je 0x989a2
leaq 0x3bd68(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25800
leaq 0x3bd59(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
movq %rax, %rdi
leaq 0xd84f(%rip), %rsi      # 0xa61b0
callq 0xc670
movq %rax, %rdi
leaq 0x114e0(%rip), %rsi     # 0xa9e50
callq 0xc670
movq %rax, %rdi
leaq 0x1113c(%rip), %rsi     # 0xa9abb
callq 0xc670
movq %rax, %rdi
movq 0x3b632(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x3bd0e(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25820
jmp 0x989a4
movb $0x0, -0x1(%rbp)
jmp 0x98a73
movq -0x18(%rbp), %rax
testb $0x1, 0x2b(%rax)
jne 0x989c6
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *0x30(%rax)
movq -0x18(%rbp), %rax
testb $0x1, 0x28(%rax)
je 0x989ec
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xc5c0
movq -0x18(%rbp), %rax
movb $0x0, 0x28(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x98a04
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x98130
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x98a3b
movq -0x20(%rbp), %rdi
callq 0x97d90
movq -0x20(%rbp), %rdi
movl $0x18, %esi
callq 0xc6a0
movq -0x18(%rbp), %rax
movq $0x0, 0x38(%rax)
movq 0x30(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x98a63
movq -0x28(%rbp), %rdi
movl $0x8, %esi
callq 0xc6a0
movq -0x18(%rbp), %rax
movq $0x0, 0x30(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop