LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rdi
callq 0xb7d0
movq 0x10(%r14), %r12
leaq 0x98(%r12), %r15
movl $0x18, %edi
callq 0xb500
movq %rbx, 0x10(%rax)
movq %rax, %rdi
movq %r15, %rsi
callq 0xb090
incq 0xa8(%r12)
movq 0x10(%r14), %rdi
decq 0x78(%rdi)
callq 0xb3b0
movq 0x10(%r14), %rdi
addq $0x28, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xb030
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0xb7d0
movq 0x10(%rbx), %rdi
leaq 0x80(%rdi), %rax
movq 0x80(%rdi), %r15
cmpq %rax, %r15
je 0x5ffbf
movzbl %bpl, %ebp
movq 0x10(%r15), %r12
leaq 0x8(%r12), %r14
movq %r14, %rdi
callq 0xb7d0
movq 0x70(%r12), %rsi
testq %rsi, %rsi
je 0x5ffa4
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
movl %ebp, %edx
callq *0x50(%rax)
movq %r14, %rdi
callq 0xb3b0
movq (%r15), %r15
movq 0x10(%rbx), %rdi
leaq 0x80(%rdi), %rax
cmpq %rax, %r15
jne 0x5ff7d
movb $0x0, 0x58(%rdi)
callq 0xb3b0
movq 0x10(%rbx), %rdi
addq $0x28, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xb030
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x0, 0x29(%rdi)
jne 0x6025f
cmpb $0x0, 0x2b(%rbx)
je 0x602eb
cmpb $0x0, 0x2b(%rbx)
jne 0x60273
movq (%rbx), %rax
movq %rbx, %rdi
movl $0x1, %esi
callq *0x30(%rax)
cmpb $0x1, 0x28(%rbx)
jne 0x6028b
movq 0x30(%rbx), %rax
movq (%rax), %rdi
xorl %esi, %esi
callq 0xb460
movb $0x0, 0x28(%rbx)
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x60299
callq 0x5fd0e
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movq 0x38(%rbx), %r14
testq %r14, %r14
je 0x602c1
movq %r14, %rdi
callq 0x5fa36
movl $0x18, %esi
movq %r14, %rdi
callq 0xb510
movq $0x0, 0x38(%rbx)
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x602dc
movl $0x8, %esi
callq 0xb510
movq $0x0, 0x30(%rbx)
movb $0x1, %al
jmp 0x6037d
leaq 0x2c27e(%rip), %r14     # 0x8c570
movq (%r14), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x6037b
addq $0x20, %rdi
callq 0xb7d0
movq (%r14), %rax
movq 0x8(%rax), %rbx
leaq 0x9e75(%rip), %rsi      # 0x6a188
movl $0xb, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0xdae1(%rip), %rsi      # 0x6de08
movl $0xb, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0xd738(%rip), %rsi      # 0x6da73
movl $0x11, %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 %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/transport/transport.cc
// Function: scdc_transport::cancel(bool)
bool scdc_transport::cancel(bool interrupt)
{
  SCDC_TRACE("cancel: interrupt: '" << interrupt << "', running: '" << running << "'");

  if (!running)
  {
    SCDC_FAIL("cancel: not running");
    return false;
  }

  compcoup_transport->cancel(interrupt);

  running = false;
  canceled = true;

  /* shutdown (potential) server */
  shutdown(0, interrupt);

  /* shutdown all connections of the connection pool */
  if (server_connections) server_connections->shutdown(interrupt);

  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movb 0x29(%rdi), %bl
testb %bl, %bl
je 0x603d7
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
movzbl %sil, %ebp
movl %ebp, %esi
callq *0x38(%rax)
movb $0x0, 0x29(%r14)
movb $0x1, 0x2b(%r14)
movq (%r14), %rax
movq %r14, %rdi
xorl %esi, %esi
movl %ebp, %edx
callq *0x50(%rax)
movq 0x38(%r14), %rdi
testq %rdi, %rdi
je 0x60467
movl %ebp, %esi
callq 0x5ff4c
jmp 0x60467
leaq 0x2c192(%rip), %r15     # 0x8c570
movq (%r15), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x60467
addq $0x20, %rdi
callq 0xb7d0
movq (%r15), %rax
movq 0x8(%rax), %r14
leaq 0x9d89(%rip), %rsi      # 0x6a188
movl $0xb, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0xd9f5(%rip), %rsi      # 0x6de08
movl $0xb, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0xd65e(%rip), %rsi      # 0x6da85
movl $0x13, %edx
movq %r14, %rdi
callq 0xb5f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %r14, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq (%r15), %rdi
addq $0x20, %rdi
callq 0xb3b0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/transport/transport.cc
// Function: scdc_transport::run()
void scdc_transport::run()
{
  SCDC_TRACE("run:");

  scdcint_t i = 0;

  while (running)
  {
    SCDC_TRACE("run: loop: " << i << ": accept");

    scdc_transport_connection_t *conn = accept();

    SCDC_TRACE("run: loop: " << i << ": accept: '" << conn << "'");

    if (conn)
    {
      if (server_connections) server_connections->insert(conn);
      else
      {
        serve(conn);
        close(conn);
      }
    }

    if (loop_handler) loop_handler(loop_handler_data, i);

    ++i;
  }
}

// Assembly:
cmpb $0x1, 0x29(%rdi)
jne 0x604e1
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x40(%rax)
testq %rax, %rax
je 0x604c1
movq %rax, %r15
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x604a9
movq %r15, %rsi
callq 0x5faf2
jmp 0x604c1
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *0x58(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *0x60(%rax)
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x604d3
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq *%rax
incq %r14
cmpb $0x0, 0x29(%rbx)
jne 0x60485
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/transport/transport.cc
// Function: scdc_transport::connect(scdc_transport_connection_t*)
scdc_transport_connection_t *scdc_transport::connect(scdc_transport_connection_t *conn)
{
  SCDC_TRACE("connect:");

  create_incoming(conn);
  create_outgoing(conn);

  compcoup_transport->connect(conn);

  conn->open = true;

  return conn;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq $-0x1, %rdx
callq *0xd8(%rax)
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
movq $-0x1, %rdx
callq *0xe8(%rax)
movq 0x8(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x50(%rax)
movb $0x1, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/transport/transport.cc
// Function: scdc_transport::disconnect(scdc_transport_connection_t*)
bool scdc_transport::disconnect(scdc_transport_connection_t *conn)
{
  SCDC_TRACE("disconnect:");

  conn->open = false;

  compcoup_transport->disconnect(conn);

  destroy_incoming(conn);
  destroy_outgoing(conn);

  SCDC_TRACE("close: conn: '" << conn << "', total_send: " << conn->total_send << ", total_receive: " << conn->total_receive);

  return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movb $0x0, 0x8(%rsi)
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0xe0(%rax)
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0xf0(%rax)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/transport/transport.cc
// Function: send_outgoing_dataset_inout(scdc_transport_connection_t*, _scdc_dataset_inout_t*)
static bool send_outgoing_dataset_inout(scdc_transport_connection_t *conn, scdc_dataset_input_t *inout)
{
#if 0
  return send_outgoing_dataset_inout(conn, input);
#else

  bool ret = true;

#if SCDC_DATASET_INOUT_BUF_MULTIPLE
  if (SCDC_DATASET_INOUT_MBUF_ISSET(inout))
  {
    scdcint_t i;
    for (i = 0; i < SCDC_DATASET_INOUT_MBUF_GET_C(inout); ++i)
    {
      ret = ret && send_outgoing_buf(conn, SCDC_DATASET_INOUT_MBUF_M(inout, i));
    }

  } else
#endif
  {
    scdc_buf_t *inout_buf;

#if SCDC_DEPRECATED
    scdc_buf_t buf;

    buf.ptr = SCDC_DATASET_INOUT_BUF_PTR(inout);
    buf.size = SCDC_DATASET_INOUT_BUF_SIZE(inout);
    buf.current = SCDC_DATASET_INOUT_BUF_CURRENT(inout);

    inout_buf = &buf;
#else /* SCDC_DEPRECATED */
    inout_buf = &inout->buf;
#endif /* SCDC_DEPRECATED */

    ret = send_outgoing_buf(conn, inout_buf);

#if SCDC_DEPRECATED
    SCDC_DATASET_INOUT_BUF_CURRENT(inout) = buf.current;
#endif /* SCDC_DEPRECATED */
  }

  return ret;

#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %rax
testq %rax, %rax
js 0x60929
movq 0x10(%rbx), %rcx
movq %rsp, %r15
movq %rcx, (%r15)
movq %rax, 0x8(%r15)
movq 0x20(%rbx), %rax
movq %rax, 0x10(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x60b2d
movq 0x10(%r15), %rcx
movq %rcx, 0x20(%rbx)
andb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movb $0x1, %al
xorl %r15d, %r15d
xorl %r12d, %r12d
cmpq $0x0, 0x18(%rbx)
js 0x6093c
xorl %ecx, %ecx
jmp 0x60945
movq 0x20(%rbx), %rdx
xorl %ecx, %ecx
subq %rdx, %rcx
cmpq %rcx, %r12
jge 0x6091b
testb $0x1, %al
je 0x6095f
movq 0x10(%rbx), %rsi
addq %r15, %rsi
movq %r14, %rdi
callq 0x60b2d
jmp 0x60961
xorl %eax, %eax
incq %r12
addq $0x18, %r15
jmp 0x60931
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/transport/transport.cc
// Function: scdc_transport::send_outgoing(scdc_transport_connection_t*)
bool scdc_transport::send_outgoing(scdc_transport_connection_t *conn)
{
  SCDC_TRACE("send_outgoing:");

  scdcint_t n = conn->outgoing.get_read_pos_buf_size();
  
  if (n > 0) n = send(conn, conn->outgoing.get_read_pos_buf(), n);

/*  SCDC_INFO("send: " << n);*/

  if (n < 0) return false;

  conn->total_send += n;

  conn->outgoing.inc_read_pos(n);

  conn->outgoing.compact();

  return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq 0x90(%rsi), %rbx
movq 0x98(%rsi), %rdx
subq %rdx, %rbx
jle 0x609a3
addq 0x78(%r14), %rdx
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rcx
callq *0x78(%rax)
movq %rax, %rbx
testq %rbx, %rbx
js 0x609bc
addq %rbx, 0x20(%r14)
leaq 0x70(%r14), %rdi
addq %rbx, 0x98(%r14)
callq 0x6794c
testq %rbx, %rbx
setns %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/transport/transport.cc
// Function: scdc_transport::recv_incoming(scdc_transport_connection_t*)
bool scdc_transport::recv_incoming(scdc_transport_connection_t *conn)
{
  SCDC_TRACE("recv_incoming:");

  conn->incoming.compact();

  scdcint_t n = conn->incoming.get_write_pos_buf_size();

  if (n > 0) n = receive(conn, conn->incoming.get_write_pos_buf(), n);

/*  SCDC_INFO("receive: " << n);*/

  if (n < 0) return false;

  conn->total_receive += n;

  conn->incoming.inc_write_pos(n);

  return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x30(%rsi), %rdi
callq 0x6794c
movq 0x40(%rbx), %rax
movq 0x50(%rbx), %rdx
subq %rdx, %rax
jle 0x60a01
addq 0x38(%rbx), %rdx
movq (%r14), %r8
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rcx
callq *0x80(%r8)
testq %rax, %rax
js 0x60a0e
addq %rax, 0x28(%rbx)
addq %rax, 0x50(%rbx)
testq %rax, %rax
setns %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/transport/transport.cc
// Function: scdc_transport::create_incoming(scdc_transport_connection_t*, long long)
void scdc_transport::create_incoming(scdc_transport_connection_t *conn, scdcint_t size)
{
  if (size < 0) size = DEFAULT_TRANSPORT_ALLOC_INCOMING_SIZE;
  conn->incoming.alloc_buf(size);

  conn->incoming.set_data(conn);
  conn->incoming.set_next(scdc_transport_incoming_next);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdx, %rdx
movl $0x8000, %r14d          # imm = 0x8000
cmovnsq %rdx, %r14
movq %r14, %rdi
callq 0xb040
movq %rax, 0x38(%rbx)
movq %r14, 0x40(%rbx)
movb $0x1, 0x48(%rbx)
movq %rbx, 0x60(%rbx)
leaq 0xc(%rip), %rax         # 0x60a5b
movq %rax, 0x68(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/transport/transport.cc
// Function: scdc_transport::create_outgoing(scdc_transport_connection_t*, long long)
void scdc_transport::create_outgoing(scdc_transport_connection_t *conn, scdcint_t size)
{
  if (size < 0) size = DEFAULT_TRANSPORT_ALLOC_OUTGOING_SIZE;
  conn->outgoing.alloc_buf(size);

  conn->outgoing.set_data(conn);
  conn->outgoing.set_next(scdc_transport_outgoing_next);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdx, %rdx
movl $0x8000, %r14d          # imm = 0x8000
cmovnsq %rdx, %r14
movq %r14, %rdi
callq 0xb040
movq %rax, 0x78(%rbx)
movq %r14, 0x80(%rbx)
movb $0x1, 0x88(%rbx)
movq %rbx, 0xa0(%rbx)
leaq 0xf(%rip), %rax         # 0x60ae5
movq %rax, 0xa8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/transport/transport.cc
// Function: send_outgoing_buf(scdc_transport_connection_t*, _scdc_buf_t*)
static bool send_outgoing_buf(scdc_transport_connection_t *conn, scdc_buf_t *buf)
{
  bool ret = true;

  scdcint_t mx = buf->current;
  buf->current = 0;

  const char *src = static_cast<char *>(buf->ptr);
  scdcint_t src_size = buf->size;

  if (mx > 0)
  {
    /* 1st: copy from inout to outgoing */
    char *dst = conn->outgoing.get_write_pos_buf();
    scdcint_t dst_size = conn->outgoing.get_write_pos_buf_size();

    scdcint_t n = min(src_size, mx);

    /* only short messages that fit into outgoing */
    if (n <= DEFAULT_TRANSPORT_SEND_OUTGOING_DATASET_INOUT_THRESHOLD && n <= dst_size)
    {
      memcpy(dst, src, n);

      conn->outgoing.inc_write_pos(n);

      src += n;
      src_size -= n;

      mx -= n;
      buf->current += n;
    }
  }

  if (mx > 0)
  {
    /* send outgoing before sending inout directly */
    ret = ret && conn->transport->send_outgoing(conn);

    /* 2nd: send from inout */

    scdcint_t n;

    while (1)
    {
      n = min(src_size, mx);

      if (n <= 0) break;

      n = conn->transport->send(conn, src, n);

/*      SCDC_INFO("conn->transport->send: " << n);*/

      if (n < 0) break;

      conn->total_send += n;

      src += n;
      src_size -= n;

      mx -= n;
      buf->current += n;
    }

    ret = ret && (n >= 0);
  }

  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %r13
movq $0x0, 0x10(%rsi)
movq (%rsi), %r15
movq 0x8(%rsi), %r12
testq %r13, %r13
jle 0x60ba2
cmpq %r12, %r13
movq %r12, %rbp
cmovlq %r13, %rbp
cmpq $0x400, %rbp            # imm = 0x400
jg 0x60ba2
movq 0x80(%r14), %rax
movq 0x90(%r14), %rdi
subq %rdi, %rax
cmpq %rax, %rbp
jg 0x60ba2
addq 0x78(%r14), %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0xb3f0
addq %rbp, 0x90(%r14)
addq %rbp, %r15
subq %rbp, %r12
subq %rbp, %r13
addq %rbp, 0x10(%rbx)
testq %r13, %r13
jle 0x60c0a
movq (%r14), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0xd0(%rax)
movl %eax, %ebp
cmpq %r12, %r13
movq %r12, %rax
cmovlq %r13, %rax
testq %r12, %r12
jle 0x60bff
movq (%r14), %rdi
movq (%rdi), %r8
movq %r14, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq *0x78(%r8)
testq %rax, %rax
js 0x60bff
addq %rax, 0x20(%r14)
addq %rax, %r15
subq %rax, %r12
subq %rax, %r13
addq %rax, 0x10(%rbx)
cmpq %r12, %r13
movq %r12, %rax
cmovlq %r13, %rax
testq %rax, %rax
jg 0x60bc7
testq %rax, %rax
setns %al
andb %al, %bpl
jmp 0x60c0d
movb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/transport/transport_stream.cc
// Function: scdc_transport_stream::start(long long, _IO_FILE*, _IO_FILE*)
bool scdc_transport_stream::start(scdcint_t mode, FILE *ifile, FILE *ofile)
{
  SCDC_TRACE("start: mode '" << mode << "', ifile: '" << ifile << "', ofile: '" << ofile << "'");

#if SCDC_TRANSPORT_STREAM_USE_IOSTREAM
  stream_server->stream_conn.is = 0;
  stream_server->stream_conn.os = 0;
#endif
  stream_server->stream_conn.ifile = (ifile)?ifile:stdin;
  stream_server->stream_conn.ofile = (ofile)?ofile:stdout;

  return scdc_transport::start(mode);
}

// Assembly:
testq %rdx, %rdx
jne 0x60d35
movq 0x2b29e(%rip), %rax     # 0x8bfd0
movq (%rax), %rdx
movq 0x40(%rdi), %rax
movq %rdx, 0x2d8(%rax)
testq %rcx, %rcx
jne 0x60d4f
movq 0x2b254(%rip), %rcx     # 0x8bfa0
movq (%rcx), %rcx
movq %rcx, 0x2e0(%rax)
jmp 0x60028
nop
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/transport/transport_stream.cc
// Function: scdc_transport_stream::stop()
bool scdc_transport_stream::stop()
{
  SCDC_TRACE("stop");

  if (!scdc_transport::stop())
  {
    SCDC_FAIL("stop: failed to stop");
    return false;
  }

#if SCDC_TRANSPORT_STREAM_USE_IOSTREAM
  stream_server->stream_conn.is = 0;
  stream_server->stream_conn.os = 0;
#endif
  stream_server->stream_conn.ifile = 0;
  stream_server->stream_conn.ofile = 0;

  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0x60248
movl %eax, %ebx
testb %al, %al
je 0x60d82
movq 0x40(%r14), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x2d8(%rax)
jmp 0x60e12
leaq 0x2b7e7(%rip), %r15     # 0x8c570
movq (%r15), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x60e12
addq $0x20, %rdi
callq 0xb7d0
movq (%r15), %rax
movq 0x8(%rax), %r14
leaq 0x93de(%rip), %rsi      # 0x6a188
movl $0xb, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0xcd5d(%rip), %rsi      # 0x6db1b
movl $0x12, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0xcd5c(%rip), %rsi      # 0x6db2e
movl $0x14, %edx
movq %r14, %rdi
callq 0xb5f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %r14, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq (%r15), %rdi
addq $0x20, %rdi
callq 0xb3b0
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/transport/transport_stream.cc
// Function: scdc_transport_stream::accept()
scdc_transport_connection_t *scdc_transport_stream::accept()
{
  SCDC_TRACE("accept:");

  scdc_transport_stream_connection_t *stream_conn = 0;

  stream_server->stream_conn.open = 
#if SCDC_TRANSPORT_STREAM_USE_IOSTREAM
    (stream_server->stream_conn.is && !stream_server->stream_conn.is->eof() && stream_server->stream_conn.os && !stream_server->stream_conn.os->eof()) ||
#endif
    (stream_server->stream_conn.ifile && !feof(stream_server->stream_conn.ifile) && stream_server->stream_conn.ofile && !feof(stream_server->stream_conn.ofile));

  SCDC_TRACE("accept: I/O streams open: " << stream_server->stream_conn.open);

  if (stream_server->stream_conn.open)
  {
    stream_conn = &stream_server->stream_conn;

  } else
  {
    cancel(false);
    return 0;
  }

  SCDC_TRACE("accept: '" << stream_conn << "'");

  return scdc_transport::accept(stream_conn);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq 0x2d8(%rax), %rdi
testq %rdi, %rdi
je 0x60e37
callq 0xb880
testl %eax, %eax
je 0x60e5c
xorl %eax, %eax
movq 0x40(%rbx), %rsi
movb %al, 0x8(%rsi)
testb %al, %al
je 0x60e4d
movq %rbx, %rdi
popq %rbx
jmp 0x604e2
movq (%rbx), %rax
movq %rbx, %rdi
xorl %esi, %esi
callq *0x30(%rax)
xorl %eax, %eax
popq %rbx
retq
movq 0x40(%rbx), %rax
movq 0x2e0(%rax), %rdi
testq %rdi, %rdi
je 0x60e37
callq 0xb880
testl %eax, %eax
sete %al
jmp 0x60e39
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/transport/transport_stream.cc
// Function: scdc_transport_stream::connect(_IO_FILE*, _IO_FILE*)
scdc_transport_connection_t *scdc_transport_stream::connect(FILE *ifile, FILE *ofile)
{
  SCDC_TRACE("start: ifile: '" << ifile << "', ofile: '" << ofile << "'");

  scdc_transport_stream_connection_t *stream_conn = new scdc_transport_stream_connection_t(this);

#if SCDC_TRANSPORT_STREAM_USE_IOSTREAM
  stream_conn->is = 0;
  stream_conn->os = 0;
#endif
  stream_conn->ifile = (ifile)?ifile:stdin;
  stream_conn->ofile = (ofile)?ofile:stdout;

  return scdc_transport::connect(stream_conn);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x2e8, %edi            # imm = 0x2E8
callq 0xb500
movq %rbx, (%rax)
movw $0x100, 0x8(%rax)       # imm = 0x100
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
leaq 0x2ae2f(%rip), %rcx     # 0x8bd08
addq $0x10, %rcx
movq %rcx, 0x30(%rax)
movups %xmm0, 0x38(%rax)
xorl %edx, %edx
movb %dl, 0x48(%rax)
movups %xmm0, 0x50(%rax)
movups %xmm0, 0x60(%rax)
movq %rcx, 0x70(%rax)
movups %xmm0, 0x78(%rax)
movb %dl, 0x88(%rax)
movups %xmm0, 0x90(%rax)
movups %xmm0, 0xa0(%rax)
movups %xmm0, 0x2c0(%rax)
movl $0x0, 0x2d0(%rax)
movups %xmm0, 0x2d8(%rax)
testq %r15, %r15
jne 0x60f35
movq 0x2b09e(%rip), %rcx     # 0x8bfd0
movq (%rcx), %r15
movq %r15, 0x2d8(%rax)
testq %r14, %r14
jne 0x60f4b
movq 0x2b058(%rip), %rcx     # 0x8bfa0
movq (%rcx), %r14
movq %r14, 0x2e0(%rax)
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x60560
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/transport/transport_stream.cc
// Function: scdc_transport_stream::send(scdc_transport_connection_t*, void const*, long long)
scdcint_t scdc_transport_stream::send(scdc_transport_connection_t *conn, const void *buf, scdcint_t buf_size)
{
  SCDC_TRACE("send: conn: '" << conn << "', buf: '" << buf << "', buf_size: " << buf_size);

  scdc_transport_stream_connection_t *stream_conn = static_cast<scdc_transport_stream_connection_t *>(conn);

  scdcint_t n;

#if SCDC_TRANSPORT_STREAM_USE_SHUTDOWN_EXCEPTION
  try
  {
#endif
#if SCDC_TRANSPORT_STREAM_USE_IOSTREAM
    if (stream_conn->os)
    {
      if (stream_conn->os->eof())
      {
        SCDC_TRACE("connection: " << stream_conn << ": send: end of output stream");
        n = -1;

      } else
      {
        stream_conn->os->write(static_cast<const char *>(buf), buf_size);
        n = buf_size;
      }

    } else
#endif
    if (stream_conn->ofile)
    {
      if (feof(stream_conn->ofile))
      {
        SCDC_TRACE("connection: " << stream_conn << ": send: end of output stream");
        n = -1;

      } else
      {
        n = fwrite(buf, 1, buf_size, stream_conn->ofile);
      }

    } else
    {
      SCDC_FATAL("connection: " << stream_conn << ": send: no output stream available");
      n = -1;
    }

#if SCDC_TRANSPORT_STREAM_USE_SHUTDOWN_EXCEPTION
  } catch (const scdc_transport_stream_shutdown_ex &ex)
  {
    SCDC_INFO("connection: " << stream_conn << ": send: catch shutdown exception");
    n = -1;
  }
#endif

  SCDC_TRACE("connection: " << stream_conn << ": send: sent " << n << " byte(s)");

  return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x2e0(%rsi), %rdi
testq %rdi, %rdi
je 0x60fdd
movq %rcx, %r14
movq %rdx, %r15
callq 0xb880
testl %eax, %eax
jne 0x61093
movq 0x2e0(%rbx), %rcx
movl $0x1, %esi
movq %r15, %rdi
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xba90
leaq 0x2b58c(%rip), %r15     # 0x8c570
movq (%r15), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x61093
addq $0x20, %rdi
callq 0xb7d0
movq (%r15), %rax
movq 0x18(%rax), %r14
leaq 0xca90(%rip), %rsi      # 0x6da99
movl $0xc, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0xcafe(%rip), %rsi      # 0x6db1b
movl $0x12, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0xcb12(%rip), %rsi      # 0x6db43
movl $0xc, %edx
movq %r14, %rdi
callq 0xb5f0
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb3c0
movq %rax, %rbx
leaq 0xcafd(%rip), %rsi      # 0x6db50
movl $0x22, %edx
movq %rax, %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 (%r15), %rdi
addq $0x20, %rdi
callq 0xb3b0
movq $-0x1, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/transport/transport_tcp.cc
// Function: scdc_transport_tcp::accept()
scdc_transport_connection_t *scdc_transport_tcp::accept()
{
  SCDC_TRACE("accept:");

  scdc_transport_tcp_connection_t *tcp_conn = new scdc_transport_tcp_connection_t(this);

  socklen_t saddrlen = sizeof(tcp_server->saddr);

#if SCDC_TRANSPORT_TCP_USE_SHUTDOWN_EXCEPTION
  try
  {
#endif
    tcp_conn->socket = ::accept(tcp_server->server_socket, (struct sockaddr *) &tcp_server->saddr, &saddrlen);

#if SCDC_TRANSPORT_TCP_USE_SHUTDOWN_EXCEPTION
  } catch (const std::exception& ex)
  {
    SCDC_ERROR("connection " << tcp_conn << ": exception during accept");
    tcp_conn->socket = -1;
  }
#endif

  if (tcp_conn->socket != -1)
  {
    tcp_conn->open = true;

  } else
  {
    if (!shutdowned) SCDC_FAIL("accept: accepting connection failed: '" << strerror(errno) << "'");
    delete tcp_conn;
    tcp_conn = 0;
    return 0;
  }

  SCDC_TRACE("accept: '" << tcp_conn << "'");

  return scdc_transport::accept(tcp_conn);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x2d8, %edi            # imm = 0x2D8
callq 0xb500
movq %rax, %rbx
movq %r14, (%rax)
movw $0x100, 0x8(%rax)       # imm = 0x100
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
leaq 0x2a685(%rip), %rax     # 0x8bd08
addq $0x10, %rax
movq %rax, 0x30(%rbx)
movups %xmm0, 0x38(%rbx)
xorl %ecx, %ecx
movb %cl, 0x48(%rbx)
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x60(%rbx)
movq %rax, 0x70(%rbx)
movups %xmm0, 0x78(%rbx)
movb %cl, 0x88(%rbx)
movups %xmm0, 0x90(%rbx)
movups %xmm0, 0xa0(%rbx)
movups %xmm0, 0x2c0(%rbx)
movq $0x0, 0x2d0(%rbx)
leaq 0x4(%rsp), %rdx
movl $0x10, (%rdx)
movq 0x40(%r14), %rsi
movl 0x10(%rsi), %edi
callq 0xb160
movl %eax, 0x2d4(%rbx)
cmpl $-0x1, %eax
je 0x61700
movb $0x1, 0x8(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x604e2
jmp 0x61811
cmpb $0x0, 0x2a(%r14)
jne 0x617fa
leaq 0x2ae5e(%rip), %r12     # 0x8c570
movq (%r12), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x617fa
addq $0x20, %rdi
callq 0xb7d0
movq (%r12), %rax
movq 0x8(%rax), %r14
leaq 0x8a4f(%rip), %rsi      # 0x6a188
movl $0xb, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0xc464(%rip), %rsi      # 0x6dbb1
movl $0xf, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0xc4f0(%rip), %rsi      # 0x6dc51
movl $0x26, %edx
movq %r14, %rdi
callq 0xb5f0
callq 0xb070
movl (%rax), %edi
callq 0xb190
testq %rax, %rax
je 0x6179a
movq %rax, %r15
movq %rax, %rdi
callq 0xb200
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xb5f0
jmp 0x617b2
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0xb990
leaq 0xaba2(%rip), %rsi      # 0x6c35b
movl $0x1, %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 (%r12), %rdi
addq $0x20, %rdi
callq 0xb3b0
movq %rbx, %rdi
callq 0x611fa
movl $0x2d8, %esi            # imm = 0x2D8
movq %rbx, %rdi
callq 0xb510
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/transport/transport_tcp.cc
// Function: scdc_transport_tcp::shutdown(scdc_transport_connection_t*, bool)
void scdc_transport_tcp::shutdown(scdc_transport_connection_t *conn, bool interrupt)
{
  SCDC_TRACE("shutdown: interrupt: '" << interrupt << "'");

  scdc_transport::shutdown(conn, interrupt);

#if SCDC_TRANSPORT_TCP_USE_SHUTDOWN_EXCEPTION
  if (interrupt) throw scdc_transport_tcp_shutdown_ex();
#endif

  if (conn)
  {
    SCDC_TRACE("shutdown: connection socket shutdown");

    scdc_transport_tcp_connection_t *tcp_conn = static_cast<scdc_transport_tcp_connection_t *>(conn);

    ::shutdown(tcp_conn->socket, SHUT_RDWR);

  } else if (tcp_server)
  {
    SCDC_TRACE("shutdown: server socket shutdown");

    ::shutdown(tcp_server->server_socket, SHUT_RDWR);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x6051e
testq %rbx, %rbx
je 0x6183b
addq $0x2d4, %rbx            # imm = 0x2D4
jmp 0x61848
movq 0x40(%r14), %rbx
testq %rbx, %rbx
je 0x6185b
addq $0x10, %rbx
movl (%rbx), %edi
movl $0x2, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb730
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/transport/transport_tcp.cc
// Function: scdc_transport_tcp::send(scdc_transport_connection_t*, void const*, long long)
scdcint_t scdc_transport_tcp::send(scdc_transport_connection_t *conn, const void *buf, scdcint_t buf_size)
{
  SCDC_TRACE("send: conn: '" << conn << "', buf: '" << buf << "', buf_size: " << buf_size);

  scdc_transport_tcp_connection_t *tcp_conn = static_cast<scdc_transport_tcp_connection_t *>(conn);

  scdcint_t n = 0;

  bool except = false;

#if SCDC_TRANSPORT_TCP_USE_SHUTDOWN_EXCEPTION
  try
  {
#endif
do_send:
    n = ::send(tcp_conn->socket, buf, buf_size, 0);

    if (n < 0 && errno == EINTR)
    {
      SCDC_TRACE("send: continuing after EINTR");
      goto do_send;
    }

#if SCDC_TRANSPORT_TCP_USE_SHUTDOWN_EXCEPTION
  } catch (const scdc_transport_tcp_shutdown_ex &ex)
  {
    SCDC_INFO("connection: " << tcp_conn << ": send: catch shutdown exception");
    n = -1;
    except = false;
  }
#endif

  if (n < 0)
  {
    if (!except) SCDC_ERROR("connection: " << tcp_conn << ": send: send failed: '" << strerror(errno) << "'");
    return -1;
  }

  SCDC_TRACE("connection: " << tcp_conn << ": sent " << n << " byte(s)");
  
  return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movl 0x2d4(%r14), %edi
movq %r13, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0xb260
testq %rax, %rax
jns 0x61d5c
callq 0xb070
cmpl $0x4, (%rax)
je 0x61c7e
leaq 0x2a8c4(%rip), %r13     # 0x8c570
movq (%r13), %rdi
movq $-0x1, %rbx
cmpq $0x0, 0x18(%rdi)
je 0x61dc3
movq %rax, %r15
addq $0x20, %rdi
callq 0xb7d0
movq (%r13), %rax
movq 0x18(%rax), %r12
leaq 0x87ab(%rip), %rsi      # 0x6a488
movl $0xc, %edx
movq %r12, %rdi
callq 0xb5f0
leaq 0xbec0(%rip), %rsi      # 0x6dbb1
movl $0xf, %edx
movq %r12, %rdi
callq 0xb5f0
leaq 0xbe3e(%rip), %rsi      # 0x6db43
movl $0xc, %edx
movq %r12, %rdi
callq 0xb5f0
movq %r12, %rdi
movq %r14, %rsi
callq 0xb3c0
movq %rax, %r14
leaq 0xbfc4(%rip), %rsi      # 0x6dceb
movl $0x16, %edx
movq %rax, %rdi
callq 0xb5f0
movl (%r15), %edi
callq 0xb190
testq %rax, %rax
je 0x61d61
movq %rax, %r15
movq %rax, %rdi
callq 0xb200
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xb5f0
jmp 0x61d7b
movq %rax, %rbx
jmp 0x61dc3
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0xb990
leaq 0xa5d9(%rip), %rsi      # 0x6c35b
movl $0x1, %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 (%r13), %rdi
addq $0x20, %rdi
callq 0xb3b0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/transport/transport_tcp.cc
// Function: scdc_transport_tcp::receive(scdc_transport_connection_t*, void*, long long)
scdcint_t scdc_transport_tcp::receive(scdc_transport_connection_t *conn, void *buf, scdcint_t max_buf_size)
{
  SCDC_TRACE("receive: conn: '" << conn << "', buf: '" << buf << "', max_buf_size: " << max_buf_size);

  scdc_transport_tcp_connection_t *tcp_conn = static_cast<scdc_transport_tcp_connection_t *>(conn);

  if (max_buf_size <= 0)
  {
    SCDC_TRACE("connection: " << tcp_conn << ": receive: nothing to receive");
    return 0;
  }

  scdcint_t n = 0;

  bool except = false;

#if SCDC_TRANSPORT_TCP_USE_SHUTDOWN_EXCEPTION
  try
  {
#endif

do_recv:
    n = ::recv(tcp_conn->socket, buf, max_buf_size, 0);

    if (n < 0 && errno == EINTR)
    {
      SCDC_TRACE("receive: continuing after EINTR");
      goto do_recv;
    }

#if SCDC_TRANSPORT_TCP_USE_SHUTDOWN_EXCEPTION
  } catch (const scdc_transport_tcp_shutdown_ex &ex)
  {
    SCDC_INFO("connection " << tcp_conn << ": receive: catch shutdown receive");
    n = -1;
    except = false;
  }
#endif

  if (n < 0)
  {
    if (!except) SCDC_ERROR("connection: " << tcp_conn << ": receive: receive failed: '" << strerror(errno) << "'");
    return -1;
  }

  SCDC_TRACE("connection " << tcp_conn << ": receive: received " << n << " byte(s)");

  /* receiving 0 bytes signals that the socket was closed */
  if (n == 0) n = -1;

  return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rcx, %rcx
jle 0x61ec9
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movl 0x2d4(%r14), %edi
movq %r12, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0xb170
testq %rax, %rax
jns 0x61ecd
callq 0xb070
cmpl $0x4, (%rax)
je 0x61deb
leaq 0x2a757(%rip), %r13     # 0x8c570
movq (%r13), %rdi
movq $-0x1, %rbx
cmpq $0x0, 0x18(%rdi)
je 0x61f3d
movq %rax, %r15
addq $0x20, %rdi
callq 0xb7d0
movq (%r13), %rax
movq 0x18(%rax), %r12
leaq 0x863e(%rip), %rsi      # 0x6a488
movl $0xc, %edx
movq %r12, %rdi
callq 0xb5f0
leaq 0xbd53(%rip), %rsi      # 0x6dbb1
movl $0xf, %edx
movq %r12, %rdi
callq 0xb5f0
leaq 0xbcd1(%rip), %rsi      # 0x6db43
movl $0xc, %edx
movq %r12, %rdi
callq 0xb5f0
movq %r12, %rdi
movq %r14, %rsi
callq 0xb3c0
movq %rax, %r14
leaq 0xbe6e(%rip), %rsi      # 0x6dd02
movl $0x1c, %edx
movq %rax, %rdi
callq 0xb5f0
movl (%r15), %edi
callq 0xb190
testq %rax, %rax
je 0x61edb
movq %rax, %r15
movq %rax, %rdi
callq 0xb200
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xb5f0
jmp 0x61ef5
xorl %ebx, %ebx
jmp 0x61f3d
xorl %ebx, %ebx
cmpq $0x1, %rax
sbbq %rbx, %rbx
orq %rax, %rbx
jmp 0x61f3d
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0xb990
leaq 0xa45f(%rip), %rsi      # 0x6c35b
movl $0x1, %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 (%r13), %rdi
addq $0x20, %rdi
callq 0xb3b0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/transport/transport_uds.cc
// Function: scdc_transport_uds::close()
void scdc_transport_uds::close()
{
  SCDC_TRACE("close:");

  ::close(uds_server->server_socket);

  ::unlink(uds_server->uds_filename.c_str());

  delete uds_server;
  uds_server = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movl 0x70(%rax), %edi
callq 0xbaa0
movq 0x40(%rbx), %rax
movq 0x78(%rax), %rdi
callq 0xb230
movq 0x40(%rbx), %r14
testq %r14, %r14
je 0x62337
movq 0x78(%r14), %rdi
leaq 0x88(%r14), %rax
cmpq %rax, %rdi
je 0x6232a
movq (%rax), %rsi
incq %rsi
callq 0xb510
movl $0x98, %esi
movq %r14, %rdi
callq 0xb510
movq $0x0, 0x40(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/transport/transport_uds.cc
// Function: scdc_transport_uds::accept()
scdc_transport_connection_t *scdc_transport_uds::accept()
{
  SCDC_TRACE("accept:");

  scdc_transport_uds_connection_t *uds_conn = new scdc_transport_uds_connection_t(this);

  socklen_t saddrlen = sizeof(uds_server->saddr);

#if SCDC_TRANSPORT_UDS_USE_SHUTDOWN_EXCEPTION
  try
  {
#endif
    uds_conn->socket = ::accept(uds_server->server_socket, (struct sockaddr *) &uds_server->saddr, &saddrlen);

#if SCDC_TRANSPORT_UDS_USE_SHUTDOWN_EXCEPTION
  } catch (const scdc_transport_uds_shutdown_ex &ex)
  {
    SCDC_INFO("connection " << uds_conn << ": exception during accept");
    uds_conn->socket = -1;
  }
#endif

  if (uds_conn->socket != -1)
  {
    uds_conn->open = true;

  } else
  {
    if (!shutdowned) SCDC_FAIL("accept: accepting connection failed: '" << strerror(errno) << "'");
    delete uds_conn;
    uds_conn = 0;
    return 0;
  }

  SCDC_TRACE("accept: '" << uds_conn << "'");

  return scdc_transport::accept(uds_conn);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x2d8, %edi            # imm = 0x2D8
callq 0xb500
movq %rax, %rbx
movq %r14, (%rax)
movw $0x100, 0x8(%rax)       # imm = 0x100
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
leaq 0x2998d(%rip), %rax     # 0x8bd08
addq $0x10, %rax
movq %rax, 0x30(%rbx)
movups %xmm0, 0x38(%rbx)
xorl %ecx, %ecx
movb %cl, 0x48(%rbx)
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x60(%rbx)
movq %rax, 0x70(%rbx)
movups %xmm0, 0x78(%rbx)
movb %cl, 0x88(%rbx)
movups %xmm0, 0x90(%rbx)
movups %xmm0, 0xa0(%rbx)
movups %xmm0, 0x2c0(%rbx)
movq $0x0, 0x2d0(%rbx)
leaq 0x4(%rsp), %rdx
movl $0x6e, (%rdx)
movq 0x40(%r14), %rsi
movl 0x70(%rsi), %edi
callq 0xb160
movl %eax, 0x2d4(%rbx)
cmpl $-0x1, %eax
je 0x623f8
movb $0x1, 0x8(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x604e2
jmp 0x62509
cmpb $0x0, 0x2a(%r14)
jne 0x624f2
leaq 0x2a166(%rip), %r12     # 0x8c570
movq (%r12), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x624f2
addq $0x20, %rdi
callq 0xb7d0
movq (%r12), %rax
movq 0x8(%rax), %r14
leaq 0x7d57(%rip), %rsi      # 0x6a188
movl $0xb, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0xb8ef(%rip), %rsi      # 0x6dd34
movl $0xf, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0xb7f8(%rip), %rsi      # 0x6dc51
movl $0x26, %edx
movq %r14, %rdi
callq 0xb5f0
callq 0xb070
movl (%rax), %edi
callq 0xb190
testq %rax, %rax
je 0x62492
movq %rax, %r15
movq %rax, %rdi
callq 0xb200
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xb5f0
jmp 0x624aa
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0xb990
leaq 0x9eaa(%rip), %rsi      # 0x6c35b
movl $0x1, %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 (%r12), %rdi
addq $0x20, %rdi
callq 0xb3b0
movq %rbx, %rdi
callq 0x611fa
movl $0x2d8, %esi            # imm = 0x2D8
movq %rbx, %rdi
callq 0xb510
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/transport/transport_uds.cc
// Function: scdc_transport_uds::shutdown(scdc_transport_connection_t*, bool)
void scdc_transport_uds::shutdown(scdc_transport_connection_t *conn, bool interrupt)
{
  SCDC_TRACE("shutdown: interrupt: '" << interrupt << "'");

  scdc_transport::shutdown(conn, interrupt);

#if SCDC_TRANSPORT_UDS_USE_SHUTDOWN_EXCEPTION
  if (interrupt) throw scdc_transport_uds_shutdown_ex();
#endif

  if (conn)
  {
    SCDC_TRACE("shutdown: connection socket shutdown");

    scdc_transport_uds_connection_t *uds_conn = static_cast<scdc_transport_uds_connection_t *>(conn);

    ::shutdown(uds_conn->socket, SHUT_RDWR);

  } else if (uds_server)
  {
    SCDC_TRACE("shutdown: server socket shutdown");

    ::shutdown(uds_server->server_socket, SHUT_RDWR);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x6051e
testq %rbx, %rbx
je 0x62533
addq $0x2d4, %rbx            # imm = 0x2D4
jmp 0x62540
movq 0x40(%r14), %rbx
testq %rbx, %rbx
je 0x62553
addq $0x70, %rbx
movl (%rbx), %edi
movl $0x2, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb730
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/transport/transport_uds.cc
// Function: scdc_transport_uds::send(scdc_transport_connection_t*, void const*, long long)
scdcint_t scdc_transport_uds::send(scdc_transport_connection_t *conn, const void *buf, scdcint_t buf_size)
{
  SCDC_TRACE("send: conn: '" << conn << "', buf: '" << buf << "', buf_size: " << buf_size);

  scdc_transport_uds_connection_t *uds_conn = static_cast<scdc_transport_uds_connection_t *>(conn);

  scdcint_t n = 0;

  bool except = false;

#if SCDC_TRANSPORT_UDS_USE_SHUTDOWN_EXCEPTION
  try
  {
#endif
do_send:
    n = ::send(uds_conn->socket, buf, buf_size, 0);

    if (n < 0 && errno == EINTR)
    {
      SCDC_TRACE("send: continuing after EINTR");
      goto do_send;
    }

#if SCDC_TRANSPORT_UDS_USE_SHUTDOWN_EXCEPTION
  } catch (const scdc_transport_uds_shutdown_ex &ex)
  {
    SCDC_INFO("connection: " << uds_conn << ": send: catch shutdown exception");
    n = -1;
    except = false;
  }
#endif

  if (n < 0)
  {
    if (!except) SCDC_ERROR("connection: " << uds_conn << ": send: send failed: '" << strerror(errno) << "'");
    return -1;
  }

  SCDC_TRACE("connection: " << uds_conn << ": send: sent " << n << " byte(s)");
  
  return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movl 0x2d4(%r14), %edi
movq %r13, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0xb260
testq %rax, %rax
jns 0x629ea
callq 0xb070
cmpl $0x4, (%rax)
je 0x6290c
leaq 0x29c36(%rip), %r13     # 0x8c570
movq (%r13), %rdi
movq $-0x1, %rbx
cmpq $0x0, 0x18(%rdi)
je 0x62a51
movq %rax, %r15
addq $0x20, %rdi
callq 0xb7d0
movq (%r13), %rax
movq 0x18(%rax), %r12
leaq 0x7b1d(%rip), %rsi      # 0x6a488
movl $0xc, %edx
movq %r12, %rdi
callq 0xb5f0
leaq 0xb3b5(%rip), %rsi      # 0x6dd34
movl $0xf, %edx
movq %r12, %rdi
callq 0xb5f0
leaq 0xb1b0(%rip), %rsi      # 0x6db43
movl $0xc, %edx
movq %r12, %rdi
callq 0xb5f0
movq %r12, %rdi
movq %r14, %rsi
callq 0xb3c0
movq %rax, %r14
leaq 0xb336(%rip), %rsi      # 0x6dceb
movl $0x16, %edx
movq %rax, %rdi
callq 0xb5f0
movl (%r15), %edi
callq 0xb190
testq %rax, %rax
je 0x629ef
movq %rax, %r15
movq %rax, %rdi
callq 0xb200
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xb5f0
jmp 0x62a09
movq %rax, %rbx
jmp 0x62a51
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0xb990
leaq 0x994b(%rip), %rsi      # 0x6c35b
movl $0x1, %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 (%r13), %rdi
addq $0x20, %rdi
callq 0xb3b0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/transport/transport_uds.cc
// Function: scdc_transport_uds::receive(scdc_transport_connection_t*, void*, long long)
scdcint_t scdc_transport_uds::receive(scdc_transport_connection_t *conn, void *buf, scdcint_t max_buf_size)
{
  SCDC_TRACE("receive: conn: '" << conn << "', buf: '" << buf << "', max_buf_size: " << max_buf_size);

  scdc_transport_uds_connection_t *uds_conn = static_cast<scdc_transport_uds_connection_t *>(conn);

  if (max_buf_size <= 0)
  {
    SCDC_TRACE("connection: " << uds_conn << ": receive: nothing to receive");
    return 0;
  }

  scdcint_t n = 0;

  bool except = false;

#if SCDC_TRANSPORT_UDS_USE_SHUTDOWN_EXCEPTION
  try
  {
#endif

do_recv:
    n = ::recv(uds_conn->socket, buf, max_buf_size, 0);

    if (n < 0 && errno == EINTR)
    {
      SCDC_TRACE("receive: continuing after EINTR");
      goto do_recv;
    }

#if SCDC_TRANSPORT_UDS_USE_SHUTDOWN_EXCEPTION
  } catch (const scdc_transport_uds_shutdown_ex &ex)
  {
    SCDC_INFO("connection " << uds_conn << ": receive: catch shutdown receive");
    n = -1;
    except = false;
  }
#endif

  if (n < 0)
  {
    if (!except) SCDC_ERROR("connection: " << uds_conn << ": receive: receive failed: '" << strerror(errno) << "'");
    return -1;
  }

  SCDC_TRACE("connection " << uds_conn << ": receive: received " << n << " byte(s)");

  /* receiving 0 bytes signals that the socket was closed */
  if (n == 0) n = -1;

  return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rcx, %rcx
jle 0x62b57
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r14
movl 0x2d4(%r14), %edi
movq %r12, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0xb170
testq %rax, %rax
jns 0x62b5b
callq 0xb070
cmpl $0x4, (%rax)
je 0x62a79
leaq 0x29ac9(%rip), %r13     # 0x8c570
movq (%r13), %rdi
movq $-0x1, %rbx
cmpq $0x0, 0x18(%rdi)
je 0x62bcb
movq %rax, %r15
addq $0x20, %rdi
callq 0xb7d0
movq (%r13), %rax
movq 0x18(%rax), %r12
leaq 0x79b0(%rip), %rsi      # 0x6a488
movl $0xc, %edx
movq %r12, %rdi
callq 0xb5f0
leaq 0xb248(%rip), %rsi      # 0x6dd34
movl $0xf, %edx
movq %r12, %rdi
callq 0xb5f0
leaq 0xb043(%rip), %rsi      # 0x6db43
movl $0xc, %edx
movq %r12, %rdi
callq 0xb5f0
movq %r12, %rdi
movq %r14, %rsi
callq 0xb3c0
movq %rax, %r14
leaq 0xb1e0(%rip), %rsi      # 0x6dd02
movl $0x1c, %edx
movq %rax, %rdi
callq 0xb5f0
movl (%r15), %edi
callq 0xb190
testq %rax, %rax
je 0x62b69
movq %rax, %r15
movq %rax, %rdi
callq 0xb200
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xb5f0
jmp 0x62b83
xorl %ebx, %ebx
jmp 0x62bcb
xorl %ebx, %ebx
cmpq $0x1, %rax
sbbq %rbx, %rbx
orq %rax, %rbx
jmp 0x62bcb
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0xb990
leaq 0x97d1(%rip), %rsi      # 0x6c35b
movl $0x1, %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 (%r13), %rdi
addq $0x20, %rdi
callq 0xb3b0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/compcoup/compcoup_direct.cc
// Function: scdc_compcoup_direct::dataset_open(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
scdc_dataset *scdc_compcoup_direct::dataset_open(const std::string &path, scdc_result &result)
{
  SCDC_TRACE("dataset_open: path: '" << path << "'");

  if (!running)
  {
    result = "direct disabled";
    return 0;
  }

  if (!dataprovs)
  {
    result = "no data provider available";
    return 0;
  }

  scdc_dataset *dataset = dataprovs->dataset_open(path, result);

  return dataset;
}

// Assembly:
pushq %rax
cmpb $0x0, 0x18(%rdi)
je 0x62c10
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x62c23
popq %rax
jmp 0x1e3de
movq 0x8(%rdx), %rax
leaq 0xb166(%rip), %rcx      # 0x6dd81
movl $0xf, %r8d
jmp 0x62c34
movq 0x8(%rdx), %rax
leaq 0xb163(%rip), %rcx      # 0x6dd91
movl $0x1a, %r8d
movq %rdx, %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0xb870
xorl %eax, %eax
popq %rcx
retq
nop