LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/lib/redirect/redirect/redirect_cache.cc
// Function: redirect_cache_init
void redirect_cache_init(redirect_cache_t *rch)
{
  TRACE_F(" ");

  rch->client = 0;

  redirect_cache_reset_params(rch);

  rch->nentries = 0;
}

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

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

    entries[nentries] = i;
    ++nentries;

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

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

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

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

  const char *s = state;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x7c91e(%rip), %r12     # 0x8bfa0
movq (%r12), %rdi
leaq 0x59f02(%rip), %rsi     # 0x6958f
leaq 0x5a0ea(%rip), %rdx     # 0x6977e
xorl %eax, %eax
callq 0xb7a0
movq (%r12), %rdi
leaq 0x5a03f(%rip), %rsi     # 0x696e5
movl %r15d, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0xb7a0
movq (%r12), %rsi
movl $0xa, %edi
callq 0xb690
cmpq $0x0, 0x8(%rbx)
jle 0xf706
leaq 0x38(%rbx), %r15
leaq 0x59f6f(%rip), %r12     # 0x69642
xorl %r13d, %r13d
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0xb4e0
movq %r14, %rdi
movl $0x3a, %esi
callq 0xb1e0
movq %rax, %r14
incq %r14
incq %r13
addq $0x28, %r15
cmpq 0x8(%rbx), %r13
jl 0xf6d6
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/lib/redirect/redirect/redirect_cache.cc
// Function: redirect_cache_put_entry
rdint_t redirect_cache_put_entry(redirect_cache_t *rch, int type, rdint_t size, const void *buf)
{
  rdint_t entry_index = redirect_cache_find_entry(rch, type, size, buf);

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

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

  entry_index = rch->nentries;

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

  ++rch->nentries;

  return entry_index;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movq 0x298(%rdi), %rax
testq %rax, %rax
jle 0xf7b1
leaq 0x2b8(%r15), %r13
xorl %r12d, %r12d
cmpl %ebp, -0x18(%r13)
jne 0xf752
cmpq %r14, -0x10(%r13)
jne 0xf752
cmpq %rbx, -0x8(%r13)
je 0xf7ee
incq %r12
addq $0x20, %r13
cmpq %r12, %rax
jne 0xf73c
cmpq $0x10, %rax
jl 0xf7b1
movq 0x7c835(%rip), %rbx     # 0x8bfa0
movq (%rbx), %rdi
leaq 0x59e1a(%rip), %rsi     # 0x6958f
leaq 0x5a01d(%rip), %rdx     # 0x69799
xorl %eax, %eax
callq 0xb7a0
movq (%rbx), %rdi
movq 0x298(%r15), %rdx
leaq 0x5a047(%rip), %rsi     # 0x697db
xorl %eax, %eax
callq 0xb7a0
movq (%rbx), %rsi
movl $0xa, %edi
callq 0xb690
movq $-0x1, %rax
jmp 0xf7df
leaq 0x2a0(%r15), %rcx
movq %rax, %rdx
shlq $0x5, %rdx
movl %ebp, (%rcx,%rdx)
movq %r14, 0x8(%rcx,%rdx)
movq %rbx, 0x10(%rcx,%rdx)
movl $0x0, 0x18(%rcx,%rdx)
leaq 0x1(%rax), %rcx
movq %rcx, 0x298(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x7c7ab(%rip), %r15     # 0x8bfa0
movq (%r15), %rdi
leaq 0x59d90(%rip), %rsi     # 0x6958f
leaq 0x59f93(%rip), %rdx     # 0x69799
xorl %eax, %eax
callq 0xb7a0
movq (%r15), %rdi
leaq 0x59f9b(%rip), %rsi     # 0x697b2
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r8
movq %r12, %r9
xorl %eax, %eax
callq 0xb7a0
movq (%r15), %rsi
movl $0xa, %edi
callq 0xb690
movl $0x0, (%r13)
movq %r12, %rax
jmp 0xf7df
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/lib/redirect/redirect/redirect_call.cc
// Function: redirect_call_create_scdc
int redirect_call_create_scdc(redirect_call_t *rc, const char *op, const char *uri)
{
  rc->client = 1;

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

  rc->dataset = SCDC_DATASET_NULL;

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

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

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

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

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

  rc->free_nbufs = 0;

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

  return 1;
}

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

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

  if (!n) n = &_n;

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

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

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

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

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

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xb08(%rdi), %rdi
testq %rdi, %rdi
je 0x10269
movq 0x38(%rdi), %rax
testq %rax, %rax
je 0x10269
xorl %esi, %esi
callq *%rax
movq 0xb08(%rbx), %rdi
jmp 0x10253
movq 0xb18(%rbx), %r12
testq %r12, %r12
je 0x102de
leaq 0x8(%r12), %r14
leaq 0x768(%rbx), %r15
movq %r15, %rdi
callq 0xb200
leaq 0x59653(%rip), %rsi     # 0x698e3
leaq 0x5c371(%rip), %rdx     # 0x6c608
movq %r14, %rdi
movq %rax, %rcx
movl %eax, %r8d
movq %r15, %r9
xorl %eax, %eax
callq 0xb0d0
movslq %eax, %r14
leaq (%r12,%r14), %rdi
addq $0x8, %rdi
leaq 0x368(%rbx), %rdx
movq 0x158(%rbx), %rcx
leaq 0x595a8(%rip), %rsi     # 0x69872
callq 0xfd2d
addq %r14, %rax
movq 0xb18(%rbx), %rcx
cmpq (%rcx), %rax
jge 0x1031c
movq 0xb10(%rbx), %rdi
testq %rdi, %rdi
je 0x10310
leaq 0x32(%rip), %rax        # 0x10323
movq %rax, 0x38(%rdi)
movq %rbx, 0x40(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x870(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x10323
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0xbaec
jmp 0x102de
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/lib/redirect/redirect/redirect_call.cc
// Function: redirect_call_cmd
int redirect_call_cmd(redirect_call_t *rc, const char *cmd, const char *params, scdc_dataset_input_t *input, scdc_dataset_output_t *output, scdc_result_t *result)
{
  TRACE_F("cmd: '%s', params: '%s', input: %p, output: %p, result: %p", cmd, params, input, output, result);

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

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

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

  return 1;
}

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, (%rdi)
je 0x10877
movq 0x208(%r14), %rax
movq %rax, 0x148(%rbx)
leaq 0x4(%r14), %r15
movq 0x150(%rbx), %rax
leaq (%rbx,%rax), %r12
addq $0x168, %r12            # imm = 0x168
movq %r15, %rdi
callq 0xb200
leaq 0x590b0(%rip), %rsi     # 0x698e3
leaq 0x5909a(%rip), %rdx     # 0x698d4
movq %r12, %rdi
movq %rax, %rcx
movl %eax, %r8d
movq %r15, %r9
xorl %eax, %eax
callq 0xb0d0
cltq
addq %rax, 0x150(%rbx)
movq 0x210(%r14), %rdx
leaq 0x59077(%rip), %rsi     # 0x698db
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x108e0
leaq 0x4(%r14), %r15
movq 0x158(%rbx), %rax
leaq (%rbx,%rax), %r12
addq $0x368, %r12            # imm = 0x368
movq %r15, %rdi
callq 0xb200
leaq 0x59047(%rip), %rsi     # 0x698e3
leaq 0x59031(%rip), %rdx     # 0x698d4
movq %r12, %rdi
movq %rax, %rcx
movl %eax, %r8d
movq %r15, %r9
xorl %eax, %eax
callq 0xb0d0
cltq
addq %rax, 0x158(%rbx)
movq 0x210(%r14), %rdx
leaq 0x5900e(%rip), %rsi     # 0x698db
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x10940
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/lib/redirect/redirect/redirect_call.cc
// Function: redirect_call_get_handle
void redirect_call_get_handle(redirect_call_t *rc, redirect_handle_t *rh)
{
  rh->client = rc->client;

  char *rh_id_ptr = rh->id;

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdi), %eax
movl %eax, (%rsi)
testl %eax, %eax
je 0x109d2
movq 0x148(%rbx), %rax
movq %rax, 0x208(%r14)
movl $0x160, %r12d           # imm = 0x160
movl $0x568, %r15d           # imm = 0x568
jmp 0x109de
movl $0x150, %r12d           # imm = 0x150
movl $0x168, %r15d           # imm = 0x168
leaq 0x4(%r14), %rsi
addq %rbx, %r15
movq (%rbx,%r12), %rdi
addq %r15, %rdi
xorl %edx, %edx
callq 0xffcc
addq (%rbx,%r12), %rax
movq %rax, (%rbx,%r12)
addq $0x210, %r14            # imm = 0x210
addq %rax, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x12195
addq %rax, (%rbx,%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7b4a4(%rip), %r13     # 0x8bfa0
movq (%r13), %rdi
leaq 0x58d22(%rip), %rsi     # 0x69829
leaq 0x58ee5(%rip), %rdx     # 0x699f3
xorl %eax, %eax
callq 0xb7a0
movq (%r13), %rdi
leaq 0x58efb(%rip), %rsi     # 0x69a1b
movq %rbx, %rdx
movq %r12, %rcx
movq %r15, %r8
movq %r14, %r9
xorl %eax, %eax
callq 0xb7a0
movq (%r13), %rsi
movl $0xa, %edi
callq 0xb690
cmpl $0x0, (%rbx)
je 0x10b97
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1239a
movq 0xba8(%rbx), %rdi
testq %rdi, %rdi
je 0x10b8d
movq 0x868(%rbx), %rax
leaq (%rax,%rax,4), %rax
leaq (%rbx,%rax,8), %rcx
addq $0x860, %rcx            # imm = 0x860
leaq 0x58edc(%rip), %rsi     # 0x69a59
xorl %edx, %edx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xed91
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0xbb24
jmp 0x10b46
// File: /workspace/github_cpp_makefile_star2_O3/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 0x123e8
leaq (%rax,%rax,4), %rax
movabsq $0x100000000, %rcx      # imm = 0x100000000
movq %rcx, 0x880(%r14,%rax,8)
movq %r15, 0x888(%r14,%rax,8)
movq %rbx, 0x890(%r14,%rax,8)
incq 0x868(%r14)
popq %rbx
popq %r14
popq %r15
retq
movq 0x79be9(%rip), %rax     # 0x8bfd8
movq (%rax), %rcx
leaq 0x57668(%rip), %rdi     # 0x69a61
movl $0x39, %esi
movl $0x1, %edx
callq 0xba90
movq 0x868(%r14), %rax
jmp 0x123b5
// File: /workspace/github_cpp_makefile_star2_O3/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 0x12a6d
movq %r14, %rdi
movq %r12, %rdx
callq 0xb3f0
movl 0xb04(%r15), %eax
addl %r12d, %eax
movl %eax, 0xb04(%r15)
subq %r12, %rbx
jle 0x12ab3
movq 0xb10(%r15), %rdi
movq 0x38(%rdi), %rax
testq %rax, %rax
je 0x12ab3
xorl %esi, %esi
callq *%rax
cmpq $0x1, %rax
jne 0x12ab3
addq %r12, %r14
movq 0xb10(%r15), %rcx
movq 0x10(%rcx), %rsi
movl $0x0, 0xb04(%r15)
xorl %eax, %eax
jmp 0x12a42
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/lib/redirect/redirect/redirect_call.cc
// Function: void redirect_call_get_output_param_dense_val<int>(_redirect_call_t*, char const*, int**, long)
void redirect_call_get_output_param_dense_val(redirect_call_t *rc, const char *id, T **b, rdint_t n)
{
  TRACE_F("rc: %p, id: '%s', b: %p, n: %" rdint_fmt, rc, id, *b, n);

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

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq 0x73220(%rip), %r13     # 0x8bfa0
movq (%r13), %rdi
leaq 0x50a9e(%rip), %rsi     # 0x69829
leaq 0x50de1(%rip), %rdx     # 0x69b73
xorl %eax, %eax
callq 0xb7a0
movq (%r13), %rdi
movq (%r12), %r8
leaq 0x50c73(%rip), %rsi     # 0x69a1b
movq %rbx, %rdx
movq %r15, %rcx
movq %r14, %r9
xorl %eax, %eax
callq 0xb7a0
movq (%r13), %rsi
movl $0xa, %edi
callq 0xb690
cmpl $0x0, (%rbx)
movq (%r12), %r15
je 0x18de6
testq %r15, %r15
jne 0x18e2d
movslq 0xb20(%rbx), %r13
cmpq $0xf, %r13
jle 0x18e07
xorl %r15d, %r15d
jmp 0x18e29
testq %r15, %r15
jne 0x18ed2
movslq 0xb20(%rbx), %r15
cmpq $0xf, %r15
jle 0x18eb0
xorl %eax, %eax
jmp 0x18ece
leaq (,%r14,4), %rdi
callq 0xb6f0
movq %rax, %r15
movq %rax, 0xb28(%rbx,%r13,8)
leal 0x1(%r13), %eax
movl %eax, 0xb20(%rbx)
movq %r15, (%r12)
shlq $0x2, %r14
movq 0xb10(%rbx), %rcx
movq 0x10(%rcx), %rsi
movl 0xb04(%rbx), %eax
movq 0x20(%rcx), %r12
movslq %eax, %rcx
subq %rcx, %r12
cmpq %r12, %r14
cmovlq %r14, %r12
addq %rcx, %rsi
cmpq %rsi, %r15
je 0x18e6c
movq %r15, %rdi
movq %r12, %rdx
callq 0xb3f0
movl 0xb04(%rbx), %eax
addl %r12d, %eax
movl %eax, 0xb04(%rbx)
subq %r12, %r14
jle 0x18ed2
movq 0xb10(%rbx), %rdi
movq 0x38(%rdi), %rax
testq %rax, %rax
je 0x18ed2
xorl %esi, %esi
callq *%rax
cmpq $0x1, %rax
jne 0x18ed2
addq %r12, %r15
movq 0xb10(%rbx), %rcx
movq 0x10(%rcx), %rsi
movl $0x0, 0xb04(%rbx)
xorl %eax, %eax
jmp 0x18e42
shlq $0x2, %r14
movq %r14, %rdi
callq 0xb6f0
movq %rax, 0xb28(%rbx,%r15,8)
leal 0x1(%r15), %ecx
movl %ecx, 0xb20(%rbx)
movq %rax, (%r12)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x349ea
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
callq 0x34a15
cmpq $0x0, 0x8(%r14)
jle 0x190ab
movq (%r14), %r15
xorl %r12d, %r12d
movq 0x10(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x34a4b
addq 0x18(%r14), %r15
incq %r12
cmpq 0x8(%r14), %r12
jl 0x1908f
movq %rbx, %rdi
callq 0x34bfa
movl %eax, %ebp
movq %rbx, %rdi
callq 0x349f4
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x19148
movaps %xmm0, 0x70(%rsp)
movaps %xmm1, 0x80(%rsp)
movaps %xmm2, 0x90(%rsp)
movaps %xmm3, 0xa0(%rsp)
movaps %xmm4, 0xb0(%rsp)
movaps %xmm5, 0xc0(%rsp)
movaps %xmm6, 0xd0(%rsp)
movaps %xmm7, 0xe0(%rsp)
movq %rsp, %r14
movq %rdi, 0x10(%r14)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r14)
movl $0x10, %edi
callq 0xb500
movq $0x0, (%rax)
movq %r14, 0x8(%rax)
leaq 0x20(%rsp), %r14
movq %rax, (%r14)
leaq 0x1f72(%rip), %rax      # 0x1b0fe
movq %rax, 0x8(%r14)
leaq 0x20e4(%rip), %rax      # 0x1b27b
movq %rax, 0x10(%r14)
leaq -0xda(%rip), %rax       # 0x190c8
movq %rax, 0x18(%r14)
leaq 0x733fb(%rip), %rdi     # 0x8c5a8
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1b2f6
movzbl %al, %ebx
movq (%r14), %rdi
movl $0x10, %esi
callq 0xb510
movq %rbx, %rax
addq $0xf8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/lib/scdc/scdc.cc
// Function: scdc_log_init
scdcint_t scdc_log_init(const char *conf, ...)
{
  SCDC_TRACE(__func__ << ": conf: '" << conf << "'");

  scdc_args_t args;

  va_list ap;
  va_start(ap, conf);

  scdc_args_va_init(&args, &ap);

  scdcint_t ret = scdc_log_init_intern(conf, &args);

  scdc_args_va_release(&args);

  va_end(ap);

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

  return ret;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xf8, %rsp
movq %rdi, %rbx
leaq 0x40(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x1932b
movaps %xmm0, 0x70(%rsp)
movaps %xmm1, 0x80(%rsp)
movaps %xmm2, 0x90(%rsp)
movaps %xmm3, 0xa0(%rsp)
movaps %xmm4, 0xb0(%rsp)
movaps %xmm5, 0xc0(%rsp)
movaps %xmm6, 0xd0(%rsp)
movaps %xmm7, 0xe0(%rsp)
movq %rsp, %r14
movq %rdi, 0x10(%r14)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r14)
movl $0x10, %edi
callq 0xb500
movq $0x0, (%rax)
movq %r14, 0x8(%rax)
leaq 0x20(%rsp), %r14
movq %rax, (%r14)
leaq 0x1d8f(%rip), %rax      # 0x1b0fe
movq %rax, 0x8(%r14)
leaq 0x1f01(%rip), %rax      # 0x1b27b
movq %rax, 0x10(%r14)
leaq -0x2bd(%rip), %rax      # 0x190c8
movq %rax, 0x18(%r14)
movq 0x731e0(%rip), %rdi     # 0x8c570
movq %rbx, %rsi
movq %r14, %rdx
callq 0x31532
movzbl %al, %ebx
movq (%r14), %rdi
movl $0x10, %esi
callq 0xb510
movq %rbx, %rax
addq $0xf8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/lib/scdc/scdc.cc
// Function: scdc_dataprov_open_intern
scdc_dataprov_t scdc_dataprov_open_intern(const char *base_path, const char *conf, scdc_args_t *args)
{
  scdc_args xargs(args);

  scdc_result result;

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

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

  if (!dataprov) return SCDC_DATAPROV_NULL;

  return static_cast<scdc_dataprov_t>(dataprov);
}

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

  va_list ap;
  va_start(ap, conf);

  scdc_args_t args;

  scdc_args_va_init(&args, &ap);

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

  scdc_args_va_release(&args);
  va_end(ap);

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

  return dataprov;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x40(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x19505
movaps %xmm0, 0x70(%rsp)
movaps %xmm1, 0x80(%rsp)
movaps %xmm2, 0x90(%rsp)
movaps %xmm3, 0xa0(%rsp)
movaps %xmm4, 0xb0(%rsp)
movaps %xmm5, 0xc0(%rsp)
movaps %xmm6, 0xd0(%rsp)
movaps %xmm7, 0xe0(%rsp)
movq %rsp, %r12
movq %rsi, 0x10(%r12)
leaq 0x120(%rsp), %rax
movq %rax, 0x8(%r12)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, (%r12)
movl $0x10, %edi
callq 0xb500
movq %rax, %r15
movq $0x0, (%rax)
movq %r12, 0x8(%rax)
leaq 0x20(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x1baf(%rip), %rax      # 0x1b0fe
movq %rax, 0x8(%rdx)
leaq 0x1d21(%rip), %rax      # 0x1b27b
movq %rax, 0x10(%rdx)
leaq -0x49d(%rip), %rax      # 0x190c8
movq %rax, 0x18(%rdx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x193c5
movq %rax, %rbx
movl $0x10, %esi
movq %r15, %rdi
callq 0xb510
movq %rbx, %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/lib/scdc/scdc.cc
// Function: scdc_dataprov_close
void scdc_dataprov_close(scdc_dataprov_t dataprov)
{
  SCDC_TRACE(__func__ << ": dataprov: '" << dataprov << "'");

  if (dataprov == SCDC_DATAPROV_NULL) return;

  scdc_result result;

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

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

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

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

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

  if (!nodeport) return SCDC_NODEPORT_NULL;

  return static_cast<scdc_nodeport_t>(nodeport);
}

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

  va_list ap;
  va_start(ap, conf);

  scdc_args_t args;

  scdc_args_va_init(&args, &ap);

  scdc_nodeport_t nodeport = scdc_nodeport_open_intern(conf, &args);

  scdc_args_va_release(&args);
  va_end(ap);

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

  return nodeport;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xf0, %rsp
movq %rdi, %rbx
leaq 0x40(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x1970c
movaps %xmm0, 0x70(%rsp)
movaps %xmm1, 0x80(%rsp)
movaps %xmm2, 0x90(%rsp)
movaps %xmm3, 0xa0(%rsp)
movaps %xmm4, 0xb0(%rsp)
movaps %xmm5, 0xc0(%rsp)
movaps %xmm6, 0xd0(%rsp)
movaps %xmm7, 0xe0(%rsp)
movq %rsp, %r15
movq %rdi, 0x10(%r15)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%r15)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r15)
movl $0x10, %edi
callq 0xb500
movq %rax, %r14
movq $0x0, (%rax)
movq %r15, 0x8(%rax)
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x19ab(%rip), %rax      # 0x1b0fe
movq %rax, 0x8(%rsi)
leaq 0x1b1d(%rip), %rax      # 0x1b27b
movq %rax, 0x10(%rsi)
leaq -0x6a1(%rip), %rax      # 0x190c8
movq %rax, 0x18(%rsi)
movq %rbx, %rdi
callq 0x1963b
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0xb510
movq %rbx, %rax
addq $0xf0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x197e5
movq 0x30(%rdi), %rax
testq %rax, %rax
je 0x197d4
movq 0x72e24(%rip), %rcx     # 0x8c5f0
addq $0x38, %rcx
movq %rcx, 0x8(%rax)
pushq %rax
movq (%rdi), %rax
callq *0x28(%rax)
movl $0x1, %eax
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1980f
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x30(%rax)
movq 0x30(%rbx), %rcx
movl $0x1, %eax
testq %rcx, %rcx
je 0x1980d
movq $0x0, 0x8(%rcx)
popq %rbx
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
leaq 0x40(%rsp), %rax
movq %rax, 0x8(%rax)
movq %rax, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x10(%rax)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movaps %xmm0, -0x20(%rax)
movaps %xmm1, -0x10(%rax)
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq %rcx, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
callq 0x339d0
movq (%rsp), %r14
cmpq $0x400, 0x8(%rsp)       # imm = 0x400
setb %cl
testb %cl, %al
je 0x198aa
leaq 0x72d68(%rip), %rbx     # 0x8c600
movl $0x400, %edx            # imm = 0x400
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb2a0
jmp 0x198ac
xorl %ebx, %ebx
cmpq %r15, %r14
je 0x198c1
movq 0x10(%rsp), %rsi
incq %rsi
movq %r14, %rdi
callq 0xb510
leaq 0x20(%rsp), %rdi
callq 0x1b76c
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x198f1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
leaq 0x20(%rsp), %rdi
callq 0x1b76c
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/lib/scdc/scdc.cc
// Function: scdc_nodeport_authority
const char *scdc_nodeport_authority(const char *conf, ...)
{
  SCDC_TRACE(__func__ << ": conf: '" << conf << "'");

  va_list ap;
  va_start(ap, conf);

  scdc_args_t args;

  scdc_args_va_init(&args, &ap);

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

  scdc_args_va_release(&args);
  va_end(ap);

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

  return authority;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xf0, %rsp
movq %rdi, %rbx
leaq 0x40(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x1996c
movaps %xmm0, 0x70(%rsp)
movaps %xmm1, 0x80(%rsp)
movaps %xmm2, 0x90(%rsp)
movaps %xmm3, 0xa0(%rsp)
movaps %xmm4, 0xb0(%rsp)
movaps %xmm5, 0xc0(%rsp)
movaps %xmm6, 0xd0(%rsp)
movaps %xmm7, 0xe0(%rsp)
movq %rsp, %r15
movq %rdi, 0x10(%r15)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%r15)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r15)
movl $0x10, %edi
callq 0xb500
movq %rax, %r14
movq $0x0, (%rax)
movq %r15, 0x8(%rax)
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x174b(%rip), %rax      # 0x1b0fe
movq %rax, 0x8(%rsi)
leaq 0x18bd(%rip), %rax      # 0x1b27b
movq %rax, 0x10(%rsi)
leaq -0x901(%rip), %rax      # 0x190c8
movq %rax, 0x18(%rsi)
movq %rbx, %rdi
callq 0x19835
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0xb510
movq %rbx, %rax
addq $0xf0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/lib/scdc/scdc.cc
// Function: scdc_nodeport_supported_intern
scdcint_t scdc_nodeport_supported_intern(const char *uri, scdc_args_t *args)
{
  scdc_args xargs(args);

  string supported;

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

  return (ret)?SCDC_SUCCESS:SCDC_FAILURE;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
leaq 0x40(%rsp), %rax
movq %rax, 0x8(%rax)
movq %rax, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x10(%rax)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movaps %xmm0, -0x20(%rax)
movaps %xmm1, -0x10(%rax)
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq %rcx, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x20(%rsp), %rsi
callq 0x33bfa
movl %eax, %ebx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x19a50
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
movzbl %bl, %ebx
leaq 0x20(%rsp), %rdi
callq 0x1b76c
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x19a81
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
leaq 0x20(%rsp), %rdi
callq 0x1b76c
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/lib/scdc/scdc.cc
// Function: scdc_nodeport_supported
scdcint_t scdc_nodeport_supported(const char *uri, ...)
{
  SCDC_TRACE(__func__ << ": uri: '" << uri << "'");

  va_list ap;
  va_start(ap, uri);

  scdc_args_t args;

  scdc_args_va_init(&args, &ap);

  scdcint_t supported = scdc_nodeport_supported_intern(uri, &args);

  scdc_args_va_release(&args);
  va_end(ap);

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

  return supported;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xf0, %rsp
movq %rdi, %rbx
leaq 0x40(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x19afc
movaps %xmm0, 0x70(%rsp)
movaps %xmm1, 0x80(%rsp)
movaps %xmm2, 0x90(%rsp)
movaps %xmm3, 0xa0(%rsp)
movaps %xmm4, 0xb0(%rsp)
movaps %xmm5, 0xc0(%rsp)
movaps %xmm6, 0xd0(%rsp)
movaps %xmm7, 0xe0(%rsp)
movq %rsp, %r15
movq %rdi, 0x10(%r15)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%r15)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r15)
movl $0x10, %edi
callq 0xb500
movq %rax, %r14
movq $0x0, (%rax)
movq %r15, 0x8(%rax)
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x15bb(%rip), %rax      # 0x1b0fe
movq %rax, 0x8(%rsi)
leaq 0x172d(%rip), %rax      # 0x1b27b
movq %rax, 0x10(%rsi)
leaq -0xa91(%rip), %rax      # 0x190c8
movq %rax, 0x18(%rsi)
movq %rbx, %rdi
callq 0x199f5
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0xb510
movq %rbx, %rax
addq $0xf0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/lib/scdc/scdc.cc
// Function: scdc_dataset_open
scdc_dataset_t scdc_dataset_open(const char *uri, ...)
{
  SCDC_TRACE(__func__ << ": uri: '" << uri << "'");

  scdc_args_t args;

  va_list ap;
  va_start(ap, uri);

  scdc_args_va_init(&args, &ap);

  scdc_dataset_t dataset = scdc_dataset_open_intern(uri, &args);

  scdc_args_va_release(&args);

  va_end(ap);

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

  return dataset;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xf0, %rsp
movq %rdi, %rbx
leaq 0x40(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x19f72
movaps %xmm0, 0x70(%rsp)
movaps %xmm1, 0x80(%rsp)
movaps %xmm2, 0x90(%rsp)
movaps %xmm3, 0xa0(%rsp)
movaps %xmm4, 0xb0(%rsp)
movaps %xmm5, 0xc0(%rsp)
movaps %xmm6, 0xd0(%rsp)
movaps %xmm7, 0xe0(%rsp)
movq %rsp, %r15
movq %rdi, 0x10(%r15)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%r15)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r15)
movl $0x10, %edi
callq 0xb500
movq %rax, %r14
movq $0x0, (%rax)
movq %r15, 0x8(%rax)
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x1145(%rip), %rax      # 0x1b0fe
movq %rax, 0x8(%rsi)
leaq 0x12b7(%rip), %rax      # 0x1b27b
movq %rax, 0x10(%rsi)
leaq -0xf07(%rip), %rax      # 0x190c8
movq %rax, 0x18(%rsi)
movq %rbx, %rdi
callq 0x19b9a
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0xb510
movq %rbx, %rax
addq $0xf0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, 0x8(%rsp)
testq %rdi, %rdi
je 0x1a1a0
movq 0x725d7(%rip), %r14     # 0x8c5f0
leaq 0x8(%r14), %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1c2c6
movq 0x30(%r14), %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1c348
subq 0x30(%r14), %r15
cmpq $0x1, %r15
jne 0x1a0f3
leaq 0x20(%rsp), %r14
movq %r14, -0x10(%r14)
movq $0x0, -0x8(%r14)
movb $0x0, (%r14)
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 0x72572(%rip), %rax     # 0x8c5f0
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
movq (%rdi), %rdx
addq $0x8, %rdi
decq %rdx
callq 0xb2a0
movl $0x98, %edi
addq 0x7254f(%rip), %rdi     # 0x8c5f0
movq 0x8(%rsp), %rax
movq (%rax), %rsi
callq 0x330f0
movq 0x8(%rsp), %rbx
testq %rbx, %rbx
je 0x1a0c6
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x1a0c6
callq 0xb6c0
movl $0x20, %esi
movq %rbx, %rdi
callq 0xb510
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x1a1a0
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xb510
jmp 0x1a1a0
movq 0x72476(%rip), %rdi     # 0x8c570
cmpq $0x0, 0x8(%rdi)
je 0x1a1a0
addq $0x20, %rdi
callq 0xb7d0
movq 0x7245b(%rip), %rax     # 0x8c570
movq 0x8(%rax), %rbx
leaq 0x50088(%rip), %rsi     # 0x6a1a8
movl $0xb, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x50080(%rip), %rsi     # 0x6a1b4
movl $0x9, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x5008f(%rip), %rsi     # 0x6a1d7
movl $0x12, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x5008e(%rip), %rsi     # 0x6a1ea
movl $0x1f, %edx
movq %rbx, %rdi
callq 0xb5f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq 0x723d9(%rip), %rdi     # 0x8c570
addq $0x20, %rdi
callq 0xb3b0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x1a1c4
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0