LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/transport/transport.cc
// Function: scdc_transport_connection_pool::~scdc_transport_connection_pool()
scdc_transport_connection_pool::~scdc_transport_connection_pool()
{
  pthread_cond_destroy(&pool->cond);
  pthread_mutex_destroy(&pool->lock);

  delete pool; pool = 0;

  transport = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
addq $0x28, %rdi
callq 0xba70
movq 0x10(%rbx), %rdi
callq 0xb620
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0x5f600
leaq 0x98(%r14), %r15
movq 0x98(%r14), %rdi
cmpq %r15, %rdi
je 0x5f5b6
movq (%rdi), %r12
movl $0x18, %esi
callq 0xb510
movq %r12, %rdi
cmpq %r15, %r12
jne 0x5f5a1
leaq 0x80(%r14), %r15
movq 0x80(%r14), %rdi
cmpq %r15, %rdi
je 0x5f5de
movq (%rdi), %r12
movl $0x18, %esi
callq 0xb510
movq %r12, %rdi
cmpq %r15, %r12
jne 0x5f5c9
leaq 0x60(%r14), %r15
movq 0x60(%r14), %rdi
cmpq %r15, %rdi
je 0x5f600
movq (%rdi), %r12
movl $0x18, %esi
callq 0xb510
movq %r12, %rdi
cmpq %r15, %r12
jne 0x5f5eb
movl $0xb0, %esi
movq %r14, %rdi
callq 0xb510
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/transport/transport.cc
// Function: scdc_transport_connection_pool::insert(scdc_transport_connection_t*)
void scdc_transport_connection_pool::insert(scdc_transport_connection_t *conn)
{
  SCDC_TRACE("insert: conn: '" << conn << "'");

  bool async = (max_connections > 1);

  scdc_transport_connection_pool_entry_t *entry = acquire_entry(async);

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

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

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

    pthread_cond_signal(&entry->cond);

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

    entry->conn = conn;

    run_entry(entry);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %r12
xorl %esi, %esi
cmpq $0x2, %r12
setge %sil
callq 0x5f6b2
testq %rax, %rax
je 0x5f67d
movq %rax, %r14
cmpq $0x2, %r12
jl 0x5f698
leaq 0x8(%r14), %r15
movq %r15, %rdi
callq 0xb7d0
movq %rbx, 0x70(%r14)
movq %r15, %rdi
callq 0xb3b0
addq $0x30, %r14
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xb030
movq 0x8(%r15), %rdi
movq (%rdi), %rax
movq 0x60(%rax), %rax
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
movq %rbx, 0x70(%r14)
movq %r15, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5f790
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/transport/transport.cc
// Function: scdc_transport_connection_pool::acquire_entry(bool)
scdc_transport_connection_pool_entry_t *scdc_transport_connection_pool::acquire_entry(bool async)
{
  SCDC_TRACE("acquire_entry:");

  pthread_mutex_lock(&pool->lock);

  while (pool->run && pool->total_entries.size() >= static_cast<unsigned>(max_connections)
#if THREAD_POOLING
    && pool->free_entries.size() <= 0
#endif
    ) pthread_cond_wait(&pool->cond, &pool->lock);

  if (!pool->run)
  {
    SCDC_TRACE("acquire_entry: stopped running");
    pthread_mutex_unlock(&pool->lock);
    return 0;
  }

#if !THREAD_POOLING
  /* cleanup dead entries */
  while (pool->dead_entries.size() > 0)
  {
    scdc_transport_connection_pool_entry_t *entry = pool->dead_entries.front();
    pool->dead_entries.pop_front();
    destroy_entry(entry);
  }
#endif

  scdc_transport_connection_pool_entry_t *entry;

#if THREAD_POOLING
  if (pool->free_entries.size() > 0)
  {
    entry = pool->free_entries.front();
    pool->free_entries.pop_front();

  } else
#endif
  {
    entry = create_entry(async);
    pool->total_entries.push_back(entry);
  }

  ++pool->naquired_entries;

  pthread_mutex_unlock(&pool->lock);

  SCDC_TRACE("acquire_entry: return: '" << entry << "'");

  return entry;
}

// 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), %rsi
cmpb $0x1, 0x58(%rsi)
jne 0x5f6fc
movl (%rbx), %ecx
movq 0xa8(%rsi), %rax
cmpq %rcx, 0x90(%rsi)
jb 0x5f709
testq %rax, %rax
jne 0x5f70e
leaq 0x28(%rsi), %rdi
callq 0xb840
movq 0x10(%rbx), %rsi
cmpb $0x0, 0x58(%rsi)
jne 0x5f6d2
movq %rsi, %rdi
callq 0xb3b0
xorl %r14d, %r14d
jmp 0x5f745
testq %rax, %rax
je 0x5f751
movq 0x98(%rsi), %r15
movq 0x10(%r15), %r14
decq %rax
movq %rax, 0xa8(%rsi)
movq %r15, %rdi
callq 0xb940
movl $0x18, %esi
movq %r15, %rdi
callq 0xb510
movq 0x10(%rbx), %rdi
incq 0x78(%rdi)
callq 0xb3b0
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movzbl %bpl, %esi
movq %rbx, %rdi
callq 0x5f924
movq %rax, %r14
movq 0x10(%rbx), %r12
leaq 0x80(%r12), %r15
movl $0x18, %edi
callq 0xb500
movq %r14, 0x10(%rax)
movq %rax, %rdi
movq %r15, %rsi
callq 0xb090
incq 0x90(%r12)
jmp 0x5f738
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/transport/transport.cc
// Function: scdc_transport_connection_pool::run_entry(scdc_transport_connection_pool_entry_t*)
void scdc_transport_connection_pool::run_entry(scdc_transport_connection_pool_entry_t *entry)
{
  SCDC_TRACE("run_entry: entry: '" << entry << "'");

  pthread_mutex_lock(&entry->lock);

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

      execute(entry->conn);

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

      release_entry(entry);

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

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

  } while (entry->run);

  pthread_mutex_unlock(&entry->lock);

  SCDC_TRACE("run_entry: return B");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x8(%rsi), %r14
movq %r14, %rdi
callq 0xb7d0
leaq 0x30(%rbx), %r12
cmpq $0x0, 0x70(%rbx)
je 0x5f7f9
movq %r14, %rdi
callq 0xb3b0
movq 0x70(%rbx), %r13
movq 0x8(%r15), %rdi
movq (%rdi), %rax
movq %r13, %rsi
callq *0x58(%rax)
movq 0x8(%r15), %rdi
movq (%rdi), %rax
movq %r13, %rsi
callq *0x60(%rax)
movq $0x0, 0x70(%rbx)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5f9c8
movq %r14, %rdi
callq 0xb7d0
jmp 0x5f80c
movb $0x1, 0x6a(%rbx)
movq %r12, %rdi
movq %r14, %rsi
callq 0xb840
movb $0x0, 0x6a(%rbx)
cmpb $0x0, 0x69(%rbx)
jne 0x5f7af
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xb3b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/transport/transport.cc
// Function: scdc_transport_connection_pool::finish()
void scdc_transport_connection_pool::finish()
{
  SCDC_TRACE("finish:");

  pthread_mutex_lock(&pool->lock);

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

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

  pthread_mutex_unlock(&pool->lock);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0xb7d0
movq 0x10(%rbx), %rsi
cmpq $0x0, 0x78(%rsi)
jle 0x5f8a3
leaq 0x28(%rsi), %rdi
callq 0xb840
jmp 0x5f835
movq 0x98(%rsi), %r14
movq 0x10(%r14), %r15
decq %rax
movq %rax, 0xa8(%rsi)
movq %r14, %rdi
callq 0xb940
movl $0x18, %esi
movq %r14, %rdi
callq 0xb510
leaq 0x8(%r15), %r14
movq %r14, %rdi
callq 0xb7d0
movb $0x0, 0x69(%r15)
movq %r14, %rdi
callq 0xb3b0
leaq 0x30(%r15), %rdi
callq 0xb030
movq %r15, %rsi
callq 0x5f8ee
movq 0x10(%rbx), %rsi
movq 0xa8(%rsi), %rax
testq %rax, %rax
jne 0x5f84b
movq %rsi, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xb3b0
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/transport/transport.cc
// Function: scdc_transport_connection_pool::destroy_entry(scdc_transport_connection_pool_entry_t*)
void scdc_transport_connection_pool::destroy_entry(scdc_transport_connection_pool_entry_t *entry)
{
  SCDC_TRACE("destroy_entry: entry: '" << entry << "'");

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

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

  delete entry;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
cmpb $0x1, 0x68(%rsi)
jne 0x5f903
movq 0x60(%rbx), %rdi
xorl %esi, %esi
callq 0xb460
leaq 0x30(%rbx), %rdi
callq 0xba70
leaq 0x8(%rbx), %rdi
callq 0xb620
movl $0x78, %esi
movq %rbx, %rdi
popq %rbx
jmp 0xb510
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5fad1
movzbl %bpl, %ebp
movq 0x10(%r15), %r12
leaq 0x8(%r12), %r14
movq %r14, %rdi
callq 0xb7d0
movq 0x70(%r12), %rsi
testq %rsi, %rsi
je 0x5fab6
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 0x5fa8f
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_O3/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
movb 0x2b(%rdi), %al
cmpb $0x0, 0x29(%rdi)
jne 0x5fd72
testb $0x1, %al
je 0x5fdf2
testb $0x1, %al
jne 0x5fd84
movq (%rbx), %rax
movq %rbx, %rdi
movl $0x1, %esi
callq *0x30(%rax)
cmpb $0x1, 0x28(%rbx)
jne 0x5fd9c
movq 0x30(%rbx), %rax
movq (%rax), %rdi
xorl %esi, %esi
callq 0xb460
movb $0x0, 0x28(%rbx)
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x5fdaa
callq 0x5f824
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movq 0x38(%rbx), %r14
testq %r14, %r14
je 0x5fdc5
movq %r14, %rdi
callq 0x5f564
movl $0x18, %esi
movq %r14, %rdi
callq 0xb510
xorl %r14d, %r14d
movq %r14, 0x38(%rbx)
movq 0x30(%rbx), %rdi
movl $0x8, %esi
callq 0xb510
movq %r14, 0x30(%rbx)
movb $0x1, %al
jmp 0x5fe84
leaq 0x2c777(%rip), %r14     # 0x8c570
movq (%r14), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x5fe82
addq $0x20, %rdi
callq 0xb7d0
movq (%r14), %rax
movq 0x8(%rax), %rbx
leaq 0xa38e(%rip), %rsi      # 0x6a1a8
movl $0xb, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0xe04a(%rip), %rsi      # 0x6de78
movl $0xb, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0xdca1(%rip), %rsi      # 0x6dae3
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
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5fedd
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 0x5ff6d
movl %ebp, %esi
callq 0x5fa5e
jmp 0x5ff6d
leaq 0x2c68c(%rip), %r15     # 0x8c570
movq (%r15), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x5ff6d
addq $0x20, %rdi
callq 0xb7d0
movq (%r15), %rax
movq 0x8(%rax), %r14
leaq 0xa2a3(%rip), %rsi      # 0x6a1a8
movl $0xb, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0xdf5f(%rip), %rsi      # 0x6de78
movl $0xb, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0xdbc8(%rip), %rsi      # 0x6daf5
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_O3/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 0x5ffe7
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 0x5ffc7
movq %rax, %r15
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x5ffaf
movq %r15, %rsi
callq 0x5f620
jmp 0x5ffc7
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 0x5ffd9
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq *%rax
incq %r14
cmpb $0x0, 0x29(%rbx)
jne 0x5ff8b
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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), %rcx
testq %rcx, %rcx
js 0x60437
movq 0x10(%rbx), %rax
movq %rsp, %r15
movq %rax, (%r15)
movq %rcx, 0x8(%r15)
movq 0x20(%rbx), %rax
movq %rax, 0x10(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x6063d
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
testq %rcx, %rcx
js 0x60448
xorl %edx, %edx
jmp 0x60451
movq 0x20(%rbx), %rsi
xorl %edx, %edx
subq %rsi, %rdx
cmpq %rdx, %r12
jge 0x60429
testb $0x1, %al
je 0x6046f
movq 0x10(%rbx), %rsi
addq %r15, %rsi
movq %r14, %rdi
callq 0x6063d
movq 0x18(%rbx), %rcx
jmp 0x60471
xorl %eax, %eax
incq %r12
addq $0x18, %r15
jmp 0x6043f
// File: /workspace/github_cpp_makefile_star2_O3/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 0x604b3
addq 0x78(%r14), %rdx
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rcx
callq *0x78(%rax)
movq %rax, %rbx
testq %rbx, %rbx
js 0x604cc
addq %rbx, 0x20(%r14)
leaq 0x70(%r14), %rdi
addq %rbx, 0x98(%r14)
callq 0x677f4
testq %rbx, %rbx
setns %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x677f4
movq 0x40(%rbx), %rax
movq 0x50(%rbx), %rdx
subq %rdx, %rax
jle 0x60511
addq 0x38(%rbx), %rdx
movq (%r14), %r8
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rcx
callq *0x80(%r8)
testq %rax, %rax
js 0x6051e
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_O3/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 0x10(%rsi), %r13
movq $0x0, 0x10(%rsi)
movb $0x1, %al
testq %r13, %r13
jle 0x60721
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %r15
movq 0x8(%rsi), %rbp
cmpq %rbp, %r13
movq %rbp, %r12
cmovlq %r13, %r12
cmpq $0x400, %r12            # imm = 0x400
jg 0x606c6
movq 0x80(%r14), %rax
movq 0x90(%r14), %rdi
subq %rdi, %rax
cmpq %rax, %r12
jg 0x606c6
addq 0x78(%r14), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xb3f0
movb $0x1, %al
addq %r12, 0x90(%r14)
addq %r12, 0x10(%rbx)
subq %r12, %r13
jle 0x60721
subq %r12, %rbp
addq %r12, %r15
cmpq %rbp, %r13
movq %rbp, %r12
cmovlq %r13, %r12
movq (%r14), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0xd0(%rax)
movb %al, 0x7(%rsp)
testq %r12, %r12
jle 0x60715
movq (%r14), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq *0x78(%rax)
movq %rax, %r12
testq %rax, %rax
js 0x60715
addq %r12, 0x20(%r14)
addq %r12, %r15
subq %r12, %rbp
subq %r12, %r13
addq %r12, 0x10(%rbx)
cmpq %rbp, %r13
movq %rbp, %r12
cmovlq %r13, %r12
jmp 0x606d9
testq %r12, %r12
setns %cl
movb 0x7(%rsp), %al
andb %cl, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq %rcx, %xmm0
movq %rdx, %xmm1
punpcklqdq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0]
pxor %xmm0, %xmm0
pcmpeqd %xmm1, %xmm0
pshufd $0xb1, %xmm0, %xmm2     # xmm2 = xmm0[1,0,3,2]
pand %xmm0, %xmm2
movq 0x2b774(%rip), %rax     # 0x8bfd0
movq 0x40(%rdi), %rcx
movq 0x2b739(%rip), %rdx     # 0x8bfa0
movq (%rdx), %xmm0
movq (%rax), %xmm3
punpcklqdq %xmm0, %xmm3    # xmm3 = xmm3[0],xmm0[0]
pand %xmm2, %xmm3
pandn %xmm1, %xmm2
por %xmm3, %xmm2
movdqu %xmm2, 0x2d8(%rcx)
jmp 0x5fb3a
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5fd5a
movl %eax, %ebx
testb %al, %al
je 0x608b2
movq 0x40(%r14), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x2d8(%rax)
jmp 0x60942
leaq 0x2bcb7(%rip), %r15     # 0x8c570
movq (%r15), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x60942
addq $0x20, %rdi
callq 0xb7d0
movq (%r15), %rax
movq 0x8(%rax), %r14
leaq 0x98ce(%rip), %rsi      # 0x6a1a8
movl $0xb, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0xd29d(%rip), %rsi      # 0x6db8b
movl $0x12, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0xd29c(%rip), %rsi      # 0x6db9e
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_O3/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), %rcx
movq 0x2d8(%rcx), %rdi
testq %rdi, %rdi
je 0x6096b
callq 0xb880
movq 0x40(%rbx), %rcx
testl %eax, %eax
je 0x6097e
movb $0x0, 0x8(%rcx)
movq (%rbx), %rax
movq %rbx, %rdi
xorl %esi, %esi
callq *0x30(%rax)
xorl %eax, %eax
popq %rbx
retq
movq 0x2e0(%rcx), %rdi
testq %rdi, %rdi
je 0x6096b
callq 0xb880
movq 0x40(%rbx), %rsi
testl %eax, %eax
sete 0x8(%rsi)
jne 0x6096f
movq %rbx, %rdi
popq %rbx
jmp 0x5ffe8
// File: /workspace/github_cpp_makefile_star2_O3/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
pxor %xmm0, %xmm0
movdqu %xmm0, 0x10(%rax)
movdqu %xmm0, 0x20(%rax)
leaq 0x2b300(%rip), %rcx     # 0x8bd08
addq $0x10, %rcx
movq %rcx, 0x30(%rax)
movdqu %xmm0, 0x38(%rax)
xorl %edx, %edx
movb %dl, 0x48(%rax)
movdqu %xmm0, 0x50(%rax)
movdqu %xmm0, 0x60(%rax)
movq %rcx, 0x70(%rax)
movdqu %xmm0, 0x78(%rax)
movb %dl, 0x88(%rax)
movdqu %xmm0, 0x90(%rax)
movdqu %xmm0, 0xa0(%rax)
movdqu %xmm0, 0x2c0(%rax)
movl $0x0, 0x2d0(%rax)
movq %r14, %xmm1
movq %r15, %xmm2
punpcklqdq %xmm1, %xmm2    # xmm2 = xmm2[0],xmm1[0]
pcmpeqd %xmm2, %xmm0
pshufd $0xb1, %xmm0, %xmm1     # xmm1 = xmm0[1,0,3,2]
pand %xmm0, %xmm1
movq 0x2b559(%rip), %rcx     # 0x8bfd0
movq 0x2b522(%rip), %rdx     # 0x8bfa0
movq (%rdx), %xmm0
movq (%rcx), %xmm3
punpcklqdq %xmm0, %xmm3    # xmm3 = xmm3[0],xmm0[0]
pand %xmm1, %xmm3
pandn %xmm2, %xmm1
por %xmm3, %xmm1
movdqu %xmm1, 0x2d8(%rax)
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x60066
// File: /workspace/github_cpp_makefile_star2_O3/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 0x60b25
movq %rcx, %r14
movq %rdx, %r15
callq 0xb880
testl %eax, %eax
jne 0x60bdb
movq 0x2e0(%rbx), %rcx
movl $0x1, %esi
movq %r15, %rdi
movq %r14, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0xba90
leaq 0x2ba44(%rip), %r15     # 0x8c570
movq (%r15), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x60bdb
addq $0x20, %rdi
callq 0xb7d0
movq (%r15), %rax
movq 0x18(%rax), %r14
leaq 0xcfb8(%rip), %rsi      # 0x6db09
movl $0xc, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0xd026(%rip), %rsi      # 0x6db8b
movl $0x12, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0xd03a(%rip), %rsi      # 0x6dbb3
movl $0xc, %edx
movq %r14, %rdi
callq 0xb5f0
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb3c0
movq %rax, %rbx
leaq 0xd025(%rip), %rsi      # 0x6dbc0
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_O3/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 0x2ab2f(%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 0x61256
movb $0x1, 0x8(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5ffe8
jmp 0x61367
cmpb $0x0, 0x2a(%r14)
jne 0x61350
leaq 0x2b308(%rip), %r12     # 0x8c570
movq (%r12), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x61350
addq $0x20, %rdi
callq 0xb7d0
movq (%r12), %rax
movq 0x8(%rax), %r14
leaq 0x8f19(%rip), %rsi      # 0x6a1a8
movl $0xb, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0xc97e(%rip), %rsi      # 0x6dc21
movl $0xf, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0xca0a(%rip), %rsi      # 0x6dcc1
movl $0x26, %edx
movq %r14, %rdi
callq 0xb5f0
callq 0xb070
movl (%rax), %edi
callq 0xb190
testq %rax, %rax
je 0x612f0
movq %rax, %r15
movq %rax, %rdi
callq 0xb200
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xb5f0
jmp 0x61308
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0xb990
leaq 0xb0c4(%rip), %rsi      # 0x6c3d3
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 0x60d40
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_O3/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 0x60024
testq %rbx, %rbx
je 0x61391
addq $0x2d4, %rbx            # imm = 0x2D4
jmp 0x6139e
movq 0x40(%r14), %rbx
testq %rbx, %rbx
je 0x613b1
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_O3/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 0x618a4
callq 0xb070
cmpl $0x4, (%rax)
je 0x617c6
leaq 0x2ad7c(%rip), %r13     # 0x8c570
movq (%r13), %rdi
movq $-0x1, %rbx
cmpq $0x0, 0x18(%rdi)
je 0x6190b
movq %rax, %r15
addq $0x20, %rdi
callq 0xb7d0
movq (%r13), %rax
movq 0x18(%rax), %r12
leaq 0x8c83(%rip), %rsi      # 0x6a4a8
movl $0xc, %edx
movq %r12, %rdi
callq 0xb5f0
leaq 0xc3e8(%rip), %rsi      # 0x6dc21
movl $0xf, %edx
movq %r12, %rdi
callq 0xb5f0
leaq 0xc366(%rip), %rsi      # 0x6dbb3
movl $0xc, %edx
movq %r12, %rdi
callq 0xb5f0
movq %r12, %rdi
movq %r14, %rsi
callq 0xb3c0
movq %rax, %r14
leaq 0xc4ec(%rip), %rsi      # 0x6dd5b
movl $0x16, %edx
movq %rax, %rdi
callq 0xb5f0
movl (%r15), %edi
callq 0xb190
testq %rax, %rax
je 0x618a9
movq %rax, %r15
movq %rax, %rdi
callq 0xb200
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xb5f0
jmp 0x618c3
movq %rax, %rbx
jmp 0x6190b
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0xb990
leaq 0xab09(%rip), %rsi      # 0x6c3d3
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_O3/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 0x61a11
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 0x61a15
callq 0xb070
cmpl $0x4, (%rax)
je 0x61933
leaq 0x2ac0f(%rip), %r13     # 0x8c570
movq (%r13), %rdi
movq $-0x1, %rbx
cmpq $0x0, 0x18(%rdi)
je 0x61a85
movq %rax, %r15
addq $0x20, %rdi
callq 0xb7d0
movq (%r13), %rax
movq 0x18(%rax), %r12
leaq 0x8b16(%rip), %rsi      # 0x6a4a8
movl $0xc, %edx
movq %r12, %rdi
callq 0xb5f0
leaq 0xc27b(%rip), %rsi      # 0x6dc21
movl $0xf, %edx
movq %r12, %rdi
callq 0xb5f0
leaq 0xc1f9(%rip), %rsi      # 0x6dbb3
movl $0xc, %edx
movq %r12, %rdi
callq 0xb5f0
movq %r12, %rdi
movq %r14, %rsi
callq 0xb3c0
movq %rax, %r14
leaq 0xc396(%rip), %rsi      # 0x6dd72
movl $0x1c, %edx
movq %rax, %rdi
callq 0xb5f0
movl (%r15), %edi
callq 0xb190
testq %rax, %rax
je 0x61a23
movq %rax, %r15
movq %rax, %rdi
callq 0xb200
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xb5f0
jmp 0x61a3d
xorl %ebx, %ebx
jmp 0x61a85
xorl %ebx, %ebx
cmpq $0x1, %rax
sbbq %rbx, %rbx
orq %rax, %rbx
jmp 0x61a85
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0xb990
leaq 0xa98f(%rip), %rsi      # 0x6c3d3
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_O3/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 0x61e72
movq 0x78(%r14), %rdi
leaq 0x88(%r14), %rax
cmpq %rax, %rdi
je 0x61e72
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_O3/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 0x29e45(%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 0x61f40
movb $0x1, 0x8(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5ffe8
jmp 0x62051
cmpb $0x0, 0x2a(%r14)
jne 0x6203a
leaq 0x2a61e(%rip), %r12     # 0x8c570
movq (%r12), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x6203a
addq $0x20, %rdi
callq 0xb7d0
movq (%r12), %rax
movq 0x8(%rax), %r14
leaq 0x822f(%rip), %rsi      # 0x6a1a8
movl $0xb, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0xbe17(%rip), %rsi      # 0x6dda4
movl $0xf, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0xbd20(%rip), %rsi      # 0x6dcc1
movl $0x26, %edx
movq %r14, %rdi
callq 0xb5f0
callq 0xb070
movl (%rax), %edi
callq 0xb190
testq %rax, %rax
je 0x61fda
movq %rax, %r15
movq %rax, %rdi
callq 0xb200
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xb5f0
jmp 0x61ff2
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0xb990
leaq 0xa3da(%rip), %rsi      # 0x6c3d3
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 0x60d40
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_O3/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 0x60024
testq %rbx, %rbx
je 0x6207b
addq $0x2d4, %rbx            # imm = 0x2D4
jmp 0x62088
movq 0x40(%r14), %rbx
testq %rbx, %rbx
je 0x6209b
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