LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x19b7f
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 0x15fe(%rip), %rax      # 0x1b1c4
movq %rax, 0x8(%rsi)
leaq 0x1770(%rip), %rax      # 0x1b341
movq %rax, 0x10(%rsi)
leaq -0xa90(%rip), %rax      # 0x1914c
movq %rax, 0x18(%rsi)
movq %rbx, %rdi
callq 0x19a78
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0xb510
movq %rbx, %rax
addq $0xf0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/lib/scdc/scdc.cc
// Function: scdc_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 0x1a241
movq 0x72536(%rip), %r14     # 0x8c5f0
leaq 0x8(%r14), %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1c36e
movq 0x30(%r14), %r15
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1c3ea
subq 0x30(%r14), %r15
cmpq $0x1, %r15
jne 0x1a194
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 0x724d1(%rip), %rax     # 0x8c5f0
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
movq (%rdi), %rdx
addq $0x8, %rdi
decq %rdx
callq 0xb2a0
movl $0x98, %edi
addq 0x724ae(%rip), %rdi     # 0x8c5f0
movq 0x8(%rsp), %rax
movq (%rax), %rsi
callq 0x33484
movq 0x8(%rsp), %rbx
testq %rbx, %rbx
je 0x1a174
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x1a167
callq 0xb6c0
movl $0x20, %esi
movq %rbx, %rdi
callq 0xb510
movq 0x10(%rsp), %rdi
cmpq %r14, %rdi
je 0x1a241
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xb510
jmp 0x1a241
movq 0x723d5(%rip), %rdi     # 0x8c570
cmpq $0x0, 0x8(%rdi)
je 0x1a241
addq $0x20, %rdi
callq 0xb7d0
movq 0x723ba(%rip), %rax     # 0x8c570
movq 0x8(%rax), %rbx
leaq 0x4ffc7(%rip), %rsi     # 0x6a188
movl $0xb, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x4ffbf(%rip), %rsi     # 0x6a194
movl $0x9, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x4ffce(%rip), %rsi     # 0x6a1b7
movl $0x12, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x4ffcd(%rip), %rsi     # 0x6a1ca
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 0x72338(%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 0x1a265
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/lib/scdc/scdc.cc
// Function: scdc_dataset_cmd
scdcint_t scdc_dataset_cmd(scdc_dataset_t dataset, const char *cmd, scdc_dataset_input_t *input, scdc_dataset_output_t *output, ...)
{
  SCDC_TRACE(__func__ << ": dataset: '" << dataset << "', cmd = '" << string(cmd) << "'" << ", input = " << static_cast<void *>(input) << ", output = " << static_cast<void *>(output));

  scdc_args_t args;

  va_list ap;
  va_start(ap, output);

  scdc_args_va_init(&args, &ap);

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

  scdc_args_va_release(&args);

  va_end(ap);

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

  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x40(%rsp), %rcx
movq %r8, 0x20(%rcx)
movq %r9, 0x28(%rcx)
testb %al, %al
je 0x1ac13
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, %rbp
movq %rcx, 0x10(%rbp)
leaq 0x130(%rsp), %rax
movq %rax, 0x8(%rbp)
movabsq $0x3000000020, %rax     # imm = 0x3000000020
movq %rax, (%rbp)
movl $0x10, %edi
callq 0xb500
movq %rax, %r13
movq $0x0, (%rax)
movq %rbp, 0x8(%rax)
leaq 0x20(%rsp), %r8
movq %rax, (%r8)
leaq 0x569(%rip), %rax       # 0x1b1c4
movq %rax, 0x8(%r8)
leaq 0x6db(%rip), %rax       # 0x1b341
movq %rax, 0x10(%r8)
leaq -0x1b25(%rip), %rax     # 0x1914c
movq %rax, 0x18(%r8)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1a26d
movq %rax, %rbx
movl $0x10, %esi
movq %r13, %rdi
callq 0xb510
movq %rbx, %rax
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/lib/scdc/scdc.cc
// Function: scdc_context::release()
void release()
    {
      SCDC_TRACE("scdc-context: " << __func__);

      if (!data) return;

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

      data->nodeconns.close_all();

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

      data->nodeports.close_all();

      scdc_dataprov_close(data->dp_config);

      data->dataprovs.close_all();

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

      ::operator delete(data->result);

      delete data; data = 0;

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

// Assembly:
movq 0x48(%rdi), %rax
testq %rax, %rax
je 0x1b81e
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rax), %r14
movq 0x48(%rdi), %rdi
leaq 0x10(%rdi), %rax
cmpq %rax, %r14
je 0x1b750
leaq 0x4e0a9(%rip), %rbp     # 0x696f6
leaq 0x4eca8(%rip), %r15     # 0x6a2fc
leaq 0x4ecad(%rip), %r12     # 0x6a308
movq 0x70f0e(%rip), %rdi     # 0x8c570
cmpq $0x0, 0x8(%rdi)
je 0x1b734
addq $0x20, %rdi
callq 0xb7d0
movq 0x70ef3(%rip), %rax     # 0x8c570
movq 0x8(%rax), %r13
movl $0xb, %edx
movq %r13, %rdi
leaq 0x4eaf8(%rip), %rsi     # 0x6a188
callq 0xb5f0
movl $0x9, %edx
movq %r13, %rdi
leaq 0x4eaf0(%rip), %rsi     # 0x6a194
callq 0xb5f0
movl $0xe, %edx
movq %r13, %rdi
leaq 0x4ec35(%rip), %rsi     # 0x6a2ed
callq 0xb5f0
movl $0x7, %edx
movq %r13, %rdi
movq %rbp, %rsi
callq 0xb5f0
movl $0xb, %edx
movq %r13, %rdi
movq %r15, %rsi
callq 0xb5f0
movq 0x20(%r14), %rsi
movq %r13, %rdi
callq 0xb3c0
movq %rax, %r13
movl $0x10, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0xb5f0
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %r13, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq 0x70e45(%rip), %rdi     # 0x8c570
addq $0x20, %rdi
callq 0xb3b0
movq %r14, %rdi
callq 0xb600
movq %rax, %r14
movq 0x48(%rbx), %rdi
leaq 0x10(%rdi), %rax
cmpq %rax, %r14
jne 0x1b65b
addq $0x98, %rdi
callq 0x33606
movq 0x48(%rbx), %rax
movq 0xd8(%rax), %r14
testq %r14, %r14
je 0x1b786
movq (%r14), %rax
movq %r14, %rdi
callq *0x30(%rax)
movq 0x30(%r14), %rax
testq %rax, %rax
je 0x1b786
movq $0x0, 0x8(%rax)
movq 0x48(%rbx), %rax
movq 0xd8(%rax), %rsi
testq %rsi, %rsi
je 0x1b7af
cmpb $0x0, 0x70e5b(%rip)     # 0x8c5f8
jne 0x1b7af
movq 0x70e4a(%rip), %rdi     # 0x8c5f0
addq $0x68, %rdi
callq 0x34306
movq 0x48(%rbx), %rdi
addq $0x68, %rdi
callq 0x34346
movq 0x48(%rbx), %rax
movq 0xd0(%rax), %rdi
callq 0x19622
movq 0x48(%rbx), %rdi
addq $0x38, %rdi
callq 0x1e322
callq 0x33d40
movq 0x48(%rbx), %rax
movq (%rax), %rdi
callq 0xb4c0
movq 0x48(%rbx), %r14
testq %r14, %r14
je 0x1b808
movq %r14, %rdi
callq 0x1bfee
movl $0xe0, %esi
movq %r14, %rdi
callq 0xb510
movq $0x0, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/lib/scdc/../../include/common.hh
// Function: stringlist::parse(int, char const*, long)
void parse(int sep_, const char *s, ssize_t len = -1)
    {
      if (!s || len == 0) return;

      const char *s_ = s;
      length = 0;

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

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

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

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

        if (n) ++l;

        s += l;
        len -= l;

        length += l;
      }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r14
movl %esi, 0x4(%rsp)
movq %rdx, 0x8(%rsp)
testq %rdx, %rdx
sete %al
testq %rcx, %rcx
sete %cl
orb %al, %cl
jne 0x1bb3e
movq %rdi, %r12
movq $0x0, 0x20(%rdi)
movq 0x8(%rsp), %rax
cmpb $0x0, (%rax)
je 0x1bb3e
leaq 0x40(%rsp), %rbx
movq 0x8(%rsp), %r15
movq %r15, %rdi
testq %r14, %r14
js 0x1b9e1
movl 0x4(%rsp), %esi
movq %r14, %rdx
callq 0xb5b0
jmp 0x1b9ea
movl 0x4(%rsp), %esi
callq 0xb1e0
movq %rax, %r13
testq %rax, %rax
leaq 0x20(%rsp), %rcx
je 0x1b9ff
movq %r13, %rbp
subq %r15, %rbp
jmp 0x1ba17
movq %r14, %rbp
testq %r14, %r14
jns 0x1ba17
movq %r15, %rdi
callq 0xb200
leaq 0x20(%rsp), %rcx
movq %rax, %rbp
movq %rcx, 0x10(%rsp)
leaq (%r15,%rbp), %rdx
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x1bee6
leaq 0x20(%rsp), %rdx
movq %rbx, 0x30(%rsp)
movq 0x10(%rsp), %rax
cmpq %rdx, %rax
je 0x1ba52
movq %rax, 0x30(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x1ba58
movups (%rdx), %xmm0
movups %xmm0, (%rbx)
movq %r15, %rax
subq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x38(%rsp)
movq %rdx, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movb $0x0, 0x20(%rsp)
movq %rax, 0x50(%rsp)
movl $0x38, %edi
callq 0xb500
movq %rax, %rcx
addq $0x20, %rcx
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rdx
cmpq %rbx, %rdx
je 0x1bab0
movq %rdx, 0x10(%rax)
movq 0x40(%rsp), %rcx
movq %rcx, 0x20(%rax)
jmp 0x1bab6
movups (%rbx), %xmm0
movups %xmm0, (%rcx)
movq 0x38(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq %rbx, 0x30(%rsp)
movq $0x0, 0x38(%rsp)
movb $0x0, 0x40(%rsp)
movq 0x50(%rsp), %rcx
movq %rcx, 0x30(%rax)
movq %rax, %rdi
movq %r12, %rsi
callq 0xb090
incq 0x10(%r12)
movq 0x30(%rsp), %rdi
cmpq %rbx, %rdi
je 0x1bb02
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xb510
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x1bb1e
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xb510
cmpq $0x1, %r13
sbbq $-0x1, %rbp
addq %rbp, 0x20(%r12)
cmpb $0x0, (%r15,%rbp)
je 0x1bb3e
addq %rbp, %r15
subq %rbp, %r14
jne 0x1b9cb
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x30(%rsp), %rdi
cmpq %rbx, %rdi
je 0x1bb67
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xb510
leaq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xc128
movq %r14, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/lib/scdc/../../include/args.hh
// Function: scdc_args::free_all()
void free_all() {
      while (gets.size() > 0) {
        const scdc_args_get_entry_t &e = gets.front();
        if (e.n == 1) free<void>(e.type, e.v0, e.arg_ref);
        else if (e.n == 2) free<void, void>(e.type, e.v0, e.v1, e.arg_ref);
      }
    }

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

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

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

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

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

  cmdline = "";

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

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
movq 0x8(%rcx), %rdx
leaq 0x4ed30(%rip), %rcx     # 0x6b50d
movq %r14, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0xb870
testq %r12, %r12
je 0x1c817
cmpb $0x0, (%r12)
je 0x1c817
cmpq $0x0, 0x8(%r14)
je 0x1c80c
leaq 0x507fc(%rip), %rsi     # 0x6d000
movq %r14, %rdi
callq 0xba60
movq %r14, %rdi
movq %r12, %rsi
callq 0xba60
testq %r15, %r15
je 0x1c843
cmpb $0x0, (%r15)
je 0x1c843
cmpq $0x0, 0x8(%r14)
je 0x1c838
leaq 0x507d0(%rip), %rsi     # 0x6d000
movq %r14, %rdi
callq 0xba60
movq %r14, %rdi
movq %r15, %rsi
callq 0xba60
testq %rbx, %rbx
je 0x1c879
cmpb $0x0, (%rbx)
je 0x1c879
cmpq $0x0, 0x8(%r14)
je 0x1c863
leaq 0x507a5(%rip), %rsi     # 0x6d000
movq %r14, %rdi
callq 0xba60
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xba60
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/common/common.cc
// Function: join_uri(char const*, char const*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void join_uri(const char *scheme, const char *authority, const char *path, string &uri)
{
  SCDC_TRACE("join_uri: scheme: '" << ((scheme)?scheme:"") << "', authority: '" << ((authority)?authority:"") << "', path: '" << ((path)?path:"") << "'");

  uri = "";

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

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movq 0x8(%rcx), %rdx
leaq 0x4e97c(%rip), %rcx     # 0x6b50d
movq %r14, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0xb870
testq %r12, %r12
je 0x1cbc4
cmpb $0x0, (%r12)
je 0x1cbc4
movq %r14, %rdi
movq %r12, %rsi
callq 0xba60
leaq 0x4d788(%rip), %rsi     # 0x6a344
movq %r14, %rdi
callq 0xba60
testq %r15, %r15
je 0x1cbf0
cmpb $0x0, (%r15)
je 0x1cbf0
cmpq $0x0, 0x8(%r14)
je 0x1cbe5
leaq 0x4d76f(%rip), %rsi     # 0x6a34c
movq %r14, %rdi
callq 0xba60
movq %r14, %rdi
movq %r15, %rsi
callq 0xba60
testq %rbx, %rbx
je 0x1cc26
cmpb $0x0, (%rbx)
je 0x1cc26
cmpq $0x0, 0x8(%r14)
je 0x1cc10
leaq 0x4d745(%rip), %rsi     # 0x6a34d
movq %r14, %rdi
callq 0xba60
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xba60
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/common/common.cc
// Function: normalize_path(char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void normalize_path(const char *path, string &normalized)
{
  SCDC_TRACE("normalize_path: path: '" << ((path)?path:"") << "'");

  normalized = "";

  if (!path) return;

  vector<string> parts;

  const char *p, *s = path;

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

    string t(s, p - s);

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

    s = p + 1;
  }

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

    normalized += *i;
  }

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rsi), %rdx
leaq 0x4e8bc(%rip), %rcx     # 0x6b50d
movq %rsi, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0xb870
testq %r15, %r15
je 0x1cdbe
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
leaq 0x38(%rsp), %r13
leaq 0x28(%rsp), %r12
movq %r15, 0x20(%rsp)
movq %r15, %rdi
movl $0x2f, %esi
callq 0xb1e0
movq %rax, %r14
testq %rax, %rax
jne 0x1ccaa
movq %r15, %rdi
callq 0xb200
movq %rax, %r14
addq %r15, %r14
movq %r13, 0x28(%rsp)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1bee6
movq %r12, %rdi
leaq 0x4d689(%rip), %rsi     # 0x6a350
callq 0xb110
testl %eax, %eax
je 0x1ccf6
movq %r12, %rdi
leaq 0x4d675(%rip), %rsi     # 0x6a34f
callq 0xb110
testl %eax, %eax
je 0x1cd26
cmpq $0x0, 0x30(%rsp)
je 0x1ccf6
movq %rsp, %rdi
movq %r12, %rsi
callq 0x1cf1c
movb (%r14), %bpl
testb %bpl, %bpl
je 0x1cd04
incq %r14
movq %r14, %r15
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x1cd1b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb510
testb %bpl, %bpl
jne 0x1cc87
jmp 0x1cd6d
movq 0x8(%rsp), %rdi
cmpq %rdi, (%rsp)
je 0x1cce3
addq $-0x20, %rdi
leaq 0x4d613(%rip), %rsi     # 0x6a34f
callq 0xb110
testl %eax, %eax
je 0x1cce3
movq 0x8(%rsp), %rax
leaq -0x20(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq -0x20(%rax), %rdi
addq $-0x10, %rax
cmpq %rax, %rdi
je 0x1ccf6
movq (%rax), %rsi
incq %rsi
callq 0xb510
jmp 0x1ccf6
movq (%rsp), %r15
cmpq 0x8(%rsp), %r15
movq 0x20(%rsp), %r12
je 0x1cdb6
leaq 0x4d5c9(%rip), %r14     # 0x6a34d
cmpb $0x2f, (%r12)
je 0x1cd91
cmpq (%rsp), %r15
je 0x1cd9c
movq %rbx, %rdi
movq %r14, %rsi
callq 0xba60
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0xb150
addq $0x20, %r15
cmpq 0x8(%rsp), %r15
jne 0x1cd84
movq %rsp, %rdi
callq 0x1cf5a
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x1cdee
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb510
jmp 0x1cdee
jmp 0x1cdeb
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1cf5a
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/common/common.cc
// Function: abstimeout(timespec*, double, double)
void abstimeout(struct timespec *abstime, double timeout, double z_time_wtime_base)
{
  if (z_time_wtime_offset < 0)
  {
    struct timeval tv;
    gettimeofday(&tv, NULL);
    z_time_wtime_offset = (double) tv.tv_sec + (tv.tv_usec * 1e-6) - z_time_wtime();
  }

  double t = z_time_wtime_base;

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

  t += timeout + z_time_wtime_offset;

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

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movapd %xmm0, 0x10(%rsp)
movq %rdi, %rbx
xorpd %xmm0, %xmm0
ucomisd 0x6f766(%rip), %xmm0    # 0x8c580
jbe 0x1ce9a
leaq 0x38(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
movsd %xmm1, 0x8(%rsp)
callq 0xb910
xorps %xmm0, %xmm0
cvtsi2sdq (%r14), %xmm0
xorps %xmm1, %xmm1
cvtsi2sdq 0x8(%r14), %xmm1
mulsd 0x4c1de(%rip), %xmm1    # 0x69028
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
leaq 0x28(%rsp), %r14
movl $0x1, %edi
movq %r14, %rsi
callq 0xb480
movsd 0x8(%rsp), %xmm1
xorps %xmm0, %xmm0
cvtsi2sdq (%r14), %xmm0
cvtsi2sdq 0x8(%r14), %xmm2
mulsd 0x4c197(%rip), %xmm2    # 0x69018
addsd %xmm0, %xmm2
xorpd %xmm0, %xmm0
movsd (%rsp), %xmm3
subsd %xmm2, %xmm3
movsd %xmm3, 0x6f6e6(%rip)    # 0x8c580
ucomisd %xmm1, %xmm0
jbe 0x1cecf
leaq 0x28(%rsp), %r14
movl $0x1, %edi
movq %r14, %rsi
callq 0xb480
xorps %xmm0, %xmm0
cvtsi2sdq (%r14), %xmm0
xorps %xmm1, %xmm1
cvtsi2sdq 0x8(%r14), %xmm1
mulsd 0x4c14d(%rip), %xmm1    # 0x69018
addsd %xmm0, %xmm1
movapd 0x10(%rsp), %xmm2
addsd 0x6f6a3(%rip), %xmm2    # 0x8c580
addsd %xmm1, %xmm2
movapd 0x4d447(%rip), %xmm0    # 0x6a330
andpd %xmm2, %xmm0
cvttsd2si %xmm0, %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
subsd %xmm0, %xmm2
mulsd 0x4d41a(%rip), %xmm2    # 0x6a320
movq %rax, (%rbx)
cvttsd2si %xmm2, %rax
movq %rax, 0x8(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataprov/dataprov_pool.cc
// Function: scdc_dataprov_pool::close_all()
void scdc_dataprov_pool::close_all()
{
  SCDC_TRACE("close_all:");

  scdc_result result;

  while (!empty()) close(begin()->second, result);

  SCDC_TRACE("close_all: return");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq %rsp, %r14
cmpq $0x0, 0x28(%rbx)
je 0x1e362
movq 0x18(%rbx), %rax
movq 0x40(%rax), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1e2c0
jmp 0x1e346
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1e378
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1e39b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataprov/dataprov_pool.cc
// Function: scdc_dataprov_pool::dataset_close_write_state(scdc_dataset*, scdc_data*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov_pool::dataset_close_write_state(scdc_dataset *dataset, scdc_data *outgoing, scdc_result &result)
{
  SCDC_TRACE("dataset_close_write_state: dataset: '" << dataset << "'");

  scdc_dataprov *dataprov = dataset->get_dataprov();

  char *buf = outgoing->get_write_pos_buf();
  scdcint_t buf_size = outgoing->get_write_pos_buf_size();

  scdcint_t n = snprintf(buf, buf_size, "%p|", dataprov);

  SCDC_ASSERT(n <= buf_size);

  if (n > buf_size) n = buf_size;

  outgoing->inc_write_pos(n);

  bool ret = dataprov->dataset_close_write_state(dataset, outgoing, result);

  SCDC_TRACE("dataset_close_write_state: return: " << ret);

  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbp
movq %rdx, %r14
movq %rsi, %r15
movq 0x8(%rsi), %r12
movq 0x10(%rdx), %r13
movq 0x20(%rdx), %rax
movq 0x8(%rdx), %rdi
addq %rax, %rdi
subq %rax, %r13
leaq 0x4bbba(%rip), %rdx     # 0x6a545
movq %r13, %rsi
movq %r12, %rcx
xorl %eax, %eax
callq 0xb8e0
movslq %eax, %rbx
cmpq %rbx, %r13
jge 0x1ea87
leaq 0x6dbc5(%rip), %rax     # 0x8c570
movq (%rax), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x1ea87
addq $0x20, %rdi
callq 0xb7d0
leaq 0x6dba7(%rip), %rax     # 0x8c570
movq (%rax), %rax
movq %rbp, (%rsp)
movq 0x18(%rax), %rbp
leaq 0x4bb6e(%rip), %rsi     # 0x6a549
movl $0xd, %edx
movq %rbp, %rdi
callq 0xb5f0
leaq 0x4bb68(%rip), %rsi     # 0x6a557
movl $0x19, %edx
movq %rbp, %rdi
callq 0xb5f0
leaq 0x4b941(%rip), %rsi     # 0x6a344
movl $0x1, %edx
movq %rbp, %rdi
callq 0xb5f0
movq %rbp, %rdi
movl $0x198, %esi            # imm = 0x198
callq 0xb9a0
movq %rax, %rbp
leaq 0x4bb4a(%rip), %rsi     # 0x6a571
movl $0x10, %edx
movq %rax, %rdi
callq 0xb5f0
leaq 0x4d44d(%rip), %rsi     # 0x6be88
movl $0x8, %edx
movq %rbp, %rdi
callq 0xb5f0
movq (%rbp), %rax
movq -0x18(%rax), %rdi
addq %rbp, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %rbp, %rdi
movq (%rsp), %rbp
callq 0xb050
movq %rax, %rdi
callq 0xb340
leaq 0x6daf5(%rip), %rax     # 0x8c570
movq (%rax), %rdi
addq $0x20, %rdi
callq 0xb3b0
cmpq %rbx, %r13
cmovlq %r13, %rbx
addq %rbx, 0x20(%r14)
movq (%r12), %rax
movq 0x50(%rax), %rax
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbp, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/../include/common.hh
// Function: stringlist::conflate[abi:cxx11](int)
std::string conflate(int sep_)
    {
      std::string s;

      for (list_t::iterator i = lst.begin(); i != lst.end(); ++i) s += i->first + static_cast<char>(sep_);

      if (s.size() > 0) s.resize(s.size() - 1);

      return s;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rsi), %r12
cmpq %rsi, %r12
je 0x1f239
movq %rsi, %r14
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r15
movsbl %dl, %ebp
movq %r13, 0x8(%rsp)
movq 0x10(%r12), %rsi
movq 0x18(%r12), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x1d19a
movq 0x10(%rsp), %rsi
movl $0x1, %ecx
movq %r15, %rdi
xorl %edx, %edx
movl %ebp, %r8d
callq 0xba40
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0xb150
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1f230
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
movq (%r12), %r12
cmpq %r14, %r12
jne 0x1f1d6
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x1f24f
decq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xb130
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1f263
movq %rax, %r14
jmp 0x1f284
jmp 0x1f26a
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1f284
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x1f29c
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0xb510
movq %r14, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataprov/dataprov_register.cc
// Function: scdc_dataprov_register::dataset_open(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
scdc_dataset *scdc_dataprov_register::dataset_open(std::string &path, scdc_result &result)
{
  SCDC_TRACE("dataset_open: path: '" << path << "'");

  scdc_dataset_register *dataset_register = new scdc_dataset_register(this);

  SCDC_TRACE("dataset_open: return: " << dataset_register);

  return dataset_register;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x38, %edi
callq 0xb500
leaq 0x6a9d3(%rip), %rcx     # 0x8a280
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rbx, 0x8(%rax)
xorl %ecx, %ecx
movb %cl, 0x10(%rax)
leaq 0x28(%rax), %rdx
movq %rdx, 0x18(%rax)
movq $0x0, 0x20(%rax)
movb %cl, 0x28(%rax)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataprov/dataprov_register.cc
// Function: scdc_dataprov_register::reg_put(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool scdc_dataprov_register::reg_put(const std::string &url)
{
  SCDC_TRACE("reg_put: url: '" << url << "'");

  pair<register_t::iterator, bool> ret = reg.insert(register_t::value_type(url, scdc_dataprov_register_entry_t()));

  if (!ret.second)
  {
    SCDC_FAIL("reg_put: inserting register entry '" << url << "' failed");
    return false;
  }

  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
xorl %eax, %eax
movq %rax, -0x8(%r15)
movb %al, (%r15)
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq %rax, -0x8(%r12)
movb %al, (%r12)
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x20372
addq $0x68, %rbx
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x20598
movl %edx, %ebx
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1fc74
movq 0x98(%rsp), %rsi
incq %rsi
callq 0xb510
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1fc8f
movq 0x78(%rsp), %rsi
incq %rsi
callq 0xb510
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1fcaa
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xb510
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x1fcc1
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb510
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1fcd8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
testb $0x1, %bl
jne 0x1fd9e
leaq 0x6c888(%rip), %r12     # 0x8c570
movq (%r12), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x1fd9e
addq $0x20, %rdi
callq 0xb7d0
movq (%r12), %rax
movq 0x8(%rax), %r15
leaq 0x4a479(%rip), %rsi     # 0x6a188
movl $0xb, %edx
movq %r15, %rdi
callq 0xb5f0
leaq 0x4ab0e(%rip), %rsi     # 0x6a831
movl $0x13, %edx
movq %r15, %rdi
callq 0xb5f0
leaq 0x4ab0e(%rip), %rsi     # 0x6a845
movl $0x23, %edx
movq %r15, %rdi
callq 0xb5f0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0xb5f0
movq %rax, %r14
leaq 0x4c12b(%rip), %rsi     # 0x6be88
movl $0x8, %edx
movq %rax, %rdi
callq 0xb5f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %r14, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq (%r12), %rdi
addq $0x20, %rdi
callq 0xb3b0
andb $0x1, %bl
movl %ebx, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x2041c
jmp 0x1fdc4
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2046a
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataprov/dataprov_register.cc
// Function: scdc_dataprov_register::reg_info(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov_register::reg_info(const std::string &url, string &r)
{
  SCDC_TRACE("reg_info: url: '" << url << "'");

  stringstream ss;

  if (url == "")
  {
    ss << reg.size() << " url(s)";

  } else
  {
    register_t::iterator i = reg.find(url);

    if (i == reg.end()) return false;

    ss << i->second.type << ":" << i->second.state;
  }

  r = ss.str();

  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x28(%rsp), %rdi
callq 0xb360
leaq 0x4b4f9(%rip), %rsi     # 0x6b50d
movq %r14, %rdi
callq 0xb110
testl %eax, %eax
je 0x20077
leaq 0x68(%r15), %rdi
movq %r14, %rsi
callq 0x207d8
movq %rax, %r14
addq $0x70, %r15
cmpq %r15, %rax
je 0x200d9
leaq 0x38(%rsp), %rdi
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdx
callq 0xb5f0
movq %rax, %r15
leaq 0x4a2ec(%rip), %rsi     # 0x6a344
movl $0x1, %edx
movq %rax, %rdi
callq 0xb5f0
movq 0x60(%r14), %rsi
movq 0x68(%r14), %rdx
movq %r15, %rdi
callq 0xb5f0
jmp 0x2009c
leaq 0x38(%rsp), %rdi
movq 0x90(%r15), %rsi
callq 0xb330
leaq 0x4a7da(%rip), %rsi     # 0x6a869
movl $0x7, %edx
movq %rax, %rdi
callq 0xb5f0
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0xb8c0
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb670
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x200d5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
movb $0x1, %bl
jmp 0x200db
xorl %ebx, %ebx
movq 0x6bece(%rip), %rsi     # 0x8bfb0
leaq 0x28(%rsp), %rdi
callq 0xb390
leaq 0xa8(%rsp), %rdi
callq 0xb180
movl %ebx, %eax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %r15
retq
jmp 0x2010c
jmp 0x2010c
movq %rax, %rbx
movq 0x6be9a(%rip), %rsi     # 0x8bfb0
leaq 0x28(%rsp), %rdi
callq 0xb390
leaq 0xa8(%rsp), %rdi
callq 0xb180
movq %rbx, %rdi
callq 0xb9c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataprov/dataprov_register.cc
// Function: scdc_dataprov_register::reg_rm(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool scdc_dataprov_register::reg_rm(const std::string &url)
{
  SCDC_TRACE("reg_rm: url: '" << url << "'");

  if (reg.erase(url) != 1)
  {
    SCDC_FAIL("relay_rm: erasing relay entry '" << url << "' failed");
    return false;
  }

  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x68(%rdi), %r15
movq %r15, %rdi
callq 0x20862
movq 0x90(%r14), %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0x2090a
subq 0x90(%r14), %r12
cmpq $0x1, %r12
je 0x2022d
leaq 0x6c3f6(%rip), %r15     # 0x8c570
movq (%r15), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x2022d
addq $0x20, %rdi
callq 0xb7d0
movq (%r15), %rax
movq 0x8(%rax), %r14
leaq 0x49fe9(%rip), %rsi     # 0x6a188
movl $0xb, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x4a67e(%rip), %rsi     # 0x6a831
movl $0x13, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x4a6aa(%rip), %rsi     # 0x6a871
movl $0x1f, %edx
movq %r14, %rdi
callq 0xb5f0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0xb5f0
movq %rax, %rbx
leaq 0x4bc9b(%rip), %rsi     # 0x6be88
movl $0x8, %edx
movq %rax, %rdi
callq 0xb5f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq (%r15), %rdi
addq $0x20, %rdi
callq 0xb3b0
cmpq $0x1, %r12
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataprov/dataprov_register.cc
// Function: scdc_dataprov_register::reg_ls(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov_register::reg_ls(const std::string &type, string &r)
{
  SCDC_TRACE("reg_ls: type: '" << type << "'");

  r = "";

  for (register_t::iterator i = reg.begin(); i != reg.end(); ++i)
  {
    if (type == "" || i->second.type == type) r += i->first + ",";
  }

  if (r.size() > 0) r.resize(r.size() - 1);

  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdx), %rdx
leaq 0x4b2ab(%rip), %rcx     # 0x6b50d
movq %rbx, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0xb870
movq 0x80(%r15), %r12
addq $0x70, %r15
cmpq %r15, %r12
je 0x20327
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %rbp
movq %r14, %rdi
leaq 0x4b276(%rip), %rsi     # 0x6b50d
callq 0xb110
testl %eax, %eax
je 0x202c1
movq 0x48(%r12), %rdx
cmpq 0x8(%r14), %rdx
jne 0x20313
testq %rdx, %rdx
je 0x202c1
movq (%r14), %rsi
movq 0x40(%r12), %rdi
callq 0xb520
testl %eax, %eax
jne 0x20313
movq %r13, 0x8(%rsp)
movq 0x20(%r12), %rsi
movq 0x28(%r12), %rdx
addq %rsi, %rdx
movq %rbp, %rdi
callq 0x1d19a
movq %rbp, %rdi
leaq 0x4a5ac(%rip), %rsi     # 0x6a891
callq 0xba60
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0xb150
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x20313
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
movq %r12, %rdi
callq 0xb350
movq %rax, %r12
cmpq %r15, %rax
jne 0x2028d
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x2033d
decq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xb130
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x20350
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x2036a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataprov/dataprov_relay.cc
// Function: scdc_dataprov_relay::relay_get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov_relay::relay_get(const std::string &path, std::string &r)
{
  SCDC_TRACE("relay_get: path: '" << path << "'");

  relay_t::iterator i = relay.find(path);

  if (i == relay.end()) return false;

  r = i->second;

  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
addq $0x98, %rdi
callq 0x2286e
movq %rax, %r15
addq $0xa0, %rbx
cmpq %rbx, %rax
je 0x21eda
leaq 0x40(%r15), %rsi
movq %r14, %rdi
callq 0xb2c0
cmpq %rbx, %r15
setne %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataprov/dataprov_relay.cc
// Function: scdc_dataprov_relay::relay_info(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov_relay::relay_info(const std::string &path, std::string &r)
{
  SCDC_TRACE("relay_info: path: '" << path << "'");

  stringstream ss;

  if (path == "")
  {
    ss << relay.size() << " path(s)";

  } else
  {
    relay_t::iterator i = relay.find(path);

    if (i == relay.end()) return false;

    if (!reg_info(i->second, r)) return false;

    ss << r;
  }

  r = ss.str();

  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x28(%rsp), %rdi
callq 0xb360
leaq 0x49601(%rip), %rsi     # 0x6b50d
movq %r15, %rdi
callq 0xb110
testl %eax, %eax
je 0x21f60
leaq 0x98(%r14), %rdi
movq %r15, %rsi
callq 0x2286e
leaq 0xa0(%r14), %rcx
cmpq %rcx, %rax
je 0x21f5c
addq $0x40, %rax
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x1ffee
testb %al, %al
je 0x21f5c
leaq 0x38(%rsp), %rdi
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
callq 0xb5f0
jmp 0x21f85
xorl %ebx, %ebx
jmp 0x21fc0
leaq 0x38(%rsp), %rdi
movq 0xc0(%r14), %rsi
callq 0xb330
leaq 0x48a32(%rip), %rsi     # 0x6a9aa
movl $0x8, %edx
movq %rax, %rdi
callq 0xb5f0
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0xb8c0
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb670
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x21fbe
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
movb $0x1, %bl
movq 0x69fe9(%rip), %rsi     # 0x8bfb0
leaq 0x28(%rsp), %rdi
callq 0xb390
leaq 0xa8(%rsp), %rdi
callq 0xb180
movl %ebx, %eax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %r15
retq
jmp 0x21ff1
jmp 0x21ff1
movq %rax, %rbx
movq 0x69fb5(%rip), %rsi     # 0x8bfb0
leaq 0x28(%rsp), %rdi
callq 0xb390
leaq 0xa8(%rsp), %rdi
callq 0xb180
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataprov/dataprov_relay.cc
// Function: scdc_dataprov_relay::relay_rm(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool scdc_dataprov_relay::relay_rm(const std::string &path)
{
  SCDC_TRACE("relay_rm: path: '" << path << "'");

  relay_t::iterator i = relay.find(path);

  if (i == relay.end() || !reg_rm(i->second) || relay.erase(path) != 1)
  {
    SCDC_FAIL("relay_rm: erasing relay entry '" << path << "' failed");
    return false;
  }

  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x98(%rdi), %r15
movq %r15, %rdi
callq 0x2286e
leaq 0xa0(%r14), %rcx
cmpq %rcx, %rax
je 0x22086
addq $0x40, %rax
movq %r14, %rdi
movq %rax, %rsi
callq 0x20136
testb %al, %al
je 0x22086
movq %r15, %rdi
movq %rbx, %rsi
callq 0x22af8
movq 0xc0(%r14), %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0x22ba0
subq 0xc0(%r14), %r12
movb $0x1, %al
cmpq $0x1, %r12
je 0x22142
leaq 0x6a4e3(%rip), %r15     # 0x8c570
movq (%r15), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x22140
addq $0x20, %rdi
callq 0xb7d0
movq (%r15), %rax
movq 0x8(%rax), %r14
leaq 0x480d6(%rip), %rsi     # 0x6a188
movl $0xb, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x487f3(%rip), %rsi     # 0x6a8b9
movl $0x10, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x48797(%rip), %rsi     # 0x6a871
movl $0x1f, %edx
movq %r14, %rdi
callq 0xb5f0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0xb5f0
movq %rax, %rbx
leaq 0x49d88(%rip), %rsi     # 0x6be88
movl $0x8, %edx
movq %rax, %rdi
callq 0xb5f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq (%r15), %rdi
addq $0x20, %rdi
callq 0xb3b0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataprov/dataprov_relay.cc
// Function: scdc_dataprov_relay::relay_ls(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov_relay::relay_ls(const std::string &type, std::string &r)
{
  SCDC_TRACE("relay_ls: type: '" << type << "'");

  r = "";

  for (relay_t::iterator i = relay.begin(); i != relay.end(); ++i)
  {
    if (type != "")
    {
      register_t::iterator j = reg.find(i->second);

      if (j == reg.end() || j->second.type != type) continue;
    }

    r += i->first + ",";
  }

  if (r.size() > 0) r.resize(r.size() - 1);

  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdx), %rdx
leaq 0x4939d(%rip), %rcx     # 0x6b50d
movq %r13, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0xb870
movq 0xb0(%r15), %r12
leaq 0xa0(%r15), %rbp
cmpq %rbp, %r12
je 0x22257
leaq 0x68(%r15), %rax
movq %rax, 0x20(%rsp)
addq $0x70, %r15
movq %r14, %rdi
leaq 0x49362(%rip), %rsi     # 0x6b50d
callq 0xb110
testl %eax, %eax
je 0x221e7
leaq 0x40(%r12), %rsi
movq 0x20(%rsp), %rdi
callq 0x207d8
cmpq %r15, %rax
je 0x22243
movq 0x48(%rax), %rdx
cmpq 0x8(%r14), %rdx
jne 0x22243
testq %rdx, %rdx
je 0x221e7
movq (%r14), %rsi
movq 0x40(%rax), %rdi
callq 0xb520
testl %eax, %eax
jne 0x22243
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%r12), %rsi
movq 0x28(%r12), %rdx
addq %rsi, %rdx
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x1d19a
movq %rbx, %rdi
leaq 0x4867f(%rip), %rsi     # 0x6a891
callq 0xba60
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r13, %rdi
callq 0xb150
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x22243
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
movq %r12, %rdi
callq 0xb350
movq %rax, %r12
cmpq %rbp, %rax
jne 0x221a1
movq 0x8(%r13), %rsi
testq %rsi, %rsi
je 0x2226d
decq %rsi
movq %r13, %rdi
xorl %edx, %edx
callq 0xb130
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x22280
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x2229e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataprov/dataprov_relay.cc
// Function: scdc_dataprov_relay::relay_update(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool scdc_dataprov_relay::relay_update(const std::string &path)
{
  SCDC_TRACE("relay_update: path: '" << path << "'");

  relay_t::iterator i = relay.find(path);

  if (i == relay.end() || !reg_update(i->second))
  {
    SCDC_FAIL("relay_update: updating relay entry '" << path << "' failed");
    return false;
  }

  return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x98, %rdi
callq 0x2286e
leaq 0xa0(%r14), %rcx
cmpq %rcx, %rax
je 0x222e4
addq $0x40, %rax
movq %r14, %rdi
movq %rax, %rsi
callq 0x1fdd6
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x223a0
leaq 0x6a285(%rip), %r15     # 0x8c570
movq (%r15), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x2239e
addq $0x20, %rdi
callq 0xb7d0
movq (%r15), %rax
movq 0x8(%rax), %r14
leaq 0x47e78(%rip), %rsi     # 0x6a188
movl $0xb, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x48595(%rip), %rsi     # 0x6a8b9
movl $0x10, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x4867b(%rip), %rsi     # 0x6a9b3
movl $0x24, %edx
movq %r14, %rdi
callq 0xb5f0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0xb5f0
movq %rax, %rbx
leaq 0x49b2a(%rip), %rsi     # 0x6be88
movl $0x8, %edx
movq %rax, %rdi
callq 0xb5f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq (%r15), %rdi
addq $0x20, %rdi
callq 0xb3b0
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq