LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x128, %rsp            # imm = 0x128
movq %r9, %r15
movq %r8, %rbp
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movq 0x65728(%rip), %rax     # 0x74fb8
movq (%rax), %rdi
leaq 0x40f6f(%rip), %rsi     # 0x50809
leaq 0x41001(%rip), %rdx     # 0x508a2
xorl %eax, %eax
callq 0xb7c0
movq 0x65709(%rip), %rax     # 0x74fb8
movq (%rax), %rdi
movq %r15, (%rsp)
leaq 0x40bad(%rip), %rsi     # 0x5046a
movq %r14, %rdx
movq %r13, %rcx
movq %r12, 0x8(%rsp)
movq %r12, %r8
movq %rbx, %r12
movq %rbp, 0x10(%rsp)
movq %rbp, %r9
xorl %eax, %eax
callq 0xb7c0
movq 0x656d4(%rip), %rax     # 0x74fb8
movq (%rax), %rsi
pushq $0xa
popq %rdi
callq 0xb6b0
movq 0xba8(%rbx), %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r15, %rcx
callq 0xe7e4
testl %eax, %eax
movl $0x0, %eax
jne 0xf9b9
movq 0x8(%rsp), %rbp
movq 0x10(%rsp), %rbx
leaq 0x20(%rsp), %r14
movl $0x100, %edx            # imm = 0x100
movq %r14, %rdi
xorl %esi, %esi
callq 0xb2f0
leaq 0x18(%rsp), %rdx
andq $0x0, (%rdx)
movq %r13, %rdi
movq %r14, %rsi
callq 0xf400
movq %rax, %r14
movq 0xba8(%r12), %rdi
testq %rdi, %rdi
je 0xf962
movq 0x18(%rsp), %rdx
leaq 0x20(%rsp), %rsi
callq 0xeab8
andq $0x0, 0x150(%r12)
addq %r14, %r13
leaq 0x168(%r12), %rsi
movq %r13, %rdi
xorl %edx, %edx
callq 0xf400
andq $0x0, 0x160(%r12)
addq %rax, %r13
leaq 0x568(%r12), %rsi
movq %r13, %rdi
xorl %edx, %edx
callq 0xf400
movq %rbp, 0xb08(%r12)
movq %rbx, 0xb10(%r12)
movq %r15, 0xb18(%r12)
pushq $0x1
popq %rax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, (%rdi)
je 0xfb23
movq 0x208(%r14), %rax
movq %rax, 0x148(%rbx)
leaq 0x4(%r14), %rdx
leaq 0x40db9(%rip), %rsi     # 0x508b4
pushq $-0x1
popq %rcx
movq %rbx, %rdi
callq 0xf52f
movq 0x210(%r14), %rdx
leaq 0x40da7(%rip), %rsi     # 0x508bb
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xfb56
leaq 0x4(%r14), %rdx
leaq 0x40d86(%rip), %rsi     # 0x508b4
pushq $-0x1
popq %rcx
movq %rbx, %rdi
callq 0xfa9d
movq 0x210(%r14), %rdx
leaq 0x40d74(%rip), %rsi     # 0x508bb
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xfb79
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %eax
movl %eax, (%rsi)
leaq 0x4(%rsi), %rdx
testl %eax, %eax
je 0xfbe3
movq 0x148(%r14), %rax
movq %rax, 0x208(%rbx)
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xf552
addq $0x210, %rbx            # imm = 0x210
movq %r14, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xfc06
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xfa74
addq $0x210, %rbx            # imm = 0x210
movq %r14, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xfc2c
// File: /workspace/github_cpp_makefile_star2_O2/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 0x652d6(%rip), %r13     # 0x74fb8
movq (%r13), %rdi
leaq 0x40b1c(%rip), %rsi     # 0x50809
leaq 0x40cdf(%rip), %rdx     # 0x509d3
xorl %eax, %eax
callq 0xb7c0
movq (%r13), %rdi
leaq 0x40cf5(%rip), %rsi     # 0x509fb
movq %rbx, %rdx
movq %r12, %rcx
movq %r15, %r8
movq %r14, %r9
xorl %eax, %eax
callq 0xb7c0
movq (%r13), %rsi
pushq $0xa
popq %rdi
callq 0xb6b0
cmpl $0x0, (%rbx)
je 0xfd78
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1145b
movq 0xba8(%rbx), %rdi
testq %rdi, %rdi
je 0xfd6e
imulq $0x28, 0x868(%rbx), %rax
leaq (%rbx,%rax), %rcx
addq $0x860, %rcx            # imm = 0x860
leaq 0x40cdb(%rip), %rsi     # 0x50a39
xorl %edx, %edx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xe297
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x65259(%rip), %rax     # 0x74fd8
movq (%rax), %rcx
leaq 0x40c92(%rip), %rdi     # 0x50a1b
pushq $0x1d
popq %rsi
pushq $0x1
popq %rdx
callq 0xba80
jmp 0xfd2a
// File: /workspace/github_cpp_makefile_star2_O2/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
movq 0x868(%rdi), %rax
cmpq $0x10, %rax
jge 0x114a9
imulq $0x28, %rax, %rax
movabsq $0x100000000, %rcx      # imm = 0x100000000
movq %rcx, 0x880(%r14,%rax)
movq %r15, 0x888(%r14,%rax)
movq %rbx, 0x890(%r14,%rax)
incq 0x868(%r14)
popq %rbx
popq %r14
popq %r15
retq
movq 0x63b28(%rip), %rax     # 0x74fd8
movq (%rax), %rcx
leaq 0x3f587(%rip), %rdi     # 0x50a41
pushq $0x39
popq %rsi
pushq $0x1
popq %rdx
callq 0xba80
movq 0x868(%r14), %rax
jmp 0x11476
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/lib/redirect/redirect/redirect_call.cc
// Function: redirect_call_alloc_buf(_redirect_call_t*, long)
static void *redirect_call_alloc_buf(redirect_call_t *rc, rdint_t size)
{
  if (rc->free_nbufs >= REDIRECT_CALL_FREE_BUFS_MAX) return NULL;

  void *buf = malloc(size);

  rc->free_bufs[rc->free_nbufs] = buf;
  ++rc->free_nbufs;

  return buf;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movslq 0xb20(%rdi), %r14
cmpq $0xf, %r14
jle 0x114e3
xorl %eax, %eax
jmp 0x11500
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xb720
movq %rax, 0xb28(%rbx,%r14,8)
leal 0x1(%r14), %ecx
movl %ecx, 0xb20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
shlq $0x2, %rbx
movq 0xb10(%rdi), %rcx
movq 0x10(%rcx), %rsi
movl 0xb04(%rdi), %eax
movq 0x20(%rcx), %r12
movslq %eax, %rcx
subq %rcx, %r12
cmpq %r12, %rbx
cmovlq %rbx, %r12
addq %rcx, %rsi
cmpq %rsi, %r14
je 0x11b3d
movq %r14, %rdi
movq %r12, %rdx
callq 0xb420
movl 0xb04(%r15), %eax
addl %r12d, %eax
movl %eax, 0xb04(%r15)
subq %r12, %rbx
jle 0x11b80
movq 0xb10(%r15), %rdi
movq 0x38(%rdi), %rax
testq %rax, %rax
je 0x11b80
xorl %esi, %esi
callq *%rax
cmpq $0x1, %rax
jne 0x11b80
addq %r12, %r14
movq 0xb10(%r15), %rcx
movq 0x10(%rcx), %rsi
andl $0x0, 0xb04(%r15)
xorl %eax, %eax
jmp 0x11b12
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/lib/redirect/redirect/redirect_call.cc
// Function: void redirect_call_get_output_param_dense_val<char>(_redirect_call_t*, char const*, char**, 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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movq 0x612e8(%rip), %r13     # 0x74fb8
movq (%r13), %rdi
leaq 0x3cb2e(%rip), %rsi     # 0x50809
leaq 0x3ce71(%rip), %rdx     # 0x50b53
xorl %eax, %eax
callq 0xb7c0
movq (%r13), %rdi
movq (%r12), %r8
leaq 0x3cd03(%rip), %rsi     # 0x509fb
movq %r14, %rdx
movq %r15, %rcx
movq %rbx, %r9
xorl %eax, %eax
callq 0xb7c0
movq (%r13), %rsi
pushq $0xa
popq %rdi
callq 0xb6b0
cmpl $0x0, (%r14)
movq (%r12), %r15
je 0x13db9
testq %r15, %r15
jne 0x13d39
movq %r14, %rdi
movq %rbx, %rsi
callq 0x114ce
movq %rax, %r15
movq %rax, (%r12)
movq 0xb10(%r14), %rcx
movq 0x10(%rcx), %rsi
movl 0xb04(%r14), %eax
movq 0x20(%rcx), %r12
movslq %eax, %rcx
subq %rcx, %r12
cmpq %r12, %rbx
cmovlq %rbx, %r12
addq %rcx, %rsi
cmpq %rsi, %r15
je 0x13d76
movq %r15, %rdi
movq %r12, %rdx
callq 0xb420
movl 0xb04(%r14), %eax
addl %r12d, %eax
movl %eax, 0xb04(%r14)
subq %r12, %rbx
jle 0x13dcd
movq 0xb10(%r14), %rdi
movq 0x38(%rdi), %rax
testq %rax, %rax
je 0x13dcd
xorl %esi, %esi
callq *%rax
cmpq $0x1, %rax
jne 0x13dcd
addq %r12, %r15
movq 0xb10(%r14), %rcx
movq 0x10(%rcx), %rsi
andl $0x0, 0xb04(%r14)
xorl %eax, %eax
jmp 0x13d4b
testq %r15, %r15
jne 0x13dcd
movq %r14, %rdi
movq %rbx, %rsi
callq 0x114ce
movq %rax, (%r12)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2cb9e
movq %rax, %rbx
xorl %r12d, %r12d
movq %rax, %rdi
xorl %esi, %esi
callq 0x2cbc7
movq (%r14), %r15
cmpq 0x8(%r14), %r12
jge 0x17c2a
movq 0x10(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2cbf7
addq 0x18(%r14), %r15
incq %r12
jmp 0x17c0c
movq %rbx, %rdi
callq 0x2cd9d
movl %eax, %ebp
movq %rbx, %rdi
callq 0x2cba6
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x17cc8
movaps %xmm0, 0x70(%rsp)
movaps %xmm1, 0x80(%rsp)
movaps %xmm2, 0x90(%rsp)
movaps %xmm3, 0xa0(%rsp)
movaps %xmm4, 0xb0(%rsp)
movaps %xmm5, 0xc0(%rsp)
movaps %xmm6, 0xd0(%rsp)
movaps %xmm7, 0xe0(%rsp)
movq %rsp, %rsi
movq %rdi, 0x10(%rsi)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%rsi)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsi)
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x17d19
movq %rbx, %rdi
movq %r14, %rsi
callq 0x17c49
movq %rax, %rbx
movq %r14, %rdi
callq 0x17d5f
movq %rbx, %rax
addq $0xf8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/lib/scdc/scdc.cc
// Function: scdc_args_va_init(_scdc_args_t*, __va_list_tag (*) [1])
static void scdc_args_va_init(scdc_args_t *args, va_list *ap)
{
  scdc_args_data_va_t *args_data_va = new scdc_args_data_va_t;

  args_data_va->arg = 0;
  args_data_va->ap = ap;

  args->data = args_data_va;
  args->get = scdc_args_get_va;
  args->set = scdc_args_set_va;
  args->free = scdc_args_free_va;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x10
popq %rdi
callq 0xb540
andq $0x0, (%rax)
movq %rbx, 0x8(%rax)
movq %rax, (%r14)
leaq 0x180a(%rip), %rax      # 0x19547
movq %rax, 0x8(%r14)
leaq 0x197a(%rip), %rax      # 0x196c2
movq %rax, 0x10(%r14)
leaq -0x10b(%rip), %rax      # 0x17c48
movq %rax, 0x18(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rax
movq %rdi, %rsi
leaq 0x40(%rsp), %rcx
movq %rcx, 0x8(%rcx)
movq %rcx, (%rcx)
andq $0x0, 0x10(%rcx)
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movaps %xmm0, -0x20(%rcx)
leaq 0x10(%rsp), %rdx
movq %rdx, -0x10(%rdx)
andq $0x0, -0x8(%rdx)
movaps %xmm1, -0x10(%rcx)
movb $0x0, (%rdx)
movq 0x5d6b4(%rip), %rdi     # 0x75600
addq $0x38, %rdi
leaq 0x20(%rsp), %rcx
movq %rsp, %r8
movq %rax, %rdx
callq 0x1b464
movq %rax, %rbx
movq 0x5d696(%rip), %rax     # 0x75600
movq (%rax), %rdi
movq %rsp, %r14
movq (%r14), %rsi
movq (%rdi), %rdx
addq $0x8, %rdi
decq %rdx
callq 0xb2c0
movq %r14, %rdi
callq 0xb230
leaq 0x20(%rsp), %rdi
callq 0x19a94
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xb230
leaq 0x20(%rsp), %rdi
callq 0x19a94
movq %rbx, %rdi
callq 0xb9a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0xf0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x40(%rsp), %rdi
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x18024
movaps %xmm0, 0x70(%rsp)
movaps %xmm1, 0x80(%rsp)
movaps %xmm2, 0x90(%rsp)
movaps %xmm3, 0xa0(%rsp)
movaps %xmm4, 0xb0(%rsp)
movaps %xmm5, 0xc0(%rsp)
movaps %xmm6, 0xd0(%rsp)
movaps %xmm7, 0xe0(%rsp)
movq %rsp, %rsi
movq %rdi, 0x10(%rsi)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%rsi)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%rsi)
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x17d19
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x17f07
movq %rax, %rbx
movq %r15, %rdi
callq 0x17d5f
movq %rbx, %rax
addq $0xf0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x20, %rsp
testq %rdi, %rdi
je 0x180dc
leaq 0x10(%rsp), %rsi
movq %rsi, -0x10(%rsi)
andq $0x0, -0x8(%rsi)
movb $0x0, (%rsi)
cmpb $0x0, 0x5d56c(%rip)     # 0x75608
jne 0x180bb
movq %rdi, %rax
movq 0x5d558(%rip), %rdi     # 0x75600
addq $0x38, %rdi
movq %rsp, %rdx
movq %rax, %rsi
callq 0x1c144
movq (%rsp), %rsi
movq 0x5d53e(%rip), %rax     # 0x75600
movq (%rax), %rdi
movq (%rdi), %rdx
addq $0x8, %rdi
decq %rdx
callq 0xb2c0
movq %rsp, %rdi
callq 0xb230
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rcx)
movq %rcx, (%rcx)
andq $0x0, 0x10(%rcx)
movq %rdi, %rax
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movaps %xmm0, -0x20(%rcx)
movaps %xmm1, -0x10(%rcx)
movq 0x5d4dc(%rip), %rdi     # 0x75600
addq $0x68, %rdi
movq %rsp, %rdx
movq %rax, %rsi
callq 0x2be56
movq %rax, %rbx
movq %rsp, %rdi
callq 0x19a94
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x19a94
movq %rbx, %rdi
callq 0xb9a0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x18260
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x18251
movq 0x5d3b7(%rip), %rcx     # 0x75600
addq $0x38, %rcx
movq %rcx, 0x8(%rax)
pushq %rax
movq (%rdi), %rax
callq *0x28(%rax)
pushq $0x1
popq %rax
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x18285
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x30(%rax)
movq 0x30(%rbx), %rcx
pushq $0x1
popq %rax
testq %rcx, %rcx
je 0x18283
andq $0x0, 0x8(%rcx)
popq %rbx
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x60, %rsp
leaq 0x40(%rsp), %rax
movq %rax, 0x8(%rax)
movq %rax, (%rax)
andq $0x0, 0x10(%rax)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movaps %xmm0, -0x20(%rax)
movaps %xmm1, -0x10(%rax)
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
callq 0x2bc28
cmpq $0x400, 0x8(%rsp)       # imm = 0x400
setb %cl
testb %cl, %al
je 0x18316
movq (%rsp), %rsi
leaq 0x5d309(%rip), %rbx     # 0x75610
movl $0x400, %edx            # imm = 0x400
movq %rbx, %rdi
callq 0xb2c0
jmp 0x18318
xorl %ebx, %ebx
movq %rsp, %rdi
callq 0xb230
leaq 0x20(%rsp), %rdi
callq 0x19a94
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xb230
leaq 0x20(%rsp), %rdi
callq 0x19a94
movq %rbx, %rdi
callq 0xb9a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x60, %rsp
leaq 0x40(%rsp), %rax
movq %rax, 0x8(%rax)
movq %rax, (%rax)
andq $0x0, 0x10(%rax)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movaps %xmm0, -0x20(%rax)
movaps %xmm1, -0x10(%rax)
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x20(%rsp), %rsi
callq 0x2bdea
movzbl %al, %ebx
movq %rsp, %rdi
callq 0xb230
leaq 0x20(%rsp), %rdi
callq 0x19a94
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xb230
leaq 0x20(%rsp), %rdi
callq 0x19a94
movq %rbx, %rdi
callq 0xb9a0
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/lib/scdc/scdc.cc
// Function: scdc_dataset_close
void scdc_dataset_close(scdc_dataset_t dataset)
{
  SCDC_TRACE(__func__ << ": '" << dataset << "'");

  if (dataset == SCDC_DATASET_NULL) return;

/*  SCDC_INFO("closing dataset " << dataset);*/

#if SCDC_DEBUG
  if (scdc_main_context.data->datasets.erase(dataset) != 1)
  {
    SCDC_FAIL(__func__ << ": no valid dataset handle given");
    return;
  }
#endif

  scdc_result result;
  dataset->nodeconn->dataset_close(static_cast<scdc_dataset *>(dataset->dataset), result);
  SCDC_RESULT_SET_STR(scdc_main_context.data->result, result.c_str());

  SCDC_TRACE(__func__ << ": result: '" << result << "'");

  scdc_main_context.data->nodeconns.close(dataset->nodeconn);

  delete dataset;

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

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, 0x8(%rsp)
testq %rdi, %rdi
je 0x189c4
movq 0x5cd53(%rip), %rdi     # 0x75600
addq $0x8, %rdi
leaq 0x8(%rsp), %rsi
callq 0x1a734
cmpq $0x1, %rax
jne 0x18951
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rsi
movq 0x60(%rcx), %rdi
movq (%rdi), %rax
leaq 0x10(%rsp), %rdx
callq *0x18(%rax)
movq 0x5cd08(%rip), %rax     # 0x75600
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
movq (%rdi), %rdx
addq $0x8, %rdi
decq %rdx
callq 0xb2c0
movl $0x98, %edi
addq 0x5cce5(%rip), %rdi     # 0x75600
movq 0x8(%rsp), %rax
movq (%rax), %rsi
callq 0x2b2da
movq 0x8(%rsp), %rbx
testq %rbx, %rbx
je 0x1893a
movq %rbx, %rdi
callq 0x19ad4
pushq $0x20
popq %rsi
movq %rbx, %rdi
callq 0xb550
leaq 0x10(%rsp), %rdi
callq 0xb230
jmp 0x189c4
movq 0x5cc28(%rip), %rdi     # 0x75580
cmpq $0x0, 0x8(%rdi)
je 0x189c4
addq $0x20, %rdi
callq 0xb800
movq 0x5cc11(%rip), %rax     # 0x75580
movq 0x8(%rax), %rdi
leaq 0x3880e(%rip), %rsi     # 0x51188
callq 0xb520
leaq 0x3880e(%rip), %rsi     # 0x51194
movq %rax, %rdi
callq 0xb520
leaq 0x38822(%rip), %rsi     # 0x511b7
movq %rax, %rdi
callq 0xb520
leaq 0x38826(%rip), %rsi     # 0x511ca
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
movq 0x5cbc5(%rip), %rdi     # 0x75580
addq $0x20, %rdi
callq 0xb3e0
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/lib/scdc/scdc.cc
// Function: scdc_dataset_cmd
scdcint_t scdc_dataset_cmd(scdc_dataset_t dataset, const char *cmd, scdc_dataset_input_t *input, scdc_dataset_output_t *output, ...)
{
  SCDC_TRACE(__func__ << ": dataset: '" << dataset << "', cmd = '" << string(cmd) << "'" << ", input = " << static_cast<void *>(input) << ", output = " << static_cast<void *>(output));

  scdc_args_t args;

  va_list ap;
  va_start(ap, output);

  scdc_args_va_init(&args, &ap);

  scdcint_t ret = scdc_dataset_cmd_intern(dataset, cmd, input, output, &args);

  scdc_args_va_release(&args);

  va_end(ap);

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

  return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf0, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x40(%rsp), %rcx
movq %r8, 0x20(%rcx)
movq %r9, 0x28(%rcx)
testb %al, %al
je 0x19106
movaps %xmm0, 0x70(%rsp)
movaps %xmm1, 0x80(%rsp)
movaps %xmm2, 0x90(%rsp)
movaps %xmm3, 0xa0(%rsp)
movaps %xmm4, 0xb0(%rsp)
movaps %xmm5, 0xc0(%rsp)
movaps %xmm6, 0xd0(%rsp)
movaps %xmm7, 0xe0(%rsp)
movq %rsp, %rsi
movq %rcx, 0x10(%rsi)
leaq 0x120(%rsp), %rax
movq %rax, 0x8(%rsi)
movabsq $0x3000000020, %rax     # imm = 0x3000000020
movq %rax, (%rsi)
leaq 0x20(%rsp), %r13
movq %r13, %rdi
callq 0x17d19
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movq %r13, %r8
callq 0x189df
movq %rax, %rbx
movq %r13, %rdi
callq 0x17d5f
movq %rbx, %rax
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/lib/scdc/scdc.cc
// Function: scdc_context::release()
void release()
    {
      SCDC_TRACE("scdc-context: " << __func__);

      if (!data) return;

#if SCDC_DEBUG
      for (set<scdc_dataset_t>::iterator i = data->datasets.begin(); i != data->datasets.end(); ++i)
      {
        SCDC_FAIL("scdc-context: " << __func__ << ": dataset '" << *i << "' was not closed");
      }
#endif

      data->nodeconns.close_all();

      scdc_nodeport_stop(data->np_direct);
      scdc_nodeport_close(data->np_direct);

      data->nodeports.close_all();

      scdc_dataprov_close(data->dp_config);

      data->dataprovs.close_all();

      scdc_nodeport_pool::release();
      scdc_nodeconn_pool::release();

      ::operator delete(data->result);

      delete data; data = 0;

      SCDC_TRACE("scdc-context: " << __func__ << ": return");
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x48(%rdi), %r12
testq %r12, %r12
je 0x19a85
movq %rdi, %rbx
movq 0x20(%r12), %r13
leaq 0x36dc3(%rip), %rbp     # 0x506f6
leaq 0x379c2(%rip), %r14     # 0x512fc
leaq 0x379c7(%rip), %r15     # 0x51308
leaq 0x10(%r12), %rax
cmpq %rax, %r13
je 0x199f8
movq 0x5bc2a(%rip), %rdi     # 0x75580
cmpq $0x0, 0x8(%rdi)
je 0x199e8
addq $0x20, %rdi
callq 0xb800
movq 0x5bc0f(%rip), %rax     # 0x75580
movq 0x8(%rax), %rdi
leaq 0x3780c(%rip), %rsi     # 0x51188
callq 0xb520
movq %rax, %rdi
leaq 0x37809(%rip), %rsi     # 0x51194
callq 0xb520
movq %rax, %rdi
leaq 0x37953(%rip), %rsi     # 0x512ed
callq 0xb520
movq %rax, %rdi
movq %rbp, %rsi
callq 0xb520
movq %rax, %rdi
movq %r14, %rsi
callq 0xb520
movq 0x20(%r13), %rsi
movq %rax, %rdi
callq 0xb3f0
movq %rax, %rdi
movq %r15, %rsi
callq 0xb520
movq %rax, %rdi
callq 0xb270
movq 0x5bba5(%rip), %rdi     # 0x75580
addq $0x20, %rdi
callq 0xb3e0
movq 0x48(%rbx), %r12
movq %r13, %rdi
callq 0xb620
movq %rax, %r13
jmp 0x19941
addq $0x98, %r12
movq %r12, %rdi
callq 0x2b404
movq 0x48(%rbx), %rax
movq 0xd8(%rax), %rdi
callq 0x18263
movq 0x48(%rbx), %rax
movq 0xd8(%rax), %rdi
callq 0x18212
movq 0x48(%rbx), %rdi
addq $0x68, %rdi
callq 0x2c118
movq 0x48(%rbx), %rax
movq 0xd0(%rax), %rdi
callq 0x1807a
movq 0x48(%rbx), %rdi
addq $0x38, %rdi
callq 0x1c1a4
callq 0x2bc0c
movq 0x48(%rbx), %rax
movq (%rax), %rdi
callq 0xb500
movq 0x48(%rbx), %r14
testq %r14, %r14
je 0x19a73
movq %r14, %rdi
callq 0x1a308
movl $0xe0, %esi
movq %r14, %rdi
callq 0xb550
andq $0x0, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/lib/scdc/../../include/common.hh
// Function: stringlist::parse(int, char const*, long)
void parse(int sep_, const char *s, ssize_t len = -1)
    {
      if (!s || len == 0) return;

      const char *s_ = s;
      length = 0;

      while (s[0] != '\0' && len != 0)
      {
        size_t l;

        const char *n = (len >= 0)?memchr(s, sep_, len):strchr(s, sep_);

        if (n) l = n - s;
        else l = (len >= 0)?len:strlen(s);

        lst.push_back(entry_t(std::string(s, l), s - s_));

        if (n) ++l;

        s += l;
        len -= l;

        length += l;
      }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r8
movl %esi, 0x4(%rsp)
movq %rdx, 0x10(%rsp)
testq %rdx, %rdx
sete %al
testq %rcx, %rcx
sete %cl
orb %al, %cl
je 0x19cbb
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r12
leaq 0x28(%rsp), %r15
xorl %ebx, %ebx
movq 0x10(%rsp), %r14
movq %rdi, 0x8(%rsp)
movq %rbx, 0x20(%r12)
cmpb $0x0, (%r14)
je 0x19cac
testq %r8, %r8
je 0x19cac
movq %r8, 0x38(%rsp)
movq %r14, %rdi
js 0x19d05
movl 0x4(%rsp), %esi
movq %r8, %rdx
movq %r8, %r12
callq 0xb5f0
testq %rax, %rax
jne 0x19d13
xorl %r13d, %r13d
movq %r12, %rbx
jmp 0x19d30
movl 0x4(%rsp), %esi
callq 0xb1e0
testq %rax, %rax
je 0x19d22
movq %rax, %rbx
movq %r15, %rax
subq %r14, %rbx
pushq $0x1
popq %r13
jmp 0x19d33
movq %r14, %rdi
callq 0xb210
movq %rax, %rbx
xorl %r13d, %r13d
movq %r15, %rax
movq %rax, 0x18(%rsp)
leaq (%r14,%rbx), %rdx
leaq 0x18(%rsp), %rdi
movq %r14, %rsi
callq 0x1a1f2
movq %r15, %rdx
leaq 0x50(%rsp), %rcx
movq %rcx, 0x40(%rsp)
movq 0x18(%rsp), %rax
cmpq %r15, %rax
je 0x19d71
movq %rax, 0x40(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x19d77
movups (%rdx), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%rsp), %r12
leaq 0x40(%rsp), %rbp
movq %r14, %rax
movq 0x20(%rsp), %rcx
movq %rdx, 0x18(%rsp)
andq $0x0, 0x20(%rsp)
subq 0x10(%rsp), %rax
movq %rcx, 0x48(%rsp)
movb $0x0, 0x28(%rsp)
movq %rax, 0x60(%rsp)
movq %r12, %rdi
movq %rbp, %rsi
callq 0x19dfc
movq %rbp, %rdi
callq 0xb230
leaq 0x18(%rsp), %rdi
callq 0xb230
addq %r13, %rbx
addq %rbx, %r14
movq 0x38(%rsp), %r8
subq %rbx, %r8
addq 0x20(%r12), %rbx
jmp 0x19ccf
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xb230
leaq 0x18(%rsp), %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/lib/scdc/../../include/args.hh
// Function: scdc_args::free_all()
void free_all() {
      while (gets.size() > 0) {
        const scdc_args_get_entry_t &e = gets.front();
        if (e.n == 1) free<void>(e.type, e.v0, e.arg_ref);
        else if (e.n == 2) free<void, void>(e.type, e.v0, e.v1, e.arg_ref);
      }
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x30(%rbx)
je 0x1a459
movq 0x20(%rbx), %rax
movq 0x20(%rax), %rcx
cmpq $0x2, %rcx
je 0x1a43f
cmpq $0x1, %rcx
jne 0x1a40e
movq 0x28(%rax), %rdx
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rcx
movq %rbx, %rdi
callq 0x1a45c
jmp 0x1a40e
movq 0x28(%rax), %rdx
movq 0x30(%rax), %rcx
movq 0x10(%rax), %rsi
movq 0x18(%rax), %r8
movq %rbx, %rdi
callq 0x1a4bc
jmp 0x1a40e
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/lib/scdc/../../include/args.hh
// Function: void scdc_args::free<void, void>(long long, void*, void*, void*)
void free(scdcint_t type, T0 *v0, T1 *v1, scdc_arg_ref_t arg_ref) {
      if (!args.free || arg_ref == SCDC_ARG_REF_NULL) return;
      del_get(type, arg_ref, 2, v0, v1);
      void *a[2] = { static_cast<void *>(v0), static_cast<void *>(v1) };
      args.free(args.data, type, static_cast<void *>(a), arg_ref);
    }

// Assembly:
testq %r8, %r8
je 0x1a51c
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
cmpq $0x0, 0x18(%rdi)
je 0x1a50f
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r15
pushq $0x2
popq %rcx
movq %r14, %rdi
movq %r8, %rdx
movq %r13, %r8
movq %r12, %r9
callq 0x1a51e
movq %rsp, %rdx
movq %r13, (%rdx)
movq %r12, 0x8(%rdx)
movq (%r14), %rdi
movq %r15, %rsi
movq %rbx, %rcx
callq *0x18(%r14)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/common/common.cc
// Function: has_prefix_suffix(char const*, char const*, char const*)
bool has_prefix_suffix(const char *s, const char *prefix, const char *suffix)
{
  size_t s_len = strlen(s);
  size_t prefix_len = (prefix)?strlen(prefix):0;
  size_t suffix_len = (suffix)?strlen(suffix):0;

/*  return (!prefix || strncmp(s, prefix, prefix_len) == 0) && (!suffix || (s_len >= suffix_len && strncmp(s + s_len - suffix_len, suffix, suffix_len) == 0));*/

  return (strncmp(s, prefix, prefix_len) == 0 && s_len >= suffix_len && strncmp(s + s_len - suffix_len, suffix, suffix_len) == 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
callq 0xb210
movq %rax, %r15
testq %r12, %r12
je 0x1a90a
movq %r12, %rdi
callq 0xb210
movq %rax, %rbp
jmp 0x1a90c
xorl %ebp, %ebp
testq %rbx, %rbx
je 0x1a91e
movq %rbx, %rdi
callq 0xb210
movq %rax, %r13
jmp 0x1a921
xorl %r13d, %r13d
movq %r14, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0xb260
testl %eax, %eax
setne %al
cmpq %r13, %r15
setb %cl
orb %al, %cl
je 0x1a942
xorl %eax, %eax
jmp 0x1a95b
addq %r15, %r14
subq %r13, %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0xb260
testl %eax, %eax
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/common/common.cc
// Function: join_cmdline(char const*, char const*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void join_cmdline(const char *cmd, const char *uri, const char *params, string &cmdline)
{
  SCDC_TRACE("join_cmdline: cmd: '" << ((cmd)?cmd:"") << "', uri: '" << ((uri)?uri:"") << "', params: '" << ((params)?params:"") << "'");

  cmdline = "";

  if (uri && strlen(uri) > 0)
  {
    if (cmdline.size() > 0) cmdline += " ";
    cmdline += uri;
  }

  if (cmd && strlen(cmd) > 0)
  {
    if (cmdline.size() > 0) cmdline += " ";
    cmdline += cmd;
  }

  if (params && strlen(params) > 0)
  {
    if (cmdline.size() > 0) cmdline += " ";
    cmdline += params;
  }

  SCDC_TRACE("join_cmdline: '" << cmdline << "'");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
leaq 0x378e6(%rip), %rsi     # 0x524bd
movq %rcx, %rdi
callq 0xba40
testq %r12, %r12
je 0x1ac0c
cmpb $0x0, (%r12)
je 0x1ac0c
cmpq $0x0, 0x8(%r14)
je 0x1ac01
leaq 0x39407(%rip), %rsi     # 0x54000
movq %r14, %rdi
callq 0xba30
movq %r14, %rdi
movq %r12, %rsi
callq 0xba30
testq %r15, %r15
je 0x1ac38
cmpb $0x0, (%r15)
je 0x1ac38
cmpq $0x0, 0x8(%r14)
je 0x1ac2d
leaq 0x393db(%rip), %rsi     # 0x54000
movq %r14, %rdi
callq 0xba30
movq %r14, %rdi
movq %r15, %rsi
callq 0xba30
testq %rbx, %rbx
je 0x1ac6e
cmpb $0x0, (%rbx)
je 0x1ac6e
cmpq $0x0, 0x8(%r14)
je 0x1ac58
leaq 0x393b0(%rip), %rsi     # 0x54000
movq %r14, %rdi
callq 0xba30
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xba30
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/common/common.cc
// Function: join_uri(char const*, char const*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void join_uri(const char *scheme, const char *authority, const char *path, string &uri)
{
  SCDC_TRACE("join_uri: scheme: '" << ((scheme)?scheme:"") << "', authority: '" << ((authority)?authority:"") << "', path: '" << ((path)?path:"") << "'");

  uri = "";

  if (scheme && strlen(scheme) > 0)
  {
    uri += scheme;
    uri += ":";
  }

  if (authority && strlen(authority) > 0)
  {
    if (uri.size() > 0) uri += "//";
    uri += authority;
  }

  if (path && strlen(path) > 0)
  {
    if (uri.size() > 0) uri += "/";
    uri += path;
  }

  SCDC_TRACE("join_uri: '" << uri << "'");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
leaq 0x375f6(%rip), %rsi     # 0x524bd
movq %rcx, %rdi
callq 0xba40
testq %r12, %r12
je 0x1aef5
cmpb $0x0, (%r12)
je 0x1aef5
movq %r14, %rdi
movq %r12, %rsi
callq 0xba30
leaq 0x36457(%rip), %rsi     # 0x51344
movq %r14, %rdi
callq 0xba30
testq %r15, %r15
je 0x1af21
cmpb $0x0, (%r15)
je 0x1af21
cmpq $0x0, 0x8(%r14)
je 0x1af16
leaq 0x3643e(%rip), %rsi     # 0x5134c
movq %r14, %rdi
callq 0xba30
movq %r14, %rdi
movq %r15, %rsi
callq 0xba30
testq %rbx, %rbx
je 0x1af57
cmpb $0x0, (%rbx)
je 0x1af57
cmpq $0x0, 0x8(%r14)
je 0x1af41
leaq 0x36414(%rip), %rsi     # 0x5134d
movq %r14, %rdi
callq 0xba30
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xba30
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/common/common.cc
// Function: normalize_path(char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void normalize_path(const char *path, string &normalized)
{
  SCDC_TRACE("normalize_path: path: '" << ((path)?path:"") << "'");

  normalized = "";

  if (!path) return;

  vector<string> parts;

  const char *p, *s = path;

  while (1)
  {
    p = strchr(s, '/');
    if (!p) p = s + strlen(s);

    string t(s, p - s);

    if (t == ".");
    else if (t == ".." && !parts.empty() && parts.back() != "..") parts.pop_back();
    else if (t.size() > 0) parts.push_back(t);
    
    if (p[0] == '\0') break;

    s = p + 1;
  }

  for (vector<string>::iterator i = parts.begin(); i != parts.end(); ++i)
  {
    if (path[0] == '/' || i != parts.begin()) normalized += "/";

    normalized += *i;
  }

  SCDC_TRACE("normalize_path: normalized: '" << normalized << "'");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x3753f(%rip), %rsi     # 0x524bd
movq %rbx, %rdi
callq 0xba40
testq %r14, %r14
je 0x1b0a8
movq %rsp, %rax
andq $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
leaq 0x18(%rsp), %r12
movq %r14, %r15
movq %r15, %rdi
pushq $0x2f
popq %rsi
callq 0xb1e0
movq %rax, %rbp
testq %rax, %rax
jne 0x1afc6
movq %r15, %rdi
callq 0xb210
movq %rax, %rbp
addq %r15, %rbp
leaq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %r12, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x1a1f2
movq %r12, %rdi
leaq 0x36368(%rip), %rsi     # 0x51350
callq 0x19be0
testb %al, %al
jne 0x1b04b
movq %r12, %rdi
leaq 0x36354(%rip), %rsi     # 0x5134f
callq 0x19be0
testb %al, %al
je 0x1b038
movq 0x8(%rsp), %rdi
cmpq %rdi, (%rsp)
je 0x1b038
addq $-0x20, %rdi
leaq 0x36335(%rip), %rsi     # 0x5134f
callq 0x1b1d7
testb %al, %al
je 0x1b038
movq 0x8(%rsp), %rdi
addq $-0x20, %rdi
movq %rdi, 0x8(%rsp)
callq 0xb230
jmp 0x1b04b
cmpq $0x0, 0x20(%rsp)
je 0x1b04b
movq %rsp, %rdi
movq %r12, %rsi
callq 0x1b1e2
movb (%rbp), %r13b
incq %rbp
movq %r12, %rdi
callq 0xb230
movq %rbp, %r15
testb %r13b, %r13b
jne 0x1afa5
movq (%rsp), %r15
leaq 0x362dc(%rip), %r12     # 0x5134d
cmpq 0x8(%rsp), %r15
je 0x1b0a0
cmpb $0x2f, (%r14)
je 0x1b084
cmpq (%rsp), %r15
je 0x1b08f
movq %rbx, %rdi
movq %r12, %rsi
callq 0xba30
movq %rbx, %rdi
movq %r15, %rsi
callq 0xba90
addq $0x20, %r15
jmp 0x1b071
movq %rsp, %rdi
callq 0x1b20e
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xb230
jmp 0x1b0cb
jmp 0x1b0c8
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1b20e
movq %rbx, %rdi
callq 0xb9a0
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/common/common.cc
// Function: abstimeout(timespec*, double, double)
void abstimeout(struct timespec *abstime, double timeout, double z_time_wtime_base)
{
  if (z_time_wtime_offset < 0)
  {
    struct timeval tv;
    gettimeofday(&tv, NULL);
    z_time_wtime_offset = (double) tv.tv_sec + (tv.tv_usec * 1e-6) - z_time_wtime();
  }

  double t = z_time_wtime_base;

  if (t < 0) t = z_time_wtime();

  t += timeout + z_time_wtime_offset;

  abstime->tv_sec = fabs(t);
  abstime->tv_nsec = (t - abstime->tv_sec) * 1e9;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
movsd 0x5a49d(%rip), %xmm2    # 0x75590
xorpd %xmm0, %xmm0
ucomisd %xmm2, %xmm0
jbe 0x1b14e
leaq 0x28(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
movsd %xmm1, (%rsp)
callq 0xb930
cvtsi2sdq (%r14), %xmm0
cvtsi2sdq 0x8(%r14), %xmm1
mulsd 0x34efc(%rip), %xmm1    # 0x50020
addsd %xmm0, %xmm1
movapd %xmm1, 0x10(%rsp)
callq 0x1b1a5
movapd 0x10(%rsp), %xmm2
movsd (%rsp), %xmm1
subsd %xmm0, %xmm2
xorpd %xmm0, %xmm0
movsd %xmm2, 0x5a442(%rip)    # 0x75590
ucomisd %xmm1, %xmm0
jbe 0x1b165
callq 0x1b1a5
movapd %xmm0, %xmm1
movsd 0x5a42b(%rip), %xmm2    # 0x75590
addsd 0x8(%rsp), %xmm2
addsd %xmm1, %xmm2
movapd 0x361b9(%rip), %xmm0    # 0x51330
andpd %xmm2, %xmm0
cvttsd2si %xmm0, %rax
cvtsi2sd %rax, %xmm0
subsd %xmm0, %xmm2
mulsd 0x3618f(%rip), %xmm2    # 0x51320
movq %rax, (%rbx)
cvttsd2si %xmm2, %rax
movq %rax, 0x8(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_pool.cc
// Function: scdc_dataprov_pool::close(scdc_dataprov*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov_pool::close(scdc_dataprov *dataprov, scdc_result &result)
{
  bool ret = false;

  for (iterator i = begin(); i != end(); ++i)
  {
    if (i->second != dataprov) continue;

    erase(i);

    ret = dataprov->close(result);

    delete dataprov;

    dataprov = 0;

    break;
  }

  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x18(%rdi), %rax
leaq 0x8(%rdi), %r12
cmpq %r12, %rax
je 0x1c172
cmpq %rbx, 0x40(%rax)
je 0x1c176
movq %rax, %rdi
callq 0xb380
jmp 0x1c15d
xorl %eax, %eax
jmp 0x1c19a
movq %r15, %rdi
movq %rax, %rsi
callq 0x1cf00
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x20(%rax)
movl %eax, %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_pool.cc
// Function: scdc_dataprov_pool::dataset_open_read_state(scdc_data*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
scdc_dataset *scdc_dataprov_pool::dataset_open_read_state(scdc_data *incoming, scdc_result &result)
{
  SCDC_TRACE("dataset_open_read_state:");

  char *buf;
  scdcint_t buf_size;
  const char *end;

  while (1)
  {
    buf = incoming->get_read_pos_buf();
    buf_size = incoming->get_read_pos_buf_size();
    end = memchr(buf, '|', buf_size);

    if (end) break;

    incoming->do_next();
  }

  scdc_dataprov *dataprov = 0;

  string dataprov_str(buf, end - buf);
  sscanf(dataprov_str.c_str(), "%p", &dataprov);

  incoming->inc_read_pos(end - buf + 1);

  if (!exists(dataprov))
  {
    result = "data provider not available";
    SCDC_FAIL(__func__ << ": " << result);
    return 0;
  }

  return dataprov->dataset_open_read_state(incoming, result);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
pushq $0x7c
popq %rbp
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rax
movq 0x8(%r14), %r12
addq %rax, %r12
subq %rax, %rdx
movq %r12, %rdi
movl %ebp, %esi
callq 0xb5f0
testq %rax, %rax
jne 0x1c4bb
movq 0x38(%r14), %rax
testq %rax, %rax
je 0x1c48a
movq %r14, %rdi
callq *%rax
jmp 0x1c48a
leaq 0x30(%rsp), %r13
andq $0x0, (%r13)
movq %rax, %rbx
subq %r12, %rbx
leaq 0x20(%rsp), %rcx
movq %rcx, -0x10(%rcx)
leaq 0x10(%rsp), %rbp
movq %rbp, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x1a1f2
movq (%rbp), %rdi
leaq 0x33fee(%rip), %rsi     # 0x504e0
movq %r13, %rdx
xorl %eax, %eax
callq 0xb510
movq 0x28(%r14), %rax
addq %rbx, %rax
incq %rax
movq %rax, 0x28(%r14)
movq (%r13), %r12
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x1c208
testb %al, %al
je 0x1c537
movq (%r12), %rax
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq *0x48(%rax)
movq %rax, %rbx
jmp 0x1c5c1
leaq 0x34fd3(%rip), %rsi     # 0x51511
movq %r15, %rdi
callq 0xba40
leaq 0x59033(%rip), %r14     # 0x75580
movq (%r14), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x1c5bf
addq $0x20, %rdi
callq 0xb800
movq (%r14), %rax
movq 0x8(%rax), %rdi
leaq 0x34c1a(%rip), %rsi     # 0x51188
callq 0xb520
leaq 0x34f1b(%rip), %rsi     # 0x51495
movq %rax, %rdi
callq 0xb520
leaq 0x34fa4(%rip), %rsi     # 0x5152d
movq %rax, %rdi
callq 0xb520
leaq 0x3850b(%rip), %rsi     # 0x54aa3
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
movq %r15, %rsi
callq 0xb490
movq %rax, %rdi
callq 0xb270
movq (%r14), %rdi
addq $0x20, %rdi
callq 0xb3e0
xorl %ebx, %ebx
leaq 0x10(%rsp), %rdi
callq 0xb230
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0