LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0xb08(%rax)
je 0x129d2
jmp 0x1299c
movq -0x8(%rbp), %rax
movq 0xb08(%rax), %rax
cmpq $0x0, 0x38(%rax)
je 0x129d0
movq -0x8(%rbp), %rax
movq 0xb08(%rax), %rax
movq 0x38(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0xb08(%rcx), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
callq *%rax
jmp 0x1299c
jmp 0x129d2
movq -0x8(%rbp), %rax
cmpq $0x0, 0xb18(%rax)
je 0x12a8f
movq -0x8(%rbp), %rax
movq 0xb18(%rax), %rax
addq $0x8, %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rdx
addq $0x768, %rdx            # imm = 0x768
leaq 0x95bef(%rip), %rsi     # 0xa8608
movq $-0x1, %rcx
callq 0x11f90
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rdx
addq $0x368, %rdx            # imm = 0x368
movq -0x8(%rbp), %rax
movq 0x158(%rax), %rcx
leaq 0x92e08(%rip), %rsi     # 0xa585a
callq 0x11f90
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0xb18(%rcx), %rcx
cmpq (%rcx), %rax
jl 0x12a8b
movq 0xc155e(%rip), %rax     # 0xd3fd8
movq (%rax), %rdi
leaq 0x92df2(%rip), %rsi     # 0xa5876
movb $0x0, %al
callq 0xc9a0
jmp 0x12a8d
jmp 0x12a8f
movq -0x8(%rbp), %rax
cmpq $0x0, 0xb10(%rax)
je 0x12b04
movq -0x8(%rbp), %rax
movq 0xb10(%rax), %rax
leaq 0x61(%rip), %rcx        # 0x12b10
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0xb10(%rax), %rax
movq %rcx, 0x40(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x878(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x870(%rax)
movq -0x8(%rbp), %rax
movq 0xb10(%rax), %rax
movq 0x38(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0xb10(%rcx), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1344b
movq -0x10(%rbp), %rax
movq 0x208(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x148(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
addq $0x4, %rdx
leaq 0x9249a(%rip), %rsi     # 0xa58bc
movq $-0x1, %rcx
callq 0x127b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x210(%rax), %rdx
leaq 0x9247f(%rip), %rsi     # 0xa58c3
callq 0x13490
jmp 0x13485
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
addq $0x4, %rdx
leaq 0x9245e(%rip), %rsi     # 0xa58bc
movq $-0x1, %rcx
callq 0x13340
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x210(%rax), %rdx
leaq 0x92443(%rip), %rsi     # 0xa58c3
callq 0x134f0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
je 0x135cc
movq -0x8(%rbp), %rax
movq 0x148(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x208(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x92316(%rip), %rsi     # 0xa58bc
xorl %eax, %eax
movl %eax, %ecx
callq 0x12810
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
addq $0x210, %rdx            # imm = 0x210
leaq 0x922fe(%rip), %rsi     # 0xa58c3
callq 0x13610
jmp 0x135ff
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x922e1(%rip), %rsi     # 0xa58bc
xorl %eax, %eax
movl %eax, %ecx
callq 0x132e0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
addq $0x210, %rdx            # imm = 0x210
leaq 0x922c9(%rip), %rsi     # 0xa58c3
callq 0x13670
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq 0xc07f1(%rip), %rax     # 0xd3fb0
movq (%rax), %rdi
leaq 0x92048(%rip), %rsi     # 0xa5811
leaq 0x9220b(%rip), %rdx     # 0xa59db
movb $0x0, %al
callq 0xc9a0
movq 0xc07d2(%rip), %rax     # 0xd3fb0
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %r9
leaq 0x9220b(%rip), %rsi     # 0xa5a03
movb $0x0, %al
callq 0xc9a0
movq 0xc07aa(%rip), %rax     # 0xd3fb0
movq (%rax), %rdi
leaq 0x92098(%rip), %rsi     # 0xa58a8
movb $0x0, %al
callq 0xc9a0
jmp 0x13819
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x1383a
movq 0xc07af(%rip), %rax     # 0xd3fd8
movq (%rax), %rdi
leaq 0x921f0(%rip), %rsi     # 0xa5a23
movb $0x0, %al
callq 0xc9a0
jmp 0x1383c
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x171f0
movq -0x8(%rbp), %rax
cmpq $0x0, 0xba8(%rax)
je 0x138a6
movq -0x8(%rbp), %rax
movq 0xba8(%rax), %rax
movq %rax, -0x28(%rbp)
callq 0x152e0
movq -0x28(%rbp), %rdi
movl %eax, %edx
movq -0x8(%rbp), %rcx
addq $0x880, %rcx            # imm = 0x880
movq -0x8(%rbp), %rax
movq 0x868(%rax), %rax
subq $0x1, %rax
imulq $0x28, %rax, %rax
addq %rax, %rcx
addq $0x8, %rcx
leaq 0x921a0(%rip), %rsi     # 0xa5a41
callq 0x10680
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: mh0fm4[P]SCDC/src/lib/redirect/redirect/redirect_call.cc
// Function: redirect_call_free_buf(_redirect_call_t*, long)
static void redirect_call_free_buf(redirect_call_t *rc, rdint_t buf_index)
{
  if (buf_index < 0 || buf_index >= rc->free_nbufs) return;

  free(rc->free_bufs[buf_index]);

  --rc->free_nbufs;

  if (buf_index != rc->free_nbufs) rc->free_bufs[buf_index] = rc->free_bufs[rc->free_nbufs];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jl 0x1632b
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0xb20(%rcx), %rcx
cmpq %rcx, %rax
jl 0x1632d
jmp 0x16390
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0xb28(%rax,%rcx,8), %rdi
callq 0xc830
movq -0x8(%rbp), %rax
movl 0xb20(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xb20(%rax)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0xb20(%rcx), %rcx
cmpq %rcx, %rax
je 0x16390
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq 0xb20(%rcx), %rcx
movq 0xb28(%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rdx, 0xb28(%rax,%rcx,8)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/lib/redirect/redirect/redirect_call.cc
// Function: long redirect_call_get_inout_conf_val<float, 3>(char const*, char const*, float*)
static rdint_t redirect_call_get_inout_conf_val(const char *conf, const char *id, T *x)
{
  const char *s = strchr(conf, ':');

  char t[32];
  sprintf(t, "%s %%n", SCANF_FMT(F));

  int n;
  sscanf(s + 1, t, SCANF_PTR(F, x), &n);

  return s + 1 + n - conf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movl $0x3a, %esi
callq 0xc220
movq %rax, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
movq 0xbb6ef(%rip), %rdx     # 0xd1b20
leaq 0x8f59c(%rip), %rsi     # 0xa59d4
movb $0x0, %al
callq 0xc0f0
movq -0x20(%rbp), %rdi
addq $0x1, %rdi
leaq -0x40(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x44(%rbp), %rcx
movb $0x0, %al
callq 0xc640
movq -0x20(%rbp), %rax
addq $0x1, %rax
movslq -0x44(%rbp), %rcx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/lib/redirect/redirect/redirect_call.cc
// Function: long redirect_call_put_inout_conf_vals<float, 3>(char*, char const*, float const*, long)
static rdint_t redirect_call_put_inout_conf_vals(char *conf, const char *id, const T *x, rdint_t n)
{
  char *s = conf;

  s += sprintf(s, "%s", id);

  rdint_t i;
  for (i = 0; i < n; ++i)
  {
    *s = ':';
    ++s;

    s += sprintf(s, PRINTF_FMT(F), x[i]);
  }

  *s = ' ';
  ++s;
  *s = '\0';

  return s - conf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x8f727(%rip), %rsi     # 0xa5bd6
movb $0x0, %al
callq 0xc0f0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x1652c
movq -0x28(%rbp), %rax
movb $0x3a, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq 0xbb622(%rip), %rsi     # 0xd1b18
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
cvtss2sd %xmm0, %xmm0
movb $0x1, %al
callq 0xc0f0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x164ce
movq -0x28(%rbp), %rax
movb $0x20, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mh0fm4[P]SCDC/src/lib/redirect/redirect/redirect_call.cc
// Function: long redirect_call_get_inout_conf_vals<float, 3>(char const*, char const*, float*, long)
static rdint_t redirect_call_get_inout_conf_vals(const char *conf, const char *id, T *x, rdint_t n)
{
  const char *s = conf;
  
  s = strchr(s, ':');

  char t[32];
  sprintf(t, ":%s %%n", SCANF_FMT(F));

  rdint_t i;
  for (i = 0; i < n; ++i)
  {
    int ns;
    sscanf(s, t, SCANF_PTR(F, &x[i]), &ns);
    s += ns;
  }

  return s - conf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl $0x3a, %esi
callq 0xc220
movq %rax, -0x28(%rbp)
leaq -0x50(%rbp), %rdi
movq 0xbb583(%rip), %rdx     # 0xd1b20
leaq 0x8f42f(%rip), %rsi     # 0xa59d3
movb $0x0, %al
callq 0xc0f0
movq $0x0, -0x58(%rbp)
movq -0x58(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x165fe
movq -0x28(%rbp), %rdi
leaq -0x50(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x58(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdx
leaq -0x5c(%rbp), %rcx
movb $0x0, %al
callq 0xc640
movl -0x5c(%rbp), %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
jmp 0x165b3
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x10, 0x868(%rax)
jl 0x1722a
movq 0xbcdbf(%rip), %rax     # 0xd3fd8
movq (%rax), %rdi
leaq 0x8e826(%rip), %rsi     # 0xa5a49
movb $0x0, %al
callq 0xc9a0
jmp 0x1722c
movq -0x8(%rbp), %rax
addq $0x880, %rax            # imm = 0x880
movq -0x8(%rbp), %rcx
imulq $0x28, 0x868(%rcx), %rcx
addq %rcx, %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
addq $0x880, %rax            # imm = 0x880
movq -0x8(%rbp), %rcx
imulq $0x28, 0x868(%rcx), %rcx
addq %rcx, %rax
movl $0x1, 0x4(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
addq $0x880, %rax            # imm = 0x880
movq -0x8(%rbp), %rdx
imulq $0x28, 0x868(%rdx), %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
shlq $0x0, %rcx
movq -0x8(%rbp), %rax
addq $0x880, %rax            # imm = 0x880
movq -0x8(%rbp), %rdx
imulq $0x28, 0x868(%rdx), %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x868(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x868(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x10, 0xb20(%rax)
jl 0x172f7
movq $0x0, -0x8(%rbp)
jmp 0x1733a
movq -0x18(%rbp), %rdi
callq 0xc900
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0xb20(%rcx), %rcx
movq %rdx, 0xb28(%rax,%rcx,8)
movq -0x10(%rbp), %rax
movl 0xb20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xb20(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/lib/redirect/redirect/redirect_call.cc
// Function: redirect_call_find_buf(_redirect_call_t*, void const*)
static rdint_t redirect_call_find_buf(redirect_call_t *rc, const void *buf)
{
  rdint_t i;
  for (i = 0; i < rc->free_nbufs; ++i)
  {
    if (rc->free_bufs[i] == buf) return i;
  }

  return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0xb20(%rcx), %rcx
cmpq %rcx, %rax
jge 0x176a8
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0xb28(%rax,%rcx,8), %rax
cmpq -0x18(%rbp), %rax
jne 0x17698
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x176b0
jmp 0x1769a
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x17664
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/lib/redirect/redirect/redirect_call.cc
// Function: void consume_output_dense<char>(_redirect_call_t*, char*, 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
shlq $0x0, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0xb10(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0xb10(%rcx), %rcx
movq 0x20(%rcx), %rcx
movq -0x8(%rbp), %rdx
movslq 0xb04(%rdx), %rdx
subq %rdx, %rcx
cmpq %rcx, %rax
jge 0x177ab
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x177cc
movq -0x8(%rbp), %rax
movq 0xb10(%rax), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0xb04(%rcx), %rcx
subq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rdx
movslq 0xb04(%rdx), %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
je 0x1780e
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x8(%rbp), %rax
movslq 0xb04(%rax), %rax
addq %rax, %rsi
movq -0x38(%rbp), %rdx
callq 0xc530
movq -0x38(%rbp), %rdx
movq -0x8(%rbp), %rax
movslq 0xb04(%rax), %rcx
addq %rdx, %rcx
movl %ecx, 0xb04(%rax)
movq -0x38(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jg 0x1784a
jmp 0x178b1
movq -0x8(%rbp), %rax
movq 0xb10(%rax), %rax
cmpq $0x0, 0x38(%rax)
je 0x17882
movq -0x8(%rbp), %rax
movq 0xb10(%rax), %rax
movq 0x38(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0xb10(%rcx), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
callq *%rax
cmpq $0x1, %rax
je 0x17884
jmp 0x178b1
movq -0x8(%rbp), %rax
movq 0xb10(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0xb04(%rax)
movb $0x1, %al
testb $0x1, %al
jne 0x1777b
jmp 0x178b1
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mh0fm4[P]SCDC/src/lib/redirect/redirect/redirect_call.cc
// Function: void register_param_blocks<float>(_redirect_call_t*, float const*, long, long, long)
static void register_param_blocks(redirect_call_t *rc, const T *buf, rdint_t count, rdint_t size, rdint_t stride)
{
  ASSERT(rc->nparams < REDIRECT_CALL_PARAMS_MAX);

  rc->params[rc->nparams].type = REDIRECT_PARAM_TYPE_BLOCKS;
#if REDIRECT_CALL_PARAMS_CACHE
  rc->params[rc->nparams].cacheable = 0;
#endif
  rc->params[rc->nparams].p.blocks.buf = const_cast<T *>(buf);
  rc->params[rc->nparams].p.blocks.count = count;
  rc->params[rc->nparams].p.blocks.size = size * sizeof(T);
  rc->params[rc->nparams].p.blocks.stride = stride * sizeof(T);

  ++rc->nparams;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x10, 0x868(%rax)
jl 0x18a72
movq 0xbb577(%rip), %rax     # 0xd3fd8
movq (%rax), %rdi
leaq 0x8cfde(%rip), %rsi     # 0xa5a49
movb $0x0, %al
callq 0xc9a0
jmp 0x18a74
movq -0x8(%rbp), %rax
addq $0x880, %rax            # imm = 0x880
movq -0x8(%rbp), %rcx
imulq $0x28, 0x868(%rcx), %rcx
addq %rcx, %rax
movl $0x1, (%rax)
movq -0x8(%rbp), %rax
addq $0x880, %rax            # imm = 0x880
movq -0x8(%rbp), %rcx
imulq $0x28, 0x868(%rcx), %rcx
addq %rcx, %rax
movl $0x0, 0x4(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
addq $0x880, %rax            # imm = 0x880
movq -0x8(%rbp), %rdx
imulq $0x28, 0x868(%rdx), %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
addq $0x880, %rax            # imm = 0x880
movq -0x8(%rbp), %rdx
imulq $0x28, 0x868(%rdx), %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
shlq $0x2, %rcx
movq -0x8(%rbp), %rax
addq $0x880, %rax            # imm = 0x880
movq -0x8(%rbp), %rdx
imulq $0x28, 0x868(%rdx), %rdx
addq %rdx, %rax
movq %rcx, 0x18(%rax)
movq -0x28(%rbp), %rcx
shlq $0x2, %rcx
movq -0x8(%rbp), %rax
addq $0x880, %rax            # imm = 0x880
movq -0x8(%rbp), %rdx
imulq $0x28, 0x868(%rdx), %rdx
addq %rdx, %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x868(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x868(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq 0xb6b61(%rip), %rax     # 0xd3fb0
movq (%rax), %rdi
leaq 0x883b8(%rip), %rsi     # 0xa5811
leaq 0x886fb(%rip), %rdx     # 0xa5b5b
movb $0x0, %al
callq 0xc9a0
movq 0xb6b42(%rip), %rax     # 0xd3fb0
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %r8
movq -0x20(%rbp), %r9
leaq 0x88578(%rip), %rsi     # 0xa5a03
movb $0x0, %al
callq 0xc9a0
movq 0xb6b17(%rip), %rax     # 0xd3fb0
movq (%rax), %rdi
leaq 0x88405(%rip), %rsi     # 0xa58a8
movb $0x0, %al
callq 0xc9a0
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
je 0x1d4ee
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1d4d8
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
shlq $0x0, %rsi
callq 0x172d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x17740
jmp 0x1d515
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1d513
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
shlq $0x0, %rsi
callq 0x172d0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x1d515
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
callq 0x55f60
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x56000
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x21c34
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdx
callq 0x56070
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x21bf3
movq -0x10(%rbp), %rdi
callq 0x57570
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x55f90
movl -0x24(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: mh0fm4[P]SCDC/src/lib/scdc/scdc.cc
// Function: scdc_init_intern
scdcint_t scdc_init_intern(const char *conf, scdc_args_t *args)
{
  SCDC_TRACE(__func__ << ": conf: '" << conf << "'");

  scdcint_t ret = (scdc_main_context.init(conf, args))?SCDC_SUCCESS:SCDC_FAILURE;

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

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x21c92
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0xb2a37(%rip), %rdi     # 0xd46d8
callq 0x25140
movb %al, %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x21cbc
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x21d0e
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %r9, -0xd8(%rbp)
movq %r8, -0xe0(%rbp)
movq %rcx, -0xe8(%rbp)
movq %rdx, -0xf0(%rbp)
movq %rsi, -0xf8(%rbp)
movq %rdi, -0x8(%rbp)
jmp 0x21d37
leaq -0x40(%rbp), %rax
leaq -0x100(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x21da0
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x21c80
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x21e20
leaq -0x40(%rbp), %rax
jmp 0x21d88
movq -0x48(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x10, %edi
callq 0xc690
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
leaq 0x2985(%rip), %rcx      # 0x24770
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
leaq 0x31e6(%rip), %rcx      # 0x24fe0
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
leaq -0x1a9(%rip), %rcx      # 0x21c60
movq %rcx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/lib/scdc/scdc.cc
// Function: scdc_release
void scdc_release()
{
  SCDC_TRACE(__func__ << ":");

  scdc_release_intern();

  SCDC_TRACE(__func__ << ": return");

  scdc_log_release_intern();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
jmp 0x21e86
jmp 0x21e88
callq 0x21e60
jmp 0x21e8f
callq 0x21ea0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/lib/scdc/scdc.cc
// Function: scdc_last_result
const char *scdc_last_result()
{
  SCDC_TRACE(__func__ << ":");

  const char *result = SCDC_RESULT_STR(scdc_main_context.data->result);

  SCDC_TRACE(__func__ << ": return: " << static_cast<void *>(result));

  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
jmp 0x21ec6
movq 0xb2853(%rip), %rax     # 0xd4720
movq (%rax), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x21eda
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: mh0fm4[P]SCDC/src/lib/scdc/scdc.cc
// Function: scdc_log_init_intern
scdcint_t scdc_log_init_intern(const char *conf, scdc_args_t *args)
{
  SCDC_TRACE(__func__ << ": conf: '" << conf << "'");

  bool ret = SCDC_MAIN_LOG()->init(conf, args);

  SCDC_TRACE(__func__ << ": return");

  return (ret)?SCDC_SUCCESS:SCDC_FAILURE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x21f92
movq 0xb270f(%rip), %rdi     # 0xd46a8
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x4dc00
andb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0x21fad
movb -0x11(%rbp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovneq %rcx, %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x2200e
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %r9, -0xd8(%rbp)
movq %r8, -0xe0(%rbp)
movq %rcx, -0xe8(%rbp)
movq %rdx, -0xf0(%rbp)
movq %rsi, -0xf8(%rbp)
movq %rdi, -0x8(%rbp)
jmp 0x22037
leaq -0x40(%rbp), %rax
leaq -0x100(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x21da0
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x21f80
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x21e20
leaq -0x40(%rbp), %rax
jmp 0x22088
movq -0x48(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x25660
leaq -0x78(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0xc960
movq -0xa8(%rbp), %rcx
movq -0xa0(%rbp), %r8
movq 0xb2610(%rip), %rdi     # 0xd4720
addq $0x38, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2bfd0
movq %rax, -0x98(%rbp)
jmp 0x2212a
movq -0x98(%rbp), %rax
movq %rax, -0x80(%rbp)
movq 0xb25e4(%rip), %rax     # 0xd4720
movq (%rax), %rax
addq $0x8, %rax
movq %rax, -0xb0(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xc260
movq -0xb0(%rbp), %rdi
movq %rax, %rsi
movq 0xb25bc(%rip), %rax     # 0xd4720
movq (%rax), %rax
movq (%rax), %rdx
subq $0x1, %rdx
callq 0xc320
cmpq $0x0, -0x80(%rbp)
jne 0x221b4
movq $0x0, -0x8(%rbp)
movl $0x1, -0x90(%rbp)
jmp 0x221c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xc3e0
leaq -0x58(%rbp), %rdi
callq 0x256b0
jmp 0x221e5
movq -0x80(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x90(%rbp)
leaq -0x78(%rbp), %rdi
callq 0xc3e0
leaq -0x58(%rbp), %rdi
callq 0x256b0
movq -0x8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0xcba0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
testb %al, %al
je 0x22241
movaps %xmm0, -0xe0(%rbp)
movaps %xmm1, -0xd0(%rbp)
movaps %xmm2, -0xc0(%rbp)
movaps %xmm3, -0xb0(%rbp)
movaps %xmm4, -0xa0(%rbp)
movaps %xmm5, -0x90(%rbp)
movaps %xmm6, -0x80(%rbp)
movaps %xmm7, -0x70(%rbp)
movq %r9, -0xe8(%rbp)
movq %r8, -0xf0(%rbp)
movq %rcx, -0xf8(%rbp)
movq %rdx, -0x100(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x22267
leaq -0x30(%rbp), %rax
leaq -0x110(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
leaq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x21da0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x220c0
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x21e20
leaq -0x30(%rbp), %rax
jmp 0x222bc
movq -0x58(%rbp), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
jmp 0x222de
cmpq $0x0, -0x8(%rbp)
jne 0x222ea
jmp 0x22374
leaq -0x28(%rbp), %rdi
callq 0xc960
testb $0x1, 0xb242e(%rip)     # 0xd4728
jne 0x2232f
movq 0xb241d(%rip), %rdi     # 0xd4720
addq $0x38, %rdi
movq -0x8(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x2d770
jmp 0x22316
jmp 0x2232f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xc3e0
jmp 0x2237a
movq 0xb23ea(%rip), %rax     # 0xd4720
movq (%rax), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xc260
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movq 0xb23c8(%rip), %rax     # 0xd4720
movq (%rax), %rax
movq (%rax), %rdx
subq $0x1, %rdx
callq 0xc320
jmp 0x22369
jmp 0x2236b
leaq -0x28(%rbp), %rdi
callq 0xc3e0
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0xcba0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x25660
movq -0x78(%rbp), %rdx
movq 0xb2361(%rip), %rdi     # 0xd4720
addq $0x68, %rdi
movq -0x10(%rbp), %rsi
callq 0x53630
movq %rax, -0x70(%rbp)
jmp 0x223d2
movq -0x70(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
jne 0x22409
movq $0x0, -0x8(%rbp)
movl $0x1, -0x68(%rbp)
jmp 0x22418
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x256b0
jmp 0x2242e
movq -0x58(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x68(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x256b0
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0xcba0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x2247e
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %r9, -0xd8(%rbp)
movq %r8, -0xe0(%rbp)
movq %rcx, -0xe8(%rbp)
movq %rdx, -0xf0(%rbp)
movq %rsi, -0xf8(%rbp)
movq %rdi, -0x8(%rbp)
jmp 0x224a7
leaq -0x20(%rbp), %rax
leaq -0x100(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
leaq -0x40(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x21da0
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x22390
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x21e20
leaq -0x20(%rbp), %rax
jmp 0x224f8
movq -0x48(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/lib/scdc/scdc.cc
// Function: scdc_nodeport_close
void scdc_nodeport_close(scdc_nodeport_t nodeport)
{
  SCDC_TRACE(__func__ << ": nodeport: '" << nodeport << "'");

  if (nodeport == SCDC_NODEPORT_NULL) return;

  if (!scdc_main_context_destroyed) scdc_main_context.data->nodeports.close(static_cast<scdc_nodeport *>(nodeport));

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
jmp 0x2251e
cmpq $0x0, -0x8(%rbp)
jne 0x22527
jmp 0x22548
testb $0x1, 0xb21fa(%rip)     # 0xd4728
jne 0x22544
movq 0xb21e9(%rip), %rdi     # 0xd4720
addq $0x68, %rdi
movq -0x8(%rbp), %rsi
callq 0x53bd0
jmp 0x22546
jmp 0x22548
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
jmp 0x22562
cmpq $0x0, -0x10(%rbp)
jne 0x22573
movq $0x0, -0x8(%rbp)
jmp 0x2259f
movq -0x10(%rbp), %rdi
movq 0xb21a2(%rip), %rsi     # 0xd4720
addq $0x38, %rsi
callq 0x256f0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
callq *0x28(%rax)
jmp 0x22597
movq $0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
jmp 0x225be
cmpq $0x0, -0x10(%rbp)
jne 0x225cf
movq $0x0, -0x8(%rbp)
jmp 0x225f0
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x256f0
jmp 0x225e8
movq $0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mh0fm4[P]SCDC/src/lib/scdc/scdc.cc
// Function: scdc_nodeport_cancel
scdcint_t scdc_nodeport_cancel(scdc_nodeport_t nodeport, scdcint_t interrupt)
{
  SCDC_TRACE(__func__ << ": nodeport: '" << nodeport << "'");

  if (nodeport == SCDC_NODEPORT_NULL) return SCDC_FAILURE;

  static_cast<scdc_nodeport *>(nodeport)->cancel(interrupt);

  SCDC_TRACE(__func__ << ": return");

  return SCDC_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
jmp 0x22612
cmpq $0x0, -0x10(%rbp)
jne 0x22623
movq $0x0, -0x8(%rbp)
jmp 0x22648
movq -0x10(%rbp), %rdi
cmpq $0x0, -0x18(%rbp)
setne %cl
movq (%rdi), %rax
movq 0x38(%rax), %rax
movzbl %cl, %esi
andl $0x1, %esi
callq *%rax
jmp 0x22640
movq $0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x25660
leaq -0x70(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0xc960
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
movq -0x10(%rbp), %rdi
callq 0x531b0
movb %al, -0x89(%rbp)
jmp 0x226b6
movb -0x89(%rbp), %al
andb $0x1, %al
movb %al, -0x71(%rbp)
testb $0x1, -0x71(%rbp)
je 0x226d8
leaq -0x70(%rbp), %rdi
callq 0xc460
cmpq $0x3ff, %rax            # imm = 0x3FF
jbe 0x2270f
movq $0x0, -0x8(%rbp)
movl $0x1, -0x88(%rbp)
jmp 0x22741
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xc3e0
leaq -0x50(%rbp), %rdi
callq 0x256b0
jmp 0x22760
leaq -0x70(%rbp), %rdi
callq 0xc260
movq %rax, %rsi
leaq 0xb200e(%rip), %rdi     # 0xd4730
movl $0x400, %edx            # imm = 0x400
callq 0xc320
leaq 0xb1ffd(%rip), %rax     # 0xd4730
movq %rax, -0x8(%rbp)
movl $0x1, -0x88(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xc3e0
leaq -0x50(%rbp), %rdi
callq 0x256b0
movq -0x8(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0xcba0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x227ae
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %r9, -0xd8(%rbp)
movq %r8, -0xe0(%rbp)
movq %rcx, -0xe8(%rbp)
movq %rdx, -0xf0(%rbp)
movq %rsi, -0xf8(%rbp)
movq %rdi, -0x8(%rbp)
jmp 0x227d7
leaq -0x20(%rbp), %rax
leaq -0x100(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
leaq -0x40(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x21da0
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x22660
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x21e20
leaq -0x20(%rbp), %rax
jmp 0x22828
movq -0x48(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x25660
leaq -0x68(%rbp), %rdi
callq 0xc960
movq -0x88(%rbp), %rsi
movq -0x8(%rbp), %rdi
callq 0x53580
movb %al, -0x7d(%rbp)
jmp 0x22885
movb -0x7d(%rbp), %al
andb $0x1, %al
movb %al, -0x69(%rbp)
movb -0x69(%rbp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, -0x90(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xc3e0
leaq -0x48(%rbp), %rdi
callq 0x256b0
movq -0x90(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xc3e0
leaq -0x48(%rbp), %rdi
callq 0x256b0
movq -0x78(%rbp), %rdi
callq 0xcba0
nop
// File: mh0fm4[P]SCDC/src/lib/scdc/scdc.cc
// Function: scdc_dataset_inout_next_hash
scdcint_t scdc_dataset_inout_next_hash(scdc_dataset_inout_t *inout)
{
  SCDC_TRACE_DATASET_INPUT(inout, __func__ << ": inout: ");

  if (!inout) return 0;

  SCDC_TRACE(__func__ << ": next: " << reinterpret_cast<void *>(inout->next));
  SCDC_TRACE(__func__ << ": data: " << static_cast<void *>(inout->data));
  SCDC_TRACE(__func__ << ": intern_data: " << static_cast<void *>(inout->intern_data));

  scdcint_t next_hash = pointer2scdcint(reinterpret_cast<void *>(inout->next)) ^ pointer2scdcint(inout->data) ^ pointer2scdcint(inout->intern_data);

  SCDC_TRACE(__func__ << ": next_hash: " << next_hash << " (" << pointer2scdcint(reinterpret_cast<void *>(inout->next)) << " + " << pointer2scdcint(inout->data) << " + " << pointer2scdcint(inout->intern_data) << ")");

  return next_hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
jmp 0x229ce
cmpq $0x0, -0x10(%rbp)
jne 0x229df
movq $0x0, -0x8(%rbp)
jmp 0x22a3c
jmp 0x229e1
jmp 0x229e3
jmp 0x229e5
jmp 0x229e7
jmp 0x229e9
jmp 0x229eb
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x22a50
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x22a50
movq %rax, %rcx
movq -0x28(%rbp), %rax
xorq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x22a50
movq %rax, %rcx
movq -0x20(%rbp), %rax
xorq %rcx, %rax
movq %rax, -0x18(%rbp)
jmp 0x22a34
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)