LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/../include/log.hh
// Function: scdc_log_timestamp[abi:cxx11]()
static inline std::string scdc_log_timestamp()
{
  time_t now = time(0);
  struct tm *timeinfo = localtime(&now);
  char s[256];
  sprintf(s, "%.2d.%.2d.%.4d %.2d:%.2d:%.2d: ", timeinfo->tm_mday, timeinfo->tm_mon + 1, timeinfo->tm_year + 1900, timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec);
  return s;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rdi, %rbx
xorl %edi, %edi
callq 0xb4e0
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
callq 0xb3c0
movl 0xc(%rax), %edx
movl 0x10(%rax), %ecx
movl $0x76c, %r8d            # imm = 0x76C
addl 0x14(%rax), %r8d
incl %ecx
movl 0x8(%rax), %r9d
movl (%rax), %r10d
movl 0x4(%rax), %r11d
leaq 0x2d8b6(%rip), %rsi     # 0x51f1b
leaq 0x10(%rsp), %r14
movq %r14, %rdi
xorl %eax, %eax
pushq %r10
pushq %r11
callq 0xb0c0
popq %rcx
popq %rdx
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a132
movq %rbx, %rax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_output_printf
void scdc_dataset_output_printf(int append, scdc_dataset_output_t *output, const char *fmt, ...)
{
  if (!output || !SCDC_DATASET_INOUT_BUF_PTR(output)) return;

  strncpy(output->format, "text", SCDC_FORMAT_MAX_SIZE);

  if (!append)
  {
    SCDC_DATASET_INOUT_BUF_CURRENT(output) = 0;
    output->total_size = 0;
  }

  char *buf = static_cast<char *>(SCDC_DATASET_INOUT_BUF_PTR(output));
  buf += SCDC_DATASET_INOUT_BUF_CURRENT(output);

  scdcint_t buf_size = SCDC_DATASET_INOUT_BUF_SIZE(output) - SCDC_DATASET_INOUT_BUF_CURRENT(output);

  va_list argptr;
  va_start(argptr, fmt);
  scdcint_t n = vsnprintf(buf, buf_size, fmt, argptr);
  va_end(argptr);

  n = min(buf_size, n);

  SCDC_DATASET_INOUT_BUF_CURRENT(output) += n;
  output->total_size += n;

  output->total_size_given = SCDC_DATASET_INOUT_TOTAL_SIZE_GIVEN_EXACT;

  output->next = 0;
  output->data = 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %rbx
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
testb %al, %al
je 0x2471d
movdqa %xmm0, 0x50(%rsp)
movdqa %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)
testq %rsi, %rsi
je 0x247b9
movl %edi, %esi
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x247b9
movups 0x2d8bc(%rip), %xmm0    # 0x51ff8
movups %xmm0, (%rbx)
leaq 0x20(%rbx), %rax
testl %esi, %esi
je 0x2474c
movq (%rax), %rax
jmp 0x24754
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
xorl %eax, %eax
addq %rax, %rdi
movq 0x18(%rbx), %r14
subq %rax, %r14
leaq 0x20(%rsp), %rax
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rcx)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, (%rcx)
movq %r14, %rsi
callq 0xb330
cltq
cmpq %rax, %r14
cmovgeq %rax, %r14
movdqu 0x20(%rbx), %xmm0
movq %r14, %xmm1
pshufd $0x44, %xmm1, %xmm1     # xmm1 = xmm1[0,1,0,1]
paddq %xmm0, %xmm1
movdqu %xmm1, 0x20(%rbx)
movb $0x78, 0x30(%rbx)
pxor %xmm0, %xmm0
movdqu %xmm0, 0x38(%rbx)
addq $0xd8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: inout_FX_data_t<int>::get_size_left()
scdcint_t inout_FX_data_t<int>::get_size_left()
{
  scdcint_t pos = lseek(fx, 0, SEEK_CUR);

  if (pos < 0) return -1;

  scdcint_t size = lseek(fx, 0, SEEK_END);

  if (size < 0) return -1;

  size -= pos;

  lseek(fx, pos, SEEK_SET);

  return size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %edi
pushq $0x1
popq %rdx
xorl %esi, %esi
callq 0xba20
pushq $-0x1
popq %r15
testq %rax, %rax
js 0x24d97
movq %rax, %r14
movl (%rbx), %edi
pushq $0x2
popq %rdx
xorl %esi, %esi
callq 0xba20
testq %rax, %rax
js 0x24d97
movq %rax, %r12
subq %r14, %r12
movl (%rbx), %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0xba20
movq %r12, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: inout_FX_data_t<_IO_FILE*>::get_size_left()
scdcint_t inout_FX_data_t<FILE *>::get_size_left()
{
  scdcint_t pos = ftello(fx);

  if (pos < 0 || fseeko(fx, 0, SEEK_END) < 0) return -1;

  scdcint_t size = ftello(fx);

  if (size < 0) return -1;

  size -= pos;

  fseeko(fx, pos, SEEK_SET);

  return size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0xb6a0
pushq $-0x1
popq %r14
testq %rax, %rax
js 0x24e6f
movq %rax, %r15
movq (%rbx), %rdi
pushq $0x2
popq %rdx
xorl %esi, %esi
callq 0xb310
testl %eax, %eax
js 0x24e6f
movq (%rbx), %rdi
callq 0xb6a0
testq %rax, %rax
js 0x24e6f
movq %rax, %r12
subq %r15, %r12
movq (%rbx), %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0xb310
movq %r12, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_input_create
scdc_dataset_input_t *scdc_dataset_input_create(scdc_dataset_input_t *input, const char *conf, ...)
{
  va_list ap;
  va_start(ap, conf);

  scdc_args_t args;

  scdc_args_va_init(&args, &ap);

  input = scdc_dataset_input_create_intern(input, conf, &args);

  scdc_args_va_release(&args);
  va_end(ap);

  return input;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xf0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x40(%rsp), %rdi
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x260de
movaps %xmm0, 0x70(%rsp)
movaps %xmm1, 0x80(%rsp)
movaps %xmm2, 0x90(%rsp)
movaps %xmm3, 0xa0(%rsp)
movaps %xmm4, 0xb0(%rsp)
movaps %xmm5, 0xc0(%rsp)
movaps %xmm6, 0xd0(%rsp)
movaps %xmm7, 0xe0(%rsp)
movq %rsp, %rsi
movq %rdi, 0x10(%rsi)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%rsi)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rsi)
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x26134
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x24e7e
movq %rax, %rbx
movq %r15, %rdi
callq 0x2616f
movq %rbx, %rax
addq $0xf0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_args_va_init(_scdc_args_t*, __va_list_tag (*) [1])
static void scdc_args_va_init(scdc_args_t *args, va_list *ap)
{
  scdc_args_data_va_t *data_va;


  data_va = new scdc_args_data_va_t;

  data_va->arg = 0;
  data_va->ap = ap;

  args->data = data_va;
  args->get = scdc_args_get_va;
  args->set = scdc_args_set_va;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x10
popq %rdi
callq 0xb540
andq $0x0, (%rax)
movq %rbx, 0x8(%rax)
movq %rax, (%r14)
leaq 0x2942(%rip), %rax      # 0x28a9a
movq %rax, 0x8(%r14)
leaq 0x2a5b(%rip), %rax      # 0x28bbe
movq %rax, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_input_destroy
void scdc_dataset_input_destroy(scdc_dataset_input_t *input)
{
  SCDC_TRACE_DATASET_INPUT(input, "scdc_dataset_input_destroy: input: ");

  if (!input)
  {
    SCDC_FAIL("scdc_dataset_input_destroy: no input given");
    return;
  }

  if (!input->intern) return;

  INOUT_INTERN_RESTORE(input);

  if (input->intern->destroy) input->intern->destroy(input);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x261a5
movq 0x48(%rdi), %rax
testq %rax, %rax
je 0x26205
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rdi)
movq 0x18(%rax), %rcx
movq %rcx, 0x40(%rdi)
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x26205
popq %rbx
jmpq *%rax
leaq 0x4f3d4(%rip), %rbx     # 0x75580
movq (%rbx), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x26205
addq $0x20, %rdi
callq 0xb800
movq (%rbx), %rax
movq 0x8(%rax), %rdi
leaq 0x2afbb(%rip), %rsi     # 0x51188
callq 0xb520
leaq 0x2be7c(%rip), %rsi     # 0x52055
movq %rax, %rdi
callq 0xb520
leaq 0x2be92(%rip), %rsi     # 0x5207a
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
movq (%rbx), %rdi
addq $0x20, %rdi
popq %rbx
jmp 0xb3e0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_output_destroy
void scdc_dataset_output_destroy(scdc_dataset_output_t *output)
{
  SCDC_TRACE_DATASET_OUTPUT(output, "scdc_dataset_output_destroy: ");

  if (!output)
  {
    SCDC_FAIL("scdc_dataset_output_destroy: no output given");
    return;
  }

  if (!output->intern) return;

  INOUT_INTERN_RESTORE(output);

  if (output->intern->destroy) output->intern->destroy(output);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x26cd5
movq 0x48(%rdi), %rax
testq %rax, %rax
je 0x26d35
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rdi)
movq 0x18(%rax), %rcx
movq %rcx, 0x40(%rdi)
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x26d35
popq %rbx
jmpq *%rax
leaq 0x4e8a4(%rip), %rbx     # 0x75580
movq (%rbx), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x26d35
addq $0x20, %rdi
callq 0xb800
movq (%rbx), %rax
movq 0x8(%rax), %rdi
leaq 0x2a48b(%rip), %rsi     # 0x51188
callq 0xb520
leaq 0x2b34c(%rip), %rsi     # 0x52055
movq %rax, %rdi
callq 0xb520
leaq 0x2b3b0(%rip), %rsi     # 0x520c8
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
movq (%rbx), %rdi
addq $0x20, %rdi
popq %rbx
jmp 0xb3e0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_input_redirect_intern
scdcint_t scdc_dataset_input_redirect_intern(scdc_dataset_input_t *input, const char *conf, scdc_args_t *args)
{
  SCDC_TRACE("scdc_dataset_input_redirect_intern: conf: '" << conf << "'");

  if (!input)
  {
    SCDC_FAIL("scdc_dataset_input_redirect_intern: no input given");
    return SCDC_FAILURE;
  }

  return scdc_dataset_inout_redirect_intern(input, conf, args);
}

// Assembly:
testq %rdi, %rdi
jne 0x26dba
pushq %rbx
leaq 0x4e822(%rip), %rbx     # 0x75580
movq (%rbx), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x26db6
addq $0x20, %rdi
callq 0xb800
movq (%rbx), %rax
movq 0x8(%rax), %rdi
leaq 0x2a409(%rip), %rsi     # 0x51188
callq 0xb520
leaq 0x2b2ca(%rip), %rsi     # 0x52055
movq %rax, %rdi
callq 0xb520
leaq 0x2b35b(%rip), %rsi     # 0x520f5
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
movq (%rbx), %rdi
addq $0x20, %rdi
callq 0xb3e0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_output_redirect_intern
scdcint_t scdc_dataset_output_redirect_intern(scdc_dataset_output_t *output, const char *conf, scdc_args_t *args)
{
  SCDC_TRACE("scdc_dataset_output_redirect_intern: conf: '" << conf << "'");

  if (!output)
  {
    SCDC_FAIL("scdc_dataset_output_redirect_intern: no output given");
    return SCDC_FAILURE;
  }

  return scdc_dataset_inout_redirect_intern(output, conf, args);
}

// Assembly:
testq %rdi, %rdi
jne 0x26dba
pushq %rbx
leaq 0x4e102(%rip), %rbx     # 0x75580
movq (%rbx), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x274d6
addq $0x20, %rdi
callq 0xb800
movq (%rbx), %rax
movq 0x8(%rax), %rdi
leaq 0x29ce9(%rip), %rsi     # 0x51188
callq 0xb520
leaq 0x2abaa(%rip), %rsi     # 0x52055
movq %rax, %rdi
callq 0xb520
leaq 0x2ac6e(%rip), %rsi     # 0x52128
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
movq (%rbx), %rdi
addq $0x20, %rdi
callq 0xb3e0
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8(%rsp), %r15
pushq $0x3a
popq %rsi
pushq $-0x1
popq %rcx
movq %r15, %rdi
callq 0x19b64
leaq 0x50(%rsp), %rax
movq %rax, 0x8(%rax)
movq %rax, (%rax)
andq $0x0, 0x10(%rax)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movaps %xmm0, -0x20(%rax)
movaps %xmm1, -0x10(%rax)
leaq 0x88(%rsp), %rdi
movq %r15, %rsi
callq 0x19f8c
leaq 0x2af45(%rip), %rsi     # 0x52547
leaq 0x88(%rsp), %r14
movq %r14, %rdi
callq 0x19be0
movl %eax, %ebp
movq %r14, %rdi
callq 0xb230
movl $0x4000, %esi           # imm = 0x4000
testb %bpl, %bpl
je 0x2765a
movq 0x38(%rsp), %rax
testq %rax, %rax
je 0x2763d
movq 0x30(%rsp), %rdi
pushq $0x2
popq %rsi
movq %rsp, %rdx
callq *%rax
leaq 0x68(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x19ba0
leaq 0x68(%rsp), %rdi
callq 0xb230
movq (%rsp), %rsi
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x276d1
testb %al, %al
je 0x27685
movq 0x48(%rbx), %rax
movq $0x2, 0x8(%rax)
leaq 0xc2(%rip), %rcx        # 0x27740
movq %rcx, 0x20(%rax)
movq %rbx, %r14
leaq 0x30(%rsp), %rdi
callq 0x19a94
leaq 0x8(%rsp), %rdi
callq 0x19ef4
movq %r14, %rax
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x276ac
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x19a94
leaq 0x8(%rsp), %rdi
callq 0x19ef4
movq %rbx, %rdi
callq 0xb9a0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x27732
movq %rdi, %r15
movb $0x1, %bl
cmpq $0x0, 0x48(%rdi)
jne 0x27734
movq %rdx, %r12
movq %rsi, %r14
leaq (%rsi,%rdx), %r13
addq $0x28, %r13
pushq $0x1
popq %rsi
movq %r13, %rdi
callq 0xb350
testq %rax, %rax
je 0x27732
movq %rax, %rcx
movq %rax, 0x48(%r15)
addq $0x28, %rax
movq %r13, (%rcx)
testq %r12, %r12
jle 0x27723
movq %rax, 0x40(%r15)
addq %r12, %rax
testq %r14, %r14
jle 0x27734
movq %rax, 0x10(%r15)
movq %r14, 0x18(%r15)
jmp 0x27734
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: long long input_FX_next<int>(_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 0x18(%rdi), %rax
movq 0x8(%r14), %rcx
cmpq %rcx, %rax
movq %rcx, %rdi
cmovlq %rax, %rdi
movq 0x10(%r14), %r8
testq %rcx, %rcx
cmovsq %rax, %rdi
cmpq %r8, %rdi
movq %r8, %rdx
cmovlq %rdi, %rdx
movq 0x10(%rbx), %rsi
testq %r8, %r8
cmovsq %rdi, %rdx
movq %r14, %rdi
callq 0x24d08
movq 0x10(%r14), %rcx
movq %rcx, %rdx
subq %rax, %rdx
movq %rdx, 0x10(%r14)
movq %rax, 0x20(%rbx)
cmpb $0x6c, 0x30(%rbx)
jne 0x27e89
addq %rax, 0x28(%rbx)
testq %rax, %rax
sete %dl
cmpq %rax, %rcx
sete %al
orb %dl, %al
cmpb $0x1, %al
jne 0x27ea4
movb $0x78, 0x30(%rbx)
andq $0x0, 0x38(%rbx)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x27ec8
pushq %rbx
movq 0x40(%rdi), %rax
movl (%rax), %ebx
callq 0x27746
movl %ebx, %edi
popq %rbx
jmp 0xbaa0
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x28657
pushq %rbp
pushq %rbx
pushq %rax
movq %rsp, %rbx
movq %rbx, %rsi
callq 0x2860d
movq (%rbx), %rdi
callq 0xb590
movl %eax, %ebp
movq (%rbx), %rdi
callq 0xb530
movl %ebp, %edi
callq 0xbaa0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
testq %rdi, %rdi
je 0x287b5
movq %rdi, %rbx
movq 0x48(%rdi), %rax
movq 0x8(%rax), %rax
leaq -0xb(%rax), %rcx
cmpq $0x2, %rcx
jb 0x287ac
cmpq $0xa, %rax
jne 0x287b5
movq 0x40(%rbx), %rax
movq 0x108(%rax), %rdi
callq 0xb910
movq %rbx, %rdi
popq %rbx
jmp 0x27746
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: input_produce_next(_scdc_dataset_inout_t*, _scdc_result_t*)
static scdcint_t input_produce_next(scdc_dataset_input_t *input, scdc_result_t *result)
{
  input_produce_data_t *data = static_cast<input_produce_data_t *>(input->data);

  SCDC_DATASET_INOUT_BUF_CURRENT(input) = min(data->total_size_left, SCDC_DATASET_INOUT_BUF_SIZE(input));

  memset(SCDC_DATASET_INOUT_BUF_PTR(input), 0, SCDC_DATASET_INOUT_BUF_CURRENT(input));

  data->total_size_left -= SCDC_DATASET_INOUT_BUF_CURRENT(input);

  if (data->total_size_left <= 0) 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 (%r14), %rdx
cmpq %rdx, %rax
cmovlq %rax, %rdx
movq %rdx, 0x20(%rbx)
xorl %esi, %esi
callq 0xb2f0
movq 0x20(%rbx), %rax
subq %rax, (%r14)
jg 0x289eb
andq $0x0, 0x38(%rbx)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: autodestroy_un_pack(_scdc_dataset_inout_t*, long long (*)(_scdc_dataset_inout_t*, _scdc_result_t*))
static void autodestroy_un_pack(scdc_dataset_inout_t *inout, scdc_dataset_inout_next_f *next)
{
  SCDC_TRACE("autodestroy_un_pack: " << (next?"pack":"unpack") << ", IN next: " << reinterpret_cast<void *>(inout->next) << ", data: " << inout->data);

  if (next)
  {
    autodestroy_data_t *data = new autodestroy_data_t();

    data->next = inout->next;
    data->data = inout->data;

    inout->next = next;
    inout->data = data;

  } else
  {
    autodestroy_data_t *data = static_cast<autodestroy_data_t *>(inout->data);

    inout->next = data->next;
    inout->data = data->data;

    delete data;
  }

  SCDC_TRACE("autodestroy_un_pack: " << (next?"pack":"unpack") << ", OUT next: " << reinterpret_cast<void *>(inout->next) << ", data: " << inout->data);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x28a24
movq %rsi, %r14
pushq $0x10
popq %rdi
callq 0xb540
movups 0x38(%rbx), %xmm0
movups %xmm0, (%rax)
movq %r14, 0x38(%rbx)
movq %rax, 0x40(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x40(%rbx), %rdi
movups (%rdi), %xmm0
movups %xmm0, 0x38(%rbx)
pushq $0x10
popq %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb550
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %esi, %esi
callq 0x289f6
movq 0x38(%rbx), %rax
testq %rax, %rax
je 0x28a73
movq %rbx, %rdi
xorl %esi, %esi
callq *%rax
movq %rax, %r14
leaq -0x28(%rip), %rsi       # 0x28a3e
movq %rbx, %rdi
callq 0x289f6
movq %r14, %rax
jmp 0x28a92
movq 0x48(%rbx), %rax
testq %rax, %rax
je 0x28a8a
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x28a8a
movq %rbx, %rdi
callq *%rax
andq $0x0, 0x20(%rbx)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: long long output_FX_next<int>(_scdc_dataset_inout_t*, _scdc_result_t*)
static scdcint_t output_FX_next(scdc_dataset_output_t *output, scdc_result_t *result)
{
  inout_FX_data_t<T> *data = static_cast<inout_FX_data_t<T> *>(output->data);

  size_t n = SCDC_DATASET_INOUT_BUF_CURRENT(output);

  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->write(SCDC_DATASET_INOUT_BUF_PTR(output), n);

#if SYNC_AFTER_WRITE
  data->sync();
#endif

  data->size_left -= n;

  /* set to the nuber of bytes that have been written */
  SCDC_DATASET_INOUT_BUF_CURRENT(output) = n;

  if (data->size_left == 0)
  {
    output->next = 0;
  }

  return SCDC_SUCCESS;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %r14
movq 0x20(%rdi), %rax
movq 0x8(%r14), %rcx
cmpq %rcx, %rax
movq %rcx, %rdi
cmovlq %rax, %rdi
movq 0x10(%r14), %r8
testq %rcx, %rcx
cmovsq %rax, %rdi
cmpq %r8, %rdi
movq %r8, %rdx
cmovlq %rdi, %rdx
movq 0x10(%rbx), %rsi
testq %r8, %r8
cmovsq %rdi, %rdx
movq %r14, %rdi
callq 0x24d10
subq %rax, 0x10(%r14)
movq %rax, 0x20(%rbx)
jne 0x2936d
andq $0x0, 0x38(%rbx)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_output_fddup_destroy(_scdc_dataset_inout_t*)
static void scdc_dataset_output_fddup_destroy(scdc_dataset_output_t *output)
{
  if (!output) return;

  int fddup;

  scdc_dataset_output_FX_destroy<int>(output, &fddup);

  close(fddup);
}

// Assembly:
testq %rdi, %rdi
je 0x29391
pushq %rbx
movq 0x40(%rdi), %rax
movl (%rax), %ebx
callq 0x27746
movl %ebx, %edi
popq %rbx
jmp 0xbaa0
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_output_streamdup_destroy(_scdc_dataset_inout_t*)
static void scdc_dataset_output_streamdup_destroy(scdc_dataset_output_t *output)
{
  if (!output) return;

  FILE *stream;

  scdc_dataset_output_FX_destroy<FILE *>(output, &stream);

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

// Assembly:
testq %rdi, %rdi
je 0x29b81
pushq %rbp
pushq %rbx
pushq %rax
movq %rsp, %rbx
movq %rbx, %rsi
callq 0x29b37
movq (%rbx), %rdi
callq 0xb590
movl %eax, %ebp
movq (%rbx), %rdi
callq 0xb530
movl %ebp, %edi
callq 0xbaa0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: inout2inout(_scdc_dataset_inout_t*, _scdc_dataset_inout_t*, bool)
static void inout2inout(scdc_dataset_inout_t *src, scdc_dataset_inout_t *dst, bool copy)
{
  strncpy(dst->format, src->format, SCDC_FORMAT_MAX_SIZE);

  scdcint_t size = SCDC_DATASET_INOUT_BUF_CURRENT(src);

  if (copy)
  {
    size = min(size, SCDC_DATASET_INOUT_BUF_SIZE(dst));
    memcpy(SCDC_DATASET_INOUT_BUF_PTR(dst), SCDC_DATASET_INOUT_BUF_PTR(src), size);

  } else
  {
    SCDC_DATASET_INOUT_BUF_PTR(dst) = SCDC_DATASET_INOUT_BUF_PTR(src);
    SCDC_DATASET_INOUT_BUF_SIZE(dst) = SCDC_DATASET_INOUT_BUF_SIZE(src);
  }

  dst->total_size = src->total_size;
  dst->total_size_given = src->total_size_given;

  SCDC_DATASET_INOUT_BUF_CURRENT(dst) = size;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x10
popq %rdx
movq %rsi, %rdi
movq %r14, %rsi
callq 0xb2c0
movq 0x20(%r14), %r15
testl %ebp, %ebp
je 0x29c1c
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rax
cmpq %r15, %rax
cmovlq %rax, %r15
movq 0x10(%r14), %rsi
movq %r15, %rdx
callq 0xb420
jmp 0x29c2c
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movq 0x18(%r14), %rax
movq %rax, 0x18(%rbx)
movq 0x28(%r14), %rax
movq %rax, 0x28(%rbx)
movb 0x30(%r14), %al
movb %al, 0x30(%rbx)
movq %r15, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/../include/args.hh
// Function: void* scdc_args_string::get<long long>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, long long, long long*)
static scdc_arg_ref_t get(std::string &s_, scdcint_t type, T *v) {
      scdc_arg_ref_t r = SCDC_ARG_REF_NULL;
      if (type == SCDC_ARGS_TYPE_SCDCINT)
      {
        if (sscanf(s_.c_str(), "%" scdcint_fmt, v) == 1) r = SCDC_ARG_REF_NONE;
      }
      return r;
    }

// Assembly:
cmpq $0x2, %rsi
jne 0x29c8f
pushq %rax
movq (%rdi), %rdi
leaq 0x2a047(%rip), %rsi     # 0x53cc0
xorl %eax, %eax
callq 0xb510
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
sete %al
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x29d03
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)
andq $0x0, 0x40(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%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 0x29d48
addq $0xd8, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdx), %rax
movq %rsp, %r13
movq %rax, 0x10(%r13)
movups (%rdx), %xmm0
movaps %xmm0, (%r13)
pushq $0x10
popq %r15
movq %r15, %rdi
callq 0xb540
movq %rax, %r12
andq $0x0, (%rax)
movq %r13, 0x8(%rax)
leaq 0x18(%rsp), %rdx
movq %rax, (%rdx)
leaq 0xb4f(%rip), %rax       # 0x2a8e4
movq %rax, 0x8(%rdx)
leaq 0xbe8(%rip), %rax       # 0x2a988
movq %rax, 0x10(%rdx)
leaq 0xbe0(%rip), %rax       # 0x2a98b
movq %rax, 0x18(%rdx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x29e8a
movl %eax, %ebp
movq %r12, %rdi
movq %r15, %rsi
callq 0xb550
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x29de2
callq 0xb370
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x29de2
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rdi
movq %rax, (%rbx)
testq %rdi, %rdi
je 0x29e06
callq 0xb370
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x29e06
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rbx), %rax
movq %rax, 0x10(%rbx)
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
callq 0x29e44
andq $0x0, 0x8(%rbx)
andq $0x0, 0x18(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x29e5e
movq %rax, %rdi
callq 0x19b58
// File: /workspace/github_cpp_makefile_star2_O2/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 0x29e70
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, (%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x29e83
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2a613
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 0x4af46(%rip), %rax     # 0x75580
movq (%rax), %rax
movq 0x8(%rax), %rdi
movq %r10, %rsi
xorl %ecx, %ecx
callq 0x2a653
addq $0xd8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2a6f1
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
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 %r14, %rdx
callq 0xb330
movl %eax, %r12d
cmpl $0x400, %eax            # imm = 0x400
jl 0x2a6d5
incl %r12d
movq %r12, %rdi
callq 0xb040
movq 0x10(%r15), %rdx
movq %rsp, %rcx
movq %rdx, 0x10(%rcx)
movups (%r15), %xmm0
movaps %xmm0, (%rcx)
movl $0x400, %esi            # imm = 0x400
movq %rax, %rdi
movq %r14, %rdx
callq 0xb330
movl %eax, %r12d
leaq 0x40(%rsp), %rsi
movq %rbx, %rdi
callq 0xb520
testb %bpl, %bpl
je 0x2a6f5
movq %rbx, %rdi
callq 0xb270
jmp 0x2a6f5
pushq $-0x1
popq %r12
movl %r12d, %eax
addq $0x440, %rsp            # imm = 0x440
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2a766
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 0x4adf3(%rip), %rax     # 0x75580
movq (%rax), %rax
movq 0x8(%rax), %rdi
pushq $0x1
popq %rcx
movq %r10, %rsi
callq 0x2a653
addq $0xd8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2a805
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 0x4ad54(%rip), %rax     # 0x75580
movq (%rax), %rax
movq 0x18(%rax), %rdi
movq %r10, %rsi
xorl %ecx, %ecx
callq 0x2a653
addq $0xd8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2a8a3
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 0x4acb6(%rip), %rax     # 0x75580
movq (%rax), %rax
movq 0x18(%rax), %rdi
pushq $0x1
popq %rcx
movq %r10, %rsi
callq 0x2a653
addq $0xd8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2a914
cmpq $0x7, %rsi
je 0x2a914
cmpq $0x11, %rsi
jne 0x2a942
movq 0x8(%rdi), %rax
movl (%rax), %esi
cmpq $0x28, %rsi
ja 0x2a945
movq %rsi, %rcx
addq 0x10(%rax), %rcx
addl $0x8, %esi
movl %esi, (%rax)
jmp 0x2a951
movq 0x8(%rdi), %rax
movl (%rax), %esi
cmpq $0x28, %rsi
ja 0x2a92e
movq %rsi, %rcx
addq 0x10(%rax), %rcx
addl $0x8, %esi
movl %esi, (%rax)
jmp 0x2a93a
movq 0x8(%rax), %rcx
leaq 0x8(%rcx), %rsi
movq %rsi, 0x8(%rax)
movq (%rcx), %rax
movq %rax, (%rdx)
jmp 0x2a984
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 0x2a971
movq %rsi, %rcx
addq 0x10(%rax), %rcx
addl $0x8, %esi
movl %esi, (%rax)
jmp 0x2a97d
movq 0x8(%rax), %rcx
leaq 0x8(%rcx), %rsi
movq %rsi, 0x8(%rax)
movq (%rcx), %rax
movq %rax, 0x8(%rdx)
pushq $0x1
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2ab74
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_O2/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 %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x28(%rsi)
jle 0x2af27
leaq 0x4a6da(%rip), %r15     # 0x75580
movq (%r15), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x2af27
addq $0x20, %rdi
callq 0xb800
movq (%r15), %rax
movq 0x18(%rax), %rdi
leaq 0x26682(%rip), %rsi     # 0x51549
callq 0xb520
leaq 0x27a85(%rip), %rsi     # 0x52958
movq %rax, %rdi
callq 0xb520
leaq 0x26462(%rip), %rsi     # 0x51344
movq %rax, %rdi
callq 0xb520
pushq $0x47
popq %rsi
movq %rax, %rdi
callq 0xb990
leaq 0x27a72(%rip), %rsi     # 0x5296e
movq %rax, %rdi
callq 0xb520
leaq 0x27f85(%rip), %rsi     # 0x52e90
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
movq (%r15), %rdi
addq $0x20, %rdi
callq 0xb3e0
addq $0x8, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2b9a6
movq %rax, %r14
leaq 0x8(%rbx), %rax
cmpq %rax, %r14
je 0x2af6d
leaq 0x40(%r14), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2b9e4
testq %rax, %rax
je 0x2af6d
cmpq $0x0, 0x68(%r14)
jne 0x2afe8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2bb8c
jmp 0x2afe8
leaq 0x4a60c(%rip), %rbx     # 0x75580
movq (%rbx), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x2afe8
addq $0x20, %rdi
callq 0xb800
movq (%rbx), %rax
movq 0x8(%rax), %rdi
leaq 0x261f3(%rip), %rsi     # 0x51188
callq 0xb520
leaq 0x279e3(%rip), %rsi     # 0x52984
movq %rax, %rdi
callq 0xb520
leaq 0x279e4(%rip), %rsi     # 0x52994
movq %rax, %rdi
callq 0xb520
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0xb3f0
leaq 0x26a3a(%rip), %rsi     # 0x51a06
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
movq (%rbx), %rdi
addq $0x20, %rdi
callq 0xb3e0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2b303
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2b312
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x486a3
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rsi), %rax
testq %rax, %rax
jg 0x2b3bc
leaq 0x4a24f(%rip), %r15     # 0x75580
movq (%r15), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x2b3d0
addq $0x20, %rdi
callq 0xb800
movq (%r15), %rax
movq 0x18(%rax), %rdi
leaq 0x261f3(%rip), %rsi     # 0x51549
callq 0xb520
leaq 0x275f6(%rip), %rsi     # 0x52958
movq %rax, %rdi
callq 0xb520
leaq 0x25fd3(%rip), %rsi     # 0x51344
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
movl $0x116, %esi            # imm = 0x116
callq 0xb990
leaq 0x27683(%rip), %rsi     # 0x52a10
movq %rax, %rdi
callq 0xb520
leaq 0x27af4(%rip), %rsi     # 0x52e90
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
movq (%r15), %rdi
addq $0x20, %rdi
callq 0xb3e0
movq 0x28(%rbx), %rax
leaq -0x1(%rax), %rcx
movq %rcx, 0x28(%rbx)
cmpq $0x1, %rax
jle 0x2b3d7
popq %rbx
popq %r14
popq %r15
retq
decq %rax
movq %rax, 0x28(%rbx)
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x2b3e8
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x28(%rbx)
je 0x2b425
movq 0x18(%rbx), %rax
movq 0x58(%rax), %rax
movq 0x20(%rax), %rsi
movq %rbx, %rdi
callq 0x2b3e8
jmp 0x2b408
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x46cba
testb %al, %al
jne 0x2be39
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4742c
testb %al, %al
jne 0x2be39
movq %r14, %rdi
movq %rbx, %rsi
callq 0x47ce0
testb %al, %al
jne 0x2be39
movq %r14, %rdi
movq %rbx, %rsi
callq 0x486e4
testb %al, %al
jne 0x2be39
movq %r14, %rdi
movq %rbx, %rsi
callq 0x486e4
testb %al, %al
je 0x2be43
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 0x486e4
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x265b9(%rip), %rsi     # 0x52a6b
movq %r12, %rdi
callq 0x19be0
testb %al, %al
je 0x2c554
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x2c4e7
addq $0xb8, %rbx
movq (%r14), %rdi
pushq $0x2
popq %rsi
movq %rbx, %rdx
callq *%rax
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x2c548
leaq 0x49092(%rip), %rbx     # 0x75580
movq (%rbx), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x2c546
addq $0x20, %rdi
callq 0xb800
movq (%rbx), %rax
movq 0x18(%rax), %rdi
leaq 0x24f79(%rip), %rsi     # 0x51488
callq 0xb520
leaq 0x2655a(%rip), %rsi     # 0x52a75
movq %rax, %rdi
callq 0xb520
leaq 0x2655c(%rip), %rsi     # 0x52a86
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
movq (%rbx), %rdi
addq $0x20, %rdi
callq 0xb3e0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
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 0x48786