LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_output_streamdup_create(_scdc_dataset_inout_t*, char const*, _scdc_args_t*)
static scdc_dataset_output_t *scdc_dataset_output_streamdup_create(scdc_dataset_output_t *output, const char *conf, scdc_args_t *args)
{
  scdc_args xargs(args);

  FILE *stream = 0;
  xargs.get<FILE *>(SCDC_ARGS_TYPE_OUT_STREAM, &stream);

  if (!stream) stream = stdout;

  if (!output) return 0;

  scdcint_t pos = ftello(stream);

  /* we use a duplicated fd, because using only a newly opened stream (with fdopen) leads to empty reads if the original stream is closed */
  int fddup = dup(fileno(stream));
  stream = fdopen(fddup, "r+");  /* try opening an existing file */
  if (!stream) stream = fdopen(fddup, "w");  /* create a new file is necessary */

  if (!stream) return 0;

  if (pos >= 0) fseeko(stream, pos, SEEK_SET);

  output = scdc_dataset_output_FX_create<FILE *>(output, conf, args, stream);

  if (!output) return 0;

  output->intern->type = SCDC_DATASET_INOUT_TYPE_STREAM;
  output->intern->destroy = scdc_dataset_output_streamdup_destroy;

  return output;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x30(%rsp), %rax
movq %rax, 0x8(%rax)
movq %rax, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x10(%rax)
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movaps %xmm0, -0x20(%rax)
movaps %xmm1, -0x10(%rax)
movq %rcx, 0x8(%rsp)
movq -0x18(%rax), %rax
testq %rax, %rax
je 0x2d349
movq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movl $0x7, %esi
callq *%rax
cmpq $0x0, 0x8(%rsp)
jne 0x2d360
movq 0x5ec48(%rip), %rax     # 0x8bfa0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
testq %r15, %r15
je 0x2d401
movq 0x8(%rsp), %rdi
callq 0xb680
movq %rax, %r12
movq 0x8(%rsp), %rdi
callq 0xb560
movl %eax, %edi
callq 0xb830
movl %eax, %ebp
leaq 0x3e302(%rip), %rsi     # 0x6b692
movl %eax, %edi
callq 0xb570
movq %rax, 0x8(%rsp)
testq %rax, %rax
jne 0x2d3b4
leaq 0x3e2ed(%rip), %rsi     # 0x6b695
movl %ebp, %edi
callq 0xb570
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2d401
testq %r12, %r12
js 0x2d3cd
movq %r12, %rsi
xorl %edx, %edx
callq 0xb2e0
movq 0x8(%rsp), %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x30afd
movq %rax, %rbx
testq %rax, %rax
je 0x2d401
movq 0x48(%rbx), %rax
movq $0x6, 0x8(%rax)
leaq 0x40cb(%rip), %rcx      # 0x314c6
movq %rcx, 0x20(%rax)
jmp 0x2d403
xorl %ebx, %ebx
leaq 0x10(%rsp), %rdi
callq 0x1b820
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2d41f
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1b820
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_output_file_create(_scdc_dataset_inout_t*, char const*, _scdc_args_t*)
static scdc_dataset_output_t *scdc_dataset_output_file_create(scdc_dataset_output_t *output, const char *conf, scdc_args_t *args)
{
  scdc_args xargs(args);

  const char *filename;
  xargs.get<const char *>(SCDC_ARGS_TYPE_CSTR, &filename);

  SCDC_TRACE("scdc_dataset_output_file_create: filename: '" << filename << "'");

  if (!output) return 0;

  FILE *file = fopen(filename, (z_fs_exists(filename))?"r+":"w");

  if (!file)
  {
    SCDC_TRACE("scdc_dataset_output_file_create: file '" << filename << "' failed!");
    return 0;
  }

  output = scdc_dataset_output_FX_create<FILE *>(output, conf, args, file);

  if (!output)
  {
    fclose(file);
    return 0;
  }

  output->intern->type = SCDC_DATASET_INOUT_TYPE_FILE;
  output->intern->destroy = scdc_dataset_output_file_destroy;

  return output;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x30(%rsp), %rax
movq %rax, 0x8(%rax)
movq %rax, (%rax)
movq $0x0, 0x10(%rax)
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movaps %xmm0, -0x20(%rax)
movaps %xmm1, -0x10(%rax)
movq -0x18(%rax), %rax
testq %rax, %rax
je 0x2d485
movq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movl $0x4, %esi
callq *%rax
testq %r15, %r15
je 0x2d4f6
movq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x35ab0
testq %rax, %rax
leaq 0x3e1f4(%rip), %rax     # 0x6b695
leaq 0x3e1ea(%rip), %rsi     # 0x6b692
cmoveq %rax, %rsi
movq %r12, %rdi
callq 0xb640
testq %rax, %rax
je 0x2d4f6
movq %rax, %r12
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x30afd
movq %rax, %rbx
testq %rax, %rax
je 0x2d4ee
movq 0x48(%rbx), %rax
movq $0x8, 0x8(%rax)
leaq 0x402a(%rip), %rcx      # 0x31512
movq %rcx, 0x20(%rax)
jmp 0x2d4f8
movq %r12, %rdi
callq 0xb4f0
xorl %ebx, %ebx
leaq 0x10(%rsp), %rdi
callq 0x1b820
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x2d513
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1b820
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_output_create
scdc_dataset_output_t *scdc_dataset_output_create(scdc_dataset_output_t *output, const char *conf, ...)
{
  va_list ap;
  va_start(ap, conf);

  scdc_args_t args;

  scdc_args_va_init(&args, &ap);

  output = scdc_dataset_output_create_intern(output, conf, &args);

  scdc_args_va_release(&args);
  va_end(ap);

  return output;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x40(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x2d73d
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, %r12
movq %rsi, 0x10(%r12)
leaq 0x120(%rsp), %rax
movq %rax, 0x8(%r12)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%r12)
movl $0x10, %edi
callq 0xb500
movq %rax, %r15
movq $0x0, (%rax)
movq %r12, 0x8(%rax)
leaq 0x20(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x2808(%rip), %rax      # 0x2ff8f
movq %rax, 0x8(%rdx)
leaq 0x292e(%rip), %rax      # 0x300c0
movq %rax, 0x10(%rdx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2ca44
movq %rax, %rbx
movl $0x10, %esi
movq %r15, %rdi
callq 0xb510
movq %rbx, %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2d7ff
movq 0x48(%rdi), %rax
testq %rax, %rax
je 0x2d89a
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rdi)
movq 0x18(%rax), %rcx
movq %rcx, 0x40(%rdi)
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x2d89a
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
leaq 0x5ed6a(%rip), %r14     # 0x8c570
movq (%r14), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x2d89a
addq $0x20, %rdi
callq 0xb7d0
movq (%r14), %rax
movq 0x8(%rax), %rbx
leaq 0x3c95d(%rip), %rsi     # 0x6a188
movl $0xb, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x3d866(%rip), %rsi     # 0x6b0a5
movl $0xf, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x3d8c5(%rip), %rsi     # 0x6b118
movl $0x2c, %edx
movq %rbx, %rdi
callq 0xb5f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq (%r14), %rdi
addq $0x20, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb3b0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2d963
pushq %r14
pushq %rbx
pushq %rax
leaq 0x5eca0(%rip), %r14     # 0x8c570
movq (%r14), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x2d959
addq $0x20, %rdi
callq 0xb7d0
movq (%r14), %rax
movq 0x8(%rax), %rbx
leaq 0x3c897(%rip), %rsi     # 0x6a188
movl $0xb, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x3d7a0(%rip), %rsi     # 0x6b0a5
movl $0xf, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x3d82c(%rip), %rsi     # 0x6b145
movl $0x32, %edx
movq %rbx, %rdi
callq 0xb5f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq (%r14), %rdi
addq $0x20, %rdi
callq 0xb3b0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_input_redirect
scdcint_t scdc_dataset_input_redirect(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);

  scdcint_t ret = scdc_dataset_input_redirect_intern(input, conf, &args);

  scdc_args_va_release(&args);
  va_end(ap);

  return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xf0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x40(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x2e27b
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, %r15
movq %rsi, 0x10(%r15)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%r15)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%r15)
movl $0x10, %edi
callq 0xb500
movq $0x0, (%rax)
movq %r15, 0x8(%rax)
leaq 0x20(%rsp), %r15
movq %rax, (%r15)
leaq 0x1cd0(%rip), %rax      # 0x2ff8f
movq %rax, 0x8(%r15)
leaq 0x1df6(%rip), %rax      # 0x300c0
movq %rax, 0x10(%r15)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2d8bc
movq %rax, %rbx
movq (%r15), %rdi
testq %rdi, %rdi
je 0x2e2f1
movl $0x10, %esi
callq 0xb510
movq %rbx, %rax
addq $0xf0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2d963
pushq %r14
pushq %rbx
pushq %rax
leaq 0x5e25b(%rip), %r14     # 0x8c570
movq (%r14), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x2e39e
addq $0x20, %rdi
callq 0xb7d0
movq (%r14), %rax
movq 0x8(%rax), %rbx
leaq 0x3be52(%rip), %rsi     # 0x6a188
movl $0xb, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x3cd5b(%rip), %rsi     # 0x6b0a5
movl $0xf, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x3ce1a(%rip), %rsi     # 0x6b178
movl $0x34, %edx
movq %rbx, %rdi
callq 0xb5f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq (%r14), %rdi
addq $0x20, %rdi
callq 0xb3b0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_output_redirect
scdcint_t scdc_dataset_output_redirect(scdc_dataset_output_t *output, const char *conf, ...)
{
  va_list ap;
  va_start(ap, conf);

  scdc_args_t args;

  scdc_args_va_init(&args, &ap);

  scdcint_t ret = scdc_dataset_output_redirect_intern(output, conf, &args);

  scdc_args_va_release(&args);
  va_end(ap);

  return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xf0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x40(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x2e410
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, %r15
movq %rsi, 0x10(%r15)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%r15)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%r15)
movl $0x10, %edi
callq 0xb500
movq $0x0, (%rax)
movq %r15, 0x8(%rax)
leaq 0x20(%rsp), %r15
movq %rax, (%r15)
leaq 0x1b3b(%rip), %rax      # 0x2ff8f
movq %rax, 0x8(%r15)
leaq 0x1c61(%rip), %rax      # 0x300c0
movq %rax, 0x10(%r15)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2e301
movq %rax, %rbx
movq (%r15), %rdi
testq %rdi, %rdi
je 0x2e486
movl $0x10, %esi
callq 0xb510
movq %rbx, %rax
addq $0xf0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1b8f2
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 0x1bc30
leaq 0x3d08e(%rip), %rsi     # 0x6b597
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xb110
movl %eax, %ebp
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2e532
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
testl %ebp, %ebp
jne 0x2e579
movq 0x78(%rsp), %rax
testq %rax, %rax
je 0x2e54f
movq 0x70(%rsp), %rdi
movq %rsp, %rdx
movl $0x2, %esi
callq *%rax
leaq 0x50(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1b92c
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2e579
movq 0x60(%rsp), %rsi
incq %rsi
callq 0xb510
movq (%rsp), %rsi
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2e611
testb %al, %al
je 0x2e5a8
movq 0x48(%rbx), %rax
movq $0x2, 0x8(%rax)
leaq 0xe7(%rip), %rcx        # 0x2e688
movq %rcx, 0x20(%rax)
movq %rbx, %r14
leaq 0x70(%rsp), %rdi
callq 0x1b820
leaq 0x28(%rsp), %rdi
callq 0x1bb7e
movq %r14, %rax
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2e5cf
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x1b820
leaq 0x28(%rsp), %rdi
callq 0x1bb7e
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O1/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:
testq %rdi, %rdi
je 0x2e637
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
cmpq $0x0, 0x48(%rdi)
je 0x2e63c
movb $0x1, %cl
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2e639
xorl %ecx, %ecx
movl %ecx, %eax
retq
movq %rdx, %r15
movq %rsi, %rbx
leaq (%rsi,%rdx), %r12
addq $0x28, %r12
movl $0x1, %esi
movq %r12, %rdi
callq 0xb320
testq %rax, %rax
setne %cl
je 0x2e62a
movq %rax, %rcx
movq %rax, 0x48(%r14)
addq $0x28, %rax
movq %r12, (%rcx)
testq %r15, %r15
jle 0x2e679
movq %rax, 0x40(%r14)
addq %r15, %rax
testq %rbx, %rbx
jle 0x2e628
movq %rax, 0x10(%r14)
movq %rbx, 0x18(%r14)
jmp 0x2e628
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2f940
addq %rax, 0x28(%rbx)
movq (%r14), %rdi
callq 0xb880
testl %eax, %eax
je 0x2f95a
movb $0x78, 0x30(%rbx)
movq $0x0, 0x38(%rbx)
jmp 0x2f961
cmpq $0x0, 0x10(%r14)
je 0x2f94c
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2f03a
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_O1/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 0x2f9b9
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_O1/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_input_file_destroy(_scdc_dataset_inout_t*)
static void scdc_dataset_input_file_destroy(scdc_dataset_input_t *input)
{
  if (!input) return;

  FILE *file;

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

  fclose(file);
}

// Assembly:
testq %rdi, %rdi
je 0x2f9f4
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 0xb4f0
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2fbff
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
movq 0x8(%rdi), %rax
cmpq $0xc, %rax
je 0x2fbe4
cmpq $0xb, %rax
je 0x2fbe4
cmpq $0xa, %rax
jne 0x2fbff
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 0x2fbf8
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_O1/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 0xb2d0
movq 0x20(%rbx), %rax
subq %rax, (%r14)
jg 0x2feec
movq $0x0, 0x38(%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq (%rdi), %rax
movq %rax, 0x38(%rbx)
movq 0x8(%rdi), %rax
movq %rax, 0x40(%rbx)
movl $0x10, %esi
callq 0xb510
movq 0x38(%rbx), %rax
testq %rax, %rax
je 0x2ff63
movq %rbx, %rdi
xorl %esi, %esi
callq *%rax
movq %rax, %r14
movl $0x10, %edi
callq 0xb500
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movq 0x38(%rbx), %rcx
movq %rcx, (%rax)
movq 0x40(%rbx), %rcx
movq %rcx, 0x8(%rax)
leaq -0x5d(%rip), %rcx       # 0x2fef9
movq %rcx, 0x38(%rbx)
movq %rax, 0x40(%rbx)
movq %r14, %rax
jmp 0x2ff87
movq 0x48(%rbx), %rax
testq %rax, %rax
je 0x2ff7a
movq 0x20(%rax), %rax
testq %rax, %rax
je 0x2ff7a
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_O1/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: long long output_FX_next<_IO_FILE*>(_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 0x10(%rdi), %rdi
movq 0x20(%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 0xba90
subq %rax, 0x10(%r14)
movq %rax, 0x20(%rbx)
jne 0x314b9
movq $0x0, 0x38(%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_output_fs_destroy(_scdc_dataset_inout_t*)
static void scdc_dataset_output_fs_destroy(scdc_dataset_output_t *output)
{
  if (!output) return;

  FILE *ptar;

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

  pclose(ptar);
}

// Assembly:
testq %rdi, %rdi
je 0x31587
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_O1/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 0x31643
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 0x3168a
addq $0xd8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xe96(%rip), %rax       # 0x3256d
movq %rax, 0x8(%rdx)
leaq 0xf31(%rip), %rax       # 0x32613
movq %rax, 0x10(%rdx)
leaq 0xf29(%rip), %rax       # 0x32616
movq %rax, 0x18(%rdx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x31806
movl %eax, %ebp
movl $0x10, %esi
movq %r15, %rdi
callq 0xb510
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x31718
callq 0xb340
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x31726
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rdi
movq %rax, (%rbx)
testq %rdi, %rdi
je 0x3173b
callq 0xb340
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x3174a
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_O1/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 0x32198
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
callq 0x321d0
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %rax, 0x18(%rbx)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x31792
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x317a8
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x10(%rbx)
popq %rbx
retq
movq %rax, %rdi
callq 0x1b8e6
// File: /workspace/github_cpp_makefile_star2_O1/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 0x317e6
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rbx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x317fc
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x32267
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 0x5a2e2(%rip), %rax     # 0x8c570
movq (%rax), %rax
movq 0x8(%rax), %rdi
movq %r10, %rsi
xorl %ecx, %ecx
callq 0x322a7
addq $0xd8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x32374
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 0x3232b
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 0x3237a
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 0x3237a
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_O1/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 0x323eb
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 0x5a15e(%rip), %rax     # 0x8c570
movq (%rax), %rax
movq 0x8(%rax), %rdi
movq %r10, %rsi
movl $0x1, %ecx
callq 0x322a7
addq $0xd8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3248c
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 0x5a0bd(%rip), %rax     # 0x8c570
movq (%rax), %rax
movq 0x18(%rax), %rdi
movq %r10, %rsi
xorl %ecx, %ecx
callq 0x322a7
addq $0xd8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3259d
cmpq $0x7, %rsi
je 0x3259d
cmpq $0x11, %rsi
jne 0x325cb
movq 0x8(%rdi), %rax
movl (%rax), %esi
cmpq $0x28, %rsi
ja 0x325ce
movq %rsi, %rcx
addq 0x10(%rax), %rcx
addl $0x8, %esi
movl %esi, (%rax)
jmp 0x325da
movq 0x8(%rdi), %rax
movl (%rax), %esi
cmpq $0x28, %rsi
ja 0x325b7
movq %rsi, %rcx
addq 0x10(%rax), %rcx
addl $0x8, %esi
movl %esi, (%rax)
jmp 0x325c3
movq 0x8(%rax), %rcx
leaq 0x8(%rcx), %rsi
movq %rsi, 0x8(%rax)
movq (%rcx), %rax
movq %rax, (%rdx)
jmp 0x3260d
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 0x325fa
movq %rsi, %rcx
addq 0x10(%rax), %rcx
addl $0x8, %esi
movl %esi, (%rax)
jmp 0x32606
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_O1/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
cmpl $-0x1, %esi
je 0x328c8
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rax
callq *0x30(%rax)
movq 0x28(%r14), %rax
movb %bl, (%rax)
incq 0x28(%r14)
jmp 0x328cd
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x28(%rsi)
jle 0x32f8c
leaq 0x596a9(%rip), %r15     # 0x8c570
movq (%r15), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x32f8c
addq $0x20, %rdi
callq 0xb7d0
movq (%r15), %rax
movq 0x18(%rax), %r14
leaq 0x3765d(%rip), %rsi     # 0x6a549
movl $0xd, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x38aa8(%rip), %rsi     # 0x6b9a8
movl $0x15, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x37430(%rip), %rsi     # 0x6a344
movl $0x1, %edx
movq %r14, %rdi
callq 0xb5f0
movq %r14, %rdi
movl $0x47, %esi
callq 0xb9a0
movq %rax, %r14
leaq 0x38a86(%rip), %rsi     # 0x6b9be
movl $0x15, %edx
movq %rax, %rdi
callq 0xb5f0
leaq 0x38f3c(%rip), %rsi     # 0x6be88
movl $0x8, %edx
movq %r14, %rdi
callq 0xb5f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %r14, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq (%r15), %rdi
addq $0x20, %rdi
callq 0xb3b0
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x33b68
leaq 0x8(%rbx), %r12
cmpq %r12, %rax
je 0x32fd6
movq %rax, %r14
leaq 0x40(%rax), %r15
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x33bae
movq 0x68(%r14), %r13
movq %r15, %rdi
movq %rax, %rsi
callq 0x33c2a
movq 0x68(%r14), %rax
cmpq %rax, %r13
jne 0x33090
leaq 0x59593(%rip), %r14     # 0x8c570
movq (%r14), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x330ab
addq $0x20, %rdi
callq 0xb7d0
movq (%r14), %rax
movq 0x8(%rax), %rbx
leaq 0x37186(%rip), %rsi     # 0x6a188
movl $0xb, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x389be(%rip), %rsi     # 0x6b9d4
movl $0xf, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x389ba(%rip), %rsi     # 0x6b9e4
movl $0xf, %edx
movq %rbx, %rdi
callq 0xb5f0
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xb3c0
movq %rax, %rbx
leaq 0x37a03(%rip), %rsi     # 0x6aa51
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 0x330ab
cmpq %r12, %r14
sete %cl
testq %rax, %rax
setne %al
orb %cl, %al
jne 0x330ab
movq %rbx, %rdi
movq %r14, %rsi
callq 0x33cd0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x334ad
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x334bc
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5e1cb
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpq $0x0, 0x28(%rsi)
jg 0x335a4
leaq 0x59094(%rip), %r12     # 0x8c570
movq (%r12), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x335a4
addq $0x20, %rdi
callq 0xb7d0
movq (%r12), %rax
movq 0x18(%rax), %r15
leaq 0x37046(%rip), %rsi     # 0x6a549
movl $0xd, %edx
movq %r15, %rdi
callq 0xb5f0
leaq 0x38491(%rip), %rsi     # 0x6b9a8
movl $0x15, %edx
movq %r15, %rdi
callq 0xb5f0
leaq 0x36e19(%rip), %rsi     # 0x6a344
movl $0x1, %edx
movq %r15, %rdi
callq 0xb5f0
movq %r15, %rdi
movl $0x116, %esi            # imm = 0x116
callq 0xb9a0
movq %rax, %r15
leaq 0x38511(%rip), %rsi     # 0x6ba60
movl $0x14, %edx
movq %rax, %rdi
callq 0xb5f0
leaq 0x38925(%rip), %rsi     # 0x6be88
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
jg 0x335de
movq %r14, %rdi
movq %rbx, %rsi
callq 0x32ea0
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)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3364b
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 0x32ea0
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
cmpq $0x0, 0x28(%rbx)
jne 0x33614
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5c104
testb %al, %al
jne 0x33fd5
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5ca5c
testb %al, %al
jne 0x33fd5
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5d55e
testb %al, %al
jne 0x33fd5
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5e210
testb %al, %al
jne 0x33fd5
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5e210
testb %al, %al
je 0x33fdf
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 0x5e210
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3447c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x344f8
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq (%r14), %rdi
testq %rdi, %rdi
je 0x3433d
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop