LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x98a9e
movq -0x20(%rbp), %rax
testb $0x1, 0x29(%rax)
jne 0x98b34
jmp 0x98aae
leaq 0x3bbf3(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
cmpq $0x0, %rax
je 0x98b2c
leaq 0x3bbde(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25800
leaq 0x3bbcf(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
movq %rax, %rdi
leaq 0xd6c5(%rip), %rsi      # 0xa61b0
callq 0xc670
movq %rax, %rdi
leaq 0x11356(%rip), %rsi     # 0xa9e50
callq 0xc670
movq %rax, %rdi
leaq 0x10fc4(%rip), %rsi     # 0xa9acd
callq 0xc670
movq %rax, %rdi
movq 0x3b4a8(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x3bb84(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25820
jmp 0x98b2e
movb $0x0, -0x1(%rbp)
jmp 0x98b8e
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movb -0x11(%rbp), %cl
movq (%rdi), %rax
andb $0x1, %cl
movzbl %cl, %esi
callq *0x38(%rax)
movq -0x20(%rbp), %rdi
movb $0x0, 0x29(%rdi)
movb $0x1, 0x2b(%rdi)
movb -0x11(%rbp), %cl
movq (%rdi), %rax
xorl %edx, %edx
movl %edx, %esi
andb $0x1, %cl
movzbl %cl, %edx
callq *0x50(%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x98b8a
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rdi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x984a0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x98bb6
movq $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, 0x29(%rax)
je 0x98c51
jmp 0x98bce
jmp 0x98bd0
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, -0x18(%rbp)
jmp 0x98be0
cmpq $0x0, -0x18(%rbp)
je 0x98c23
movq -0x20(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x98c05
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x97e10
jmp 0x98c21
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
callq *0x58(%rax)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
callq *0x60(%rax)
jmp 0x98c23
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x98c40
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rax
movq 0x18(%rcx), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x98bbe
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/transport/transport.cc
// Function: scdc_transport::accept(scdc_transport_connection_t*)
scdc_transport_connection_t *scdc_transport::accept(scdc_transport_connection_t *conn)
{
  SCDC_TRACE("accept: conn: '" << conn << "'");

  create_incoming(conn);
  create_outgoing(conn);

  return 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 0x98c7a
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
movq $-0x1, %rdx
callq *0xd8(%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
movq $-0x1, %rdx
callq *0xe8(%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/transport/transport.cc
// Function: scdc_transport::close(scdc_transport_connection_t*)
void scdc_transport::close(scdc_transport_connection_t *conn)
{
  SCDC_TRACE("close: conn: '" << conn << "'");

  destroy_incoming(conn);
  destroy_outgoing(conn);

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

// 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 0x98d4a
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0xe0(%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0xf0(%rax)
jmp 0x98d6e
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x98d9a
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
movq $-0x1, %rdx
callq *0xd8(%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
movq $-0x1, %rdx
callq *0xe8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x50(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x98e0a
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movb $0x0, 0x8(%rcx)
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x58(%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0xe0(%rax)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0xf0(%rax)
jmp 0x98e48
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/transport/transport.cc
// Function: recv_incoming_dataset_inout(scdc_transport_connection_t*, _scdc_dataset_inout_t*, long long, bool&, scdc_transport*, bool&)
static bool recv_incoming_dataset_inout(scdc_transport_connection_t *conn, scdc_dataset_inout_t *inout, scdcint_t max_recv, bool &cont_recv, scdc_transport *transport, bool &inout_intern)
{
  inout_intern = !incoming_dataset_inout_has_buf(conn, inout);

  if (inout_intern)
  {
    bool ret = recv_incoming_dataset_inout_intern(conn, inout, max_recv, cont_recv, transport);

    if (!SCDC_DATASET_INOUT_BUF_PTR(inout)) inout_intern = false;

    return ret;
  }

  return recv_incoming_dataset_inout_extern(conn, inout, max_recv, cont_recv);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x99530
movb %al, %cl
xorb $-0x1, %cl
movq -0x38(%rbp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movq -0x38(%rbp), %rax
testb $0x1, (%rax)
je 0x9900e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x99590
andb $0x1, %al
movb %al, -0x39(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x99004
movq -0x38(%rbp), %rax
movb $0x0, (%rax)
movb -0x39(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x99028
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x99720
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jge 0x9915e
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jge 0x9910a
movq -0x10(%rbp), %rcx
xorl %eax, %eax
subq 0x20(%rcx), %rax
movq %rax, -0x50(%rbp)
jmp 0x99112
xorl %eax, %eax
movq %rax, -0x50(%rbp)
jmp 0x99112
movq -0x48(%rbp), %rax
movq -0x50(%rbp), %rcx
cmpq %rcx, %rax
jge 0x9915c
xorl %eax, %eax
testb $0x1, -0x11(%rbp)
movb %al, -0x51(%rbp)
je 0x99146
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
imulq $0x18, -0x20(%rbp), %rax
addq %rax, %rsi
callq 0x99900
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x990e7
jmp 0x991a8
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
leaq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x99900
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movb -0x11(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x9920a
movq -0x18(%rbp), %rdi
addq $0x70, %rdi
callq 0x2ec00
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jle 0x99250
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
addq $0x70, %rdi
callq 0x2ebe0
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
movq -0x20(%rbp), %rcx
movq (%rdi), %rax
callq *0x78(%rax)
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jge 0x9925d
movb $0x0, -0x1(%rbp)
jmp 0x9928f
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rdi
addq $0x70, %rdi
movq -0x20(%rbp), %rsi
callq 0x2ec60
movq -0x18(%rbp), %rdi
addq $0x70, %rdi
callq 0xa4450
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x992ba
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
callq 0xa4450
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
callq 0x2eca0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jle 0x99310
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
callq 0x2ec80
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
movq -0x20(%rbp), %rcx
movq (%rdi), %rax
callq *0x80(%rax)
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jge 0x9931d
movb $0x0, -0x1(%rbp)
jmp 0x99342
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
addq 0x28(%rax), %rcx
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
movq -0x20(%rbp), %rsi
callq 0x2ecc0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jge 0x99373
movq $0x8000, -0x18(%rbp)    # imm = 0x8000
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
movq -0x18(%rbp), %rsi
callq 0x99d30
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
movq -0x10(%rbp), %rsi
callq 0x99d70
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
leaq 0xc(%rip), %rsi         # 0x993b0
callq 0x99d90
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jge 0x99463
movq $0x8000, -0x18(%rbp)    # imm = 0x8000
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
movq -0x18(%rbp), %rsi
callq 0x99d30
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
movq -0x10(%rbp), %rsi
callq 0x99d70
movq -0x10(%rbp), %rdi
addq $0x70, %rdi
leaq 0xc(%rip), %rsi         # 0x994a0
callq 0x99d90
addq $0x20, %rsp
popq %rbp
retq
nop
// File: mh0fm4[P]SCDC/src/components/transport/transport.cc
// Function: recv_incoming_dataset_inout_intern(scdc_transport_connection_t*, _scdc_dataset_inout_t*, long long, bool&, scdc_transport*)
static bool recv_incoming_dataset_inout_intern(scdc_transport_connection_t *conn, scdc_dataset_inout_t *inout, scdcint_t max_recv, bool &cont_recv, scdc_transport *transport)
{
  bool ret = true;

  if (SCDC_DATASET_INOUT_BUF_CURRENT(inout) != 0)
  {
    SCDC_FATAL("recv_incoming_dataset_inout_intern: non-empty inout during internal receive through incoming buffer");
    return false;
  }

  if (max_recv > 0)
  {
    if (conn->incoming.get_read_pos_buf_size() <= 0) transport->recv_incoming(conn);

    scdcint_t n = min(conn->incoming.get_read_pos_buf_size(), max_recv);

    SCDC_DATASET_INOUT_BUF_PTR(inout) = conn->incoming.get_read_pos_buf();
    SCDC_DATASET_INOUT_BUF_SIZE(inout) = n;
    SCDC_DATASET_INOUT_BUF_CURRENT(inout) = n;

    conn->incoming.inc_read_pos(n);

  } else
  {
    SCDC_DATASET_INOUT_BUF_PTR(inout) = 0;
    SCDC_DATASET_INOUT_BUF_SIZE(inout) = 0;
    SCDC_DATASET_INOUT_BUF_CURRENT(inout) = 0;
  }

  cont_recv = false;

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movb $0x1, -0x31(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x9964a
jmp 0x995c1
leaq 0x3b0e0(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e8e0
cmpq $0x0, %rax
je 0x9963f
leaq 0x3b0cb(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e900
leaq 0x3b0bc(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e8e0
movq %rax, %rdi
leaq 0x104e3(%rip), %rsi     # 0xa9ae1
callq 0xc670
movq %rax, %rdi
leaq 0x10843(%rip), %rsi     # 0xa9e50
callq 0xc670
movq %rax, %rdi
leaq 0x104d2(%rip), %rsi     # 0xa9aee
callq 0xc670
movq %rax, %rdi
movq 0x3a995(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x3b071(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e920
jmp 0x99641
movb $0x0, -0x1(%rbp)
jmp 0x99714
cmpq $0x0, -0x20(%rbp)
jle 0x996e1
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x2ec00
cmpq $0x0, %rax
jg 0x99679
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0xc8(%rax)
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x2ec00
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2b080
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x2ebe0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x40(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x40(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
movq -0x40(%rbp), %rsi
callq 0x2ec60
jmp 0x99705
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movb -0x31(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nop
// File: 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:
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, -0x28(%rbp)
jmp 0x9a9c2
cmpq $0x0, -0x18(%rbp)
je 0x9a9d3
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x9a9e1
movq 0x395f6(%rip), %rax     # 0xd3fd0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq 0x40(%rax), %rax
movq %rcx, 0x2d8(%rax)
cmpq $0x0, -0x20(%rbp)
je 0x9aa05
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x9aa13
movq 0x395a4(%rip), %rax     # 0xd3fb0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rcx
movq 0x40(%rdi), %rax
movq %rcx, 0x2e0(%rax)
movq -0x10(%rbp), %rsi
callq 0x98660
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x9aa56
movq -0x18(%rbp), %rdi
callq 0x988f0
testb $0x1, %al
jne 0x9aaef
jmp 0x9aa69
leaq 0x39c38(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
cmpq $0x0, %rax
je 0x9aae7
leaq 0x39c23(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25800
leaq 0x39c14(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
movq %rax, %rdi
leaq 0xb70a(%rip), %rsi      # 0xa61b0
callq 0xc670
movq %rax, %rdi
leaq 0xf0ae(%rip), %rsi      # 0xa9b63
callq 0xc670
movq %rax, %rdi
leaq 0xf0b2(%rip), %rsi      # 0xa9b76
callq 0xc670
movq %rax, %rdi
movq 0x394ed(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x39bc9(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25820
jmp 0x9aae9
movb $0x0, -0x1(%rbp)
jmp 0x9ab15
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rcx
movq $0x0, 0x2d8(%rcx)
movq 0x40(%rax), %rax
movq $0x0, 0x2e0(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x9ab36
movq -0x20(%rbp), %rax
movq $0x0, -0x18(%rbp)
movq 0x40(%rax), %rcx
xorl %eax, %eax
cmpq $0x0, 0x2d8(%rcx)
movb %al, -0x21(%rbp)
je 0x9abab
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x2d8(%rax), %rdi
callq 0xca80
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
jne 0x9abab
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rcx
xorl %eax, %eax
cmpq $0x0, 0x2e0(%rcx)
movb %al, -0x21(%rbp)
je 0x9abab
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x2e0(%rax), %rdi
callq 0xca80
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x21(%rbp)
movq -0x20(%rbp), %rax
movb -0x21(%rbp), %cl
movq 0x40(%rax), %rax
andb $0x1, %cl
movb %cl, 0x8(%rax)
jmp 0x9abbe
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
testb $0x1, 0x8(%rax)
je 0x9abda
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x9abf0
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *0x30(%rax)
movq $0x0, -0x8(%rbp)
jmp 0x9ac05
jmp 0x9abf2
jmp 0x9abf4
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x98c60
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: mh0fm4[P]SCDC/src/components/transport/transport_stream.cc
// Function: scdc_transport_stream::shutdown(scdc_transport_connection_t*, bool)
void scdc_transport_stream::shutdown(scdc_transport_connection_t *conn, bool interrupt)
{
  SCDC_TRACE("shutdown: conn: '" << conn << "', interrupt: '" << interrupt << "'");

  scdc_transport::shutdown(conn, interrupt);

#if SCDC_TRANSPORT_STREAM_USE_SHUTDOWN_EXCEPTION
  if (interrupt) throw scdc_transport_stream_shutdown_ex();
#endif

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

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

    /* FIXME: make closing streams optional */
    if (stream_conn->ifile) fclose(stream_conn->ifile);
/*    if (stream_conn->ofile) fclose(stream_conn->ofile);*/
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x9ac31
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x98cc0
cmpq $0x0, -0x10(%rbp)
je 0x9ac79
jmp 0x9ac4f
jmp 0x9ac51
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x2d8(%rax)
je 0x9ac77
movq -0x20(%rbp), %rax
movq 0x2d8(%rax), %rdi
callq 0xc680
jmp 0x9ac79
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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 %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, -0x38(%rbp)
jmp 0x9acfe
movl $0x2e8, %edi            # imm = 0x2E8
callq 0xc690
movq -0x38(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x9b160
jmp 0x9ad1d
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x9ad36
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x9ad44
movq 0x39293(%rip), %rax     # 0xd3fd0
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x2d8(%rax)
cmpq $0x0, -0x18(%rbp)
je 0x9ad64
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x9ad72
movq 0x39245(%rip), %rax     # 0xd3fb0
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rdi
movq -0x50(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x2e0(%rax)
movq -0x20(%rbp), %rsi
callq 0x98d80
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x2e8, %esi            # imm = 0x2E8
callq 0xc6a0
movq -0x28(%rbp), %rdi
callq 0xcba0
nopw (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/transport/transport_stream.cc
// Function: scdc_transport_stream::disconnect(scdc_transport_connection_t*)
bool scdc_transport_stream::disconnect(scdc_transport_connection_t *conn)
{
  SCDC_TRACE("disconnect: conn: '" << conn << "'");

  if (!scdc_transport::disconnect(conn)) return false;

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

  delete stream_conn;

  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, -0x28(%rbp)
jmp 0x9adda
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x98df0
testb $0x1, %al
jne 0x9adf1
movb $0x0, -0x1(%rbp)
jmp 0x9ae22
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x9ae1e
movq -0x30(%rbp), %rdi
callq 0x9b1b0
movq -0x30(%rbp), %rdi
movl $0x2e8, %esi            # imm = 0x2E8
callq 0xc6a0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
jmp 0x9ae4a
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x2e0(%rax)
je 0x9aea9
movq -0x28(%rbp), %rax
movq 0x2e0(%rax), %rdi
callq 0xca80
cmpl $0x0, %eax
je 0x9ae83
jmp 0x9ae77
jmp 0x9ae79
movq $-0x1, -0x30(%rbp)
jmp 0x9aea4
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rax
movq 0x2e0(%rax), %rcx
movl $0x1, %esi
callq 0xccb0
movq %rax, -0x30(%rbp)
jmp 0x9af52
jmp 0x9aeab
leaq 0x397f6(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e8e0
cmpq $0x0, %rax
je 0x9af48
leaq 0x397dd(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e900
leaq 0x397ce(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e8e0
movq %rax, %rdi
leaq 0xebf5(%rip), %rsi      # 0xa9ae1
callq 0xc670
movq %rax, %rdi
leaq 0xec68(%rip), %rsi      # 0xa9b63
callq 0xc670
movq %rax, %rdi
leaq 0xec81(%rip), %rsi      # 0xa9b8b
callq 0xc670
movq %rax, %rdi
movq -0x28(%rbp), %rsi
callq 0xc4f0
movq %rax, %rdi
leaq 0xec73(%rip), %rsi      # 0xa9b98
callq 0xc670
movq %rax, %rdi
movq 0x3908c(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x39768(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e920
jmp 0x9af4a
movq $-0x1, -0x30(%rbp)
jmp 0x9af54
jmp 0x9af56
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: mh0fm4[P]SCDC/src/components/transport/transport_tcp.cc
// Function: scdc_transport_tcp::close()
void scdc_transport_tcp::close()
{
  SCDC_TRACE("close:");

  ::close(tcp_server->server_socket);

  delete tcp_server;
  tcp_server = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x9b8b6
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movl 0x10(%rax), %edi
callq 0xccd0
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x9b8e6
movq -0x18(%rbp), %rdi
movl $0x14, %esi
callq 0xc6a0
movq -0x10(%rbp), %rax
movq $0x0, 0x40(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x9b916
movl $0x2d8, %edi            # imm = 0x2D8
callq 0xc690
movq -0x30(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x9c360
jmp 0x9b935
movq -0x30(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl $0x10, -0x28(%rbp)
movq 0x40(%rax), %rcx
movl 0x10(%rcx), %edi
movq 0x40(%rax), %rsi
leaq -0x28(%rbp), %rdx
callq 0xc1b0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x2d4(%rax)
movq -0x18(%rbp), %rax
cmpl $-0x1, 0x2d4(%rax)
je 0x9b9a1
movq -0x18(%rbp), %rax
movb $0x1, 0x8(%rax)
jmp 0x9ba99
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x2d8, %esi            # imm = 0x2D8
callq 0xc6a0
jmp 0x9bab8
movq -0x30(%rbp), %rax
testb $0x1, 0x2a(%rax)
jne 0x9ba62
jmp 0x9b9b1
leaq 0x38cf0(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
cmpq $0x0, %rax
je 0x9ba5e
leaq 0x38cd7(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25800
leaq 0x38cc8(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
movq %rax, %rdi
leaq 0xa7be(%rip), %rsi      # 0xa61b0
callq 0xc670
movq %rax, %rdi
leaq 0xe1f8(%rip), %rsi      # 0xa9bf9
callq 0xc670
movq %rax, %rdi
leaq 0xe289(%rip), %rsi      # 0xa9c99
callq 0xc670
movq %rax, -0x40(%rbp)
callq 0xc080
movl (%rax), %edi
callq 0xc1d0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0xc670
movq %rax, %rdi
leaq 0xc998(%rip), %rsi      # 0xa83d3
callq 0xc670
movq %rax, %rdi
movq 0x38576(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x38c52(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25820
jmp 0x9ba60
jmp 0x9ba62
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0x9ba87
movq -0x48(%rbp), %rdi
callq 0x9c3a0
movq -0x48(%rbp), %rdi
movl $0x2d8, %esi            # imm = 0x2D8
callq 0xc6a0
movq $0x0, -0x18(%rbp)
movq $0x0, -0x8(%rbp)
jmp 0x9baae
jmp 0x9ba9b
jmp 0x9ba9d
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x98c60
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xcba0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x9baf1
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x98cc0
cmpq $0x0, -0x10(%rbp)
je 0x9bb2f
jmp 0x9bb0f
jmp 0x9bb11
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x2d4(%rax), %edi
movl $0x2, %esi
callq 0xc930
jmp 0x9bb55
movq -0x28(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x9bb53
jmp 0x9bb3c
jmp 0x9bb3e
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movl 0x10(%rax), %edi
movl $0x2, %esi
callq 0xc930
jmp 0x9bb55
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/transport/transport_tcp.cc
// Function: scdc_transport_tcp::close(scdc_transport_connection_t*)
void scdc_transport_tcp::close(scdc_transport_connection_t *conn)
{
  SCDC_TRACE("close: '" << conn << "'");

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

  ::close(tcp_conn->socket);

  scdc_transport::close(conn);

  delete tcp_conn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x9bbaa
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x2d4(%rax), %edi
callq 0xccd0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x98d30
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x9bbf3
movq -0x28(%rbp), %rdi
callq 0x9c3a0
movq -0x28(%rbp), %rdi
movl $0x2d8, %esi            # imm = 0x2D8
callq 0xc6a0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: mh0fm4[P]SCDC/src/components/transport/transport_tcp.cc
// Function: scdc_transport_tcp::disconnect(scdc_transport_connection_t*)
bool scdc_transport_tcp::disconnect(scdc_transport_connection_t *conn)
{
  SCDC_TRACE("disconnect: conn: '" << conn << "'");

  if (!scdc_transport::disconnect(conn)) return false;

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

  ::close(tcp_conn->socket);

  delete tcp_conn;

  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, -0x28(%rbp)
jmp 0x9bfda
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x98df0
testb $0x1, %al
jne 0x9bff1
movb $0x0, -0x1(%rbp)
jmp 0x9c031
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x2d4(%rax), %edi
callq 0xccd0
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x9c02d
movq -0x30(%rbp), %rdi
callq 0x9c3a0
movq -0x30(%rbp), %rdi
movl $0x2d8, %esi            # imm = 0x2D8
callq 0xc6a0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
jmp 0x9c05a
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movb $0x0, -0x39(%rbp)
movq -0x30(%rbp), %rax
movl 0x2d4(%rax), %edi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
xorl %ecx, %ecx
callq 0xc2e0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jge 0x9c0a2
callq 0xc080
cmpl $0x4, (%rax)
jne 0x9c0a2
jmp 0x9c09e
jmp 0x9c0a0
jmp 0x9c06e
cmpq $0x0, -0x38(%rbp)
jge 0x9c18f
testb $0x1, -0x39(%rbp)
jne 0x9c185
jmp 0x9c0b9
leaq 0x385e8(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e8e0
cmpq $0x0, %rax
je 0x9c181
leaq 0x385cf(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e900
leaq 0x385c0(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e8e0
movq %rax, %rdi
leaq 0xa3ae(%rip), %rsi      # 0xa64a8
callq 0xc670
movq %rax, %rdi
leaq 0xdaf0(%rip), %rsi      # 0xa9bf9
callq 0xc670
movq %rax, %rdi
leaq 0xda73(%rip), %rsi      # 0xa9b8b
callq 0xc670
movq %rax, %rdi
movq -0x30(%rbp), %rsi
callq 0xc4f0
movq %rax, %rdi
leaq 0xdc00(%rip), %rsi      # 0xa9d33
callq 0xc670
movq %rax, -0x48(%rbp)
callq 0xc080
movl (%rax), %edi
callq 0xc1d0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0xc670
movq %rax, %rdi
leaq 0xc275(%rip), %rsi      # 0xa83d3
callq 0xc670
movq %rax, %rdi
movq 0x37e53(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x3852f(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e920
jmp 0x9c183
jmp 0x9c185
movq $-0x1, -0x8(%rbp)
jmp 0x9c19b
jmp 0x9c191
jmp 0x9c193
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x9c826
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movl 0x70(%rax), %edi
callq 0xccd0
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
addq $0x78, %rdi
callq 0xc260
movq %rax, %rdi
callq 0xc2c0
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x9c878
movq -0x18(%rbp), %rdi
callq 0x9d240
movq -0x18(%rbp), %rdi
movl $0x98, %esi
callq 0xc6a0
movq -0x10(%rbp), %rax
movq $0x0, 0x40(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x9ca81
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x98cc0
cmpq $0x0, -0x10(%rbp)
je 0x9cabf
jmp 0x9ca9f
jmp 0x9caa1
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x2d4(%rax), %edi
movl $0x2, %esi
callq 0xc930
jmp 0x9cae5
movq -0x28(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x9cae3
jmp 0x9cacc
jmp 0x9cace
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movl 0x70(%rax), %edi
movl $0x2, %esi
callq 0xc930
jmp 0x9cae5
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/transport/transport_uds.cc
// Function: scdc_transport_uds::close(scdc_transport_connection_t*)
void scdc_transport_uds::close(scdc_transport_connection_t *conn)
{
  SCDC_TRACE("close: '" << conn << "'");

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

  ::close(uds_conn->socket);

  scdc_transport::close(conn);

  delete uds_conn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x9cb3a
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x2d4(%rax), %edi
callq 0xccd0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x98d30
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x9cb83
movq -0x28(%rbp), %rdi
callq 0x9d2a0
movq -0x28(%rbp), %rdi
movl $0x2d8, %esi            # imm = 0x2D8
callq 0xc6a0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: mh0fm4[P]SCDC/src/components/transport/transport_uds.cc
// Function: scdc_transport_uds::disconnect(scdc_transport_connection_t*)
bool scdc_transport_uds::disconnect(scdc_transport_connection_t *conn)
{
  SCDC_TRACE("disconnect: conn: '" << conn << "'");

  if (!scdc_transport::disconnect(conn)) return false;

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

  ::close(uds_conn->socket);

  delete uds_conn;

  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, -0x28(%rbp)
jmp 0x9ceaa
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x98df0
testb $0x1, %al
jne 0x9cec1
movb $0x0, -0x1(%rbp)
jmp 0x9cf01
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x2d4(%rax), %edi
callq 0xccd0
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x9cefd
movq -0x30(%rbp), %rdi
callq 0x9d2a0
movq -0x30(%rbp), %rdi
movl $0x2d8, %esi            # imm = 0x2D8
callq 0xc6a0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)