LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/test/units/redirect/redirect_common.c
// Function: vector_init
void vector_init(double *v, rdint_t n, rdint_t inc, double xv, double xn)
{
  int i, j;

  for (i = 0; i < n; ++i)
  {
    v[i * inc + 0] = xv;
    if (i + 1 == n) break;
    for (j = 1; j < inc; ++j) v[i * inc + j] = xn;
  }
}

// Assembly:
testq %rsi, %rsi
jle 0xdb55
movsd %xmm0, (%rdi)
cmpq $0x1, %rsi
je 0xdb55
leaq (,%rdx,8), %rax
movl $0x1, %ecx
movq %rdi, %r8
cmpq $0x2, %rdx
jl 0xdb3d
movl $0x1, %r9d
movsd %xmm1, (%r8,%r9,8)
incq %r9
cmpq %r9, %rdx
jne 0xdb2f
movq %rcx, %r9
imulq %rdx, %r9
movsd %xmm0, (%rdi,%r9,8)
incq %rcx
addq %rax, %r8
cmpq %rsi, %rcx
jne 0xdb23
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/test/units/redirect/redirect_test.c
// Function: redirect_test_open
void *redirect_test_open(const char *conf, va_list ap)
{
  TRACE_F("conf: '%s'", conf);

  redirect_call_t *rc = malloc(sizeof(redirect_call_t)
#if REDIRECT_CALL_PARAMS_CACHE
    + sizeof(redirect_cache_t)
#endif
    );

#if REDIRECT_CALL_PARAMS_CACHE
  redirect_cache_t *rch = (redirect_cache_t *) (rc + 1);

  redirect_cache_init(rch);
#endif

  TRACE_F("return: %p", rc);

  return rc;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0x7e436(%rip), %r12     # 0x8bfa0
movq (%r12), %rdi
leaq 0x5b85b(%rip), %rbx     # 0x693d0
leaq 0x5b868(%rip), %r14     # 0x693e4
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0xb7a0
movq (%r12), %rdi
leaq 0x5b863(%rip), %rsi     # 0x693f7
movq %r15, %rdx
xorl %eax, %eax
callq 0xb7a0
movq (%r12), %rsi
movl $0xa, %edi
callq 0xb690
movl $0x1050, %edi           # imm = 0x1050
callq 0xb6f0
movq %rax, %r15
leaq 0xbb0(%rax), %rdi
callq 0xf23a
movq (%r12), %rdi
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0xb7a0
movq (%r12), %rdi
leaq 0x5b821(%rip), %rsi     # 0x69402
movq %r15, %rdx
xorl %eax, %eax
callq 0xb7a0
movq (%r12), %rsi
movl $0xa, %edi
callq 0xb690
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/test/units/redirect/redirect_test.c
// Function: redirect_test_close
scdcint_t redirect_test_close(void *dataprov)
{
  TRACE_F("dataprov: %p", dataprov);

  redirect_call_t *rc = dataprov;

#if REDIRECT_CALL_PARAMS_CACHE
  redirect_cache_t *rch = (redirect_cache_t *) (rc + 1);

  redirect_cache_release(rch);
#endif

  free(rc);

  TRACE_F("return");

  return SCDC_SUCCESS;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq 0x7e386(%rip), %r12     # 0x8bfa0
movq (%r12), %rdi
leaq 0x5b7ab(%rip), %rbx     # 0x693d0
leaq 0x5b7e1(%rip), %r14     # 0x6940d
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0xb7a0
movq (%r12), %rdi
leaq 0x5b7dd(%rip), %rsi     # 0x69421
movq %r15, %rdx
xorl %eax, %eax
callq 0xb7a0
movq (%r12), %rsi
movl $0xa, %edi
callq 0xb690
leaq 0xbb0(%r15), %rdi
callq 0xf29a
movq %r15, %rdi
callq 0xb650
movq (%r12), %rdi
movq %rbx, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0xb7a0
movq (%r12), %rcx
leaq 0x5b7a2(%rip), %rdi     # 0x6942e
movl $0x6, %esi
movl $0x1, %edx
callq 0xba90
movq (%r12), %rsi
movl $0xa, %edi
callq 0xb690
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/lib/redirect/redirect/redirect_cache.cc
// Function: redirect_cache_create
void redirect_cache_create(redirect_cache_t *rch)
{
  TRACE_F(" ");

  rch->client = 1;

  redirect_cache_reset_params(rch);

  rch->nentries = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x7d34a(%rip), %r14     # 0x8bfa0
movq (%r14), %rdi
leaq 0x5a90f(%rip), %rsi     # 0x6956f
leaq 0x5a91d(%rip), %rdx     # 0x69584
xorl %eax, %eax
callq 0xb7a0
movq (%r14), %rsi
movl $0x20, %edi
callq 0xb690
movq (%r14), %rsi
movl $0xa, %edi
callq 0xb690
movl $0x1, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq $0x0, 0x298(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/lib/redirect/redirect/redirect_cache.cc
// Function: redirect_cache_register_param_dense
void redirect_cache_register_param_dense(redirect_cache_t *rch, const char *id, int type, redirect_param_dense_t *param)
{
  TRACE_F("id: %s, type: %d, size: %" rdint_fmt, id, type, param->size);

  if (rch->nparams < REDIRECT_CACHE_PARAMS_MAX)
  {
    rch->params[rch->nparams].type = type;
    rch->params[rch->nparams].size = param->size;
    rch->params[rch->nparams].buf = param->buf;
    rch->params[rch->nparams].hash = 0;

    ++rch->nparams;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movq 0x7d209(%rip), %r12     # 0x8bfa0
movq (%r12), %rdi
leaq 0x5a7cd(%rip), %rsi     # 0x6956f
leaq 0x5a808(%rip), %rdx     # 0x695b1
xorl %eax, %eax
callq 0xb7a0
movq (%r12), %rdi
movq 0x8(%r14), %r8
leaq 0x5a816(%rip), %rsi     # 0x695d5
movq %r15, %rdx
movl %ebp, %ecx
xorl %eax, %eax
callq 0xb7a0
movq (%r12), %rsi
movl $0xa, %edi
callq 0xb690
movq 0x8(%rbx), %rax
cmpq $0xf, %rax
jg 0xee0b
leaq (%rax,%rax,4), %rcx
movl %ebp, 0x18(%rbx,%rcx,8)
movq 0x8(%r14), %rdx
movq %rdx, 0x20(%rbx,%rcx,8)
movq (%r14), %rdx
movq %rdx, 0x28(%rbx,%rcx,8)
movl $0x0, 0x30(%rbx,%rcx,8)
incq %rax
movq %rax, 0x8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/lib/redirect/redirect/redirect_cache.cc
// Function: redirect_cache_init
void redirect_cache_init(redirect_cache_t *rch)
{
  TRACE_F(" ");

  rch->client = 0;

  redirect_cache_reset_params(rch);

  rch->nentries = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x7cd58(%rip), %r14     # 0x8bfa0
movq (%r14), %rdi
leaq 0x5a31d(%rip), %rsi     # 0x6956f
leaq 0x5a47a(%rip), %rdx     # 0x696d3
xorl %eax, %eax
callq 0xb7a0
movq (%r14), %rsi
movl $0x20, %edi
callq 0xb690
movq (%r14), %rsi
movl $0xa, %edi
callq 0xb690
movl $0x0, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq $0x0, 0x298(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/lib/redirect/redirect/redirect_cache.cc
// Function: redirect_cache_find_entries
rdint_t redirect_cache_find_entries(redirect_cache_t *rch, int type, rdint_t size, rdint_t *entries)
{
  rdint_t nentries = 0;

  rdint_t i;
  for (i = 0; i < rch->nentries; ++i)
  {
    if (rch->entries[i].type != type || rch->entries[i].size != size) continue;

    entries[nentries] = i;
    ++nentries;

    if (nentries >= REDIRECT_CACHE_FIND_ENTRIES_MAX) break;
  }
  
  return nentries;
}

// Assembly:
cmpq $0x0, 0x298(%rdi)
jle 0xf5ed
leaq 0x2a8(%rdi), %r8
xorl %r9d, %r9d
xorl %eax, %eax
cmpl %esi, -0x8(%r8)
jne 0xf5dc
cmpq %rdx, (%r8)
jne 0xf5dc
movq %r9, (%rcx,%rax,8)
leaq 0x1(%rax), %r10
cmpq $0xe, %rax
movq %r10, %rax
jg 0xf5ec
incq %r9
addq $0x20, %r8
cmpq 0x298(%rdi), %r9
jl 0xf5c0
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/lib/redirect/redirect/redirect_cache.cc
// Function: redirect_cache_get_entry_hash
redirect_param_hash_t redirect_cache_get_entry_hash(redirect_cache_t *rch, rdint_t entry)
{
  if (!rch->entries[entry].hash_set)
  {
    redirect_param_dense_t p;
    p.buf = rch->entries[entry].buf;
    p.size = rch->entries[entry].size;
    rch->entries[entry].hash = redirect_param_hash_dense(&p);
    rch->entries[entry].hash_set = 1;
  }

  return rch->entries[entry].hash;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
shlq $0x5, %rsi
leaq (%rdi,%rsi), %rbx
addq $0x2a0, %rbx            # imm = 0x2A0
cmpl $0x0, 0x18(%rbx)
jne 0xf62b
movq 0x10(%rbx), %rax
movq %rsp, %rdi
movq %rax, (%rdi)
movq 0x8(%rbx), %rax
movq %rax, 0x8(%rdi)
callq 0x190d8
movl %eax, 0x1c(%rbx)
movl $0x1, 0x18(%rbx)
movl 0x1c(%rbx), %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/lib/redirect/redirect/redirect_cache.cc
// Function: redirect_cache_check_state
void redirect_cache_check_state(redirect_cache_t *rch, const char *state, rdint_t state_size)
{
  TRACE_F("state: '%.*s'", static_cast<int>(state_size), state);

  const char *s = state;

  rdint_t i;
  for (i = 0; i < rch->nparams; ++i)
  {
    sscanf(s, "%" rdint_fmt ":", &rch->params[i].entry_index);
    s = strchr(s, ':') + 1;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x7c953(%rip), %r12     # 0x8bfa0
movq (%r12), %rdi
leaq 0x59f17(%rip), %rsi     # 0x6956f
leaq 0x5a0ff(%rip), %rdx     # 0x6975e
xorl %eax, %eax
callq 0xb7a0
movq (%r12), %rdi
leaq 0x5a054(%rip), %rsi     # 0x696c5
movl %r15d, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0xb7a0
movq (%r12), %rsi
movl $0xa, %edi
callq 0xb690
cmpq $0x0, 0x8(%rbx)
jle 0xf6d1
leaq 0x38(%rbx), %r15
leaq 0x59f84(%rip), %r12     # 0x69622
xorl %r13d, %r13d
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0xb4e0
movq %r14, %rdi
movl $0x3a, %esi
callq 0xb1e0
movq %rax, %r14
incq %r14
incq %r13
addq $0x28, %r15
cmpq 0x8(%rbx), %r13
jl 0xf6a1
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/lib/redirect/redirect/redirect_cache.cc
// Function: redirect_cache_put_entry
rdint_t redirect_cache_put_entry(redirect_cache_t *rch, int type, rdint_t size, const void *buf)
{
  rdint_t entry_index = redirect_cache_find_entry(rch, type, size, buf);

  if (entry_index >= 0)
  {
    TRACE_F("entry [%d,%" rdint_fmt ",%p] / %" rdint_fmt " already in cache", type, size, buf, entry_index);
    redirect_cache_update_entry(rch, entry_index);
    return entry_index;
  }

  if (rch->nentries >= REDIRECT_CACHE_ENTRIES_MAX)
  {
    TRACE_F("max. number of entries %" rdint_fmt " in cache", rch->nentries);
    // FIXME: cache replacement strategy: FIFO, LRU, LFU
    return -1;
  }

  entry_index = rch->nentries;

  rch->entries[entry_index].type = type;
  rch->entries[entry_index].size = size;
  rch->entries[entry_index].buf = const_cast<void *>(buf);
  rch->entries[entry_index].hash_set = 0;

  ++rch->nentries;

  return entry_index;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r12
movq 0x298(%rdi), %rax
movq $-0x1, %rbx
testq %rax, %rax
jle 0xf72f
leaq 0x2b0(%r12), %rdx
xorl %ecx, %ecx
cmpl %ebp, -0x10(%rdx)
jne 0xf71e
cmpq %r15, -0x8(%rdx)
jne 0xf71e
cmpq %r14, (%rdx)
je 0xf72c
incq %rcx
addq $0x20, %rdx
cmpq %rcx, %rax
jne 0xf70e
jmp 0xf72f
movq %rcx, %rbx
leaq 0x2a0(%r12), %r13
testq %rbx, %rbx
js 0xf79c
movq 0x7c85d(%rip), %r12     # 0x8bfa0
movq (%r12), %rdi
leaq 0x59e21(%rip), %rsi     # 0x6956f
leaq 0x5a024(%rip), %rdx     # 0x69779
xorl %eax, %eax
callq 0xb7a0
movq (%r12), %rdi
leaq 0x5a02b(%rip), %rsi     # 0x69792
movl %ebp, %edx
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
xorl %eax, %eax
callq 0xb7a0
movq (%r12), %rsi
movl $0xa, %edi
callq 0xb690
movq %rbx, %rax
shlq $0x5, %rax
movl $0x0, 0x18(%r13,%rax)
jmp 0xf81e
cmpq $0x10, %rax
jl 0xf7f0
movq 0x7c7f7(%rip), %rbx     # 0x8bfa0
movq (%rbx), %rdi
leaq 0x59dbc(%rip), %rsi     # 0x6956f
leaq 0x59fbf(%rip), %rdx     # 0x69779
xorl %eax, %eax
callq 0xb7a0
movq (%rbx), %rdi
movq 0x298(%r12), %rdx
leaq 0x59fe8(%rip), %rsi     # 0x697bb
xorl %eax, %eax
callq 0xb7a0
movq (%rbx), %rsi
movl $0xa, %edi
callq 0xb690
movq $-0x1, %rbx
jmp 0xf81e
movq %rax, %rcx
shlq $0x5, %rcx
movl %ebp, (%r13,%rcx)
movq %r15, 0x8(%r13,%rcx)
movq %r14, 0x10(%r13,%rcx)
movl $0x0, 0x18(%r13,%rcx)
leaq 0x1(%rax), %rcx
movq %rcx, 0x298(%r12)
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/lib/redirect/redirect/redirect_call.cc
// Function: redirect_call_create_scdc
int redirect_call_create_scdc(redirect_call_t *rc, const char *op, const char *uri)
{
  rc->client = 1;

  strncpy(rc->op, op, sizeof(rc->op));
  if (uri) strncpy(rc->uri, uri, sizeof(rc->uri));
  else rc->uri[0] = '\0';

  rc->dataset = SCDC_DATASET_NULL;

  rc->input_conf_n = 0;
  rc->input_conf[0] = '\0';

  rc->output_conf_put_n = rc->output_conf_get_n = 0;
  rc->output_conf_put[0] = rc->output_conf_get[0] = '\0';

  rc->result_str[0] = '\0';

#if REDIRECT_CALL_PARAMS_NEW
  rc->nparams = 0;
#else
  rc->dense_nparams = 0;
#endif

  rc->input_offset = rc->output_offset = 0;
  rc->input = static_cast<scdc_dataset_input_t *>(malloc(sizeof(scdc_dataset_input_t) + sizeof(scdc_dataset_output_t)));
  rc->output = rc->input + 1;
  scdc_dataset_input_unset(rc->input);
  scdc_dataset_output_unset(rc->output);

  rc->free_nbufs = 0;

#if REDIRECT_CALL_PARAMS_CACHE
  rc->cache = 0;
#endif

  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movl $0x1, (%rdi)
addq $0x4, %rdi
movl $0x40, %edx
callq 0xb2a0
leaq 0x44(%rbx), %rdi
testq %r14, %r14
je 0xf922
movl $0x100, %edx            # imm = 0x100
movq %r14, %rsi
callq 0xb2a0
jmp 0xf925
movb $0x0, (%rdi)
xorl %r14d, %r14d
movb %r14b, 0x568(%rbx)
movb %r14b, 0x368(%rbx)
movb %r14b, 0x768(%rbx)
movq %r14, 0x868(%rbx)
movq %r14, 0xb00(%rbx)
movl $0xb0, %edi
callq 0xb6f0
xorps %xmm0, %xmm0
movups %xmm0, 0x148(%rbx)
movups %xmm0, 0x158(%rbx)
movb %r14b, 0x168(%rbx)
movq %rax, 0xb08(%rbx)
leaq 0x58(%rax), %rcx
movq %rcx, 0xb10(%rbx)
movq %rax, %rdi
callq 0x2b07c
movq 0xb10(%rbx), %rdi
callq 0x2b09c
movl $0x0, 0xb20(%rbx)
movq %r14, 0xba8(%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/lib/redirect/redirect/redirect_call.cc
// Function: redirect_call_free_bufs(_redirect_call_t*)
static void redirect_call_free_bufs(redirect_call_t *rc)
{
#if 1
  while (rc->free_nbufs > 0) redirect_call_free_buf(rc, rc->free_nbufs - 1);
#else
  rdint_t i;
  for (i = 0; i < rc->free_nbufs; ++i) free(rc->free_bufs[i]);
  rc->free_nbufs = 0;
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl 0xb20(%rdi), %r14d
testl %r14d, %r14d
jle 0xfa3a
movq %rdi, %rbx
leal -0x1(%r14), %r15d
movq 0xb28(%rbx,%r15,8), %rdi
callq 0xb650
movslq 0xb20(%rbx), %rax
leal -0x1(%rax), %ecx
movl %ecx, 0xb20(%rbx)
cmpl %r14d, %eax
je 0xfa2e
movq 0xb20(%rbx,%rax,8), %rax
movq %rax, 0xb28(%rbx,%r15,8)
movl 0xb20(%rbx), %r14d
testl %r14d, %r14d
jg 0xf9f8
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/lib/redirect/redirect/redirect_call.cc
// Function: redirect_call_get_inout_conf_str(char const*, char const*, char*, long*)
static rdint_t redirect_call_get_inout_conf_str(const char *conf, const char *id, char *x, rdint_t *n)
{
  rdint_t _n = 0;

  if (!n) n = &_n;

  const char *s = strchr(conf, ':');
  sscanf(s + 1, "%" rdint_fmt ":", n);

  s = strchr(s + 1, ':');
  strncpy(x, s + 1, *n);
  x[*n] = '\0';

  return s + 1 + *n + 1 - conf;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %rax
movq $0x0, (%rax)
testq %rdx, %rdx
cmoveq %rax, %r14
movl $0x3a, %esi
callq 0xb1e0
leaq 0x1(%rax), %r12
leaq 0x595cc(%rip), %rsi     # 0x69622
movq %r12, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0xb4e0
movq %r12, %rdi
movl $0x3a, %esi
callq 0xb1e0
movq %rax, %r12
incq %r12
movq (%r14), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0xb2a0
movq (%r14), %rax
movb $0x0, (%r15,%rax)
addq (%r14), %r12
subq %rbx, %r12
incq %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/lib/redirect/redirect/redirect_call.cc
// Function: redirect_call_release_scdc
void redirect_call_release_scdc(redirect_call_t *rc)
{
  if (rc->input)
  {
    /* consume remaining input */
    while (rc->input->next) rc->input->next(rc->input, 0);
  }

  if (rc->result)
  {
    /* prepare result with result_str and output_conf_put */
    char *s = SCDC_RESULT_STR(rc->result);
    rdint_t n = 0;
    n += redirect_call_put_inout_conf_str(s + n, "result", rc->result_str, -1);
    n += redirect_call_put_inout_conf_str(s + n, "oconf", rc->output_conf_put, rc->output_conf_put_n);

    ASSERT(n < SCDC_RESULT_SIZE(rc->result));
  }

  if (rc->output)
  {
    /* prepare parameter output */
    rc->output->next = release_scdc_output_next;
    rc->output->data = rc;
#if REDIRECT_CALL_PARAMS_NEW
    rc->params_state[0] = rc->params_state[1] = 0;
#else
    rc->output_state = 0;
#endif

    /* set first paramter to output */
    rc->output->next(rc->output, 0);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0xb08(%rdi)
je 0x102ba
movq 0xb08(%rbx), %rdi
movq 0x38(%rdi), %rax
testq %rax, %rax
je 0x102ba
xorl %esi, %esi
callq *%rax
jmp 0x102a4
movq 0xb18(%rbx), %r12
testq %r12, %r12
je 0x1032f
leaq 0x8(%r12), %r14
leaq 0x768(%rbx), %r15
movq %r15, %rdi
callq 0xb200
leaq 0x595e2(%rip), %rsi     # 0x698c3
leaq 0x5c2a8(%rip), %rdx     # 0x6c590
movq %r14, %rdi
movq %rax, %rcx
movl %eax, %r8d
movq %r15, %r9
xorl %eax, %eax
callq 0xb0d0
movslq %eax, %r14
leaq (%r12,%r14), %rdi
addq $0x8, %rdi
leaq 0x368(%rbx), %rdx
movq 0x158(%rbx), %rcx
leaq 0x59537(%rip), %rsi     # 0x69852
callq 0xfd2a
addq %r14, %rax
movq 0xb18(%rbx), %rcx
cmpq (%rcx), %rax
jge 0x1036d
movq 0xb10(%rbx), %rdi
testq %rdi, %rdi
je 0x10361
leaq 0x32(%rip), %rax        # 0x10374
movq %rax, 0x38(%rdi)
movq %rbx, 0x40(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x870(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x10374
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0xbaec
jmp 0x1032f
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/lib/redirect/redirect/redirect_call.cc
// Function: redirect_call_cmd
int redirect_call_cmd(redirect_call_t *rc, const char *cmd, const char *params, scdc_dataset_input_t *input, scdc_dataset_output_t *output, scdc_result_t *result)
{
  TRACE_F("cmd: '%s', params: '%s', input: %p, output: %p, result: %p", cmd, params, input, output, result);

#if REDIRECT_CALL_PARAMS_CACHE
  if (redirect_cache_check_cmd(rc->cache, cmd, params, result)) return 0;
#endif

  rdint_t n = 0;
#if REDIRECT_CALL_PARAMS_CACHE
  char cache_state[REDIRECT_CALL_CACHE_STATE_MAX_SIZE] = { '\0' };
  rdint_t cache_state_size = 0;
  n += redirect_call_get_inout_conf_str(params + n, "cstate", cache_state, &cache_state_size);
  if (rc->cache) redirect_cache_check_state(rc->cache, cache_state, cache_state_size);
#endif
  rc->input_conf_n = 0;
  n += redirect_call_get_inout_conf_str(params + n, "iconf", rc->input_conf, 0);
  rc->output_conf_get_n = 0;
  n += redirect_call_get_inout_conf_str(params + n, "oconf", rc->output_conf_get, 0);

  rc->input = input;
  rc->output = output;
  rc->result = result;

  return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movq %r9, %rbx
movq %r8, %rbp
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, 0x20(%rsp)
movq 0x7ba4f(%rip), %r12     # 0x8bfa0
movq (%r12), %rdi
leaq 0x592ad(%rip), %rsi     # 0x69809
leaq 0x5933f(%rip), %rdx     # 0x698a2
xorl %eax, %eax
callq 0xb7a0
movq (%r12), %rdi
movq %rbx, (%rsp)
leaq 0x58ef1(%rip), %rsi     # 0x6946a
movq %r14, %rdx
movq %r13, %rcx
movq %r15, 0x10(%rsp)
movq %r15, %r8
movq %rbp, 0x18(%rsp)
movq %rbp, %r9
xorl %eax, %eax
callq 0xb7a0
movq (%r12), %rsi
movq 0x20(%rsp), %r12
movl $0xa, %edi
callq 0xb690
movq 0xba8(%r12), %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0xf2e9
testl %eax, %eax
movl $0x0, %eax
jne 0x10684
movq 0x10(%rsp), %rbp
movq %rbx, 0x8(%rsp)
movq 0x18(%rsp), %rbx
leaq 0x30(%rsp), %r14
movl $0x100, %edx            # imm = 0x100
movq %r14, %rdi
xorl %esi, %esi
callq 0xb2d0
leaq 0x28(%rsp), %rdx
movq $0x0, (%rdx)
movq %r13, %rdi
movq %r14, %rsi
callq 0x1001f
movq %rax, %r14
movq 0xba8(%r12), %rdi
testq %rdi, %rdi
je 0x10625
movq 0x28(%rsp), %rdx
leaq 0x30(%rsp), %rsi
callq 0xf634
xorl %r15d, %r15d
movq %r15, 0x150(%r12)
addq %r14, %r13
leaq 0x168(%r12), %rsi
movq %r13, %rdi
xorl %edx, %edx
callq 0x1001f
movq %r15, 0x160(%r12)
addq %rax, %r13
leaq 0x568(%r12), %rsi
movq %r13, %rdi
xorl %edx, %edx
callq 0x1001f
movq %rbp, 0xb08(%r12)
movq %rbx, 0xb10(%r12)
movq 0x8(%rsp), %rax
movq %rax, 0xb18(%r12)
movl $0x1, %eax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/lib/redirect/redirect/redirect_call.cc
// Function: redirect_call_set_handle
void redirect_call_set_handle(redirect_call_t *rc, redirect_handle_t *rh)
{
  if (rc->client)
  {
    rc->dataset = rh->dataset;
    redirect_call_put_input_conf_str(rc, "hdl_id", rh->id, -1);
    redirect_call_put_input_conf_void_p(rc, "hdl_ptr", rh->ptr);

  } else
  {
    redirect_call_put_output_conf_str(rc, "hdl_id", rh->id, -1);
    redirect_call_put_output_conf_void_p(rc, "hdl_ptr", rh->ptr);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, (%rdi)
je 0x108c8
movq 0x208(%r14), %rax
movq %rax, 0x148(%rbx)
leaq 0x4(%r14), %r15
movq 0x150(%rbx), %rax
leaq (%rbx,%rax), %r12
addq $0x168, %r12            # imm = 0x168
movq %r15, %rdi
callq 0xb200
leaq 0x5903f(%rip), %rsi     # 0x698c3
leaq 0x59029(%rip), %rdx     # 0x698b4
movq %r12, %rdi
movq %rax, %rcx
movl %eax, %r8d
movq %r15, %r9
xorl %eax, %eax
callq 0xb0d0
cltq
addq %rax, 0x150(%rbx)
movq 0x210(%r14), %rdx
leaq 0x59006(%rip), %rsi     # 0x698bb
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x10931
leaq 0x4(%r14), %r15
movq 0x158(%rbx), %rax
leaq (%rbx,%rax), %r12
addq $0x368, %r12            # imm = 0x368
movq %r15, %rdi
callq 0xb200
leaq 0x58fd6(%rip), %rsi     # 0x698c3
leaq 0x58fc0(%rip), %rdx     # 0x698b4
movq %r12, %rdi
movq %rax, %rcx
movl %eax, %r8d
movq %r15, %r9
xorl %eax, %eax
callq 0xb0d0
cltq
addq %rax, 0x158(%rbx)
movq 0x210(%r14), %rdx
leaq 0x58f9d(%rip), %rsi     # 0x698bb
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x10991
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/lib/redirect/redirect/redirect_call.cc
// Function: redirect_call_get_handle
void redirect_call_get_handle(redirect_call_t *rc, redirect_handle_t *rh)
{
  rh->client = rc->client;

  char *rh_id_ptr = rh->id;

  if (rc->client)
  {
    rh->dataset = rc->dataset;
    redirect_call_get_output_conf_str(rc, "hdl_id", rh_id_ptr, 0);
    redirect_call_get_output_conf_void_p(rc, "hdl_ptr", &rh->ptr);

  } else
  {
    redirect_call_get_input_conf_str(rc, "hdl_id", rh_id_ptr, 0);
    redirect_call_get_input_conf_void_p(rc, "hdl_ptr", &rh->ptr);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdi), %eax
movl %eax, (%rsi)
testl %eax, %eax
je 0x10a23
movq 0x148(%rbx), %rax
movq %rax, 0x208(%r14)
movl $0x160, %r12d           # imm = 0x160
movl $0x568, %r15d           # imm = 0x568
jmp 0x10a2f
movl $0x150, %r12d           # imm = 0x150
movl $0x168, %r15d           # imm = 0x168
leaq 0x4(%r14), %rsi
addq %rbx, %r15
movq (%rbx,%r12), %rdi
addq %r15, %rdi
xorl %edx, %edx
callq 0x1001f
addq (%rbx,%r12), %rax
movq %rax, (%rbx,%r12)
addq $0x210, %r14            # imm = 0x210
addq %rax, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x121f7
addq %rax, (%rbx,%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/lib/redirect/redirect/redirect_call.cc
// Function: void redirect_call_put_input_param_dense_val<char>(_redirect_call_t*, char const*, char const*, long)
static void redirect_call_put_input_param_dense_val(redirect_call_t *rc, const char *id, const T *b, rdint_t n)
{
  TRACE_F("rc: %p, id: '%s', b: %p, n: %" rdint_fmt, rc, id, b, n);

  /* client only */
  ASSERT(rc->client);

  /* register dense input */
  register_param_dense<T>(rc, b, n);

#if REDIRECT_CALL_PARAMS_CACHE
  if (rc->cache) redirect_cache_register_param_dense(rc->cache, "unknown", get_type<T>(), &rc->params[rc->nparams - 1].p.dense);
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x7b453(%rip), %r13     # 0x8bfa0
movq (%r13), %rdi
leaq 0x58cb1(%rip), %rsi     # 0x69809
leaq 0x58e74(%rip), %rdx     # 0x699d3
xorl %eax, %eax
callq 0xb7a0
movq (%r13), %rdi
leaq 0x58e8a(%rip), %rsi     # 0x699fb
movq %rbx, %rdx
movq %r12, %rcx
movq %r15, %r8
movq %r14, %r9
xorl %eax, %eax
callq 0xb7a0
movq (%r13), %rsi
movl $0xa, %edi
callq 0xb690
cmpl $0x0, (%rbx)
je 0x10be8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x123fc
movq 0xba8(%rbx), %rdi
testq %rdi, %rdi
je 0x10bde
movq 0x868(%rbx), %rax
leaq (%rax,%rax,4), %rax
leaq (%rbx,%rax,8), %rcx
addq $0x860, %rcx            # imm = 0x860
leaq 0x58e6b(%rip), %rsi     # 0x69a39
xorl %edx, %edx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xed7d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0xbb24
jmp 0x10b97
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/lib/redirect/redirect/redirect_call.cc
// Function: void register_param_dense<char>(_redirect_call_t*, char const*, long)
static void register_param_dense(redirect_call_t *rc, const T *buf, rdint_t size)
{
#if REDIRECT_CALL_PARAMS_NEW
  ASSERT(rc->nparams < REDIRECT_CALL_PARAMS_MAX);

  rc->params[rc->nparams].type = REDIRECT_PARAM_TYPE_DENSE;
#if REDIRECT_CALL_PARAMS_CACHE
  rc->params[rc->nparams].cacheable = 1;
#endif
  rc->params[rc->nparams].p.dense.buf = const_cast<T *>(buf);
  rc->params[rc->nparams].p.dense.size = size * sizeof(T);

  ++rc->nparams;
#else
  rc->dense_params[rc->dense_nparams].buf = const_cast<void *>(buf);
  rc->dense_params[rc->dense_nparams].size = size * sizeof(T);

  ++rc->dense_nparams;
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpq $0x10, 0x868(%rdi)
jge 0x1244e
movq 0x868(%r14), %rax
leaq (%rax,%rax,4), %rax
movabsq $0x100000000, %rcx      # imm = 0x100000000
movq %rcx, 0x880(%r14,%rax,8)
movq %r15, 0x888(%r14,%rax,8)
movq %rbx, 0x890(%r14,%rax,8)
incq 0x868(%r14)
popq %rbx
popq %r14
popq %r15
retq
callq 0xbf4c
jmp 0x12414
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/lib/redirect/redirect/redirect_call.cc
// Function: void consume_output_dense<float>(_redirect_call_t*, float*, long)
static void consume_output_dense(redirect_call_t *rc, T *buf, rdint_t size)
{
  rdint_t size_left = size * sizeof(T);

  char *src = static_cast<char *>(SCDC_DATASET_INOUT_BUF_PTR(rc->output));
  char *dst = reinterpret_cast<char *>(buf);

  do
  {
    rdint_t t = z_min(size_left, SCDC_DATASET_INOUT_BUF_CURRENT(rc->output) - rc->output_offset);
    if (dst != src + rc->output_offset) memcpy(dst, src + rc->output_offset, t);
    rc->output_offset += t;
    dst += t;
    size_left -= t;

    /* done */
    if (size_left <= 0) break;

    /* have no next or next fails? */
    if (rc->output->next == 0 || rc->output->next(rc->output, 0) != SCDC_SUCCESS) break;

    src = static_cast<char *>(SCDC_DATASET_INOUT_BUF_PTR(rc->output));
    rc->output_offset = 0;

  } while (1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
shlq $0x2, %rbx
movq 0xb10(%rdi), %rax
movq 0x10(%rax), %r13
movq 0xb10(%r15), %rax
movq 0x20(%rax), %r12
movslq 0xb04(%r15), %rsi
subq %rsi, %r12
cmpq %r12, %rbx
cmovlq %rbx, %r12
addq %r13, %rsi
cmpq %rsi, %r14
je 0x12aad
movq %r14, %rdi
movq %r12, %rdx
callq 0xb3f0
addl %r12d, 0xb04(%r15)
subq %r12, %rbx
jle 0x12af0
movq 0xb10(%r15), %rdi
movq 0x38(%rdi), %rax
testq %rax, %rax
je 0x12af0
xorl %ebp, %ebp
xorl %esi, %esi
callq *%rax
cmpq $0x1, %rax
jne 0x12af2
movq 0xb10(%r15), %rax
movq 0x10(%rax), %r13
movl $0x0, 0xb04(%r15)
movb $0x1, %bpl
jmp 0x12af2
xorl %ebp, %ebp
addq %r12, %r14
testb %bpl, %bpl
jne 0x12a7e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/lib/redirect/redirect/redirect_call.cc
// Function: void redirect_call_get_output_param_dense_val<int>(_redirect_call_t*, char const*, int**, long)
void redirect_call_get_output_param_dense_val(redirect_call_t *rc, const char *id, T **b, rdint_t n)
{
  TRACE_F("rc: %p, id: '%s', b: %p, n: %" rdint_fmt, rc, id, *b, n);

  if (rc->client) /* client */
  {
    if (*b == NULL)
    {
      /* allocate buffer */
      *b = static_cast<T *>(redirect_call_alloc_buf(rc, n * sizeof(T)));
    }

    /* copy data from output to buffer */
    consume_output_dense<T>(rc, *b, n);

  } else /* server */
  {
    if (*b == NULL)
    {
      /* FIXME: use output instead of allocation */

      /* allocate buffer */
      *b = static_cast<T *>(redirect_call_alloc_buf(rc, n * sizeof(T)));
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x731b7(%rip), %r13     # 0x8bfa0
movq (%r13), %rdi
leaq 0x50a15(%rip), %rsi     # 0x69809
leaq 0x50d58(%rip), %rdx     # 0x69b53
xorl %eax, %eax
callq 0xb7a0
movq (%r13), %rdi
movq (%r15), %r8
leaq 0x50beb(%rip), %rsi     # 0x699fb
movq %rbx, %rdx
movq %r12, %rcx
movq %r14, %r9
xorl %eax, %eax
callq 0xb7a0
movq (%r13), %rsi
movl $0xa, %edi
callq 0xb690
cmpl $0x0, (%rbx)
movq (%r15), %rax
je 0x18e4c
testq %rax, %rax
jne 0x18e90
movslq 0xb20(%rbx), %r12
cmpq $0xf, %r12
jle 0x18e6d
xorl %eax, %eax
jmp 0x18e8d
testq %rax, %rax
jne 0x18f1d
movslq 0xb20(%rbx), %r12
cmpq $0xf, %r12
jle 0x18f2c
xorl %eax, %eax
jmp 0x18f4b
leaq (,%r14,4), %rdi
callq 0xb6f0
movq %rax, 0xb28(%rbx,%r12,8)
leal 0x1(%r12), %ecx
movl %ecx, 0xb20(%rbx)
movq %rax, (%r15)
movq (%r15), %r15
shlq $0x2, %r14
movq 0xb10(%rbx), %rax
movq 0x10(%rax), %r13
movq 0xb10(%rbx), %rax
movq 0x20(%rax), %r12
movslq 0xb04(%rbx), %rsi
subq %rsi, %r12
cmpq %r12, %r14
cmovlq %r14, %r12
addq %r13, %rsi
cmpq %rsi, %r15
je 0x18ed1
movq %r15, %rdi
movq %r12, %rdx
callq 0xb3f0
addl %r12d, 0xb04(%rbx)
subq %r12, %r14
jle 0x18f13
movq 0xb10(%rbx), %rdi
movq 0x38(%rdi), %rax
testq %rax, %rax
je 0x18f13
xorl %ebp, %ebp
xorl %esi, %esi
callq *%rax
cmpq $0x1, %rax
jne 0x18f15
movq 0xb10(%rbx), %rax
movq 0x10(%rax), %r13
movl $0x0, 0xb04(%rbx)
movb $0x1, %bpl
jmp 0x18f15
xorl %ebp, %ebp
addq %r12, %r15
testb %bpl, %bpl
jne 0x18ea2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
shlq $0x2, %r14
movq %r14, %rdi
callq 0xb6f0
movq %rax, 0xb28(%rbx,%r12,8)
leal 0x1(%r12), %ecx
movl %ecx, 0xb20(%rbx)
movq %rax, (%r15)
jmp 0x18f1d
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/lib/redirect/redirect/redirect_param.cc
// Function: redirect_param_hash_blocks(_redirect_param_blocks_t*)
redirect_param_hash_t redirect_param_hash_blocks(redirect_param_blocks_t *param)
{
  XXHXX(_state_t) *s = XXHXX(_createState)();
  XXHXX(_reset)(s, redirect_param_hash_seed);

  rdint_t i;
  char *buf = static_cast<char *>(param->buf);
  for (i = 0; i < param->count; ++i)
  {
    XXH32_update(s, buf, param->size);
    buf += param->stride;
  }

  XXHXX(_hash_t) h = XXHXX(_digest)(s);

  XXHXX(_freeState)(s);

  return h;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
callq 0x34d7e
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
callq 0x34da9
cmpq $0x0, 0x8(%r14)
jle 0x1912f
movq (%r14), %r15
xorl %r12d, %r12d
movq 0x10(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x34ddf
addq 0x18(%r14), %r15
incq %r12
cmpq 0x8(%r14), %r12
jl 0x19113
movq %rbx, %rdi
callq 0x34f7f
movl %eax, %ebp
movq %rbx, %rdi
callq 0x34d88
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/lib/scdc/scdc.cc
// Function: scdc_init
scdcint_t scdc_init(const char *conf, ...)
{
  SCDC_TRACE(__func__ << ": conf: '" << conf << "'");

  scdc_args_t args;

  va_list ap;
  va_start(ap, conf);

  scdc_args_va_init(&args, &ap);

  scdcint_t ret = scdc_init_intern(conf, &args);

  scdc_args_va_release(&args);

  va_end(ap);

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

  return ret;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xf8, %rsp
movq %rdi, %rbx
leaq 0x40(%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 0x191cc
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, %r14
movq %rdi, 0x10(%r14)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r14)
movl $0x10, %edi
callq 0xb500
movq $0x0, (%rax)
movq %r14, 0x8(%rax)
leaq 0x20(%rsp), %r14
movq %rax, (%r14)
leaq 0x1fb4(%rip), %rax      # 0x1b1c4
movq %rax, 0x8(%r14)
leaq 0x2126(%rip), %rax      # 0x1b341
movq %rax, 0x10(%r14)
leaq -0xda(%rip), %rax       # 0x1914c
movq %rax, 0x18(%r14)
leaq 0x73377(%rip), %rdi     # 0x8c5a8
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1b3bc
movl %eax, %ebx
movq (%r14), %rdi
testq %rdi, %rdi
je 0x19250
movl $0x10, %esi
callq 0xb510
movzbl %bl, %eax
addq $0xf8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/lib/scdc/scdc.cc
// Function: scdc_log_init
scdcint_t scdc_log_init(const char *conf, ...)
{
  SCDC_TRACE(__func__ << ": conf: '" << conf << "'");

  scdc_args_t args;

  va_list ap;
  va_start(ap, conf);

  scdc_args_va_init(&args, &ap);

  scdcint_t ret = scdc_log_init_intern(conf, &args);

  scdc_args_va_release(&args);

  va_end(ap);

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

  return ret;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xf8, %rsp
movq %rdi, %rbx
leaq 0x40(%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 0x193b3
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, %r14
movq %rdi, 0x10(%r14)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r14)
movl $0x10, %edi
callq 0xb500
movq $0x0, (%rax)
movq %r14, 0x8(%rax)
leaq 0x20(%rsp), %r14
movq %rax, (%r14)
leaq 0x1dcd(%rip), %rax      # 0x1b1c4
movq %rax, 0x8(%r14)
leaq 0x1f3f(%rip), %rax      # 0x1b341
movq %rax, 0x10(%r14)
leaq -0x2c1(%rip), %rax      # 0x1914c
movq %rax, 0x18(%r14)
movq 0x73158(%rip), %rdi     # 0x8c570
movq %rbx, %rsi
movq %r14, %rdx
callq 0x31806
movl %eax, %ebx
movq (%r14), %rdi
testq %rdi, %rdi
je 0x19437
movl $0x10, %esi
callq 0xb510
movzbl %bl, %eax
addq $0xf8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/lib/scdc/scdc.cc
// Function: scdc_dataprov_open_intern
scdc_dataprov_t scdc_dataprov_open_intern(const char *base_path, const char *conf, scdc_args_t *args)
{
  scdc_args xargs(args);

  scdc_result result;

  scdc_dataprov *dataprov = scdc_main_context.data->dataprovs.open(base_path, conf, &xargs, result);

  SCDC_RESULT_SET_STR(scdc_main_context.data->result, result.c_str());

  if (!dataprov) return SCDC_DATAPROV_NULL;

  return static_cast<scdc_dataprov_t>(dataprov);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rax
movq %rdi, %rsi
leaq 0x40(%rsp), %rcx
movq %rcx, 0x8(%rcx)
movq %rcx, (%rcx)
xorl %edi, %edi
movq %rdi, 0x10(%rcx)
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movaps %xmm0, -0x20(%rcx)
movaps %xmm1, -0x10(%rcx)
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq %rdi, -0x8(%r15)
movb $0x0, (%r15)
movq 0x73157(%rip), %rdi     # 0x8c5f0
addq $0x38, %rdi
leaq 0x20(%rsp), %rcx
movq %rsp, %r8
movq %rax, %rdx
callq 0x1d28c
movq %rax, %rbx
movq 0x73139(%rip), %rax     # 0x8c5f0
movq (%rax), %rdi
movq (%rsp), %r14
movq (%rdi), %rdx
addq $0x8, %rdi
decq %rdx
movq %r14, %rsi
callq 0xb2a0
cmpq %r15, %r14
je 0x194e5
movq 0x10(%rsp), %rsi
incq %rsi
movq %r14, %rdi
callq 0xb510
leaq 0x20(%rsp), %rdi
callq 0x1b820
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x19515
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
leaq 0x20(%rsp), %rdi
callq 0x1b820
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/lib/scdc/scdc.cc
// Function: scdc_dataprov_open
scdc_dataprov_t scdc_dataprov_open(const char *base_path, const char *conf, ...)
{
  SCDC_TRACE(__func__ << ":");

  va_list ap;
  va_start(ap, conf);

  scdc_args_t args;

  scdc_args_va_init(&args, &ap);

  scdc_dataprov_t dataprov = scdc_dataprov_open_intern(base_path, conf, &args);

  scdc_args_va_release(&args);
  va_end(ap);

  SCDC_TRACE(__func__ << ": return '" << dataprov << "'");

  return dataprov;
}

// 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 0x19591
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 0x1be9(%rip), %rax      # 0x1b1c4
movq %rax, 0x8(%rdx)
leaq 0x1d5b(%rip), %rax      # 0x1b341
movq %rax, 0x10(%rdx)
leaq -0x4a5(%rip), %rax      # 0x1914c
movq %rax, 0x18(%rdx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x19451
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/lib/scdc/scdc.cc
// Function: scdc_dataprov_close
void scdc_dataprov_close(scdc_dataprov_t dataprov)
{
  SCDC_TRACE(__func__ << ": dataprov: '" << dataprov << "'");

  if (dataprov == SCDC_DATAPROV_NULL) return;

  scdc_result result;

  if (!scdc_main_context_destroyed) scdc_main_context.data->dataprovs.close(static_cast<scdc_dataprov *>(dataprov), result);

  SCDC_RESULT_SET_STR(scdc_main_context.data->result, result.c_str());

  SCDC_TRACE(__func__ << ": return");
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
testq %rdi, %rdi
je 0x1969a
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
cmpb $0x0, 0x72fae(%rip)     # 0x8c5f8
jne 0x19664
movq %rdi, %rsi
movq 0x72f9a(%rip), %rdi     # 0x8c5f0
addq $0x38, %rdi
leaq 0x8(%rsp), %rdx
callq 0x1e2c0
movq 0x72f85(%rip), %rax     # 0x8c5f0
movq (%rax), %rdi
movq 0x8(%rsp), %rbx
movq (%rdi), %rdx
addq $0x8, %rdi
decq %rdx
movq %rbx, %rsi
callq 0xb2a0
cmpq %r14, %rbx
je 0x1969a
movq 0x18(%rsp), %rsi
incq %rsi
movq %rbx, %rdi
callq 0xb510
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x196bc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/lib/scdc/scdc.cc
// Function: scdc_nodeport_open_intern
scdc_nodeport_t scdc_nodeport_open_intern(const char *conf, scdc_args_t *args)
{
  scdc_args xargs(args);

  scdc_nodeport *nodeport = scdc_main_context.data->nodeports.open(conf, &xargs);

  if (!nodeport) return SCDC_NODEPORT_NULL;

  return static_cast<scdc_nodeport_t>(nodeport);
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rax
leaq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rcx)
movq %rcx, (%rcx)
movq $0x0, 0x10(%rcx)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movaps %xmm0, -0x20(%rcx)
movaps %xmm1, -0x10(%rcx)
movq 0x72efa(%rip), %rdi     # 0x8c5f0
addq $0x68, %rdi
movq %rsp, %rdx
movq %rax, %rsi
callq 0x33ff2
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1b820
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1b820
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/lib/scdc/scdc.cc
// Function: scdc_nodeport_open
scdc_nodeport_t scdc_nodeport_open(const char *conf, ...)
{
  SCDC_TRACE(__func__ << ": conf: '" << conf << "'");

  va_list ap;
  va_start(ap, conf);

  scdc_args_t args;

  scdc_args_va_init(&args, &ap);

  scdc_nodeport_t nodeport = scdc_nodeport_open_intern(conf, &args);

  scdc_args_va_release(&args);
  va_end(ap);

  SCDC_TRACE(__func__ << ": return '" << nodeport << "'");

  return nodeport;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xf0, %rsp
movq %rdi, %rbx
leaq 0x40(%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 0x19795
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 %rdi, 0x10(%r15)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%r15)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r15)
movl $0x10, %edi
callq 0xb500
movq %rax, %r14
movq $0x0, (%rax)
movq %r15, 0x8(%rax)
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x19e8(%rip), %rax      # 0x1b1c4
movq %rax, 0x8(%rsi)
leaq 0x1b5a(%rip), %rax      # 0x1b341
movq %rax, 0x10(%rsi)
leaq -0x6a6(%rip), %rax      # 0x1914c
movq %rax, 0x18(%rsi)
movq %rbx, %rdi
callq 0x196c4
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
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/lib/scdc/scdc.cc
// Function: scdc_nodeport_start
scdcint_t scdc_nodeport_start(scdc_nodeport_t nodeport, scdcint_t mode)
{
  SCDC_TRACE(__func__ << ": nodeport: '" << nodeport << "', mode: '" << mode << "'");

  if (nodeport == SCDC_NODEPORT_NULL) return SCDC_FAILURE;

  static_cast<scdc_nodeport *>(nodeport)->set_dataprovs(&scdc_main_context.data->dataprovs);

  static_cast<scdc_nodeport *>(nodeport)->start(mode);

  SCDC_TRACE(__func__ << ": return");

  return SCDC_SUCCESS;
}

// Assembly:
testq %rdi, %rdi
je 0x1986e
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x1985d
movq 0x72d9b(%rip), %rcx     # 0x8c5f0
addq $0x38, %rcx
movq %rcx, 0x8(%rax)
pushq %rax
movq (%rdi), %rax
callq *0x28(%rax)
movl $0x1, %eax
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/lib/scdc/scdc.cc
// Function: scdc_nodeport_stop
scdcint_t scdc_nodeport_stop(scdc_nodeport_t nodeport)
{
  SCDC_TRACE(__func__ << ": nodeport: '" << nodeport << "'");

  if (nodeport == SCDC_NODEPORT_NULL) return SCDC_FAILURE;

  static_cast<scdc_nodeport *>(nodeport)->stop();

  static_cast<scdc_nodeport *>(nodeport)->set_dataprovs(0);

  SCDC_TRACE(__func__ << ": return");

  return SCDC_SUCCESS;
}

// Assembly:
testq %rdi, %rdi
je 0x19898
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x30(%rax)
movq 0x30(%rbx), %rcx
movl $0x1, %eax
testq %rcx, %rcx
je 0x19896
movq $0x0, 0x8(%rcx)
popq %rbx
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/lib/scdc/scdc.cc
// Function: scdc_nodeport_authority_intern
const char *scdc_nodeport_authority_intern(const char *conf, scdc_args_t *args)
{
  scdc_args xargs(args);

  string authority;

  bool ret = scdc_nodeport_pool::authority(conf, &xargs, authority);

  if (!ret || authority.size() > SCDC_MAIN_NODEPORT_AUTHORITY_SIZE_MAX - 1) return 0;

  strncpy(scdc_main_nodeport_authority, authority.c_str(), SCDC_MAIN_NODEPORT_AUTHORITY_SIZE_MAX);

  return scdc_main_nodeport_authority;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
leaq 0x40(%rsp), %rax
movq %rax, 0x8(%rax)
movq %rax, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x10(%rax)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movaps %xmm0, -0x20(%rax)
movaps %xmm1, -0x10(%rax)
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq %rcx, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
callq 0x33d5c
cmpq $0x400, 0x8(%rsp)       # imm = 0x400
setb %cl
testb %cl, %al
je 0x1992e
movq (%rsp), %rsi
leaq 0x72ce1(%rip), %rbx     # 0x8c600
movl $0x400, %edx            # imm = 0x400
movq %rbx, %rdi
callq 0xb2a0
jmp 0x19930
xorl %ebx, %ebx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x19946
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
leaq 0x20(%rsp), %rdi
callq 0x1b820
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x19974
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
leaq 0x20(%rsp), %rdi
callq 0x1b820
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/lib/scdc/scdc.cc
// Function: scdc_nodeport_authority
const char *scdc_nodeport_authority(const char *conf, ...)
{
  SCDC_TRACE(__func__ << ": conf: '" << conf << "'");

  va_list ap;
  va_start(ap, conf);

  scdc_args_t args;

  scdc_args_va_init(&args, &ap);

  const char *authority = scdc_nodeport_authority_intern(conf, &args);

  scdc_args_va_release(&args);
  va_end(ap);

  SCDC_TRACE(__func__ << ": return '" << authority << "'");

  return authority;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xf0, %rsp
movq %rdi, %rbx
leaq 0x40(%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 0x199ef
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 %rdi, 0x10(%r15)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%r15)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r15)
movl $0x10, %edi
callq 0xb500
movq %rax, %r14
movq $0x0, (%rax)
movq %r15, 0x8(%rax)
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x178e(%rip), %rax      # 0x1b1c4
movq %rax, 0x8(%rsi)
leaq 0x1900(%rip), %rax      # 0x1b341
movq %rax, 0x10(%rsi)
leaq -0x900(%rip), %rax      # 0x1914c
movq %rax, 0x18(%rsi)
movq %rbx, %rdi
callq 0x198be
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
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/lib/scdc/scdc.cc
// Function: scdc_nodeport_supported_intern
scdcint_t scdc_nodeport_supported_intern(const char *uri, scdc_args_t *args)
{
  scdc_args xargs(args);

  string supported;

  bool ret = scdc_nodeport_pool::supported(uri, &xargs);

  return (ret)?SCDC_SUCCESS:SCDC_FAILURE;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
leaq 0x40(%rsp), %rax
movq %rax, 0x8(%rax)
movq %rax, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x10(%rax)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movaps %xmm0, -0x20(%rax)
movaps %xmm1, -0x10(%rax)
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq %rcx, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x20(%rsp), %rsi
callq 0x33f86
movl %eax, %ebx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x19ad3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
movzbl %bl, %ebx
leaq 0x20(%rsp), %rdi
callq 0x1b820
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x19b04
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
leaq 0x20(%rsp), %rdi
callq 0x1b820
movq %rbx, %rdi
callq 0xb9c0