LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
jmp 0x9cf2a
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movb $0x0, -0x39(%rbp)
movq -0x30(%rbp), %rax
movl 0x2d4(%rax), %edi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
xorl %ecx, %ecx
callq 0xc2e0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jge 0x9cf72
callq 0xc080
cmpl $0x4, (%rax)
jne 0x9cf72
jmp 0x9cf6e
jmp 0x9cf70
jmp 0x9cf3e
cmpq $0x0, -0x38(%rbp)
jge 0x9d05f
testb $0x1, -0x39(%rbp)
jne 0x9d055
jmp 0x9cf89
leaq 0x37718(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e8e0
cmpq $0x0, %rax
je 0x9d051
leaq 0x376ff(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e900
leaq 0x376f0(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e8e0
movq %rax, %rdi
leaq 0x94de(%rip), %rsi      # 0xa64a8
callq 0xc670
movq %rax, %rdi
leaq 0xcda3(%rip), %rsi      # 0xa9d7c
callq 0xc670
movq %rax, %rdi
leaq 0xcba3(%rip), %rsi      # 0xa9b8b
callq 0xc670
movq %rax, %rdi
movq -0x30(%rbp), %rsi
callq 0xc4f0
movq %rax, %rdi
leaq 0xcd30(%rip), %rsi      # 0xa9d33
callq 0xc670
movq %rax, -0x48(%rbp)
callq 0xc080
movl (%rax), %edi
callq 0xc1d0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0xc670
movq %rax, %rdi
leaq 0xb3a5(%rip), %rsi      # 0xa83d3
callq 0xc670
movq %rax, %rdi
movq 0x36f83(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x3765f(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e920
jmp 0x9d053
jmp 0x9d055
movq $-0x1, -0x8(%rbp)
jmp 0x9d06b
jmp 0x9d061
jmp 0x9d063
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x9d36e
movq -0x30(%rbp), %rax
testb $0x1, 0x18(%rax)
jne 0x9d392
movq -0x20(%rbp), %rdi
leaq 0xca46(%rip), %rsi      # 0xa9dc9
callq 0xc920
movq $0x0, -0x8(%rbp)
jmp 0x9d3d8
movq -0x30(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x9d3b7
movq -0x20(%rbp), %rdi
leaq 0xca31(%rip), %rsi      # 0xa9dd9
callq 0xc920
movq $0x0, -0x8(%rbp)
jmp 0x9d3d8
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2d950
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/compcoup/compcoup_direct.cc
// Function: scdc_compcoup_direct::dataset_close(scdc_dataset*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_compcoup_direct::dataset_close(scdc_dataset *dataset, scdc_result &result)
{
  SCDC_TRACE("dataset_close: '" << dataset << "'");

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

  return dataprovs->dataset_close(dataset, result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x9d40e
movq -0x28(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x9d42f
movq -0x20(%rbp), %rdi
leaq 0xc9b5(%rip), %rsi      # 0xa9dd9
callq 0xc920
movb $0x0, -0x1(%rbp)
jmp 0x9d449
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2dde0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x9d486
movq -0x38(%rbp), %rax
testb $0x1, 0x18(%rax)
jne 0x9d4a6
movq -0x30(%rbp), %rdi
leaq 0xc92e(%rip), %rsi      # 0xa9dc9
callq 0xc920
movb $0x0, -0x1(%rbp)
jmp 0x9d4c4
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0xa44d0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
jmp 0x9d4ed
movq -0x78(%rbp), %rax
testb $0x1, 0x18(%rax)
je 0x9d500
movb $0x0, -0x1(%rbp)
jmp 0x9d646
cmpq $0x1, -0x18(%rbp)
jne 0x9d585
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0xc350
leaq -0x40(%rbp), %rdi
callq 0xc9f0
movq -0x78(%rbp), %rax
movb $0x1, 0x18(%rax)
leaq -0x70(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0xc350
movq -0x78(%rbp), %rax
leaq -0x70(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xca50
movq -0x78(%rbp), %rax
movq $0x0, 0x10(%rax)
leaq -0x70(%rbp), %rdi
callq 0xcc90
movq -0x78(%rbp), %rax
movb $0x0, 0x18(%rax)
leaq -0x40(%rbp), %rdi
callq 0xc4c0
leaq -0x40(%rbp), %rdi
callq 0xc7f0
jmp 0x9d642
cmpq $0x4, -0x18(%rbp)
jne 0x9d599
movq -0x78(%rbp), %rax
movb $0x1, 0x18(%rax)
jmp 0x9d640
jmp 0x9d59b
leaq 0x37106(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e8e0
cmpq $0x0, %rax
je 0x9d638
leaq 0x370ed(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e900
leaq 0x370de(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e8e0
movq %rax, %rdi
leaq 0x8ecc(%rip), %rsi      # 0xa64a8
callq 0xc670
movq %rax, %rdi
leaq 0xc809(%rip), %rsi      # 0xa9df4
callq 0xc670
movq %rax, %rdi
leaq 0xc80c(%rip), %rsi      # 0xa9e06
callq 0xc670
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0xc340
movq %rax, %rdi
leaq 0xc496(%rip), %rsi      # 0xa9aab
callq 0xc670
movq %rax, %rdi
movq 0x3699c(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x37078(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e920
jmp 0x9d63a
movb $0x0, -0x1(%rbp)
jmp 0x9d646
jmp 0x9d642
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/compcoup/compcoup_direct.cc
// Function: scdc_compcoup_direct::stop()
bool scdc_compcoup_direct::stop()
{
  SCDC_TRACE("stop");

  if (!running) return false;

  cancel(true);

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x9d676
movq -0x18(%rbp), %rax
testb $0x1, 0x18(%rax)
jne 0x9d686
movb $0x0, -0x1(%rbp)
jmp 0x9d699
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
movl $0x1, %esi
callq *0x38(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x9d6ce
movq -0x28(%rbp), %rax
testb $0x1, 0x18(%rax)
jne 0x9d6de
movb $0x0, -0x1(%rbp)
jmp 0x9d70a
movq -0x28(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x9d6fe
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xc030
movq -0x28(%rbp), %rax
movb $0x0, 0x18(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
jmp 0xa0412
jmp 0xa0414
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa21b0
testb $0x1, %al
jne 0xa04b4
jmp 0xa042b
leaq 0x34276(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
cmpq $0x0, %rax
je 0xa04a9
leaq 0x34261(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25800
leaq 0x34252(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
movq %rax, %rdi
leaq 0x5d48(%rip), %rsi      # 0xa61b0
callq 0xc670
movq %rax, %rdi
leaq 0x99d0(%rip), %rsi      # 0xa9e47
callq 0xc670
movq %rax, %rdi
leaq 0x9e91(%rip), %rsi      # 0xaa317
callq 0xc670
movq %rax, %rdi
movq 0x33b2b(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x34207(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25820
jmp 0xa04ab
movb $0x0, -0x1(%rbp)
jmp 0xa057c
cmpq $0x0, -0x18(%rbp)
je 0xa04c6
movq -0x18(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0xa04cb
jmp 0xa0578
jmp 0xa04cd
jmp 0xa04cf
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x18(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
callq *%rax
cmpq $0x0, %rax
jne 0xa0573
jmp 0xa04ed
leaq 0x341b4(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
cmpq $0x0, %rax
je 0xa056b
leaq 0x3419f(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25800
leaq 0x34190(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
movq %rax, %rdi
leaq 0x5c86(%rip), %rsi      # 0xa61b0
callq 0xc670
movq %rax, %rdi
leaq 0x990e(%rip), %rsi      # 0xa9e47
callq 0xc670
movq %rax, %rdi
leaq 0x9dfb(%rip), %rsi      # 0xaa343
callq 0xc670
movq %rax, %rdi
movq 0x33a69(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x34145(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25820
jmp 0xa056d
movb $0x0, -0x1(%rbp)
jmp 0xa057c
jmp 0xa0410
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0xa0772
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movb $0x1, -0x1a(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x2d1(%rax)
jne 0xa07a1
movq -0x18(%rbp), %rax
cmpq $0x0, 0x2c8(%rax)
jle 0xa07b9
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq -0x19(%rbp), %rdx
callq 0xa2330
andb $0x1, %al
movb %al, -0x1a(%rbp)
jmp 0xa07c5
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
testb $0x1, -0x19(%rbp)
je 0xa07cd
jmp 0xa080a
movq -0x18(%rbp), %rax
testb $0x1, 0x2d3(%rax)
je 0xa07e7
movq -0x18(%rbp), %rax
movb $0x0, 0x2d3(%rax)
jmp 0xa0808
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x18(%rbp), %rdi
callq 0x97bd0
jmp 0xa080a
movb -0x1a(%rbp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovneq %rcx, %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, 0x20(%rax)
jne 0xa1db9
movb $0x0, -0x1(%rbp)
jmp 0xa1e23
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0xa1dcb
movb $0x1, -0x1(%rbp)
jmp 0xa1e23
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x28(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2ebe0
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2ec00
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %rax, %rcx
movq -0x38(%rbp), %rax
callq *%rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
setge %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nop
// File: mh0fm4[P]SCDC/src/components/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
jmp 0xa21c2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0xa36a0
testb $0x1, %al
jne 0xa2264
jmp 0xa21db
leaq 0x324c6(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
cmpq $0x0, %rax
je 0xa2259
leaq 0x324b1(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25800
leaq 0x324a2(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
movq %rax, %rdi
leaq 0x3f98(%rip), %rsi      # 0xa61b0
callq 0xc670
movq %rax, %rdi
leaq 0x7c20(%rip), %rsi      # 0xa9e47
callq 0xc670
movq %rax, %rdi
leaq 0x7f0d(%rip), %rsi      # 0xaa143
callq 0xc670
movq %rax, %rdi
movq 0x31d7b(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x32457(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25820
jmp 0xa225b
movb $0x0, -0x1(%rbp)
jmp 0xa231d
cmpq $0x0, -0x18(%rbp)
je 0xa2319
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq (%rdi), %rax
callq *0xb8(%rax)
testb $0x1, %al
jne 0xa2317
jmp 0xa2291
leaq 0x32410(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
cmpq $0x0, %rax
je 0xa230f
leaq 0x323fb(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25800
leaq 0x323ec(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
movq %rax, %rdi
leaq 0x3ee2(%rip), %rsi      # 0xa61b0
callq 0xc670
movq %rax, %rdi
leaq 0x7b6a(%rip), %rsi      # 0xa9e47
callq 0xc670
movq %rax, %rdi
leaq 0x7e8c(%rip), %rsi      # 0xaa178
callq 0xc670
movq %rax, %rdi
movq 0x31cc5(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x323a1(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25820
jmp 0xa2311
movb $0x0, -0x1(%rbp)
jmp 0xa231d
jmp 0xa2319
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
jmp 0xa26b2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0xa3620
testb $0x1, %al
jne 0xa2754
jmp 0xa26cb
leaq 0x31fd6(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
cmpq $0x0, %rax
je 0xa2749
leaq 0x31fc1(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25800
leaq 0x31fb2(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
movq %rax, %rdi
leaq 0x3aa8(%rip), %rsi      # 0xa61b0
callq 0xc670
movq %rax, %rdi
leaq 0x7730(%rip), %rsi      # 0xa9e47
callq 0xc670
movq %rax, %rdi
leaq 0x7b26(%rip), %rsi      # 0xaa24c
callq 0xc670
movq %rax, %rdi
movq 0x3188b(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x31f67(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25820
jmp 0xa274b
movb $0x0, -0x1(%rbp)
jmp 0xa280d
cmpq $0x0, -0x18(%rbp)
je 0xa2809
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq (%rdi), %rax
callq *0xc0(%rax)
testb $0x1, %al
jne 0xa2807
jmp 0xa2781
leaq 0x31f20(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
cmpq $0x0, %rax
je 0xa27ff
leaq 0x31f0b(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25800
leaq 0x31efc(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
movq %rax, %rdi
leaq 0x39f2(%rip), %rsi      # 0xa61b0
callq 0xc670
movq %rax, %rdi
leaq 0x767a(%rip), %rsi      # 0xa9e47
callq 0xc670
movq %rax, %rdi
leaq 0x7aa7(%rip), %rsi      # 0xaa283
callq 0xc670
movq %rax, %rdi
movq 0x317d5(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x31eb1(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25820
jmp 0xa2801
movb $0x0, -0x1(%rbp)
jmp 0xa280d
jmp 0xa2809
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
jmp 0xa2a02
jmp 0xa2a04
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa26a0
cmpq $0x0, -0x18(%rbp)
je 0xa2a23
movq -0x18(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0xa2a28
jmp 0xa2ad5
jmp 0xa2a2a
jmp 0xa2a2c
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x18(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
callq *%rax
cmpq $0x0, %rax
jne 0xa2ad0
jmp 0xa2a4a
leaq 0x31c57(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
cmpq $0x0, %rax
je 0xa2ac8
leaq 0x31c42(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25800
leaq 0x31c33(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
movq %rax, %rdi
leaq 0x3729(%rip), %rsi      # 0xa61b0
callq 0xc670
movq %rax, %rdi
leaq 0x73b1(%rip), %rsi      # 0xa9e47
callq 0xc670
movq %rax, %rdi
leaq 0x7927(%rip), %rsi      # 0xaa3cc
callq 0xc670
movq %rax, %rdi
movq 0x3150c(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x31be8(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25820
jmp 0xa2aca
movb $0x0, -0x1(%rbp)
jmp 0xa2ad9
jmp 0xa2a00
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/compcoup/compcoup_transport.cc
// Function: read_input_next(_scdc_dataset_inout_t*, _scdc_result_t*)
static scdcint_t read_input_next(scdc_dataset_input_t *input, scdc_result_t *result)
{
  SCDC_TRACE("read_input_next:");

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

  bool next = false, ret = true;

  if (transport_connection->current_incoming_input_next || transport_connection->current_incoming_input_size > 0) ret = scdc_compcoup_transport::dataset_input_incoming_recv(transport_connection, input, &next);
  else SCDC_DATASET_INOUT_BUF_CURRENT(input) = 0;

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

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

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

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

      /* read_input_next is only used by the server, and thus connection acquire/release is not required */
    }
  }

  return (ret)?SCDC_SUCCESS:SCDC_FAILURE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0xa2b02
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
movb $0x1, -0x1a(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x2d0(%rax)
jne 0xa2b31
movq -0x18(%rbp), %rax
cmpq $0x0, 0x2c0(%rax)
jle 0xa2b49
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq -0x19(%rbp), %rdx
callq 0xa1e40
andb $0x1, %al
movb %al, -0x1a(%rbp)
jmp 0xa2b55
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
testb $0x1, -0x19(%rbp)
je 0xa2b5d
jmp 0xa2b91
movq -0x18(%rbp), %rax
testb $0x1, 0x2d2(%rax)
je 0xa2b77
movq -0x18(%rbp), %rax
movb $0x0, 0x2d2(%rax)
jmp 0xa2b8f
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
jmp 0xa2b91
movb -0x1a(%rbp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovneq %rcx, %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
movb $0x1, -0x19(%rbp)
xorl %eax, %eax
testb $0x1, -0x19(%rbp)
movb %al, -0x1a(%rbp)
je 0xa2bed
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
xorl %edx, %edx
callq 0xa3620
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
andb $0x1, %al
movb %al, -0x19(%rbp)
xorl %eax, %eax
testb $0x1, -0x19(%rbp)
movb %al, -0x1b(%rbp)
je 0xa2c1b
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rdx
movq (%rdi), %rax
callq *0xc0(%rax)
movb %al, -0x1b(%rbp)
movb -0x1b(%rbp), %al
andb $0x1, %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovneq %rcx, %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
cmpq $0x0, -0x18(%rbp)
jge 0xa2cbd
movq -0x10(%rbp), %rdi
callq 0xc280
movq %rax, -0x18(%rbp)
movb $0x1, -0x1a(%rbp)
xorl %eax, %eax
testb $0x1, -0x1a(%rbp)
movb %al, -0x1b(%rbp)
je 0xa2ce0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xa3bb0
movb %al, -0x1b(%rbp)
movb -0x1b(%rbp), %al
andb $0x1, %al
movb %al, -0x1a(%rbp)
xorl %eax, %eax
testb $0x1, -0x1a(%rbp)
movb %al, -0x1c(%rbp)
je 0xa2d08
movq -0x8(%rbp), %rdi
leaq -0x19(%rbp), %rsi
movl $0x1, %edx
callq 0xa3bb0
movb %al, -0x1c(%rbp)
movb -0x1c(%rbp), %al
andb $0x1, %al
movb %al, -0x1a(%rbp)
testb $0x1, -0x1a(%rbp)
jne 0xa2d9e
jmp 0xa2d1c
leaq 0x31985(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
cmpq $0x0, %rax
je 0xa2d9a
leaq 0x31970(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25800
leaq 0x31961(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
movq %rax, %rdi
leaq 0x3457(%rip), %rsi      # 0xa61b0
callq 0xc670
movq %rax, %rdi
leaq 0x70df(%rip), %rsi      # 0xa9e47
callq 0xc670
movq %rax, %rdi
leaq 0x7707(%rip), %rsi      # 0xaa47e
callq 0xc670
movq %rax, %rdi
movq 0x3123a(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x31916(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25820
jmp 0xa2d9c
jmp 0xa2d9e
movb -0x1a(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0xa3650
movq %rax, -0x28(%rbp)
movb $0x1, -0x29(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc8f0
testb $0x1, -0x29(%rbp)
je 0xa2f9a
movq -0x28(%rbp), %rdi
callq 0x2ebe0
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2ec00
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movsbl -0x11(%rbp), %esi
movq -0x40(%rbp), %rdx
callq 0xa2c60
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0xa2e8a
movq -0x48(%rbp), %rax
movq -0x38(%rbp), %rcx
subq %rcx, %rax
movq %rax, -0x90(%rbp)
jmp 0xa2e95
movq -0x40(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x71(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0xcbc0
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdx
movq -0x98(%rbp), %rcx
leaq -0x70(%rbp), %rdi
callq 0xc7a0
jmp 0xa2ee6
movq -0x10(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xc8a0
jmp 0xa2ef5
leaq -0x70(%rbp), %rdi
callq 0xc3e0
leaq -0x71(%rbp), %rdi
callq 0xc730
cmpq $0x0, -0x48(%rbp)
je 0xa2f50
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0xa2f50
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0xa2f45
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xc3e0
leaq -0x71(%rbp), %rdi
callq 0xc730
jmp 0xa2fa8
movq -0x28(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x2ec60
cmpq $0x0, -0x20(%rbp)
je 0xa2f7e
cmpq $0x0, -0x50(%rbp)
jle 0xa2f7e
cmpq $0x0, -0x48(%rbp)
setne %cl
movq -0x20(%rbp), %rax
andb $0x1, %cl
movb %cl, (%rax)
jmp 0xa2f9a
cmpq $0x0, -0x48(%rbp)
je 0xa2f87
jmp 0xa2f9a
movq -0x28(%rbp), %rdi
callq 0x2ec20
andb $0x1, %al
movb %al, -0x29(%rbp)
jmp 0xa2e36
movb -0x29(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0xcba0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb $0x1, -0x9(%rbp)
xorl %eax, %eax
testb $0x1, -0x9(%rbp)
movb %al, -0xb(%rbp)
je 0xa3093
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0xa38d0
movb %al, -0xb(%rbp)
movb -0xb(%rbp), %al
andb $0x1, %al
movb %al, -0x9(%rbp)
xorl %eax, %eax
testb $0x1, -0x9(%rbp)
movb %al, -0x19(%rbp)
je 0xa30c3
movq -0x18(%rbp), %rsi
movq 0x60(%rsi), %rdi
addq $0x38, %rsi
movl $0x3e, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0xa2e00
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movb %al, -0x9(%rbp)
xorl %eax, %eax
testb $0x1, -0x9(%rbp)
movb %al, -0x1a(%rbp)
je 0xa30ef
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rdi
leaq -0xa(%rbp), %rsi
movl $0x1, %edx
callq 0xa3d30
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
andb $0x1, %al
movb %al, -0x9(%rbp)
movsbl -0xa(%rbp), %eax
cmpl $0x20, %eax
je 0xa31b7
jmp 0xa3106
leaq 0x3159b(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e8e0
cmpq $0x0, %rax
je 0xa31b3
leaq 0x31582(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e900
leaq 0x31573(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e8e0
movq %rax, %rdi
leaq 0x3422(%rip), %rsi      # 0xa6569
callq 0xc670
movq %rax, %rdi
leaq 0x6d2f(%rip), %rsi      # 0xa9e85
callq 0xc670
movq %rax, %rdi
leaq 0x31ff(%rip), %rsi      # 0xa6364
callq 0xc670
movq %rax, %rdi
movl $0x7d, %esi
callq 0xcb80
movq %rax, %rdi
leaq 0x7311(%rip), %rsi      # 0xaa492
callq 0xc670
movq %rax, %rdi
leaq 0x4d7c(%rip), %rsi      # 0xa7f0c
callq 0xc670
movq %rax, %rdi
movq 0x30e21(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x314fd(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e920
jmp 0xa31b5
jmp 0xa31b7
jmp 0xa31b9
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb $0x1, -0x9(%rbp)
xorl %eax, %eax
testb $0x1, -0x9(%rbp)
movb %al, -0xa(%rbp)
je 0xa3583
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0xa3700
movb %al, -0xa(%rbp)
movb -0xa(%rbp), %al
andb $0x1, %al
movb %al, -0x9(%rbp)
xorl %eax, %eax
testb $0x1, -0x9(%rbp)
movb %al, -0x19(%rbp)
je 0xa35d4
movq -0x18(%rbp), %rdi
movq 0x60(%rdi), %rax
movq %rax, -0x30(%rbp)
addq $0x38, %rdi
callq 0xc380
movq -0x18(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x38, %rdi
callq 0xc460
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
movl $0x3e, %ecx
callq 0xa2c90
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movb %al, -0x9(%rbp)
xorl %eax, %eax
testb $0x1, -0x9(%rbp)
movb %al, -0x31(%rbp)
je 0xa3603
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rdi
leaq 0x6f54(%rip), %rsi      # 0xaa54a
movl $0x1, %edx
callq 0xa3bb0
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
andb $0x1, %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movb $0x1, -0x9(%rbp)
xorl %eax, %eax
testb $0x1, -0x9(%rbp)
movb %al, -0xa(%rbp)
je 0xa3783
movq -0x8(%rbp), %rdi
leaq 0x6dd6(%rip), %rsi      # 0xaa54c
movl $0x1, %edx
callq 0xa3bb0
movb %al, -0xa(%rbp)
movb -0xa(%rbp), %al
andb $0x1, %al
movb %al, -0x9(%rbp)
xorl %eax, %eax
testb $0x1, -0x9(%rbp)
movb %al, -0xb(%rbp)
je 0xa37ae
movq -0x8(%rbp), %rdi
leaq 0x6da9(%rip), %rsi      # 0xaa54a
movl $0x1, %edx
callq 0xa3bb0
movb %al, -0xb(%rbp)
movb -0xb(%rbp), %al
andb $0x1, %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jge 0xa37f8
movq -0x10(%rbp), %rdi
callq 0xc280
movq %rax, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x54b1(%rip), %rsi      # 0xa8cb8
movb $0x0, %al
callq 0xc0f0
cltq
movq %rax, -0x38(%rbp)
movb $0x1, -0x39(%rbp)
xorl %eax, %eax
testb $0x1, -0x39(%rbp)
movb %al, -0x3a(%rbp)
je 0xa383c
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movl $0x27, %ecx
callq 0xa2c90
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %al
andb $0x1, %al
movb %al, -0x39(%rbp)
xorl %eax, %eax
testb $0x1, -0x39(%rbp)
movb %al, -0x3b(%rbp)
je 0xa3863
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xa3bb0
movb %al, -0x3b(%rbp)
movb -0x3b(%rbp), %al
andb $0x1, %al
movb %al, -0x39(%rbp)
xorl %eax, %eax
testb $0x1, -0x39(%rbp)
movb %al, -0x3c(%rbp)
je 0xa388e
movq -0x8(%rbp), %rdi
leaq 0x6ccc(%rip), %rsi      # 0xaa54d
movl $0x1, %edx
callq 0xa3bb0
movb %al, -0x3c(%rbp)
movb -0x3c(%rbp), %al
andb $0x1, %al
movb %al, -0x39(%rbp)
xorl %eax, %eax
testb $0x1, -0x39(%rbp)
movb %al, -0x3d(%rbp)
je 0xa38b9
movq -0x8(%rbp), %rdi
leaq 0x6c9e(%rip), %rsi      # 0xaa54a
movl $0x1, %edx
callq 0xa3bb0
movb %al, -0x3d(%rbp)
movb -0x3d(%rbp), %al
andb $0x1, %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: mh0fm4[P]SCDC/src/components/compcoup/compcoup_transport.cc
// Function: scdc_dataset_transport::read_state_end(scdc_transport_connection_t*)
static bool read_state_end(scdc_transport_connection_t *transport_connection_)
    {
      bool ret = true;

      char c;
      ret = ret && read_bytes(transport_connection_, &c, 1);
      SCDC_ASSERT(c == state_end);

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

      return ret;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movb $0x1, -0x9(%rbp)
xorl %eax, %eax
testb $0x1, -0x9(%rbp)
movb %al, -0xb(%rbp)
je 0xa39f0
movq -0x8(%rbp), %rdi
leaq -0xa(%rbp), %rsi
movl $0x1, %edx
callq 0xa3d30
movb %al, -0xb(%rbp)
movb -0xb(%rbp), %al
andb $0x1, %al
movb %al, -0x9(%rbp)
movsbl -0xa(%rbp), %eax
cmpl $0x3e, %eax
je 0xa3ab8
jmp 0xa3a07
leaq 0x30c9a(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e8e0
cmpq $0x0, %rax
je 0xa3ab4
leaq 0x30c81(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e900
leaq 0x30c72(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e8e0
movq %rax, %rdi
leaq 0x2b21(%rip), %rsi      # 0xa6569
callq 0xc670
movq %rax, %rdi
leaq 0x642e(%rip), %rsi      # 0xa9e85
callq 0xc670
movq %rax, %rdi
leaq 0x28fe(%rip), %rsi      # 0xa6364
callq 0xc670
movq %rax, %rdi
movl $0x5e, %esi
callq 0xcb80
movq %rax, %rdi
leaq 0x6a9c(%rip), %rsi      # 0xaa51e
callq 0xc670
movq %rax, %rdi
leaq 0x447b(%rip), %rsi      # 0xa7f0c
callq 0xc670
movq %rax, %rdi
movq 0x30520(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x30bfc(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e920
jmp 0xa3ab6
jmp 0xa3ab8
jmp 0xa3aba
xorl %eax, %eax
testb $0x1, -0x9(%rbp)
movb %al, -0xc(%rbp)
je 0xa3ada
movq -0x8(%rbp), %rdi
leaq -0xa(%rbp), %rsi
movl $0x1, %edx
callq 0xa3d30
movb %al, -0xc(%rbp)
movb -0xc(%rbp), %al
andb $0x1, %al
movb %al, -0x9(%rbp)
movsbl -0xa(%rbp), %eax
cmpl $0x20, %eax
je 0xa3ba2
jmp 0xa3af1
leaq 0x30bb0(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e8e0
cmpq $0x0, %rax
je 0xa3b9e
leaq 0x30b97(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e900
leaq 0x30b88(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e8e0
movq %rax, %rdi
leaq 0x2a37(%rip), %rsi      # 0xa6569
callq 0xc670
movq %rax, %rdi
leaq 0x6344(%rip), %rsi      # 0xa9e85
callq 0xc670
movq %rax, %rdi
leaq 0x2814(%rip), %rsi      # 0xa6364
callq 0xc670
movq %rax, %rdi
movl $0x61, %esi
callq 0xcb80
movq %rax, %rdi
leaq 0x6926(%rip), %rsi      # 0xaa492
callq 0xc670
movq %rax, %rdi
leaq 0x4391(%rip), %rsi      # 0xa7f0c
callq 0xc670
movq %rax, %rdi
movq 0x30436(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x30b12(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e920
jmp 0xa3ba0
jmp 0xa3ba2
jmp 0xa3ba4
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nop
// File: mh0fm4[P]SCDC/src/components/compcoup/compcoup_transport.cc
// Function: scdc_dataset_transport::write_bytes(scdc_transport_connection_t*, void const*, long long)
static bool write_bytes(scdc_transport_connection_t *transport_connection_, const void *buf, scdcint_t nbytes)
    {
      scdc_data *outgoing = transport_connection_->get_outgoing();
      bool ret = true;

      const char *src = static_cast<const char*>(buf);

      while (ret)
      {
        scdcint_t n = min(nbytes, outgoing->get_write_pos_buf_size());

        memcpy(outgoing->get_write_pos_buf(), src, n);

        src += n;
        outgoing->inc_write_pos(n);
        nbytes -= n;

        if (nbytes <= 0) break;

        ret = outgoing->do_next();
      }

      return ret;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0xa3730
movq %rax, -0x20(%rbp)
movb $0x1, -0x21(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
testb $0x1, -0x21(%rbp)
je 0xa3c61
movq -0x20(%rbp), %rdi
callq 0x2eca0
movq %rax, -0x40(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2b080
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2ec80
movq %rax, %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0xc530
movq -0x38(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x2ecc0
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jg 0xa3c4e
jmp 0xa3c61
movq -0x20(%rbp), %rdi
callq 0x2ec20
andb $0x1, %al
movb %al, -0x21(%rbp)
jmp 0xa3bdd
movb -0x21(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: mh0fm4[P]SCDC/src/components/compcoup/compcoup_transport.cc
// Function: scdc_dataset_transport::read_bytes(scdc_transport_connection_t*, void*, long long)
static bool read_bytes(scdc_transport_connection_t *transport_connection_, void *buf, scdcint_t nbytes)
    {
      scdc_data *incoming = transport_connection_->get_incoming();
      bool ret = true;

      char *dst = static_cast<char *>(buf);

      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);

        memcpy(dst, src, n);
        dst += n;

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

        if (nbytes <= 0) break;

        ret = incoming->do_next();
      }

      return ret;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0xa3650
movq %rax, -0x20(%rbp)
movb $0x1, -0x21(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
testb $0x1, -0x21(%rbp)
je 0xa3dea
movq -0x20(%rbp), %rdi
callq 0x2ebe0
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2ec00
movq %rax, -0x40(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2b080
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0xc530
movq -0x48(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x2ec60
movq -0x48(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jg 0xa3dd7
jmp 0xa3dea
movq -0x20(%rbp), %rdi
callq 0x2ec20
andb $0x1, %al
movb %al, -0x21(%rbp)
jmp 0xa3d5d
movb -0x21(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop