LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_inout_alloc_create(_scdc_dataset_inout_t*, char const*, _scdc_args_t*)
static scdc_dataset_inout_t *scdc_dataset_inout_alloc_create(scdc_dataset_inout_t *inout, const char *conf, scdc_args_t *args)
{
  scdcint_t size = DEFAULT_DATASET_INOUT_BUF_SIZE;

  stringlist confs(':', conf);
  scdc_args xargs(args);

  if (confs.front() == "size")
  {
    xargs.get<scdcint_t>(SCDC_ARGS_TYPE_SCDCINT, &size);
    confs.front_pop();
  }

  if (!scdc_dataset_inout_alloc(inout, size, 0)) return 0;

  inout->intern->type = SCDC_DATASET_INOUT_TYPE_ALLOC;
  inout->intern->destroy = scdc_dataset_inout_alloc_destroy;

  return inout;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r14
movq %rsi, %rdx
movq %rdi, %rbx
movq $0x4000, (%rsp)         # imm = 0x4000
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movl $0x3a, %esi
movq $-0x1, %rcx
callq 0x1b83e
leaq 0x90(%rsp), %rax
movq %rax, 0x8(%rax)
movq %rax, (%rax)
movq $0x0, 0x10(%rax)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movaps %xmm0, -0x20(%rax)
movaps %xmm1, -0x10(%rax)
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x1bb82
leaq 0x3d355(%rip), %rsi     # 0x6b5b7
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xb110
movl %eax, %ebp
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2e28b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
testl %ebp, %ebp
jne 0x2e2d2
movq 0x78(%rsp), %rax
testq %rax, %rax
je 0x2e2a8
movq 0x70(%rsp), %rdi
movq %rsp, %rdx
movl $0x2, %esi
callq *%rax
leaq 0x50(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1b878
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e2d2
movq 0x60(%rsp), %rsi
incq %rsi
callq 0xb510
movq (%rsp), %rsi
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2e36a
testb %al, %al
je 0x2e301
movq 0x48(%rbx), %rax
movq $0x2, 0x8(%rax)
leaq 0xe1(%rip), %rcx        # 0x2e3db
movq %rcx, 0x20(%rax)
movq %rbx, %r14
leaq 0x70(%rsp), %rdi
callq 0x1b76c
leaq 0x28(%rsp), %rdi
callq 0x1bad0
movq %r14, %rax
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2e328
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x1b76c
leaq 0x28(%rsp), %rdi
callq 0x1bad0
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_inout_alloc(_scdc_dataset_inout_t*, long long, long long)
static bool scdc_dataset_inout_alloc(scdc_dataset_inout_t *inout, scdcint_t buf_size, scdcint_t data_size)
{
  if (!inout) return false;

  if (inout->intern) return true;

  scdcint_t alloc_size = sizeof(scdc_dataset_inout_intern_t) + data_size + buf_size;

#if USE_DEBUG
  char *b = static_cast<char *>(calloc(alloc_size, 1));
#else
  char *b = static_cast<char *>(malloc(alloc_size));
#endif

  if (!b) return false;

  inout->intern = (scdc_dataset_inout_intern_t *) b;
  b += sizeof(scdc_dataset_inout_intern_t);

  inout->intern->alloc_size = alloc_size;

  if (data_size > 0)
  {
    inout->data = b;
    b += data_size;
  }

  if (buf_size > 0)
  {
    SCDC_DATASET_INOUT_BUF_PTR(inout) = b;
    SCDC_DATASET_INOUT_BUF_SIZE(inout) = buf_size;
  }

  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x2e3cd
movq %rdi, %r15
movb $0x1, %bl
cmpq $0x0, 0x48(%rdi)
jne 0x2e3cf
movq %rdx, %r12
movq %rsi, %r14
leaq (%rsi,%rdx), %r13
addq $0x28, %r13
movl $0x1, %esi
movq %r13, %rdi
callq 0xb320
testq %rax, %rax
je 0x2e3cd
movq %rax, %rcx
movq %rax, 0x48(%r15)
addq $0x28, %rax
movq %r13, (%rcx)
testq %r12, %r12
jle 0x2e3be
movq %rax, 0x40(%r15)
addq %r12, %rax
testq %r14, %r14
jle 0x2e3cf
movq %rax, 0x10(%r15)
movq %r14, 0x18(%r15)
jmp 0x2e3cf
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: long long input_FX_next<_IO_FILE*>(_scdc_dataset_inout_t*, _scdc_result_t*)
static scdcint_t input_FX_next(scdc_dataset_input_t *input, scdc_result_t *result)
{
  inout_FX_data_t<T> *data = static_cast<inout_FX_data_t<T> *>(input->data);

  size_t n = SCDC_DATASET_INOUT_BUF_SIZE(input);

  if (data->chunk_size >= 0) n = z_min(static_cast<scdcint_t>(n), data->chunk_size);

  if (data->size_left >= 0) n = z_min(static_cast<scdcint_t>(n), data->size_left);

  n = data->read(SCDC_DATASET_INOUT_BUF_PTR(input), n);

  data->size_left -= n;

  /* set to the number of bytes read in buf */
  SCDC_DATASET_INOUT_BUF_CURRENT(input) = n;

  if (input->total_size_given == SCDC_DATASET_INOUT_TOTAL_SIZE_GIVEN_AT_LEAST) input->total_size += n;

  if (data->eof(n) || data->size_left == 0)
  {
    input->total_size_given = SCDC_DATASET_INOUT_TOTAL_SIZE_GIVEN_EXACT;
    input->next = 0;
  }

  return SCDC_SUCCESS;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %r14
movq 0x10(%rdi), %rdi
movq 0x18(%rbx), %rax
movq 0x8(%r14), %rcx
cmpq %rcx, %rax
movq %rcx, %rsi
cmovlq %rax, %rsi
testq %rcx, %rcx
cmovsq %rax, %rsi
movq 0x10(%r14), %rax
cmpq %rax, %rsi
movq %rax, %rdx
cmovlq %rsi, %rdx
movq (%r14), %rcx
testq %rax, %rax
cmovsq %rsi, %rdx
movl $0x1, %esi
callq 0xb7f0
subq %rax, 0x10(%r14)
movq %rax, 0x20(%rbx)
cmpb $0x6c, 0x30(%rbx)
jne 0x2f690
addq %rax, 0x28(%rbx)
movq (%r14), %rdi
callq 0xb880
testl %eax, %eax
je 0x2f6aa
movb $0x78, 0x30(%rbx)
movq $0x0, 0x38(%rbx)
jmp 0x2f6b1
cmpq $0x0, 0x10(%r14)
je 0x2f69c
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_input_fddup_destroy(_scdc_dataset_inout_t*)
static void scdc_dataset_input_fddup_destroy(scdc_dataset_input_t *input)
{
  if (!input) return;

  int fddup;

  scdc_dataset_input_FX_destroy<int>(input, &fddup);

  close(fddup);
}

// Assembly:
testq %rdi, %rdi
je 0x2ed8a
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq 0x48(%rdi), %rdi
movl (%rax), %ebp
callq 0xb650
movq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movl %ebp, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xbaa0
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_input_streamdup_destroy(_scdc_dataset_inout_t*)
static void scdc_dataset_input_streamdup_destroy(scdc_dataset_input_t *input)
{
  if (!input) return;

  FILE *stream;

  scdc_dataset_input_FX_destroy<FILE *>(input, &stream);

  int fddup = fileno(stream);
  fclose(stream);
  close(fddup);
}

// Assembly:
testq %rdi, %rdi
je 0x2f709
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq 0x48(%rdi), %rdi
movq (%rax), %r14
callq 0xb650
movq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movq %r14, %rdi
callq 0xb560
movl %eax, %ebx
movq %r14, %rdi
callq 0xb4f0
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xbaa0
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_input_fs_destroy(_scdc_dataset_inout_t*)
static void scdc_dataset_input_fs_destroy(scdc_dataset_input_t *input)
{
  if (!input) return;

  FILE *ptar;

  scdc_dataset_input_FX_destroy<FILE *>(input, &ptar);

  pclose(ptar);
}

// Assembly:
testq %rdi, %rdi
je 0x2f8e3
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %rax
movq 0x48(%rdi), %rdi
movq (%rax), %r14
callq 0xb650
movq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb790
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_input_fslist_destroy(_scdc_dataset_inout_t*)
static void scdc_dataset_input_fslist_destroy(scdc_dataset_input_t *input)
{
  if (!input) return;

  if (input->intern->type == SCDC_DATASET_INOUT_TYPE_FSLIST_DIR)
    scdc_dataset_input_fslist_dir_destroy(input);
  else if (input->intern->type == SCDC_DATASET_INOUT_TYPE_FSLIST_FILE)
    scdc_dataset_input_fslist_file_destroy(input);
  else if (input->intern->type == SCDC_DATASET_INOUT_TYPE_FSLIST_LINK)
    scdc_dataset_input_fslist_link_destroy(input);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2f94c
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
movq 0x8(%rdi), %rax
cmpq $0xc, %rax
je 0x2f931
cmpq $0xb, %rax
je 0x2f931
cmpq $0xa, %rax
jne 0x2f94c
leaq 0x40(%rbx), %r14
movq 0x40(%rbx), %rax
movq 0x108(%rax), %rdi
callq 0xb8f0
movq 0x48(%rbx), %rdi
callq 0xb650
movq $0x0, 0x10(%rbx)
jmp 0x2f945
callq 0xb650
movq $0x0, 0x10(%rbx)
addq $0x40, %rbx
movq %rbx, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: autodestroy_next(_scdc_dataset_inout_t*, _scdc_result_t*)
static scdcint_t autodestroy_next(scdc_dataset_input_t *inout, scdc_result_t *result)
{
  autodestroy_un_pack(inout, 0);

  scdcint_t ret;

  if (inout->next)
  {
    ret = inout->next(inout, 0);
    autodestroy_un_pack(inout, autodestroy_next);

  } else
  {
    if (inout->intern && inout->intern->destroy) inout->intern->destroy(inout);
    SCDC_DATASET_INOUT_BUF_CURRENT(inout) = 0;
    ret = SCDC_SUCCESS;
  }

  return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
movups (%rdi), %xmm0
movups %xmm0, 0x38(%rbx)
movl $0x10, %esi
callq 0xb510
movq 0x38(%rbx), %rax
testq %rax, %rax
je 0x2fc8e
movq %rbx, %rdi
xorl %esi, %esi
callq *%rax
movq %rax, %r14
movl $0x10, %edi
callq 0xb500
movups 0x38(%rbx), %xmm0
movups %xmm0, (%rax)
leaq -0x47(%rip), %rcx       # 0x2fc3a
movq %rcx, 0x38(%rbx)
movq %rax, 0x40(%rbx)
movq %r14, %rax
jmp 0x2fcb2
movq 0x48(%rbx), %rax
testq %rax, %rax
je 0x2fca5
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x2fca5
movq %rbx, %rdi
callq *%rax
movq $0x0, 0x20(%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/common/log.cc
// Function: scdc_log::scdc_log(char const*, ...)
scdc_log::scdc_log(const char *conf, ...)
  :cout_default(0), cout(0), cerr_default(0), cerr(0)
{
#if SCDC_LOG_LOCK
  pthread_mutex_t static_mutex = PTHREAD_MUTEX_INITIALIZER;
  lock = static_mutex;
#endif

  va_list ap;
  va_start(ap, conf);

  default_init_intern(conf, ap);

  va_end(ap);
}

// Assembly:
subq $0xd8, %rsp
leaq 0x20(%rsp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x3136f
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movq $0x0, 0x40(%rdi)
movq %rsp, %rdx
movq %r10, 0x10(%rdx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rdx)
callq 0x313b6
addq $0xd8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/common/log.cc
// Function: scdc_log::default_init_intern(char const*, __va_list_tag*)
bool scdc_log::default_init_intern(const char *conf, va_list aq)
{
  SCDC_TRACE("default_init_intern: conf: '" << conf << "'");

  scdc_args_t args;

  va_list ap;
  va_copy(ap, aq);

  scdc_args_va_init(&args, &ap);

  bool ret = init(conf, &args);

  scdc_args_va_release(&args);

  va_end(ap);

  if (cout_default) cout_default->flush();
  delete cout_default;
  cout_default = cout;

  if (cerr_default) cerr_default->flush();
  delete cerr_default;
  cerr_default = cerr;

  SCDC_TRACE("default_init_intern: return: " << ret << "'");

  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdx), %rax
movq %rsp, %r12
movq %rax, 0x10(%r12)
movups (%rdx), %xmm0
movaps %xmm0, (%r12)
movl $0x10, %edi
callq 0xb500
movq %rax, %r15
movq $0x0, (%rax)
movq %r12, 0x8(%rax)
leaq 0x20(%rsp), %rdx
movq %rax, (%rdx)
leaq 0xe2e(%rip), %rax       # 0x32231
movq %rax, 0x8(%rdx)
leaq 0xec9(%rip), %rax       # 0x322d7
movq %rax, 0x10(%rdx)
leaq 0xec1(%rip), %rax       # 0x322da
movq %rax, 0x18(%rdx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x31532
movl %eax, %ebp
movl $0x10, %esi
movq %r15, %rdi
callq 0xb510
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x31452
callq 0xb340
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x31452
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rdi
movq %rax, (%rbx)
testq %rdi, %rdi
je 0x31476
callq 0xb340
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x31476
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rbx), %rax
movq %rax, 0x10(%rbx)
movl %ebp, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/common/log.cc
// Function: scdc_log::~scdc_log()
scdc_log::~scdc_log()
{
  release();

  cout = 0;
  cerr = 0;

  default_release();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rsi
callq 0x31e5c
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
callq 0x31e94
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %rax, 0x18(%rbx)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x314be
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x314d4
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x10(%rbx)
popq %rbx
retq
movq %rax, %rdi
callq 0x1b832
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/common/log.cc
// Function: scdc_log::default_release()
void scdc_log::default_release()
{
  SCDC_TRACE("default_release:");

  delete cout_default;
  cout_default = 0;

  delete cerr_default;
  cerr_default =  0;

  SCDC_TRACE("default_release: return");
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x31512
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x31528
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/common/log.cc
// Function: scdc_log_cout_printf
int scdc_log_cout_printf(const char *format, ...)
{
  va_list ap;
  va_start(ap, format);
  int r = ostream_printf(SCDC_MAIN_LOG()->get_cout(), format, ap, false);
  va_end(ap);

  return r;
}

// Assembly:
subq $0xd8, %rsp
movq %rdi, %r10
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x31f2b
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rdx
movq %rdi, 0x10(%rdx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
leaq 0x5a61e(%rip), %rax     # 0x8c570
movq (%rax), %rax
movq 0x8(%rax), %rdi
movq %r10, %rsi
xorl %ecx, %ecx
callq 0x31f6b
addq $0xd8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/common/log.cc
// Function: ostream_printf(std::ostream*, char const*, __va_list_tag*, bool)
static int ostream_printf(ostream *os, const char *format, va_list ap, bool nl)
{
  int n;
  char ss[OSTREAM_PRINTF_DEFAULT_SIZE], *s = ss;


  if (!os) return -1;

  va_list ap1;
  va_copy(ap1, ap);
  n = vsnprintf(s, OSTREAM_PRINTF_DEFAULT_SIZE, format, ap1);
  va_end(ap1);

  if (n >= OSTREAM_PRINTF_DEFAULT_SIZE)
  {
    char *s = new char[n + 1];

    va_list ap2;
    va_copy(ap2, ap);
    n = vsnprintf(s, OSTREAM_PRINTF_DEFAULT_SIZE, format, ap2);
    va_end(ap2);
  }

  *os << s;

  if (nl) *os << endl;

  if (s != ss) delete[] s;

  return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x440, %rsp            # imm = 0x440
testq %rdi, %rdi
je 0x32038
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rdx), %rax
leaq 0x20(%rsp), %rcx
movq %rax, 0x10(%rcx)
movups (%rdx), %xmm0
movaps %xmm0, (%rcx)
leaq 0x40(%rsp), %rdi
movl $0x400, %esi            # imm = 0x400
movq %r15, %rdx
callq 0xb300
movl %eax, %r14d
cmpl $0x400, %eax            # imm = 0x400
jl 0x31fef
incl %r14d
movq %r14, %rdi
callq 0xb040
movq 0x10(%r12), %rdx
movq %rsp, %rcx
movq %rdx, 0x10(%rcx)
movups (%r12), %xmm0
movaps %xmm0, (%rcx)
movl $0x400, %esi            # imm = 0x400
movq %rax, %rdi
movq %r15, %rdx
callq 0xb300
movl %eax, %r14d
leaq 0x40(%rsp), %r15
movq %r15, %rdi
callq 0xb200
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xb5f0
testb %bpl, %bpl
je 0x3203e
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
jmp 0x3203e
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl %r14d, %eax
addq $0x440, %rsp            # imm = 0x440
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/common/log.cc
// Function: scdc_log_cout_printf_nl
int scdc_log_cout_printf_nl(const char *format, ...)
{
  va_list ap;
  va_start(ap, format);
  int r = ostream_printf(SCDC_MAIN_LOG()->get_cout(), format, ap, true);
  va_end(ap);

  return r;
}

// Assembly:
subq $0xd8, %rsp
movq %rdi, %r10
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x320af
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rdx
movq %rdi, 0x10(%rdx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
leaq 0x5a49a(%rip), %rax     # 0x8c570
movq (%rax), %rax
movq 0x8(%rax), %rdi
movq %r10, %rsi
movl $0x1, %ecx
callq 0x31f6b
addq $0xd8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/common/log.cc
// Function: scdc_log_cerr_printf
int scdc_log_cerr_printf(const char *format, ...)
{
  va_list ap;
  va_start(ap, format);
  int r = ostream_printf(SCDC_MAIN_LOG()->get_cerr(), format, ap, false);
  va_end(ap);

  return r;
}

// Assembly:
subq $0xd8, %rsp
movq %rdi, %r10
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x32150
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rdx
movq %rdi, 0x10(%rdx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
leaq 0x5a3f9(%rip), %rax     # 0x8c570
movq (%rax), %rax
movq 0x18(%rax), %rdi
movq %r10, %rsi
xorl %ecx, %ecx
callq 0x31f6b
addq $0xd8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/common/log.cc
// Function: scdc_log_cerr_printf_nl
int scdc_log_cerr_printf_nl(const char *format, ...)
{
  va_list ap;
  va_start(ap, format);
  int r = ostream_printf(SCDC_MAIN_LOG()->get_cerr(), format, ap, true);
  va_end(ap);

  return r;
}

// Assembly:
subq $0xd8, %rsp
movq %rdi, %r10
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x321ee
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rdx
movq %rdi, 0x10(%rdx)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rdx)
leaq 0x5a35b(%rip), %rax     # 0x8c570
movq (%rax), %rax
movq 0x18(%rax), %rdi
movq %r10, %rsi
movl $0x1, %ecx
callq 0x31f6b
addq $0xd8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/common/log.cc
// Function: scdc_args_get_va(void*, long long, void*)
static scdc_arg_ref_t scdc_args_get_va(void *data, scdcint_t type, void *v)
{
  scdc_args_data_va_t *data_va = static_cast<scdc_args_data_va_t *>(data);

  SCDC_TRACE("scdc_args_get_va: data: '" << data_va << "' (arg: '" << data_va->arg << "', ap: '" << data_va->ap << "'), type: '" << type << "', v: " << v);

  switch (type)
  {
    case SCDC_ARGS_TYPE_CSTR:
    case SCDC_ARGS_TYPE_PTR:
      *((void **) v) = va_arg(*data_va->ap, void *);
      return SCDC_ARG_REF_NONE;
    case SCDC_ARGS_TYPE_OUT_STREAM:
      *((FILE **) v) = va_arg(*data_va->ap, FILE *);
      return SCDC_ARG_REF_NONE;
    case SCDC_ARGS_TYPE_LOG_HANDLER:
      ((scdc_log_handler_args_t *) v)->handler = va_arg(*data_va->ap, scdc_log_handler_f *);
      ((scdc_log_handler_args_t *) v)->data = va_arg(*data_va->ap, void *);
      return SCDC_ARG_REF_NONE;
  }

  SCDC_TRACE("scdc_args_get_va: error: unknown type '" << type << "'");

  return SCDC_ARG_REF_NULL;
}

// Assembly:
leaq -0x4(%rsi), %rax
cmpq $0x2, %rax
jb 0x32261
cmpq $0x7, %rsi
je 0x32261
cmpq $0x11, %rsi
jne 0x3228f
movq 0x8(%rdi), %rax
movl (%rax), %esi
cmpq $0x28, %rsi
ja 0x32292
movq %rsi, %rcx
addq 0x10(%rax), %rcx
addl $0x8, %esi
movl %esi, (%rax)
jmp 0x3229e
movq 0x8(%rdi), %rax
movl (%rax), %esi
cmpq $0x28, %rsi
ja 0x3227b
movq %rsi, %rcx
addq 0x10(%rax), %rcx
addl $0x8, %esi
movl %esi, (%rax)
jmp 0x32287
movq 0x8(%rax), %rcx
leaq 0x8(%rcx), %rsi
movq %rsi, 0x8(%rax)
movq (%rcx), %rax
movq %rax, (%rdx)
jmp 0x322d1
xorl %eax, %eax
retq
movq 0x8(%rax), %rcx
leaq 0x8(%rcx), %rsi
movq %rsi, 0x8(%rax)
movq (%rcx), %rax
movq %rax, (%rdx)
movq 0x8(%rdi), %rax
movl (%rax), %esi
cmpq $0x28, %rsi
ja 0x322be
movq %rsi, %rcx
addq 0x10(%rax), %rcx
addl $0x8, %esi
movl %esi, (%rax)
jmp 0x322ca
movq 0x8(%rax), %rcx
leaq 0x8(%rcx), %rsi
movq %rsi, 0x8(%rax)
movq (%rcx), %rax
movq %rax, 0x8(%rdx)
movl $0x1, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/common/log.cc
// Function: ostreambuf_buf_write::overflow(int)
int_type overflow(int_type ch)
    {
      if (ch == traits_type::eof()) return traits_type::eof();

      sync();

      *pptr() = ch;
      pbump(1);

      return ch;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
cmpl $-0x1, %esi
je 0x3258a
movq %rdi, %r14
movq (%rdi), %rax
callq *0x30(%rax)
movq 0x28(%r14), %rax
movb %bl, (%rax)
incq 0x28(%r14)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/node/nodeconn_pool.cc
// Function: scdc_nodeconn_pool::del(scdc_nodeconn*)
void scdc_nodeconn_pool::del(scdc_nodeconn *nodeconn)
{
  SCDC_TRACE("del: nodeconn: '" << nodeconn << "'");

  SCDC_ASSERT(nodeconn->ref <= 0);

  iterator i = find(nodeconn->key);

  if (i == end() || i->second.erase(nodeconn) < 1)
  {
    SCDC_FAIL("del: nodeconn '" << nodeconn << "' not found");
    return;
  }

  if (i != end() && i->second.size() <= 0) erase(i);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, (%rsp)
cmpq $0x0, 0x28(%rsi)
jle 0x32c08
leaq 0x59a30(%rip), %r12     # 0x8c570
movq (%r12), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x32c08
addq $0x20, %rdi
callq 0xb7d0
movq (%r12), %rax
movq 0x18(%rax), %r15
leaq 0x37a02(%rip), %rsi     # 0x6a569
movl $0xd, %edx
movq %r15, %rdi
callq 0xb5f0
leaq 0x38e4d(%rip), %rsi     # 0x6b9c8
movl $0x15, %edx
movq %r15, %rdi
callq 0xb5f0
leaq 0x377d5(%rip), %rsi     # 0x6a364
movl $0x1, %edx
movq %r15, %rdi
callq 0xb5f0
movq %r15, %rdi
movl $0x47, %esi
callq 0xb9a0
movq %rax, %r15
leaq 0x38e2b(%rip), %rsi     # 0x6b9de
movl $0x15, %edx
movq %rax, %rdi
callq 0xb5f0
leaq 0x39339(%rip), %rsi     # 0x6bf00
movl $0x8, %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 (%r12), %rdi
addq $0x20, %rdi
callq 0xb3b0
addq $0x8, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x337d8
movq %rax, %r14
leaq 0x8(%rbx), %rax
cmpq %rax, %r14
je 0x32c51
movq %r14, %r15
addq $0x40, %r15
movq %rsp, %rsi
movq %r15, %rdi
callq 0x3381e
movq 0x68(%r14), %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0x338a0
movq 0x68(%r14), %rax
cmpq %rax, %r12
jne 0x32d0a
leaq 0x59918(%rip), %r14     # 0x8c570
movq (%r14), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x32d1a
addq $0x20, %rdi
callq 0xb7d0
movq (%r14), %rax
movq 0x8(%rax), %rbx
leaq 0x3752b(%rip), %rsi     # 0x6a1a8
movl $0xb, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x38d63(%rip), %rsi     # 0x6b9f4
movl $0xf, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x38d5f(%rip), %rsi     # 0x6ba04
movl $0xf, %edx
movq %rbx, %rdi
callq 0xb5f0
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0xb3c0
movq %rax, %rbx
leaq 0x37da9(%rip), %rsi     # 0x6aa71
movl $0xb, %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 (%r14), %rdi
addq $0x20, %rdi
callq 0xb3b0
jmp 0x32d1a
testq %rax, %rax
jne 0x32d1a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x33946
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/node/nodeconn_pool.cc
// Function: scdc_nodeconn_pool::close(scdc_nodeconn*)
void scdc_nodeconn_pool::close(scdc_nodeconn *nodeconn)
{
  SCDC_TRACE("close: nodeconn: '" << nodeconn << "'");

  bool is_idle = nodeconn->is_idle();

  if (is_idle)
  {
    SCDC_TRACE("close: closing idle connection");

    close_idle(nodeconn);

  } else
  {
    SCDC_TRACE("close: enable closing on idle");

    scdc_nodeconn_on_idle_close(nodeconn);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x20(%rax)
testb %al, %al
je 0x33119
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x33128
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5dd0f
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/node/nodeconn_pool.cc
// Function: scdc_nodeconn_pool::close_idle(scdc_nodeconn*)
void scdc_nodeconn_pool::close_idle(scdc_nodeconn *nodeconn)
{
  SCDC_TRACE("close_idle: nodeconn: '" << nodeconn << "', ref: " << nodeconn->ref);

  SCDC_ASSERT(nodeconn->ref > 0);

  --nodeconn->ref;

  if (nodeconn->ref <= 0)
  {
#if NODECONN_CACHE_CONNECTIONS
    if (cache_add(nodeconn))
    {
      SCDC_TRACE("close_idle: caching unreferenced connection '" << nodeconn << "'");

    } else
#endif
    {
      SCDC_TRACE("close_idle: closing unreferenced connection '" << nodeconn << "'");

      close_real(nodeconn);
    }

  } else
  {
    SCDC_TRACE("close_idle: keeping connection '" << nodeconn << "' with " << nodeconn->ref << " reference(s)");
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rsi), %rax
testq %rax, %rax
jg 0x33216
leaq 0x59426(%rip), %r12     # 0x8c570
movq (%r12), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x33230
addq $0x20, %rdi
callq 0xb7d0
movq (%r12), %rax
movq 0x18(%rax), %r15
leaq 0x373f8(%rip), %rsi     # 0x6a569
movl $0xd, %edx
movq %r15, %rdi
callq 0xb5f0
leaq 0x38843(%rip), %rsi     # 0x6b9c8
movl $0x15, %edx
movq %r15, %rdi
callq 0xb5f0
leaq 0x371cb(%rip), %rsi     # 0x6a364
movl $0x1, %edx
movq %r15, %rdi
callq 0xb5f0
movq %r15, %rdi
movl $0x116, %esi            # imm = 0x116
callq 0xb9a0
movq %rax, %r15
leaq 0x388c3(%rip), %rsi     # 0x6ba80
movl $0x14, %edx
movq %rax, %rdi
callq 0xb5f0
leaq 0x38d2f(%rip), %rsi     # 0x6bf00
movl $0x8, %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 (%r12), %rdi
addq $0x20, %rdi
callq 0xb3b0
movq 0x28(%rbx), %rax
leaq -0x1(%rax), %rcx
movq %rcx, 0x28(%rbx)
cmpq $0x1, %rax
jle 0x33237
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
decq %rax
movq %rax, 0x28(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x32b1c
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *0x8(%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/node/nodeconn_pool.cc
// Function: scdc_nodeconn_pool::close_all()
void scdc_nodeconn_pool::close_all()
{
  SCDC_TRACE("close_all:");

  while (size() > 0)
  {
    close_real(*begin()->second.begin());
  }

#if NODECONN_CACHE_CONNECTIONS
  cache.clear();
#endif
}

// Assembly:
cmpq $0x0, 0x28(%rdi)
je 0x332c1
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rbx), %rax
movq 0x58(%rax), %rax
movq 0x20(%rax), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x32b1c
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
cmpq $0x0, 0x28(%rbx)
jne 0x3328a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/node/nodeport_pool.cc
// Function: scdc_nodeport_pool::supported(char const*, scdc_args*)
bool scdc_nodeport_pool::supported(const char *uri, scdc_args *args)
{
#if USE_NODE_DIRECT
  if (scdc_nodeport_direct::supported(uri, args)) return true;
#endif
#if USE_NODE_TCP
  if (scdc_nodeport_tcp::supported(uri, args)) return true;
#endif
#if USE_NODE_UDS
  if (scdc_nodeport_uds::supported(uri, args)) return true;
#endif
#if USE_NODE_MPI
  if (scdc_nodeport_mpi::supported(uri, args)) return true;
#endif
#if USE_NODE_STREAM
  if (scdc_nodeport_stream::supported(uri, args)) return true;
#endif
#if USE_NODE_TIMER
  if (scdc_nodeport_timer::supported(uri, args)) return true;
#endif

  return scdc_nodeport::supported(uri, args);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x5bcc2
testb %al, %al
jne 0x33c49
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5c61a
testb %al, %al
jne 0x33c49
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5d0c8
testb %al, %al
jne 0x33c49
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5dd54
testb %al, %al
jne 0x33c49
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5dd54
testb %al, %al
je 0x33c53
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5dd54
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/node/nodeport_pool.cc
// Function: scdc_nodeport_pool::close(scdc_nodeport*)
void scdc_nodeport_pool::close(scdc_nodeport *nodeport)
{
  SCDC_TRACE("close: nodeport: '" << nodeport << "'");

  erase(nodeport);

  nodeport->close();

  delete nodeport;

  SCDC_TRACE("close: return");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
movq %rsi, (%r14)
movq %r14, %rsi
callq 0x340e0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x34162
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq (%r14), %rdi
testq %rdi, %rdi
je 0x33fa1
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/node/nodeport_timer.cc
// Function: scdc_nodeport_timer::open_config_conf(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, scdc_args*, bool&)
bool scdc_nodeport_timer::open_config_conf(const std::string &conf, scdc_args *args, bool &done)
{
  done = true;
  bool ret = true;

  if (conf == "max_count")
  {
    if (args->get<scdcint_t>(SCDC_ARGS_TYPE_SCDCINT, &max_count) == SCDC_ARG_REF_NULL)
    {
      SCDC_ERROR("open_config_conf: getting max. count");
      ret = false;

    } else
    {
      SCDC_TRACE("open_config_conf: max_count: '" << max_count << "'");
    }

  } else
  {
    done = false;
    ret = scdc_nodeport::open_config_conf(conf, args, done);
  }

  return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movb $0x1, (%rcx)
leaq 0x37855(%rip), %rsi     # 0x6badb
movq %r12, %rdi
callq 0xb110
testl %eax, %eax
je 0x342b2
movb $0x0, (%r15)
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r15, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5de1a
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x342dd
addq $0xb8, %rbx
movq (%r14), %rdi
movl $0x2, %esi
movq %rbx, %rdx
callq *%rax
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x3436f
leaq 0x5828c(%rip), %r14     # 0x8c570
movq (%r14), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x3436d
addq $0x20, %rdi
callq 0xb7d0
movq (%r14), %rax
movq 0x18(%rax), %rbx
leaq 0x361a3(%rip), %rsi     # 0x6a4a8
movl $0xc, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x377cc(%rip), %rsi     # 0x6bae5
movl $0x10, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x377c9(%rip), %rsi     # 0x6baf6
movl $0x24, %edx
movq %rbx, %rdi
callq 0xb5f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq (%r14), %rdi
addq $0x20, %rdi
callq 0xb3b0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/node/nodeport_timer.cc
// Function: scdc_nodeport_timer::start(long long)
bool scdc_nodeport_timer::start(scdcint_t mode)
{
  SCDC_TRACE("start: ");

  if (!scdc_nodeport::start(mode)) return false;

  last_time = z_time_wtime();
  current_count = 0;

  loop_run = true;

  loop_async = false;

  pthread_mutex_init(&loop_lock, NULL);
  pthread_cond_init(&loop_cond, NULL);

  if (mode & SCDC_NODEPORT_START_LOOP_UNTIL_CANCEL) loop();
  else
  {
    loop_async = true;
    pthread_create(&loop_thread, NULL, timer_server_run, this);
  }

  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %r14
callq 0x5e576
movl %eax, %ebx
testb %al, %al
je 0x34665
leaq 0x8(%rsp), %r12
movl $0x1, %edi
movq %r12, %rsi
callq 0xb480
cvtsi2sdq (%r12), %xmm0
cvtsi2sdq 0x8(%r12), %xmm1
mulsd 0x34a21(%rip), %xmm1    # 0x69018
addsd %xmm0, %xmm1
movsd %xmm1, 0x90(%r14)
movq $0x0, 0xb0(%r14)
movw $0x1, 0xc0(%r14)
leaq 0xd0(%r14), %rdi
xorl %esi, %esi
callq 0xb7e0
leaq 0xf8(%r14), %rdi
xorl %esi, %esi
callq 0xb660
testb $0x1, %r15b
jne 0x3465d
movb $0x1, 0xc1(%r14)
leaq 0xc8(%r14), %rdi
leaq 0x137(%rip), %rdx       # 0x34788
xorl %esi, %esi
movq %r14, %rcx
callq 0xba00
jmp 0x34665
movq %r14, %rdi
callq 0x34674
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/node/nodeport_timer.cc
// Function: scdc_nodeport_timer::loop()
void scdc_nodeport_timer::loop()
{
  SCDC_TRACE("loop: ");

  pthread_mutex_lock(&loop_lock);
  while (loop_run)
  {
    struct timespec abstime;
    abstimeout(&abstime, timeout, last_time);

    if (pthread_cond_timedwait(&loop_cond, &loop_lock, &abstime) == ETIMEDOUT)
    {
      last_time = z_time_wtime();

      /* unlock, so that timer_handler can do cancel */
      pthread_mutex_unlock(&loop_lock);

      timer_handler_args.handler(timer_handler_args.data);

      pthread_mutex_lock(&loop_lock);

      ++current_count;

      if (max_count >= 0 && current_count >= max_count) loop_run = false;
    }
  }
  pthread_mutex_unlock(&loop_lock);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
leaq 0xd0(%rdi), %rbx
movq %rbx, %rdi
callq 0xb7d0
cmpb $0x1, 0xc0(%r14)
jne 0x34772
leaq 0xf8(%r14), %r15
leaq 0x10(%rsp), %r12
movq %rsp, %r13
movsd 0x90(%r14), %xmm1
movsd 0x98(%r14), %xmm0
movq %r12, %rdi
callq 0x1cd2f
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0xb810
cmpl $0x6e, %eax
jne 0x34764
movl $0x1, %edi
movq %r13, %rsi
callq 0xb480
xorps %xmm0, %xmm0
cvtsi2sdq (%rsp), %xmm0
xorps %xmm1, %xmm1
cvtsi2sdq 0x8(%rsp), %xmm1
mulsd 0x3490f(%rip), %xmm1    # 0x69018
addsd %xmm0, %xmm1
movsd %xmm1, 0x90(%r14)
movq %rbx, %rdi
callq 0xb3b0
movq 0xa8(%r14), %rdi
callq *0xa0(%r14)
movq %rbx, %rdi
callq 0xb7d0
movq 0xb0(%r14), %rax
movq 0xb8(%r14), %rcx
incq %rax
movq %rax, 0xb0(%r14)
testq %rcx, %rcx
sets %dl
cmpq %rcx, %rax
setl %al
orb %dl, %al
jne 0x34764
movb $0x0, 0xc0(%r14)
cmpb $0x0, 0xc0(%r14)
jne 0x346b0
movq %rbx, %rdi
callq 0xb3b0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/node/nodeport_timer.cc
// Function: scdc_nodeport_timer::stop()
bool scdc_nodeport_timer::stop()
{
  SCDC_TRACE("stop: ");

  cancel(false);

  if (loop_async) pthread_join(loop_thread, NULL);

  pthread_cond_destroy(&loop_cond);
  pthread_mutex_destroy(&loop_lock);

  scdc_nodeport::stop();

  return true;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
xorl %esi, %esi
callq *0x38(%rax)
cmpb $0x1, 0xc1(%rbx)
jne 0x347b5
movq 0xc8(%rbx), %rdi
xorl %esi, %esi
callq 0xb460
leaq 0xf8(%rbx), %rdi
callq 0xba70
leaq 0xd0(%rbx), %rdi
callq 0xb620
movq %rbx, %rdi
callq 0x5e59e
movb $0x1, %al
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/../include/args.hh
// Function: void* scdc_args::get<scdc_nodeport_timer_handler_args_t>(long long, scdc_nodeport_timer_handler_args_t*, bool)
scdc_arg_ref_t get(scdcint_t type, T *v, bool long_ref = false) {
      if (!args.get) return SCDC_ARG_REF_NULL;
      scdc_arg_ref_t r = args.get(args.data, type, static_cast<void *>(v));
      if (long_ref && r != SCDC_ARG_REF_NULL) add_get(type, r, 1, v, 0);
      return r;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x348df
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdi), %rdi
callq *%rax
movq %rax, %r14
testq %rax, %rax
sete %al
xorb $0x1, %bpl
orb %al, %bpl
jne 0x348e2
leaq 0x20(%rbx), %r13
movl $0x38, %edi
callq 0xb500
movq %r12, 0x10(%rax)
movq %r14, 0x18(%rax)
movq $0x1, 0x20(%rax)
movq %r15, 0x28(%rax)
movq $0x0, 0x30(%rax)
movq %rax, %rdi
movq %r13, %rsi
callq 0xb090
incq 0x30(%rbx)
jmp 0x348e2
xorl %r14d, %r14d
movq %r14, %rax
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/extra/xxhash/xxhash.c
// Function: XXH32_digest
XXH_PUBLIC_API unsigned int XXH32_digest (const XXH32_state_t* state_in)
{
    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;

    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
        return XXH32_digest_endian(state_in, XXH_littleEndian);
    else
        return XXH32_digest_endian(state_in, XXH_bigEndian);
}

// Assembly:
movq %rdi, %rsi
cmpl $0x0, 0x4(%rdi)
je 0x34c5a
movdqu 0x8(%rsi), %xmm0
movdqa 0x36f90(%rip), %xmm1    # 0x6bba0
pshufd $0xf5, %xmm0, %xmm2     # xmm2 = xmm0[1,1,3,3]
pmuludq %xmm1, %xmm0
pshufd $0xed, %xmm0, %xmm3     # xmm3 = xmm0[1,3,2,3]
pshufd $0xf5, %xmm1, %xmm1     # xmm1 = xmm1[1,1,3,3]
pmuludq %xmm2, %xmm1
pshufd $0xed, %xmm1, %xmm2     # xmm2 = xmm1[1,3,2,3]
punpckldq %xmm2, %xmm3    # xmm3 = xmm3[0],xmm2[0],xmm3[1],xmm2[1]
pshufd $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3]
pshufd $0xe8, %xmm1, %xmm1     # xmm1 = xmm1[0,2,2,3]
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
por %xmm3, %xmm0
pshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
paddd %xmm0, %xmm1
pshufd $0x55, %xmm1, %xmm0     # xmm0 = xmm1[1,1,1,1]
paddd %xmm1, %xmm0
movd %xmm0, %edi
jmp 0x34c62
movl $0x165667b1, %edi       # imm = 0x165667B1
addl 0x10(%rsi), %edi
addl (%rsi), %edi
movl 0x28(%rsi), %edx
addq $0x18, %rsi
jmp 0x350da
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/extra/xxhash/xxhash.c
// Function: XXH64
XXH_PUBLIC_API unsigned long long XXH64 (const void* input, size_t len, unsigned long long seed)
{
#if 0
    /* Simple version, good for code maintenance, but unfortunately slow for small inputs */
    XXH64_state_t state;
    XXH64_reset(&state, seed);
    XXH64_update(&state, input, len);
    return XXH64_digest(&state);
#else
    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;

    if (XXH_FORCE_ALIGN_CHECK) {
        if ((((size_t)input) & 7)==0) {  /* Input is aligned, let's leverage the speed advantage */
            if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
                return XXH64_endian_align(input, len, seed, XXH_littleEndian, XXH_aligned);
            else
                return XXH64_endian_align(input, len, seed, XXH_bigEndian, XXH_aligned);
    }   }

    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
        return XXH64_endian_align(input, len, seed, XXH_littleEndian, XXH_unaligned);
    else
        return XXH64_endian_align(input, len, seed, XXH_bigEndian, XXH_unaligned);
#endif
}

// Assembly:
movq %rdx, %rax
movq %rsi, %rdx
movq %rdi, %rsi
cmpq $0x20, %rdx
jb 0x34dbb
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movabsq $-0x3d4d51c2d82b14b1, %r15 # imm = 0xC2B2AE3D27D4EB4F
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
leaq (%rsi,%rdx), %r12
addq $-0x20, %r12
movabsq $0x60ea27eeadc0b5d6, %r14 # imm = 0x60EA27EEADC0B5D6
addq %rax, %r14
leaq (%rax,%r15), %rbx
movabsq $0x61c8864e7a143579, %r11 # imm = 0x61C8864E7A143579
addq %rax, %r11
movq (%rsi), %r10
imulq %r15, %r10
addq %r14, %r10
rolq $0x1f, %r10
movq %r10, %r14
imulq %rcx, %r14
movq 0x8(%rsi), %r9
imulq %r15, %r9
addq %rbx, %r9
rolq $0x1f, %r9
movq %r9, %rbx
movq 0x10(%rsi), %r8
imulq %r15, %r8
addq %rax, %r8
rolq $0x1f, %r8
imulq %rcx, %rbx
movq %r8, %rax
imulq %rcx, %rax
movq 0x18(%rsi), %rdi
imulq %r15, %rdi
addq %r11, %rdi
rolq $0x1f, %rdi
movq %rdi, %r11
imulq %rcx, %r11
addq $0x20, %rsi
cmpq %r12, %rsi
jbe 0x34cce
rolq %r14
rolq $0x7, %rbx
addq %r14, %rbx
rolq $0xc, %rax
rolq $0x12, %r11
addq %rax, %r11
addq %rbx, %r11
movabsq $-0x210ca4fef0869357, %rax # imm = 0xDEF35B010F796CA9
imulq %rax, %r10
rolq $0x1f, %r10
imulq %rcx, %r10
xorq %r11, %r10
imulq %rcx, %r10
movabsq $-0x7a1435883d4d519d, %r11 # imm = 0x85EBCA77C2B2AE63
addq %r11, %r10
imulq %rax, %r9
rolq $0x1f, %r9
imulq %rcx, %r9
xorq %r10, %r9
imulq %rcx, %r9
imulq %rax, %r8
rolq $0x1f, %r8
addq %r11, %r9
imulq %rcx, %r8
xorq %r9, %r8
imulq %rcx, %r8
addq %r11, %r8
imulq %rax, %rdi
rolq $0x1f, %rdi
imulq %rcx, %rdi
xorq %r8, %rdi
imulq %rcx, %rdi
addq %r11, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x34dcb
movabsq $0x27d4eb2f165667c5, %rcx # imm = 0x27D4EB2F165667C5
addq %rcx, %rax
movq %rax, %rdi
addq %rdx, %rdi
jmp 0x3527b
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/extra/z_pack/z_pack.c
// Function: z_fs_stat
z_int_t z_fs_stat(const char *pathname, z_fs_stat_t *stat)
{
  struct stat s;


  if (lstat(pathname, &s) != 0) return 0;

  stat->is_directory = S_ISDIR(s.st_mode)?1:0;
  stat->is_file = S_ISREG(s.st_mode)?1:0;
  stat->is_link = S_ISLNK(s.st_mode)?1:0;
  stat->file_size = (z_int_t) s.st_size;

  return 1;
}

// Assembly:
pushq %rbx
subq $0x90, %rsp
movq %rsi, %rbx
movq %rsp, %rsi
callq 0xba80
testl %eax, %eax
je 0x35899
xorl %eax, %eax
jmp 0x358db
movl $0xf000, %eax           # imm = 0xF000
andl 0x18(%rsp), %eax
movd %eax, %xmm0
pshufd $0x40, %xmm0, %xmm0     # xmm0 = xmm0[0,0,0,1]
pcmpeqd 0x363bd(%rip), %xmm0    # 0x6bc70
pand 0x363c5(%rip), %xmm0    # 0x6bc80
movdqu %xmm0, (%rbx)
xorl %ecx, %ecx
cmpl $0xa000, %eax           # imm = 0xA000
sete %cl
movq %rcx, 0x10(%rbx)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rbx)
movl $0x1, %eax
addq $0x90, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/extra/z_pack/z_pack.c
// Function: z_fs_mkdir_p
z_int_t z_fs_mkdir_p(const char *pathname) /* z_proto, z_func z_fs_mkdir_p */
{
  z_int_t ret = 1;
  char *p, *pb, *pe;


  pb = p = strdup(pathname);

  while (ret && pb != NULL)
  {
    pe = strchr(pb, '/');

    if (pe != pb)
    {
      if (pe) *pe = '\0';

      ret = z_fs_mkdir(p);

      if (pe) *pe = '/';
    }

    pb = pe;

    if (pb) ++pb;
  }

  free(p);

  return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
callq 0xba10
movq %rax, %rbx
testq %rax, %rax
je 0x3595e
movq %rbx, %r15
movq %r15, %rdi
movl $0x2f, %esi
callq 0xb1e0
movq %rax, %r14
cmpq %r15, %rax
je 0x35946
testq %r14, %r14
je 0x35966
movb $0x0, (%r14)
movq %rbx, %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0xb220
testl %eax, %eax
sete %al
movb $0x2f, (%r14)
jmp 0x35948
movb $0x1, %al
leaq 0x1(%r14), %r15
testq %r14, %r14
cmoveq %r14, %r15
testb %al, %al
je 0x35978
testq %r14, %r14
jne 0x35910
jmp 0x35978
movl $0x1, %r14d
jmp 0x3597c
movq %rbx, %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0xb220
testl %eax, %eax
sete %al
movzbl %al, %r14d
movq %rbx, %rdi
callq 0xb650
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/dataprov/dataprov.cc
// Function: scdc_dataprov::open(char const*, scdc_args*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov::open(const char *conf, scdc_args *args, scdc_result &result)
{
  SCDC_TRACE("open: conf: '" << (conf?conf:"") << "'");

  bool ret = true;

  if (conf)
  {
    string confs(conf);

    if (!open_config(confs, args))
    {
      SCDC_FAIL("open: processing configuration failed");
      ret = false;
    }
  }

  return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
testq %rsi, %rsi
je 0x35f3c
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq %rsi, %rdi
callq 0xb200
leaq (%rax,%r15), %rdx
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x1be38
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x35a8a
movl %eax, %ebx
testb %al, %al
jne 0x35f24
leaq 0x566d5(%rip), %r15     # 0x8c570
movq (%r15), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x35f24
addq $0x20, %rdi
callq 0xb7d0
movq (%r15), %rax
movq 0x8(%rax), %r14
leaq 0x342ec(%rip), %rsi     # 0x6a1a8
movl $0xb, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x35dc0(%rip), %rsi     # 0x6bc90
movl $0xa, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x35e0d(%rip), %rsi     # 0x6bcf1
movl $0x25, %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
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x35f3e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
jmp 0x35f3e
movb $0x1, %bl
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x35f67
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/dataprov/dataprov.cc
// Function: scdc_dataprov::config_close(scdc_dataset*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov::config_close(scdc_dataset *dataset, scdc_result &result)
{
  SCDC_TRACE("config_close: dataset: '" << dataset << "'");

  bool ret = false;

  if (typeid(*dataset) == typeid(scdc_dataset_config))
  {
    delete dataset;
    ret = true;
  }

  SCDC_TRACE("config_close: return: '" << ret << "'");

  return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x36467
movq %rsi, %rbx
movq (%rsi), %r14
movq -0x8(%r14), %rax
movq 0x8(%rax), %rdi
leaq 0x359df(%rip), %rax     # 0x6be17
cmpq %rax, %rdi
je 0x36456
cmpb $0x2a, (%rdi)
je 0x36452
leaq 0x359ce(%rip), %rsi     # 0x6be17
callq 0xb770
testl %eax, %eax
je 0x36456
xorl %eax, %eax
jmp 0x3645f
movq %rbx, %rdi
callq *0x8(%r14)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xb5a0