LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/transport/transport_uds.cc
// Function: scdc_transport_uds::send(scdc_transport_connection_t*, void const*, long long)
scdcint_t scdc_transport_uds::send(scdc_transport_connection_t *conn, const void *buf, scdcint_t buf_size)
{
  SCDC_TRACE("send: conn: '" << conn << "', buf: '" << buf << "', buf_size: " << buf_size);

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

  scdcint_t n = 0;

  bool except = false;

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

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

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movl 0x2d4(%r14), %edi
movq %r13, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
callq 0xb260
testq %rax, %rax
jns 0x62522
callq 0xb070
cmpl $0x4, (%rax)
je 0x62444
leaq 0x2a0fe(%rip), %r13     # 0x8c570
movq (%r13), %rdi
movq $-0x1, %rbx
cmpq $0x0, 0x18(%rdi)
je 0x62589
movq %rax, %r15
addq $0x20, %rdi
callq 0xb7d0
movq (%r13), %rax
movq 0x18(%rax), %r12
leaq 0x8005(%rip), %rsi      # 0x6a4a8
movl $0xc, %edx
movq %r12, %rdi
callq 0xb5f0
leaq 0xb8ed(%rip), %rsi      # 0x6dda4
movl $0xf, %edx
movq %r12, %rdi
callq 0xb5f0
leaq 0xb6e8(%rip), %rsi      # 0x6dbb3
movl $0xc, %edx
movq %r12, %rdi
callq 0xb5f0
movq %r12, %rdi
movq %r14, %rsi
callq 0xb3c0
movq %rax, %r14
leaq 0xb86e(%rip), %rsi      # 0x6dd5b
movl $0x16, %edx
movq %rax, %rdi
callq 0xb5f0
movl (%r15), %edi
callq 0xb190
testq %rax, %rax
je 0x62527
movq %rax, %r15
movq %rax, %rdi
callq 0xb200
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xb5f0
jmp 0x62541
movq %rax, %rbx
jmp 0x62589
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0xb990
leaq 0x9e8b(%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_uds.cc
// Function: scdc_transport_uds::receive(scdc_transport_connection_t*, void*, long long)
scdcint_t scdc_transport_uds::receive(scdc_transport_connection_t *conn, void *buf, scdcint_t max_buf_size)
{
  SCDC_TRACE("receive: conn: '" << conn << "', buf: '" << buf << "', max_buf_size: " << max_buf_size);

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

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

  scdcint_t n = 0;

  bool except = false;

#if SCDC_TRANSPORT_UDS_USE_SHUTDOWN_EXCEPTION
  try
  {
#endif

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

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

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

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

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

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

  return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rcx, %rcx
jle 0x6268f
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 0x62693
callq 0xb070
cmpl $0x4, (%rax)
je 0x625b1
leaq 0x29f91(%rip), %r13     # 0x8c570
movq (%r13), %rdi
movq $-0x1, %rbx
cmpq $0x0, 0x18(%rdi)
je 0x62703
movq %rax, %r15
addq $0x20, %rdi
callq 0xb7d0
movq (%r13), %rax
movq 0x18(%rax), %r12
leaq 0x7e98(%rip), %rsi      # 0x6a4a8
movl $0xc, %edx
movq %r12, %rdi
callq 0xb5f0
leaq 0xb780(%rip), %rsi      # 0x6dda4
movl $0xf, %edx
movq %r12, %rdi
callq 0xb5f0
leaq 0xb57b(%rip), %rsi      # 0x6dbb3
movl $0xc, %edx
movq %r12, %rdi
callq 0xb5f0
movq %r12, %rdi
movq %r14, %rsi
callq 0xb3c0
movq %rax, %r14
leaq 0xb718(%rip), %rsi      # 0x6dd72
movl $0x1c, %edx
movq %rax, %rdi
callq 0xb5f0
movl (%r15), %edi
callq 0xb190
testq %rax, %rax
je 0x626a1
movq %rax, %r15
movq %rax, %rdi
callq 0xb200
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xb5f0
jmp 0x626bb
xorl %ebx, %ebx
jmp 0x62703
xorl %ebx, %ebx
cmpq $0x1, %rax
sbbq %rbx, %rbx
orq %rax, %rbx
jmp 0x62703
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0xb990
leaq 0x9d11(%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/compcoup/compcoup_direct.cc
// Function: scdc_compcoup_direct::dataset_open(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
scdc_dataset *scdc_compcoup_direct::dataset_open(const std::string &path, scdc_result &result)
{
  SCDC_TRACE("dataset_open: path: '" << path << "'");

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

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

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

  return dataset;
}

// Assembly:
pushq %rax
cmpb $0x0, 0x18(%rdi)
je 0x62748
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x6275b
popq %rax
jmp 0x1e2ce
movq 0x8(%rdx), %rax
leaq 0xb69e(%rip), %rcx      # 0x6ddf1
movl $0xf, %r8d
jmp 0x6276c
movq 0x8(%rdx), %rax
leaq 0xb69b(%rip), %rcx      # 0x6de01
movl $0x1a, %r8d
movq %rdx, %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0xb870
xorl %eax, %eax
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/compcoup/compcoup_direct.cc
// Function: scdc_compcoup_direct::dataset_cmd(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, _scdc_dataset_inout_t*, _scdc_dataset_inout_t*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_compcoup_direct::dataset_cmd(const std::string &cmd, scdc_dataset_input_t *input, scdc_dataset_output_t *output, scdc_result &result)
{
  SCDC_TRACE("dataset_cmd: cmd: '" << cmd << "'");

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

  return scdc_compcoup::dataset_cmd(cmd, input, output, result);
}

// Assembly:
movq %r8, %rax
cmpb $0x0, 0x18(%rdi)
je 0x627bf
movq %rax, %r8
jmp 0x67834
pushq %rax
movq 0x8(%rax), %rdx
leaq 0xb626(%rip), %rcx      # 0x6ddf1
movl $0xf, %r8d
movq %rax, %rdi
xorl %esi, %esi
callq 0xb870
xorl %eax, %eax
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/compcoup/compcoup_direct.cc
// Function: scdc_compcoup_direct::start(long long)
bool scdc_compcoup_direct::start(scdcint_t mode)
{
  SCDC_TRACE("start: mode: '" << mode << "'");

  if (running) return false;

  if (mode == SCDC_NODEPORT_START_LOOP_UNTIL_CANCEL)
  {
    pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
    pthread_mutex_lock(&lock);

    running = true;

    pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

    data = static_cast<void *>(&cond);
    pthread_cond_wait(&cond, &lock);
    data = 0;

    pthread_cond_destroy(&cond);

    running = false;

    pthread_mutex_unlock(&lock);
    pthread_mutex_destroy(&lock);

  } else if (mode == SCDC_NODEPORT_START_ASYNC_UNTIL_CANCEL)
  {
    running = true;

  } else
  {
    SCDC_ERROR("start: mode '" << mode << "' not supported");
    return false;
  }

  return true;
}

// Assembly:
cmpb $0x0, 0x18(%rdi)
je 0x627e9
xorl %eax, %eax
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x4, %rsi
je 0x6286f
cmpq $0x1, %rbx
jne 0x6287b
xorps %xmm0, %xmm0
movq %rsp, %rbx
movaps %xmm0, 0x10(%rbx)
movaps %xmm0, (%rbx)
xorl %r12d, %r12d
movq %r12, 0x20(%rbx)
movq %rbx, %rdi
callq 0xb7d0
movb $0x1, 0x18(%r14)
leaq 0x30(%rsp), %r15
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%r15)
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
movq %r15, 0x10(%r14)
movq %r15, %rdi
movq %rbx, %rsi
callq 0xb840
movq %r12, 0x10(%r14)
movq %r15, %rdi
callq 0xba70
movb $0x0, 0x18(%r14)
movq %rbx, %rdi
callq 0xb3b0
movq %rbx, %rdi
callq 0xb620
jmp 0x62874
movb $0x1, 0x18(%r14)
movb $0x1, %al
jmp 0x62933
leaq 0x29cee(%rip), %r15     # 0x8c570
movq (%r15), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x62931
addq $0x20, %rdi
callq 0xb7d0
movq (%r15), %rax
movq 0x18(%rax), %r14
leaq 0x7c01(%rip), %rsi      # 0x6a4a8
movl $0xc, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0xb561(%rip), %rsi      # 0x6de1c
movl $0x11, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0xb55f(%rip), %rsi      # 0x6de2e
movl $0xd, %edx
movq %r14, %rdi
callq 0xb5f0
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb1d0
movq %rax, %rbx
leaq 0xb1e2(%rip), %rsi      # 0x6dad3
movl $0xf, %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
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/compcoup/compcoup_direct.cc
// Function: scdc_compcoup_direct::cancel(bool)
bool scdc_compcoup_direct::cancel(bool interrupt)
{
  SCDC_TRACE("cancel: interrupt: '" << interrupt << "'");

  if (!running) return false;

  if (data)
  {
    pthread_cond_t *cond = static_cast<pthread_cond_t *>(data);
    pthread_cond_signal(cond);
  }

  running = false;

  return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movb 0x18(%rdi), %bl
cmpb $0x1, %bl
jne 0x6297a
movq %rdi, %r14
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x62975
callq 0xb030
movb $0x0, 0x18(%r14)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/compcoup/compcoup_transport.cc
// Function: scdc_compcoup_transport::dataset_input_outgoing_produce(scdc_transport_connection_t*, _scdc_dataset_inout_t*)
bool scdc_compcoup_transport::dataset_input_outgoing_produce(scdc_transport_connection_t *conn, scdc_dataset_input_t *input)
{
  while (1)
  {
    SCDC_TRACE("dataset_input_outgoing_produce: outgoing produce");
    if (!dataset_input_outgoing_send(conn, input))
    {
      SCDC_FAIL("dataset_input_outgoing_produce: send failed");
      return false;
    }

    if (!input || !input->next) break;

    SCDC_TRACE("dataset_input_outgoing_produce: next");
    if (!input->next(input, 0))
    {
      SCDC_FAIL("dataset_input_outgoing_produce: next failed");
      return false;
    }
  }

  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x65b24
testb %al, %al
je 0x64607
movb $0x1, %bl
testq %r14, %r14
je 0x646a7
movq 0x38(%r14), %rax
testq %rax, %rax
je 0x646a7
movq %r14, %rdi
xorl %esi, %esi
callq *%rax
testq %rax, %rax
je 0x646af
movq %r15, %rdi
movq %r14, %rsi
callq 0x65b24
testb %al, %al
jne 0x645db
leaq 0x27f62(%rip), %rax     # 0x8c570
movq (%rax), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x646a5
leaq 0x9d1c(%rip), %rbx      # 0x6e33f
addq $0x20, %rdi
callq 0xb7d0
leaq 0x27f3d(%rip), %r15     # 0x8c570
movq (%r15), %rax
movq 0x8(%rax), %r14
leaq 0x5b67(%rip), %rsi      # 0x6a1a8
movl $0xb, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x981a(%rip), %rsi      # 0x6de6f
movl $0x14, %edx
movq %r14, %rdi
callq 0xb5f0
movl $0x2b, %edx
movq %r14, %rdi
movq %rbx, %rsi
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
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x27eba(%rip), %rax     # 0x8c570
movq (%rax), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x646a5
leaq 0x9ca4(%rip), %rbx      # 0x6e36b
jmp 0x64623
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/compcoup/compcoup_transport.cc
// Function: scdc_compcoup_transport::dataset_output_incoming_consume(scdc_transport_connection_t*, _scdc_dataset_inout_t*, bool*)
bool scdc_compcoup_transport::dataset_output_incoming_consume(scdc_transport_connection_t *conn, scdc_dataset_output_t *output, bool *next)
{
  scdc_dataset_output_t output_null;

  /* use null output for consuming all output */
  if (!output)
  {
    scdc_dataset_output_unset(&output_null);
    output = &output_null;
  }

  *next = true;

  while (*next)
  {
    SCDC_TRACE("dataset_output_incoming_consume: incoming receive");
    if (!dataset_output_incoming_recv(conn, output, next))
    {
      SCDC_FAIL("dataset_output_incoming_consume: receive failed");
      return false;
    }

    if (output == &output_null) continue; 

    if (!output->next) break;

    SCDC_TRACE("dataset_output_incoming_consume: next");
    if (!output->next(output, 0))
    {
      SCDC_FAIL("dataset_output_incoming_consume: next failed");
      return false;
    }
  }

  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq %rsp, %r15
testq %rsi, %rsi
jne 0x646f3
movq %r15, %rdi
callq 0x2ae72
movq %r15, %r12
movb $0x1, (%rbx)
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x65c62
testb %al, %al
je 0x6472f
cmpq %r15, %r12
je 0x64723
movq 0x38(%r12), %rax
testq %rax, %rax
je 0x64728
movq %r12, %rdi
xorl %esi, %esi
callq *%rax
testq %rax, %rax
je 0x6478a
cmpb $0x0, (%rbx)
jne 0x646f6
movb $0x1, %al
jmp 0x64827
leaq 0x27e3a(%rip), %rbx     # 0x8c570
movq (%rbx), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x64825
addq $0x20, %rdi
callq 0xb7d0
movq (%rbx), %rax
movq 0x8(%rax), %rbx
leaq 0x5a4d(%rip), %rsi      # 0x6a1a8
movl $0xb, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x9700(%rip), %rsi      # 0x6de6f
movl $0x14, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x9c14(%rip), %rsi      # 0x6e397
movl $0x2f, %edx
jmp 0x647e3
leaq 0x27ddf(%rip), %rbx     # 0x8c570
movq (%rbx), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x64825
addq $0x20, %rdi
callq 0xb7d0
movq (%rbx), %rax
movq 0x8(%rax), %rbx
leaq 0x59f2(%rip), %rsi      # 0x6a1a8
movl $0xb, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x96a5(%rip), %rsi      # 0x6de6f
movl $0x14, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x9be9(%rip), %rsi      # 0x6e3c7
movl $0x2c, %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
leaq 0x27d57(%rip), %rax     # 0x8c570
movq (%rax), %rdi
addq $0x20, %rdi
callq 0xb3b0
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/compcoup/compcoup_transport.cc
// Function: read_output_next(_scdc_dataset_inout_t*, _scdc_result_t*)
static scdcint_t read_output_next(scdc_dataset_output_t *output, scdc_result_t *result)
{
  SCDC_TRACE("read_output_next:");

  scdc_transport_connection_t *transport_connection = static_cast<scdc_transport_connection_t *>(output->data);

  bool next = false, ret = true;

  if (transport_connection->current_incoming_output_next || transport_connection->current_incoming_output_size > 0) ret = scdc_compcoup_transport::dataset_output_incoming_recv(transport_connection, output, &next);
  else SCDC_DATASET_INOUT_BUF_CURRENT(output) = 0;

  if (next)
  {
    /* continue with current output->next and output->data */

  } else
  {
    if (transport_connection->current_incoming_output_intern)
    {
      /* continue with current output->next and output->data */

      /* unset internal buffer usage for next 'next' */
      transport_connection->current_incoming_output_intern = false;

    } else
    {
      /* stop and release connection */
      output->next = 0;
      output->data = 0;

      transport_connection->release();
    }
  }

  return (ret)?SCDC_SUCCESS:SCDC_FAILURE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x40(%rdi), %rbx
movb $0x0, 0x7(%rsp)
cmpb $0x0, 0x2d1(%rbx)
jne 0x6485a
cmpq $0x0, 0x2c8(%rbx)
jle 0x6487a
leaq 0x7(%rsp), %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x65c62
movzbl %al, %r15d
testb $0x1, (%r12)
je 0x64888
jmp 0x648aa
movq $0x0, 0x20(%r14)
movl $0x1, %r15d
cmpb $0x1, 0x2d3(%rbx)
jne 0x6489a
movb $0x0, 0x2d3(%rbx)
jmp 0x648aa
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%r14)
movq %rbx, %rdi
callq 0x5f3c4
movq %r15, %rax
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/compcoup/compcoup_transport.cc
// Function: scdc_compcoup_transport::on_dataset_close(scdc_transport_connection_t*)
void scdc_compcoup_transport::on_dataset_close(scdc_transport_connection_t *conn)
{
  SCDC_TRACE("on_dataset_close:");

  /* read request: DATASET_CLOSE <state> */

  scdc_result result;

  scdc_dataset_transport::read_state_begin(conn);
  scdc_dataset *dataset = dataprovs->dataset_open_read_state(conn->get_incoming(), result);
  scdc_dataset_transport::read_state_end(conn);

  /* send answer: DATASET_CLOSE (OK|FAILED) RESULT <string> */

  scdc_dataset_transport::write_delim(conn, "DATASET_CLOSE", -1, default_delim);

  if (dataset)
  {
    scdc_dataset_transport::write_delim(conn, "OK", -1, default_delim);
    dataprovs->dataset_close(dataset, result);

  } else
  {
    SCDC_FAIL("on_dataset_close: failed");
    scdc_dataset_transport::write_delim(conn, "FAILED", -1, default_delim);
  }

  scdc_dataset_transport::write_delim(conn, "RESULT", -1, default_delim);
  scdc_dataset_transport::write_string(conn, result.c_str(), result.size());

  transport->send_outgoing(conn);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq %rsi, %rdi
callq 0x66ed8
movq 0x8(%r14), %rdi
leaq 0x30(%rbx), %rsi
movq %rsp, %rdx
callq 0x1e62c
movq %rax, %r15
movq %rbx, %rdi
callq 0x67026
leaq 0x8feb(%rip), %rsi      # 0x6df66
movq %rbx, %rdi
movq $-0x1, %rdx
movl $0x20, %ecx
callq 0x6638a
testq %r15, %r15
je 0x64fc3
leaq 0x45b9(%rip), %rsi      # 0x69554
movq %rbx, %rdi
movq $-0x1, %rdx
movl $0x20, %ecx
callq 0x6638a
movq 0x8(%r14), %rdi
movq %rsp, %rdx
movq %r15, %rsi
callq 0x1e61e
jmp 0x65075
leaq 0x275a6(%rip), %r13     # 0x8c570
movq (%r13), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x6505a
addq $0x20, %rdi
callq 0xb7d0
movq (%r13), %rax
movq 0x8(%rax), %r15
leaq 0x51b7(%rip), %rsi      # 0x6a1a8
movl $0xb, %edx
movq %r15, %rdi
callq 0xb5f0
leaq 0x8e6a(%rip), %rsi      # 0x6de6f
movl $0x14, %edx
movq %r15, %rdi
callq 0xb5f0
leaq 0x942d(%rip), %rsi      # 0x6e446
movl $0x18, %edx
movq %r15, %rdi
callq 0xb5f0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %r15, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq (%r13), %rdi
addq $0x20, %rdi
callq 0xb3b0
leaq 0x8e82(%rip), %rsi      # 0x6dee3
movq %rbx, %rdi
movq $-0x1, %rdx
movl $0x20, %ecx
callq 0x6638a
leaq 0x8e99(%rip), %rsi      # 0x6df15
movq %rbx, %rdi
movq $-0x1, %rdx
movl $0x20, %ecx
callq 0x6638a
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x66d5a
movq 0x10(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0xd0(%rax)
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x650c7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x650d7
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x650f0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/compcoup/compcoup_transport.cc
// Function: scdc_compcoup_transport::on_cmd_handler(char const*, scdc_data*)
bool scdc_compcoup_transport::on_cmd_handler(const char *cmd, scdc_data *incoming)
{
  if (!cmd_handler) return false;
  
  if (cmd[0] == '\0') return true;

  scdcint_t n = cmd_handler(cmd_handler_data, cmd, incoming->get_read_pos_buf(), incoming->get_read_pos_buf_size());

  return (n >= 0);
}

// Assembly:
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0x65830
cmpb $0x0, (%rsi)
je 0x65833
pushq %rax
movq 0x28(%rdi), %rdi
movq 0x20(%rdx), %rcx
movq 0x28(%rdx), %r8
movq 0x8(%rdx), %rdx
addq %r8, %rdx
subq %r8, %rcx
callq *%rax
testq %rax, %rax
setns %al
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
movb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/compcoup/compcoup_transport.cc
// Function: scdc_compcoup_transport::dataset_input_outgoing_send(scdc_transport_connection_t*, _scdc_dataset_inout_t*)
bool scdc_compcoup_transport::dataset_input_outgoing_send(scdc_transport_connection_t *conn, scdc_dataset_input_t *input)
{
  SCDC_TRACE("dataset_input_outgoing_send:");

  if (!scdc_dataset_transport::write_input_info(conn, input))
  {
    SCDC_FAIL("dataset_input_outgoing_send: write input info failed");
    return false;
  }

  if (input)
  {
    if (!conn->transport->send_outgoing_dataset_input(conn, input))
    {
      SCDC_FAIL("dataset_input_outgoing_send: send dataset input failed");
      return false;
    }
  }

  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x6745a
testb %al, %al
je 0x65bbc
movb $0x1, %bl
testq %r14, %r14
je 0x65c59
movq (%r15), %rdi
movq (%rdi), %rax
movq %r15, %rsi
movq %r14, %rdx
callq *0xb8(%rax)
testb %al, %al
jne 0x65c59
leaq 0x26a08(%rip), %rbx     # 0x8c570
movq (%rbx), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x65c57
addq $0x20, %rdi
callq 0xb7d0
movq (%rbx), %rax
movq 0x8(%rax), %rbx
leaq 0x461b(%rip), %rsi      # 0x6a1a8
movl $0xb, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x82ce(%rip), %rsi      # 0x6de6f
movl $0x14, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x85eb(%rip), %rsi      # 0x6e1a0
movl $0x36, %edx
jmp 0x65c15
leaq 0x269ad(%rip), %rbx     # 0x8c570
movq (%rbx), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x65c57
addq $0x20, %rdi
callq 0xb7d0
movq (%rbx), %rax
movq 0x8(%rax), %rbx
leaq 0x45c0(%rip), %rsi      # 0x6a1a8
movl $0xb, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x8273(%rip), %rsi      # 0x6de6f
movl $0x14, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x855b(%rip), %rsi      # 0x6e16b
movl $0x34, %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
leaq 0x26925(%rip), %rax     # 0x8c570
movq (%rax), %rdi
addq $0x20, %rdi
callq 0xb3b0
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/compcoup/compcoup_transport.cc
// Function: scdc_compcoup_transport::dataset_output_outgoing_send(scdc_transport_connection_t*, _scdc_dataset_inout_t*)
bool scdc_compcoup_transport::dataset_output_outgoing_send(scdc_transport_connection_t *conn, scdc_dataset_output_t *output)
{
  SCDC_TRACE("dataset_output_outgoing_send:");

  if (!scdc_dataset_transport::write_output_info(conn, output))
  {
    SCDC_FAIL("dataset_output_outgoing_send: write output info failed");
    return false;
  }

  if (output)
  {
    if (!conn->transport->send_outgoing_dataset_output(conn, output))
    {
      SCDC_FAIL("dataset_output_outgoing_send: send dataset output failed");
      return false;
    }
  }

  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x6745a
testb %al, %al
je 0x65fe6
movb $0x1, %bl
testq %r14, %r14
je 0x66083
movq (%r15), %rdi
movq (%rdi), %rax
movq %r15, %rsi
movq %r14, %rdx
callq *0xc0(%rax)
testb %al, %al
jne 0x66083
leaq 0x265de(%rip), %rbx     # 0x8c570
movq (%rbx), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x66081
addq $0x20, %rdi
callq 0xb7d0
movq (%rbx), %rax
movq 0x8(%rax), %rbx
leaq 0x41f1(%rip), %rsi      # 0x6a1a8
movl $0xb, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x7ea4(%rip), %rsi      # 0x6de6f
movl $0x14, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x82cc(%rip), %rsi      # 0x6e2ab
movl $0x38, %edx
jmp 0x6603f
leaq 0x26583(%rip), %rbx     # 0x8c570
movq (%rbx), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x66081
addq $0x20, %rdi
callq 0xb7d0
movq (%rbx), %rax
movq 0x8(%rax), %rbx
leaq 0x4196(%rip), %rsi      # 0x6a1a8
movl $0xb, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x7e49(%rip), %rsi      # 0x6de6f
movl $0x14, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x823a(%rip), %rsi      # 0x6e274
movl $0x36, %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
leaq 0x264fb(%rip), %rax     # 0x8c570
movq (%rax), %rdi
addq $0x20, %rdi
callq 0xb3b0
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/compcoup/compcoup_transport.cc
// Function: scdc_compcoup_transport::dataset_input_incoming_consume(scdc_transport_connection_t*, _scdc_dataset_inout_t*, bool*)
bool scdc_compcoup_transport::dataset_input_incoming_consume(scdc_transport_connection_t *conn, scdc_dataset_input_t *input, bool *next)
{
  scdc_dataset_input_t input_null;

  /* use null input for consuming all input */
  if (!input)
  {
    scdc_dataset_input_unset(&input_null);
    input = &input_null;
  }

  *next = true;

  while (*next)
  {
    SCDC_TRACE("dataset_input_incoming_consume: incoming receive");
    if (!dataset_input_incoming_recv(conn, input, next))
    {
      SCDC_FAIL("dataset_input_incoming_consume: receive failed");
      return false;
    }

    if (input == &input_null) continue; 

    if (!input->next) break;

    SCDC_TRACE("dataset_input_incoming_consume: next");
    if (!input->next(input, 0))
    {
      SCDC_FAIL("dataset_input_incoming_consume: next failed");
      return false;
    }
  }

  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq %rsp, %r15
testq %rsi, %rsi
jne 0x660b3
movq %r15, %rdi
callq 0x2ae52
movq %r15, %r12
movb $0x1, (%rbx)
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x65838
testb %al, %al
je 0x660ef
cmpq %r15, %r12
je 0x660e3
movq 0x38(%r12), %rax
testq %rax, %rax
je 0x660e8
movq %r12, %rdi
xorl %esi, %esi
callq *%rax
testq %rax, %rax
je 0x6614a
cmpb $0x0, (%rbx)
jne 0x660b6
movb $0x1, %al
jmp 0x661e7
leaq 0x2647a(%rip), %rbx     # 0x8c570
movq (%rbx), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x661e5
addq $0x20, %rdi
callq 0xb7d0
movq (%rbx), %rax
movq 0x8(%rax), %rbx
leaq 0x408d(%rip), %rsi      # 0x6a1a8
movl $0xb, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x7d40(%rip), %rsi      # 0x6de6f
movl $0x14, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x81a1(%rip), %rsi      # 0x6e2e4
movl $0x2e, %edx
jmp 0x661a3
leaq 0x2641f(%rip), %rbx     # 0x8c570
movq (%rbx), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x661e5
addq $0x20, %rdi
callq 0xb7d0
movq (%rbx), %rax
movq 0x8(%rax), %rbx
leaq 0x4032(%rip), %rsi      # 0x6a1a8
movl $0xb, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x7ce5(%rip), %rsi      # 0x6de6f
movl $0x14, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x8175(%rip), %rsi      # 0x6e313
movl $0x2b, %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
leaq 0x26397(%rip), %rax     # 0x8c570
movq (%rax), %rdi
addq $0x20, %rdi
callq 0xb3b0
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/compcoup/compcoup_transport.cc
// Function: scdc_compcoup_transport::dataset_output_outgoing_produce(scdc_transport_connection_t*, _scdc_dataset_inout_t*)
bool scdc_compcoup_transport::dataset_output_outgoing_produce(scdc_transport_connection_t *conn, scdc_dataset_output_t *output)
{
  while (1)
  {
    SCDC_TRACE("dataset_output_outgoing_produce: outgoing produce");
    dataset_output_outgoing_send(conn, output);

    if (!output || !output->next) break;

    SCDC_TRACE("dataset_output_outgoing_produce: next");
    if (!output->next(output, 0))
    {
      SCDC_FAIL("dataset_output_outgoing_produce: next failed");
      return false;
    }
  }

  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x65f4e
movb $0x1, %bl
testq %r14, %r14
je 0x662c7
movq 0x38(%r14), %rax
testq %rax, %rax
je 0x662c7
movq %r14, %rdi
xorl %esi, %esi
callq *%rax
testq %rax, %rax
je 0x66235
movq %r15, %rdi
movq %r14, %rsi
callq 0x65f4e
jmp 0x6620f
leaq 0x26334(%rip), %r14     # 0x8c570
movq (%r14), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x662c5
addq $0x20, %rdi
callq 0xb7d0
movq (%r14), %rax
movq 0x8(%rax), %rbx
leaq 0x3f4b(%rip), %rsi      # 0x6a1a8
movl $0xb, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x7bfe(%rip), %rsi      # 0x6de6f
movl $0x14, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x816f(%rip), %rsi      # 0x6e3f4
movl $0x2c, %edx
movq %rbx, %rdi
callq 0xb5f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq (%r14), %rdi
addq $0x20, %rdi
callq 0xb3b0
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/compcoup/compcoup_transport.cc
// Function: write_output_next(_scdc_dataset_inout_t*, _scdc_result_t*)
static scdcint_t write_output_next(scdc_dataset_output_t *output, scdc_result_t *result)
{
  scdc_transport_connection_t *transport_connection = static_cast<scdc_transport_connection_t *>(output->data);

  bool ret = true;

  ret = ret && scdc_dataset_transport::write_output_info(transport_connection, output);
  ret = ret && transport_connection->transport->send_outgoing_dataset_output(transport_connection, output);

  return (ret)?SCDC_SUCCESS:SCDC_FAILURE;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6745a
testb %al, %al
je 0x66379
movq (%r14), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0xc0(%rax)
movzbl %al, %eax
jmp 0x6637b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/compcoup/compcoup_transport.cc
// Function: scdc_dataset_transport::write_delim(scdc_transport_connection_t*, char const*, long long, char)
static bool write_delim(scdc_transport_connection_t *transport_connection_, const char *s, scdcint_t n, char delim)
    {
      if (n < 0) n = strlen(s);

      bool ret = true;

      ret = ret && write_bytes(transport_connection_, s, n);
      ret = ret && write_bytes(transport_connection_, &delim, 1);

      if (!ret) SCDC_FAIL("write_delim: failed");

      return ret;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movb %cl, 0xf(%rsp)
testq %rdx, %rdx
jns 0x663b4
movq %r15, %rdi
callq 0xb200
movq %rax, %r12
leaq 0x70(%rbx), %r14
movq 0x80(%rbx), %r13
movq 0x90(%rbx), %rdi
subq %rdi, %r13
cmpq %r12, %r13
cmovgeq %r12, %r13
addq 0x78(%rbx), %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0xb3f0
addq %r13, 0x90(%rbx)
subq %r13, %r12
jle 0x66405
movq 0xa8(%rbx), %rax
testq %rax, %rax
je 0x6645f
addq %r13, %r15
movq %r14, %rdi
callq *%rax
testb %al, %al
jne 0x663b8
jmp 0x6645f
movl $0x1, %r13d
leaq 0xf(%rsp), %r15
movq 0x80(%rbx), %r12
movq 0x90(%rbx), %rdi
subq %rdi, %r12
cmpq %r13, %r12
cmovgeq %r13, %r12
addq 0x78(%rbx), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xb3f0
addq %r12, 0x90(%rbx)
subq %r12, %r13
jle 0x664ff
movq 0xa8(%rbx), %rax
testq %rax, %rax
je 0x6645f
addq %r12, %r15
movq %r14, %rdi
callq *%rax
testb %al, %al
jne 0x66410
leaq 0x2610a(%rip), %r14     # 0x8c570
movq (%r14), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x664ef
addq $0x20, %rdi
callq 0xb7d0
movq (%r14), %rax
movq 0x8(%rax), %rbx
leaq 0x3d21(%rip), %rsi      # 0x6a1a8
movl $0xb, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x79d4(%rip), %rsi      # 0x6de6f
movl $0x14, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x7ff7(%rip), %rsi      # 0x6e4a6
movl $0x13, %edx
movq %rbx, %rdi
callq 0xb5f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq (%r14), %rdi
addq $0x20, %rdi
callq 0xb3b0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movb $0x1, %al
jmp 0x664f1
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/compcoup/compcoup_transport.cc
// Function: scdc_dataset_transport::read_delim(scdc_transport_connection_t*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char, bool*)
static bool read_delim(scdc_transport_connection_t *transport_connection_, std::string *s, char delim, bool *stop_at_delim = 0)
    {
      scdc_data *incoming = transport_connection_->get_incoming();
      bool ret = true;

      (*s).clear();

      while (ret)
      {
        const char *src = incoming->get_read_pos_buf();
        scdcint_t src_size = incoming->get_read_pos_buf_size();

/*        SCDC_TRACE("read_delim: '" << string(src, src_size) << "'");*/

        const char *end = memchr(src, delim, src_size);

        scdcint_t n = (end)?(end - src):src_size;

        *s += string(src, n);

        if (end) n += 1;
        incoming->inc_read_pos(n);

        if (stop_at_delim && n > 0)
        {
          *stop_at_delim = (end != 0);
          break;
        }

        if (end) break;

        ret = incoming->do_next();
      }

      return ret;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq %rdi, %r15
leaq 0x30(%rdi), %rax
movq %rax, 0x38(%rsp)
movq $0x0, 0x8(%rsi)
movq %rsi, 0x40(%rsp)
movq (%rsi), %rax
movb $0x0, (%rax)
leaq 0x28(%rsp), %r13
movq 0x50(%r15), %r12
movq 0x58(%r15), %rax
movq 0x38(%r15), %rbx
addq %rax, %rbx
subq %rax, %r12
movq %rbx, %rdi
movl 0xc(%rsp), %esi
movq %r12, %rdx
callq 0xb5b0
movq %rax, %r14
movq %rax, %rbp
subq %rbx, %rbp
testq %rax, %rax
setne 0xb(%rsp)
movq %r12, %rdx
cmovneq %rbp, %rdx
movq %r13, 0x18(%rsp)
addq %rbx, %rdx
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x1be38
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x40(%rsp), %rdi
callq 0xb150
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x665b8
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xb510
incq %rbp
testq %r14, %r14
cmovneq %rbp, %r12
addq %r12, 0x58(%r15)
cmpq $0x0, 0x10(%rsp)
je 0x665d3
testq %r12, %r12
jg 0x665f2
testq %r14, %r14
jne 0x66602
movq 0x68(%r15), %rax
testq %rax, %rax
je 0x66602
movq 0x38(%rsp), %rdi
callq *%rax
testb %al, %al
jne 0x6653f
jmp 0x66602
testq %r14, %r14
movq 0x10(%rsp), %rax
setne (%rax)
movb $0x1, 0xb(%rsp)
movb 0xb(%rsp), %al
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x6662f
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/compcoup/compcoup_transport.cc
// Function: scdc_dataset_transport::read_state()
bool read_state()
    {
      bool ret = true;

      ret = ret && read_state_begin(transport_connection);
      ret = ret && read_delim(transport_connection, &state, state_end);

      char c;
      ret = ret && read_bytes(transport_connection, &c, 1);
      SCDC_ASSERT(c == default_delim);

      return ret;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq 0x60(%rdi), %rdi
callq 0x66ed8
testb %al, %al
je 0x666ea
movq 0x60(%r14), %rdi
leaq 0x38(%r14), %rsi
xorl %ebx, %ebx
movl $0x3e, %edx
xorl %ecx, %ecx
callq 0x66504
testb %al, %al
je 0x666ec
movq 0x60(%r14), %r13
leaq 0x30(%r13), %rax
movq %rax, 0x10(%rsp)
movl $0x1, %ebp
leaq 0xf(%rsp), %r15
movq 0x50(%r13), %r12
movq 0x58(%r13), %r14
movq 0x38(%r13), %rsi
addq %r14, %rsi
subq %r14, %r12
cmpq %rbp, %r12
cmovgeq %rbp, %r12
movq %r15, %rdi
movq %r12, %rdx
callq 0xb3f0
addq %r12, %r14
movq %rbp, %rax
subq %r12, %rax
testq %rax, %rax
setle %bl
movq %r14, 0x58(%r13)
subq %r12, %rbp
jle 0x666de
movq 0x68(%r13), %rax
testq %rax, %rax
je 0x666de
addq %r12, %r15
movq 0x10(%rsp), %rdi
callq *%rax
testb %al, %al
jne 0x6668b
cmpb $0x20, 0xf(%rsp)
jne 0x666ec
jmp 0x667b8
xorl %ebx, %ebx
leaq 0x25e7d(%rip), %r15     # 0x8c570
movq (%r15), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x667b8
addq $0x20, %rdi
callq 0xb7d0
movq (%r15), %rax
movq 0x18(%rax), %r14
leaq 0x3e51(%rip), %rsi      # 0x6a569
movl $0xd, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x7781(%rip), %rsi      # 0x6dead
movl $0x1e, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x3c24(%rip), %rsi      # 0x6a364
movl $0x1, %edx
movq %r14, %rdi
callq 0xb5f0
movq %r14, %rdi
movl $0x7d, %esi
callq 0xb9a0
movq %rax, %r14
leaq 0x7d56(%rip), %rsi      # 0x6e4ba
movl $0x15, %edx
movq %rax, %rdi
callq 0xb5f0
leaq 0x5788(%rip), %rsi      # 0x6bf00
movl $0x8, %edx
movq %r14, %rdi
callq 0xb5f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %r14, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq (%r15), %rdi
addq $0x20, %rdi
callq 0xb3b0
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/compcoup/compcoup_transport.cc
// Function: scdc_dataset_transport::write_state()
bool write_state()
    {
      bool ret = true;

      ret = ret && write_state_begin(transport_connection);
      ret = ret && write_delim(transport_connection, state.data(), state.size(), state_end);

      ret = ret && write_bytes(transport_connection, &default_delim, 1);

      return ret;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x66bfe
testb %al, %al
je 0x66bea
movq 0x60(%rbx), %rdi
movq 0x38(%rbx), %rsi
movq 0x40(%rbx), %rdx
movl $0x3e, %ecx
callq 0x6638a
testb %al, %al
je 0x66bea
movq 0x60(%rbx), %r12
leaq 0x70(%r12), %rbx
movl $0x1, %r13d
leaq 0x79e7(%rip), %r14      # 0x6e572
movq 0x80(%r12), %r15
movq 0x90(%r12), %rdi
subq %rdi, %r15
cmpq %r13, %r15
cmovgeq %r13, %r15
addq 0x78(%r12), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xb3f0
addq %r15, 0x90(%r12)
movq %r13, %rax
subq %r15, %rax
testq %rax, %rax
setle %bpl
subq %r15, %r13
jle 0x66bec
movq 0xa8(%r12), %rax
testq %rax, %rax
je 0x66bec
addq %r15, %r14
movq %rbx, %rdi
callq *%rax
testb %al, %al
jne 0x66b8b
jmp 0x66bec
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/compcoup/compcoup_transport.cc
// Function: scdc_dataset_transport::write_state_end(scdc_transport_connection_t*)
static bool write_state_end(scdc_transport_connection_t *transport_connection_)
    {
      bool ret = true;

      ret = ret && write_bytes(transport_connection_, &state_end, 1);
      ret = ret && write_bytes(transport_connection_, &default_delim, 1);

      return ret;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x70(%rdi), %r14
movl $0x1, %r13d
leaq 0x78df(%rip), %r15      # 0x6e574
movq 0x80(%rbx), %r12
movq 0x90(%rbx), %rdi
subq %rdi, %r12
cmpq %r13, %r12
cmovgeq %r13, %r12
addq 0x78(%rbx), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xb3f0
addq %r12, 0x90(%rbx)
subq %r12, %r13
jle 0x66cf3
movq 0xa8(%rbx), %rax
testq %rax, %rax
je 0x66ce0
addq %r12, %r15
movq %r14, %rdi
callq *%rax
testb %al, %al
jne 0x66c95
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %r13d
leaq 0x7872(%rip), %r15      # 0x6e572
movq 0x80(%rbx), %r12
movq 0x90(%rbx), %rdi
subq %rdi, %r12
cmpq %r13, %r12
cmovgeq %r13, %r12
addq 0x78(%rbx), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xb3f0
addq %r12, 0x90(%rbx)
movq %r13, %rax
subq %r12, %rax
testq %rax, %rax
setle %bpl
subq %r12, %r13
jle 0x66ce2
movq 0xa8(%rbx), %rax
testq %rax, %rax
je 0x66ce2
addq %r12, %r15
movq %r14, %rdi
callq *%rax
testb %al, %al
jne 0x66d00
jmp 0x66ce2
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/compcoup/compcoup_transport.cc
// Function: scdc_dataset_transport::write_string(scdc_transport_connection_t*, char const*, long long)
static bool write_string(scdc_transport_connection_t *transport_connection_, const char *s, scdcint_t n)
    {
      if (n < 0) n = strlen(s);

      char t[16];
      scdcint_t nt = sprintf(t, "%" scdcint_fmt, n);

      bool ret = true;

      ret = ret && write_delim(transport_connection_, t, nt, string_begin);
      ret = ret && write_bytes(transport_connection_, s, n);
      ret = ret && write_bytes(transport_connection_, &string_end, 1);
      ret = ret && write_bytes(transport_connection_, &default_delim, 1);

      return ret;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
testq %rdx, %rdx
jns 0x66d81
movq %r15, %rdi
callq 0xb200
movq %rax, %r12
leaq 0x5fa8(%rip), %rsi      # 0x6cd30
xorl %ebp, %ebp
movq %rsp, %r14
movq %r14, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0xb0d0
movslq %eax, %rdx
movq %rbx, %rdi
movq %r14, %rsi
movl $0x27, %ecx
callq 0x6638a
testb %al, %al
je 0x66e60
leaq 0x70(%rbx), %r14
movq 0x80(%rbx), %r13
movq 0x90(%rbx), %rdi
subq %rdi, %r13
cmpq %r12, %r13
cmovgeq %r12, %r13
addq 0x78(%rbx), %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0xb3f0
addq %r13, 0x90(%rbx)
subq %r13, %r12
jle 0x66e06
movq 0xa8(%rbx), %rax
testq %rax, %rax
je 0x66e5e
addq %r13, %r15
movq %r14, %rdi
callq *%rax
testb %al, %al
jne 0x66db9
jmp 0x66e5e
movl $0x1, %r13d
leaq 0x7762(%rip), %r15      # 0x6e575
movq 0x80(%rbx), %r12
movq 0x90(%rbx), %rdi
subq %rdi, %r12
cmpq %r13, %r12
cmovgeq %r13, %r12
addq 0x78(%rbx), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xb3f0
addq %r12, 0x90(%rbx)
subq %r12, %r13
jle 0x66e71
movq 0xa8(%rbx), %rax
testq %rax, %rax
je 0x66e5e
addq %r12, %r15
movq %r14, %rdi
callq *%rax
testb %al, %al
jne 0x66e13
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %r13d
leaq 0x76f4(%rip), %r15      # 0x6e572
movq 0x80(%rbx), %r12
movq 0x90(%rbx), %rdi
subq %rdi, %r12
cmpq %r13, %r12
cmovgeq %r13, %r12
addq 0x78(%rbx), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xb3f0
addq %r12, 0x90(%rbx)
movq %r13, %rax
subq %r12, %rax
testq %rax, %rax
setle %bpl
subq %r12, %r13
jle 0x66e60
movq 0xa8(%rbx), %rax
testq %rax, %rax
je 0x66e60
addq %r12, %r15
movq %r14, %rdi
callq *%rax
testb %al, %al
jne 0x66e7e
jmp 0x66e60
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/compcoup/compcoup_transport.cc
// Function: scdc_dataset_transport::read_state_begin(scdc_transport_connection_t*)
static bool read_state_begin(scdc_transport_connection_t *transport_connection_)
    {
      char c;
      bool ret = read_bytes(transport_connection_, &c, 1);

      SCDC_ASSERT(c == state_begin);

      return ret;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x30(%rdi), %r14
movl $0x1, %r13d
leaq 0x7(%rsp), %r15
movq 0x50(%rbx), %r12
movq 0x58(%rbx), %rbp
movq 0x38(%rbx), %rsi
addq %rbp, %rsi
subq %rbp, %r12
cmpq %r13, %r12
cmovgeq %r13, %r12
movq %r15, %rdi
movq %r12, %rdx
callq 0xb3f0
addq %r12, %rbp
movq %rbp, 0x58(%rbx)
subq %r12, %r13
jle 0x66f3a
movq 0x68(%rbx), %rax
testq %rax, %rax
je 0x66f3a
addq %r12, %r15
movq %r14, %rdi
callq *%rax
testb %al, %al
jne 0x66ef5
cmpb $0x3c, 0x7(%rsp)
je 0x67011
leaq 0x25624(%rip), %r14     # 0x8c570
movq (%r14), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x67011
addq $0x20, %rdi
callq 0xb7d0
movq (%r14), %rax
movq 0x18(%rax), %rbx
leaq 0x35f8(%rip), %rsi      # 0x6a569
movl $0xd, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x6f28(%rip), %rsi      # 0x6dead
movl $0x1e, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x33cb(%rip), %rsi      # 0x6a364
movl $0x1, %edx
movq %rbx, %rdi
callq 0xb5f0
movq %rbx, %rdi
movl $0x47, %esi
callq 0xb9a0
movq %rax, %rbx
leaq 0x7575(%rip), %rsi      # 0x6e532
movl $0x13, %edx
movq %rax, %rdi
callq 0xb5f0
leaq 0x4f2f(%rip), %rsi      # 0x6bf00
movl $0x8, %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
testq %r13, %r13
setle %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/compcoup/compcoup_transport.cc
// Function: scdc_dataset_transport::read_bytes(scdc_transport_connection_t*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, long long)
static bool read_bytes(scdc_transport_connection_t *transport_connection_, string *s, scdcint_t nbytes)
    {
      scdc_data *incoming = transport_connection_->get_incoming();
      bool ret = true;

      (*s).clear();

      while (ret)
      {
        const char *src = incoming->get_read_pos_buf();
        scdcint_t src_size = incoming->get_read_pos_buf_size();

        scdcint_t n = min(nbytes, src_size);

        *s += string(src, n);

        incoming->inc_read_pos(n);
        nbytes -= n;

        if (nbytes <= 0) break;

        ret = incoming->do_next();
      }

      return ret;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x30(%rdi), %r12
movq $0x0, 0x8(%rsi)
movq (%rsi), %rax
movb $0x0, (%rax)
leaq 0x18(%rsp), %rbp
movq 0x50(%r15), %r13
movq 0x58(%r15), %rax
movq 0x38(%r15), %rsi
addq %rax, %rsi
subq %rax, %r13
cmpq %rbx, %r13
cmovgeq %rbx, %r13
movq %rbp, 0x8(%rsp)
leaq (%rsi,%r13), %rdx
leaq 0x8(%rsp), %rdi
callq 0x1be38
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0xb150
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x67407
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
addq %r13, 0x58(%r15)
subq %r13, %rbx
jle 0x67422
movq 0x68(%r15), %rax
testq %rax, %rax
je 0x67422
movq %r12, %rdi
callq *%rax
testb %al, %al
jne 0x673b2
testq %rbx, %rbx
setle %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x67451
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
nop