LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1ab72
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 0x544(%rip), %rax       # 0x1b0fe
movq %rax, 0x8(%r8)
leaq 0x6b6(%rip), %rax       # 0x1b27b
movq %rax, 0x10(%r8)
leaq -0x1b08(%rip), %rax     # 0x190c8
movq %rax, 0x18(%r8)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1a1cc
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_O3/mh0fm4[P]SCDC/src/lib/scdc/scdc.cc
// Function: scdc_context::release()
void release()
    {
      SCDC_TRACE("scdc-context: " << __func__);

      if (!data) return;

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

      data->nodeconns.close_all();

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

      data->nodeports.close_all();

      scdc_dataprov_close(data->dp_config);

      data->dataprovs.close_all();

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

      ::operator delete(data->result);

      delete data; data = 0;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x48(%rdi), %r13
testq %r13, %r13
je 0x1b75c
movq %rdi, %rbx
movq 0x20(%r13), %r14
leaq 0x10(%r13), %rax
cmpq %rax, %r14
je 0x1b699
movq 0x70fe1(%rip), %rbp     # 0x8c570
leaq 0x4ed86(%rip), %r15     # 0x6a31c
leaq 0x4ed8b(%rip), %r12     # 0x6a328
cmpq $0x0, 0x8(%rbp)
je 0x1b681
addq $0x20, %rbp
movq %rbp, %rdi
callq 0xb7d0
movq 0x70fb5(%rip), %rax     # 0x8c570
movq 0x8(%rax), %r13
movl $0xb, %edx
movq %r13, %rdi
leaq 0x4ebda(%rip), %rsi     # 0x6a1a8
callq 0xb5f0
movl $0x9, %edx
movq %r13, %rdi
leaq 0x4ebd2(%rip), %rsi     # 0x6a1b4
callq 0xb5f0
movl $0xe, %edx
movq %r13, %rdi
leaq 0x4ed17(%rip), %rsi     # 0x6a30d
callq 0xb5f0
movl $0x7, %edx
movq %r13, %rdi
leaq 0x4e10c(%rip), %rsi     # 0x69716
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 0x70f03(%rip), %rdi     # 0x8c570
addq $0x20, %rdi
callq 0xb3b0
movq 0x70ef3(%rip), %rbp     # 0x8c570
movq 0x48(%rbx), %r13
movq %r14, %rdi
callq 0xb600
movq %rax, %r14
leaq 0x10(%r13), %rax
cmpq %rax, %r14
jne 0x1b59d
addq $0x98, %r13
movq %r13, %rdi
callq 0x3327c
movq 0x48(%rbx), %rax
movq 0xd8(%rax), %r14
testq %r14, %r14
je 0x1b6d2
movq (%r14), %rax
movq %r14, %rdi
callq *0x30(%rax)
movq 0x30(%r14), %rax
testq %rax, %rax
je 0x1b6d2
movq $0x0, 0x8(%rax)
movq 0x48(%rbx), %rdi
movq 0xd8(%rdi), %rsi
testq %rsi, %rsi
je 0x1b6ff
cmpb $0x0, 0x70f0f(%rip)     # 0x8c5f8
jne 0x1b6ff
movq 0x70efe(%rip), %rdi     # 0x8c5f0
addq $0x68, %rdi
callq 0x33f6a
movq 0x48(%rbx), %rdi
addq $0x68, %rdi
callq 0x33faa
movq 0x48(%rbx), %rax
movq 0xd0(%rax), %rdi
callq 0x19596
movq 0x48(%rbx), %rdi
addq $0x38, %rdi
callq 0x1e212
callq 0x339b4
movq 0x48(%rbx), %rax
movq (%rax), %rdi
callq 0xb4c0
movq 0x48(%rbx), %r14
testq %r14, %r14
je 0x1b747
movq %r14, %rdi
callq 0x1bf46
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_O3/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, %rbp
movl %esi, 0x4(%rsp)
movq %rdx, 0x28(%rsp)
testq %rdx, %rdx
sete %al
testq %rcx, %rcx
sete %cl
orb %al, %cl
jne 0x1ba8f
movq %rdi, %r12
movq $0x0, 0x20(%rdi)
movq 0x28(%rsp), %rax
cmpb $0x0, (%rax)
je 0x1ba8f
leaq 0x40(%rsp), %r13
movq 0x28(%rsp), %r15
movq %r15, %rdi
testq %rbp, %rbp
js 0x1b937
movl 0x4(%rsp), %esi
movq %rbp, %rdx
callq 0xb5b0
testq %rax, %rax
jne 0x1b945
xorl %ebx, %ebx
movq %rbp, %r14
jmp 0x1b964
movl 0x4(%rsp), %esi
callq 0xb1e0
testq %rax, %rax
je 0x1b957
movq %rax, %r14
leaq 0x18(%rsp), %rax
subq %r15, %r14
movl $0x1, %ebx
jmp 0x1b969
movq %r15, %rdi
callq 0xb200
movq %rax, %r14
xorl %ebx, %ebx
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq (%r15,%r14), %rdx
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x1be38
leaq 0x18(%rsp), %rdx
movq %r13, 0x30(%rsp)
movq 0x8(%rsp), %rax
cmpq %rdx, %rax
je 0x1b9a4
movq %rax, 0x30(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x1b9ac
movups (%rdx), %xmm0
movups %xmm0, (%r13)
movq %r15, %rax
subq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x38(%rsp)
movq %rdx, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%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 %r13, %rdx
je 0x1ba04
movq %rdx, 0x10(%rax)
movq 0x40(%rsp), %rcx
movq %rcx, 0x20(%rax)
jmp 0x1ba0c
movups (%r13), %xmm0
movups %xmm0, (%rcx)
movq 0x38(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq %r13, 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 %r13, %rdi
je 0x1ba58
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xb510
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x1ba74
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
addq %rbx, %r14
addq %r14, 0x20(%r12)
cmpb $0x0, (%r15,%r14)
je 0x1ba8f
addq %r14, %r15
subq %r14, %rbp
jne 0x1b917
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x30(%rsp), %rdi
cmpq %r13, %rdi
je 0x1bab8
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xb510
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xc09c
movq %r14, %rdi
callq 0xb9c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1c09f
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rbx), %rax
movq 0x20(%rax), %rcx
cmpq $0x2, %rcx
je 0x1c07f
cmpq $0x1, %rcx
jne 0x1c097
movq 0x28(%rax), %rdx
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rcx
movq %rbx, %rdi
callq 0x1c0a0
jmp 0x1c097
movq 0x28(%rax), %rdx
movq 0x30(%rax), %rcx
movq 0x10(%rax), %rsi
movq 0x18(%rax), %r8
movq %rbx, %rdi
callq 0x1c102
cmpq $0x0, 0x30(%rbx)
jne 0x1c055
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1c164
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
cmpq $0x0, 0x18(%rdi)
je 0x1c157
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 0x1c166
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_O3/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 0x1c41e
movq %r12, %rdi
callq 0xb200
movq %rax, %rbp
jmp 0x1c420
xorl %ebp, %ebp
testq %rbx, %rbx
je 0x1c432
movq %rbx, %rdi
callq 0xb200
movq %rax, %r13
jmp 0x1c435
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 0x1c456
xorl %eax, %eax
jmp 0x1c46f
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_O3/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 0x4edf6(%rip), %rcx     # 0x6b52d
movq %r14, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0xb870
testq %r12, %r12
je 0x1c771
cmpb $0x0, (%r12)
je 0x1c771
cmpq $0x0, 0x8(%r14)
je 0x1c766
leaq 0x50912(%rip), %rsi     # 0x6d070
movq %r14, %rdi
callq 0xba60
movq %r14, %rdi
movq %r12, %rsi
callq 0xba60
testq %r15, %r15
je 0x1c79d
cmpb $0x0, (%r15)
je 0x1c79d
cmpq $0x0, 0x8(%r14)
je 0x1c792
leaq 0x508e6(%rip), %rsi     # 0x6d070
movq %r14, %rdi
callq 0xba60
movq %r14, %rdi
movq %r15, %rsi
callq 0xba60
testq %rbx, %rbx
je 0x1c7d3
cmpb $0x0, (%rbx)
je 0x1c7d3
cmpq $0x0, 0x8(%r14)
je 0x1c7bd
leaq 0x508bb(%rip), %rsi     # 0x6d070
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_O3/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 0x4ea68(%rip), %rcx     # 0x6b52d
movq %r14, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0xb870
testq %r12, %r12
je 0x1caf8
cmpb $0x0, (%r12)
je 0x1caf8
movq %r14, %rdi
movq %r12, %rsi
callq 0xba60
leaq 0x4d874(%rip), %rsi     # 0x6a364
movq %r14, %rdi
callq 0xba60
testq %r15, %r15
je 0x1cb24
cmpb $0x0, (%r15)
je 0x1cb24
cmpq $0x0, 0x8(%r14)
je 0x1cb19
leaq 0x4d85b(%rip), %rsi     # 0x6a36c
movq %r14, %rdi
callq 0xba60
movq %r14, %rdi
movq %r15, %rsi
callq 0xba60
testq %rbx, %rbx
je 0x1cb5a
cmpb $0x0, (%rbx)
je 0x1cb5a
cmpq $0x0, 0x8(%r14)
je 0x1cb44
leaq 0x4d831(%rip), %rsi     # 0x6a36d
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_O3/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 0x4e9a8(%rip), %rcx     # 0x6b52d
movq %rsi, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0xb870
testq %r15, %r15
je 0x1ccef
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, %rbp
testq %rax, %rax
jne 0x1cbde
movq %r15, %rdi
callq 0xb200
movq %rax, %rbp
addq %r15, %rbp
movq %r13, 0x28(%rsp)
movq %r12, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x1be38
movq %r12, %rdi
leaq 0x4d775(%rip), %rsi     # 0x6a370
callq 0xb110
testl %eax, %eax
je 0x1cc2a
movq %r12, %rdi
leaq 0x4d761(%rip), %rsi     # 0x6a36f
callq 0xb110
testl %eax, %eax
je 0x1cc56
cmpq $0x0, 0x30(%rsp)
je 0x1cc2a
movq %rsp, %rdi
movq %r12, %rsi
callq 0x1ce58
movb (%rbp), %r14b
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x1cc45
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb510
incq %rbp
movq %rbp, %r15
testb %r14b, %r14b
jne 0x1cbbb
jmp 0x1cc9d
movq 0x8(%rsp), %rdi
cmpq %rdi, (%rsp)
je 0x1cc17
addq $-0x20, %rdi
leaq 0x4d703(%rip), %rsi     # 0x6a36f
callq 0xb110
testl %eax, %eax
je 0x1cc17
movq 0x8(%rsp), %rax
leaq -0x20(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq -0x20(%rax), %rdi
addq $-0x10, %rax
cmpq %rax, %rdi
je 0x1cc2a
movq (%rax), %rsi
incq %rsi
callq 0xb510
jmp 0x1cc2a
movq (%rsp), %r12
cmpq 0x8(%rsp), %r12
movq 0x20(%rsp), %r14
je 0x1cce7
leaq 0x4d6b9(%rip), %r15     # 0x6a36d
cmpb $0x2f, (%r14)
je 0x1ccc0
cmpq (%rsp), %r12
je 0x1cccb
movq %rbx, %rdi
movq %r15, %rsi
callq 0xba60
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rbx, %rdi
callq 0xb150
addq $0x20, %r12
cmpq 0x8(%rsp), %r12
jne 0x1ccb4
movq %rsp, %rdi
callq 0x1ce96
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 0x1cd1f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb510
jmp 0x1cd1f
jmp 0x1cd1c
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1ce96
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O3/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
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
movsd 0x6f839(%rip), %xmm2    # 0x8c580
xorpd %xmm0, %xmm0
ucomisd %xmm2, %xmm0
jbe 0x1cdd6
leaq 0x38(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
movsd %xmm1, (%rsp)
callq 0xb910
xorps %xmm0, %xmm0
cvtsi2sdq (%r14), %xmm0
xorps %xmm1, %xmm1
cvtsi2sdq 0x8(%r14), %xmm1
mulsd 0x4c2a6(%rip), %xmm1    # 0x69028
addsd %xmm0, %xmm1
movapd %xmm1, 0x10(%rsp)
leaq 0x28(%rsp), %r14
movl $0x1, %edi
movq %r14, %rsi
callq 0xb480
movapd 0x10(%rsp), %xmm2
xorps %xmm0, %xmm0
cvtsi2sdq (%r14), %xmm0
xorps %xmm1, %xmm1
cvtsi2sdq 0x8(%r14), %xmm1
mulsd 0x4c25b(%rip), %xmm1    # 0x69018
addsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
subsd %xmm1, %xmm2
movsd (%rsp), %xmm1
movsd %xmm2, 0x6f7aa(%rip)    # 0x8c580
ucomisd %xmm1, %xmm0
jbe 0x1ce13
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 0x4c211(%rip), %xmm1    # 0x69018
addsd %xmm0, %xmm1
movsd 0x6f76d(%rip), %xmm2    # 0x8c580
addsd 0x8(%rsp), %xmm2
addsd %xmm1, %xmm2
movapd 0x4d52b(%rip), %xmm0    # 0x6a350
andpd %xmm2, %xmm0
cvttsd2si %xmm0, %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
subsd %xmm0, %xmm2
mulsd 0x4d4fe(%rip), %xmm2    # 0x6a340
movq %rax, (%rbx)
cvttsd2si %xmm2, %rax
movq %rax, 0x8(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1e252
movq 0x18(%rbx), %rax
movq 0x40(%rax), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1e1b0
jmp 0x1e236
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1e268
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 0x1e28b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4bcea(%rip), %rdx     # 0x6a565
movq %r13, %rsi
movq %r12, %rcx
xorl %eax, %eax
callq 0xb8e0
movslq %eax, %rbx
cmpq %rbx, %r13
jge 0x1e977
leaq 0x6dcd5(%rip), %rax     # 0x8c570
movq (%rax), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x1e977
addq $0x20, %rdi
callq 0xb7d0
leaq 0x6dcb7(%rip), %rax     # 0x8c570
movq (%rax), %rax
movq %rbp, (%rsp)
movq 0x18(%rax), %rbp
leaq 0x4bc9e(%rip), %rsi     # 0x6a569
movl $0xd, %edx
movq %rbp, %rdi
callq 0xb5f0
leaq 0x4bc98(%rip), %rsi     # 0x6a577
movl $0x19, %edx
movq %rbp, %rdi
callq 0xb5f0
leaq 0x4ba71(%rip), %rsi     # 0x6a364
movl $0x1, %edx
movq %rbp, %rdi
callq 0xb5f0
movq %rbp, %rdi
movl $0x198, %esi            # imm = 0x198
callq 0xb9a0
movq %rax, %rbp
leaq 0x4bc7a(%rip), %rsi     # 0x6a591
movl $0x10, %edx
movq %rax, %rdi
callq 0xb5f0
leaq 0x4d5d5(%rip), %rsi     # 0x6bf00
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 0x6dc05(%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_O3/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 0x1f125
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 0x1d0a0
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 0x1f106
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
movq (%r12), %r12
cmpq %r14, %r12
jne 0x1f0ac
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x1f125
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 0x1f139
movq %rax, %r14
jmp 0x1f15a
jmp 0x1f140
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1f15a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x1f172
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0xb510
movq %r14, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6ab8f(%rip), %rcx     # 0x8a310
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_O3/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 0x2024c
addq $0x68, %rbx
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x20472
movl %edx, %ebx
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1fb4e
movq 0x98(%rsp), %rsi
incq %rsi
callq 0xb510
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1fb69
movq 0x78(%rsp), %rsi
incq %rsi
callq 0xb510
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1fb84
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xb510
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x1fb9b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb510
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1fbb2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
testb $0x1, %bl
jne 0x1fc78
leaq 0x6c9ae(%rip), %r12     # 0x8c570
movq (%r12), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x1fc78
addq $0x20, %rdi
callq 0xb7d0
movq (%r12), %rax
movq 0x8(%rax), %r15
leaq 0x4a5bf(%rip), %rsi     # 0x6a1a8
movl $0xb, %edx
movq %r15, %rdi
callq 0xb5f0
leaq 0x4ac54(%rip), %rsi     # 0x6a851
movl $0x13, %edx
movq %r15, %rdi
callq 0xb5f0
leaq 0x4ac54(%rip), %rsi     # 0x6a865
movl $0x23, %edx
movq %r15, %rdi
callq 0xb5f0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0xb5f0
movq %rax, %r14
leaq 0x4c2c9(%rip), %rsi     # 0x6bf00
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 0x202f6
jmp 0x1fc9e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20344
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4b63f(%rip), %rsi     # 0x6b52d
movq %r14, %rdi
callq 0xb110
testl %eax, %eax
je 0x1ff51
leaq 0x68(%r15), %rdi
movq %r14, %rsi
callq 0x206b2
movq %rax, %r14
addq $0x70, %r15
cmpq %r15, %rax
je 0x1ffb3
leaq 0x38(%rsp), %rdi
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdx
callq 0xb5f0
movq %rax, %r15
leaq 0x4a432(%rip), %rsi     # 0x6a364
movl $0x1, %edx
movq %rax, %rdi
callq 0xb5f0
movq 0x60(%r14), %rsi
movq 0x68(%r14), %rdx
movq %r15, %rdi
callq 0xb5f0
jmp 0x1ff76
leaq 0x38(%rsp), %rdi
movq 0x90(%r15), %rsi
callq 0xb330
leaq 0x4a920(%rip), %rsi     # 0x6a889
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 0x1ffaf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
movb $0x1, %bl
jmp 0x1ffb5
xorl %ebx, %ebx
movq 0x6bff4(%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 0x1ffe6
jmp 0x1ffe6
movq %rax, %rbx
movq 0x6bfc0(%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_O3/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 0x2073c
movq 0x90(%r14), %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0x207f0
subq 0x90(%r14), %r12
cmpq $0x1, %r12
je 0x20107
leaq 0x6c51c(%rip), %r15     # 0x8c570
movq (%r15), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x20107
addq $0x20, %rdi
callq 0xb7d0
movq (%r15), %rax
movq 0x8(%rax), %r14
leaq 0x4a12f(%rip), %rsi     # 0x6a1a8
movl $0xb, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x4a7c4(%rip), %rsi     # 0x6a851
movl $0x13, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x4a7f0(%rip), %rsi     # 0x6a891
movl $0x1f, %edx
movq %r14, %rdi
callq 0xb5f0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0xb5f0
movq %rax, %rbx
leaq 0x4be39(%rip), %rsi     # 0x6bf00
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_O3/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 0x4b3f1(%rip), %rcx     # 0x6b52d
movq %rbx, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0xb870
movq 0x80(%r15), %r12
addq $0x70, %r15
cmpq %r15, %r12
je 0x20201
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %rbp
movq %r14, %rdi
leaq 0x4b3bc(%rip), %rsi     # 0x6b52d
callq 0xb110
testl %eax, %eax
je 0x2019b
movq 0x48(%r12), %rdx
cmpq 0x8(%r14), %rdx
jne 0x201ed
testq %rdx, %rdx
je 0x2019b
movq (%r14), %rsi
movq 0x40(%r12), %rdi
callq 0xb520
testl %eax, %eax
jne 0x201ed
movq %r13, 0x8(%rsp)
movq 0x20(%r12), %rsi
movq 0x28(%r12), %rdx
addq %rsi, %rdx
movq %rbp, %rdi
callq 0x1d0a0
movq %rbp, %rdi
leaq 0x4a6f2(%rip), %rsi     # 0x6a8b1
callq 0xba60
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0xb150
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x201ed
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
movq %r12, %rdi
callq 0xb350
movq %rax, %r12
cmpq %r15, %rax
jne 0x20167
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x20217
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 0x2022a
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x20244
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x22790
movq %rax, %r15
addq $0xa0, %rbx
cmpq %rbx, %rax
je 0x21dfc
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_O3/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 0x496ff(%rip), %rsi     # 0x6b52d
movq %r15, %rdi
callq 0xb110
testl %eax, %eax
je 0x21e82
leaq 0x98(%r14), %rdi
movq %r15, %rsi
callq 0x22790
leaq 0xa0(%r14), %rcx
cmpq %rcx, %rax
je 0x21e7e
addq $0x40, %rax
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x1fec8
testb %al, %al
je 0x21e7e
leaq 0x38(%rsp), %rdi
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
callq 0xb5f0
jmp 0x21ea7
xorl %ebx, %ebx
jmp 0x21ee2
leaq 0x38(%rsp), %rdi
movq 0xc0(%r14), %rsi
callq 0xb330
leaq 0x48b30(%rip), %rsi     # 0x6a9ca
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 0x21ee0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
movb $0x1, %bl
movq 0x6a0c7(%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 0x21f13
jmp 0x21f13
movq %rax, %rbx
movq 0x6a093(%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_O3/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 0x22790
leaq 0xa0(%r14), %rcx
cmpq %rcx, %rax
je 0x21fa8
addq $0x40, %rax
movq %r14, %rdi
movq %rax, %rsi
callq 0x20010
testb %al, %al
je 0x21fa8
movq %r15, %rdi
movq %rbx, %rsi
callq 0x22a1a
movq 0xc0(%r14), %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0x22ace
subq 0xc0(%r14), %r12
movb $0x1, %al
cmpq $0x1, %r12
je 0x22064
leaq 0x6a5c1(%rip), %r15     # 0x8c570
movq (%r15), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x22062
addq $0x20, %rdi
callq 0xb7d0
movq (%r15), %rax
movq 0x8(%rax), %r14
leaq 0x481d4(%rip), %rsi     # 0x6a1a8
movl $0xb, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x488f1(%rip), %rsi     # 0x6a8d9
movl $0x10, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x48895(%rip), %rsi     # 0x6a891
movl $0x1f, %edx
movq %r14, %rdi
callq 0xb5f0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0xb5f0
movq %rax, %rbx
leaq 0x49ede(%rip), %rsi     # 0x6bf00
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_O3/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 0x4949b(%rip), %rcx     # 0x6b52d
movq %r13, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0xb870
movq 0xb0(%r15), %r12
leaq 0xa0(%r15), %rbp
cmpq %rbp, %r12
je 0x22179
leaq 0x68(%r15), %rax
movq %rax, 0x20(%rsp)
addq $0x70, %r15
movq %r14, %rdi
leaq 0x49460(%rip), %rsi     # 0x6b52d
callq 0xb110
testl %eax, %eax
je 0x22109
leaq 0x40(%r12), %rsi
movq 0x20(%rsp), %rdi
callq 0x206b2
cmpq %r15, %rax
je 0x22165
movq 0x48(%rax), %rdx
cmpq 0x8(%r14), %rdx
jne 0x22165
testq %rdx, %rdx
je 0x22109
movq (%r14), %rsi
movq 0x40(%rax), %rdi
callq 0xb520
testl %eax, %eax
jne 0x22165
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 0x1d0a0
movq %rbx, %rdi
leaq 0x4877d(%rip), %rsi     # 0x6a8b1
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 0x22165
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
movq %r12, %rdi
callq 0xb350
movq %rax, %r12
cmpq %rbp, %rax
jne 0x220c3
movq 0x8(%r13), %rsi
testq %rsi, %rsi
je 0x2218f
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 0x221a2
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x221c0
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x22790
leaq 0xa0(%r14), %rcx
cmpq %rcx, %rax
je 0x22206
addq $0x40, %rax
movq %r14, %rdi
movq %rax, %rsi
callq 0x1fcb0
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x222c2
leaq 0x6a363(%rip), %r15     # 0x8c570
movq (%r15), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x222c0
addq $0x20, %rdi
callq 0xb7d0
movq (%r15), %rax
movq 0x8(%rax), %r14
leaq 0x47f76(%rip), %rsi     # 0x6a1a8
movl $0xb, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x48693(%rip), %rsi     # 0x6a8d9
movl $0x10, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x48779(%rip), %rsi     # 0x6a9d3
movl $0x24, %edx
movq %r14, %rdi
callq 0xb5f0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0xb5f0
movq %rax, %rbx
leaq 0x49c80(%rip), %rsi     # 0x6bf00
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
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/dataprov/dataprov_relay.cc
// Function: scdc_dataset_relay::do_cmd(char const*, long long, _scdc_dataset_inout_t*, _scdc_dataset_inout_t*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
virtual bool do_cmd(const char *cmd, scdcint_t cmd_size, scdc_dataset_input_t *input, scdc_dataset_output_t *output, scdc_result &result)
    {
      SCDC_TRACE("do_cmd: '" << string(cmd, cmd_size) << "'");

      scdcint_t ret = scdc_dataset_cmd(dataset, string(cmd, cmd_size).c_str(), input, output);

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

      return (ret == SCDC_SUCCESS);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq 0x38(%rdi), %r15
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
addq %rsi, %rdx
movq %rsp, %r12
movq %r12, %rdi
callq 0x1be38
movq (%r12), %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x1ab07
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x2267f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
cmpq $0x1, %rbx
sete %al
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x226ad
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/dataprov/dataprov_store_mem.cc
// Function: scdc_dataprov_store_mem_handler::clear_stores()
void scdc_dataprov_store_mem_handler::clear_stores()
{
  SCDC_TRACE_F();

  for (stores_t::iterator i = stores.begin(); i != stores.end(); ++i) del_store(*i);

  stores.clear();

  SCDC_TRACE_F("return:");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
cmpq %rdi, %r14
je 0x22c23
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x23762
movq (%r14), %r14
cmpq %rbx, %r14
jne 0x22c0f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x26834
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/src/components/dataprov/dataprov_store_mem.cc
// Function: scdc_dataprov_store_mem_handler::ls_stores(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov_store_mem_handler::ls_stores(std::string &result)
{
  SCDC_TRACE_F();

  bool ret = false;

  result = zxx::to_string(stores.size()) + "|";

  for (stores_t::const_iterator i = stores.begin(); i != stores.end(); ++i)
  {
    result += (*i)->name + "|";
  }

  ret = true;

  SCDC_TRACE_F("return: " << ret << ", result: " << result);

  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r15
movl $0x1, %esi
cmpq $0xa, %r15
jb 0x22ca4
movl $0x4, %esi
movabsq $0x346dc5d63886594b, %rdi # imm = 0x346DC5D63886594B
movq %r15, %rcx
cmpq $0x63, %rcx
jbe 0x22c9d
cmpq $0x3e7, %rcx            # imm = 0x3E7
jbe 0x22ca2
cmpq $0x2710, %rcx           # imm = 0x2710
jb 0x22ca4
movq %rcx, %rax
mulq %rdi
shrq $0xb, %rdx
addl $0x4, %esi
cmpq $0x1869f, %rcx          # imm = 0x1869F
movq %rdx, %rcx
ja 0x22c67
addl $-0x3, %esi
jmp 0x22ca4
addl $-0x2, %esi
jmp 0x22ca4
decl %esi
movl %esi, %esi
leaq 0x38(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x28(%rsp), %r12
movq %r12, %rdi
xorl %edx, %edx
callq 0xb610
movq (%r12), %rdi
movl 0x8(%r12), %esi
movq %r15, %rdx
callq 0x26caa
leaq 0x4886c(%rip), %rsi     # 0x6b542
movq %r12, %rdi
callq 0xba60
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x22d05
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x22d0d
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %r15
movq %rdx, 0x8(%r15)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb670
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x22d49
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x22d60
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb510
movq (%r14), %rbp
cmpq %r14, %rbp
je 0x22dcc
leaq 0x8(%rsp), %r15
leaq 0x487ce(%rip), %r12     # 0x6b542
movq 0x10(%rbp), %rax
movq %r13, 0x8(%rsp)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x1d0a0
movq %r15, %rdi
movq %r12, %rsi
callq 0xba60
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0xb150
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x22dc3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
movq (%rbp), %rbp
cmpq %r14, %rbp
jne 0x22d74
movb $0x1, %al
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x22e0d
movq 0x38(%rsp), %rsi
jmp 0x22e05
jmp 0x22df3
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x22e0d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
nop