LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: mh0fm4[P]SCDC/src/lib/scdc/scdc.cc
// Function: scdc_dataset_open
scdc_dataset_t scdc_dataset_open(const char *uri, ...)
{
  SCDC_TRACE(__func__ << ": uri: '" << uri << "'");

  scdc_args_t args;

  va_list ap;
  va_start(ap, uri);

  scdc_args_va_init(&args, &ap);

  scdc_dataset_t dataset = scdc_dataset_open_intern(uri, &args);

  scdc_args_va_release(&args);

  va_end(ap);

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

  return dataset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x22f2e
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %r9, -0xd8(%rbp)
movq %r8, -0xe0(%rbp)
movq %rcx, -0xe8(%rbp)
movq %rdx, -0xf0(%rbp)
movq %rsi, -0xf8(%rbp)
movq %rdi, -0x8(%rbp)
jmp 0x22f57
leaq -0x40(%rbp), %rax
leaq -0x100(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x21da0
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x22a80
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x21e20
leaq -0x40(%rbp), %rax
jmp 0x22fa8
movq -0x48(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/lib/scdc/scdc.cc
// Function: scdc_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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
jmp 0x22fce
cmpq $0x0, -0x8(%rbp)
jne 0x22fda
jmp 0x23131
movq 0xb173f(%rip), %rdi     # 0xd4720
addq $0x8, %rdi
leaq -0x8(%rbp), %rsi
callq 0x25890
cmpq $0x1, %rax
je 0x23082
jmp 0x22ffa
movq 0xb16a7(%rip), %rdi     # 0xd46a8
callq 0x257e0
cmpq $0x0, %rax
je 0x2307b
movq 0xb1695(%rip), %rdi     # 0xd46a8
callq 0x25800
movq 0xb1689(%rip), %rdi     # 0xd46a8
callq 0x257e0
movq %rax, %rdi
leaq 0x83182(%rip), %rsi     # 0xa61b0
callq 0xc670
movq %rax, %rdi
leaq 0x8317f(%rip), %rsi     # 0xa61bc
callq 0xc670
movq %rax, %rdi
leaq 0x83193(%rip), %rsi     # 0xa61df
callq 0xc670
movq %rax, %rdi
leaq 0x83197(%rip), %rsi     # 0xa61f2
callq 0xc670
movq %rax, %rdi
movq 0xb0f56(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
movq 0xb1632(%rip), %rdi     # 0xd46a8
callq 0x25820
jmp 0x2307d
jmp 0x23131
leaq -0x28(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0xc960
movq -0x40(%rbp), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x258c0
jmp 0x230a5
movq 0xb1674(%rip), %rax     # 0xd4720
movq (%rax), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xc260
movq -0x48(%rbp), %rdi
movq %rax, %rsi
movq 0xb1652(%rip), %rax     # 0xd4720
movq (%rax), %rax
movq (%rax), %rdx
subq $0x1, %rdx
callq 0xc320
jmp 0x230df
jmp 0x230e1
movq 0xb1638(%rip), %rdi     # 0xd4720
addq $0x98, %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x50d50
jmp 0x230fd
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x23122
movq -0x50(%rbp), %rdi
callq 0x25780
movq -0x50(%rbp), %rdi
movl $0x20, %esi
callq 0xc6a0
jmp 0x23124
jmp 0x23126
jmp 0x23128
leaq -0x28(%rbp), %rdi
callq 0xc3e0
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xc3e0
movq -0x30(%rbp), %rdi
callq 0xcba0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
testb %al, %al
je 0x23dc4
movaps %xmm0, -0xf0(%rbp)
movaps %xmm1, -0xe0(%rbp)
movaps %xmm2, -0xd0(%rbp)
movaps %xmm3, -0xc0(%rbp)
movaps %xmm4, -0xb0(%rbp)
movaps %xmm5, -0xa0(%rbp)
movaps %xmm6, -0x90(%rbp)
movaps %xmm7, -0x80(%rbp)
movq %r9, -0xf8(%rbp)
movq %r8, -0x100(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
jmp 0x23de4
leaq -0x60(%rbp), %rax
leaq -0x120(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x20, (%rax)
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x21da0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x40(%rbp), %r8
callq 0x23160
movq %rax, -0x68(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x21e20
leaq -0x60(%rbp), %rax
jmp 0x23e41
movq -0x68(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nop
// File: mh0fm4[P]SCDC/src/lib/scdc/scdc.cc
// Function: scdc_dataprov_hook_open_intern(void*, char const*, _scdc_args_t*, long long*)
static void *scdc_dataprov_hook_open_intern(void *intern_data, const char *conf, scdc_args_t *args, scdcint_t *ret)
{
  SCDC_TRACE(__func__ << ": intern_data: " << intern_data << ", conf: '" << conf << "', args: " << args);

  scdc_dataprov_hook_open_f *open = reinterpret_cast<scdc_dataprov_hook_open_f *>(intern_data);

  void *dataprov = 0;

  *ret = SCDC_SUCCESS;

  if (open)
  {
    scdc_args_data_va_t *args_data_va = static_cast<scdc_args_data_va_t *>(args->data);

    va_list aq;

    va_copy(aq, *args_data_va->ap);

    dataprov = open(conf, aq);

    if (!dataprov) *ret = SCDC_FAILURE;

    va_end(aq);
  }

  return dataprov;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
jmp 0x2501a
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq $0x1, (%rax)
cmpq $0x0, -0x28(%rbp)
je 0x25089
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
leaq -0x50(%rbp), %rax
movq -0x38(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movups (%rcx), %xmm0
movups %xmm0, (%rax)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq *%rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x25085
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
leaq -0x50(%rbp), %rax
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x25476
movq -0x20(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x25486
jmp 0x25659
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rdi
addq $0x8, %rdi
callq 0x27f30
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rdi
addq $0x8, %rdi
callq 0x27f90
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x27f60
testb $0x1, %al
jne 0x254c6
jmp 0x25596
jmp 0x254c8
movq 0xaf1d9(%rip), %rdi     # 0xd46a8
callq 0x257e0
cmpq $0x0, %rax
je 0x25584
movq 0xaf1c3(%rip), %rdi     # 0xd46a8
callq 0x25800
movq 0xaf1b7(%rip), %rdi     # 0xd46a8
callq 0x257e0
movq %rax, %rdi
leaq 0x80cb0(%rip), %rsi     # 0xa61b0
callq 0xc670
movq %rax, %rdi
leaq 0x80cad(%rip), %rsi     # 0xa61bc
callq 0xc670
movq %rax, %rdi
leaq 0x80df7(%rip), %rsi     # 0xa6315
callq 0xc670
movq %rax, %rdi
leaq 0x801d1(%rip), %rsi     # 0xa56fe
callq 0xc670
movq %rax, %rdi
leaq 0x80de8(%rip), %rsi     # 0xa6324
callq 0xc670
movq %rax, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x27fc0
movq -0x28(%rbp), %rdi
movq (%rax), %rsi
callq 0xc4f0
movq %rax, %rdi
leaq 0x80dcc(%rip), %rsi     # 0xa6330
callq 0xc670
movq %rax, %rdi
movq 0xaea4d(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
movq 0xaf129(%rip), %rdi     # 0xd46a8
callq 0x25820
jmp 0x25586
jmp 0x25588
leaq -0x10(%rbp), %rdi
callq 0x27ff0
jmp 0x2549b
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rdi
addq $0x98, %rdi
callq 0x50f20
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rax
movq 0xd8(%rax), %rdi
callq 0x225b0
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rax
movq 0xd8(%rax), %rdi
callq 0x22510
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rdi
addq $0x68, %rdi
callq 0x53c30
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rax
movq 0xd0(%rax), %rdi
callq 0x222d0
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rdi
addq $0x38, %rdi
callq 0x2d840
callq 0x53190
callq 0x28020
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rdi
callq 0xc620
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x2564b
movq -0x30(%rbp), %rdi
callq 0x28030
movq -0x30(%rbp), %rdi
movl $0xe0, %esi
callq 0xc6a0
movq -0x20(%rbp), %rax
movq $0x0, 0x48(%rax)
jmp 0x25659
addq $0x30, %rsp
popq %rbp
retq
nop
// File: mh0fm4[P]SCDC/src/lib/scdc/../../include/common.hh
// Function: stringlist::front_pop(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool front_pop(std::string &s)
    {
      if (lst.size() <= 0) return false;

      s = front();

      lst.pop_front();

      return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x266c0
cmpq $0x0, %rax
ja 0x26759
movb $0x0, -0x1(%rbp)
jmp 0x26789
movq -0x40(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x267a0
movq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xc850
leaq -0x38(%rbp), %rdi
callq 0xc3e0
movq -0x40(%rbp), %rdi
callq 0x26820
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: mh0fm4[P]SCDC/src/lib/scdc/../../include/args.hh
// Function: scdc_args::free_all()
void free_all() {
      while (gets.size() > 0) {
        const scdc_args_get_entry_t &e = gets.front();
        if (e.n == 1) free<void>(e.type, e.v0, e.arg_ref);
        else if (e.n == 2) free<void, void>(e.type, e.v0, e.v1, e.arg_ref);
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0x289e0
cmpq $0x0, %rax
jbe 0x289af
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0x28a10
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x1, 0x10(%rax)
jne 0x28975
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
callq 0x28a40
jmp 0x289aa
movq -0x10(%rbp), %rax
cmpq $0x2, 0x10(%rax)
jne 0x289a8
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %r8
callq 0x28ab0
jmp 0x289aa
jmp 0x28924
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, 0x18(%rax)
je 0x28ae2
cmpq $0x0, -0x28(%rbp)
jne 0x28ae4
jmp 0x28b2b
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %r9
movl $0x2, %ecx
callq 0x28c50
movq -0x48(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x18(%rcx), %rax
movq (%rcx), %rdi
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq *%rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0xc280
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x29f47
movq -0x10(%rbp), %rdi
callq 0xc280
movq %rax, -0x38(%rbp)
jmp 0x29f4f
xorl %eax, %eax
movq %rax, -0x38(%rbp)
jmp 0x29f4f
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x29f6d
movq -0x18(%rbp), %rdi
callq 0xc280
movq %rax, -0x40(%rbp)
jmp 0x29f75
xorl %eax, %eax
movq %rax, -0x40(%rbp)
jmp 0x29f75
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0xc2d0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x41(%rbp)
jne 0x29fd0
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq -0x30(%rbp), %rcx
movb %al, -0x41(%rbp)
jb 0x29fd0
movq -0x8(%rbp), %rdi
addq -0x20(%rbp), %rdi
xorl %eax, %eax
subq -0x30(%rbp), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xc2d0
cmpl $0x0, %eax
sete %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
jmp 0x2a67a
movq -0x20(%rbp), %rdi
leaq 0x7bf1f(%rip), %rsi     # 0xa65a4
callq 0xc920
cmpq $0x0, -0x10(%rbp)
je 0x2a6cc
movq -0x10(%rbp), %rdi
callq 0xc280
cmpq $0x0, %rax
jbe 0x2a6cc
movq -0x20(%rbp), %rdi
callq 0xc460
cmpq $0x0, %rax
jbe 0x2a6bf
movq -0x20(%rbp), %rdi
leaq 0x7e93e(%rip), %rsi     # 0xa8ff8
callq 0xc630
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdi
callq 0xc630
cmpq $0x0, -0x8(%rbp)
je 0x2a70e
movq -0x8(%rbp), %rdi
callq 0xc280
cmpq $0x0, %rax
jbe 0x2a70e
movq -0x20(%rbp), %rdi
callq 0xc460
cmpq $0x0, %rax
jbe 0x2a701
movq -0x20(%rbp), %rdi
leaq 0x7e8fc(%rip), %rsi     # 0xa8ff8
callq 0xc630
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdi
callq 0xc630
cmpq $0x0, -0x18(%rbp)
je 0x2a750
movq -0x18(%rbp), %rdi
callq 0xc280
cmpq $0x0, %rax
jbe 0x2a750
movq -0x20(%rbp), %rdi
callq 0xc460
cmpq $0x0, %rax
jbe 0x2a743
movq -0x20(%rbp), %rdi
leaq 0x7e8ba(%rip), %rsi     # 0xa8ff8
callq 0xc630
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdi
callq 0xc630
jmp 0x2a752
jmp 0x2a754
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
jmp 0x2ab4a
movq -0x20(%rbp), %rdi
leaq 0x7ba4f(%rip), %rsi     # 0xa65a4
callq 0xc920
cmpq $0x0, -0x8(%rbp)
je 0x2ab8d
movq -0x8(%rbp), %rdi
callq 0xc280
cmpq $0x0, %rax
jbe 0x2ab8d
movq -0x8(%rbp), %rsi
movq -0x20(%rbp), %rdi
callq 0xc630
movq -0x20(%rbp), %rdi
leaq 0x7b7dc(%rip), %rsi     # 0xa6364
callq 0xc630
cmpq $0x0, -0x10(%rbp)
je 0x2abcf
movq -0x10(%rbp), %rdi
callq 0xc280
cmpq $0x0, %rax
jbe 0x2abcf
movq -0x20(%rbp), %rdi
callq 0xc460
cmpq $0x0, %rax
jbe 0x2abc2
movq -0x20(%rbp), %rdi
leaq 0x7b7af(%rip), %rsi     # 0xa636c
callq 0xc630
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdi
callq 0xc630
cmpq $0x0, -0x18(%rbp)
je 0x2ac11
movq -0x18(%rbp), %rdi
callq 0xc280
cmpq $0x0, %rax
jbe 0x2ac11
movq -0x20(%rbp), %rdi
callq 0xc460
cmpq $0x0, %rax
jbe 0x2ac04
movq -0x20(%rbp), %rdi
leaq 0x7b76e(%rip), %rsi     # 0xa636d
callq 0xc630
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdi
callq 0xc630
jmp 0x2ac13
jmp 0x2ac15
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
xorps %xmm0, %xmm0
ucomisd 0xa9787(%rip), %xmm0    # 0xd46b8
jbe 0x2af7a
leaq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xcb10
cvtsi2sdq -0x28(%rbp), %xmm1
cvtsi2sdq -0x20(%rbp), %xmm0
movsd 0x7a0b4(%rip), %xmm2    # 0xa5008
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
callq 0x2b000
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0xa973e(%rip)    # 0xd46b8
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x30(%rbp), %xmm0
jbe 0x2af98
callq 0x2b000
movsd %xmm0, -0x30(%rbp)
movsd -0x10(%rbp), %xmm0
addsd 0xa9713(%rip), %xmm0    # 0xd46b8
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movaps 0x7b395(%rip), %xmm1    # 0xa6350
pand %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movsd -0x30(%rbp), %xmm0
movq -0x8(%rbp), %rax
cvtsi2sdq (%rax), %xmm1
subsd %xmm1, %xmm0
movsd 0x7b363(%rip), %xmm1    # 0xa6348
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_pool.cc
// Function: scdc_dataprov_pool::close(scdc_dataprov*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov_pool::close(scdc_dataprov *dataprov, scdc_result &result)
{
  bool ret = false;

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

    erase(i);

    ret = dataprov->close(result);

    delete dataprov;

    dataprov = 0;

    break;
  }

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x2ea20
movq %rax, -0x28(%rbp)
movq -0x48(%rbp), %rdi
callq 0x2ea80
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2ea50
testb $0x1, %al
jne 0x2d7b9
jmp 0x2d82a
leaq -0x28(%rbp), %rdi
callq 0x2eab0
movq 0x20(%rax), %rax
cmpq -0x10(%rbp), %rax
je 0x2d7ce
jmp 0x2d81c
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
callq 0x2ead0
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
callq *0x20(%rax)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x2d812
movq -0x50(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, -0x10(%rbp)
jmp 0x2d82a
leaq -0x28(%rbp), %rdi
callq 0x2eb10
jmp 0x2d799
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x2d856
leaq -0x28(%rbp), %rdi
callq 0xc960
movq -0x48(%rbp), %rdi
callq 0x2eb40
xorb $-0x1, %al
testb $0x1, %al
jne 0x2d870
jmp 0x2d8b2
movq -0x48(%rbp), %rdi
callq 0x2ea20
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2eab0
movq -0x48(%rbp), %rdi
movq 0x20(%rax), %rsi
leaq -0x28(%rbp), %rdx
callq 0x2d770
jmp 0x2d899
jmp 0x2d85f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xc3e0
jmp 0x2d8c7
jmp 0x2d8b4
jmp 0x2d8b6
jmp 0x2d8b8
leaq -0x28(%rbp), %rdi
callq 0xc3e0
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xcba0
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_pool.cc
// Function: scdc_dataprov_pool::dataset_close(scdc_dataset*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov_pool::dataset_close(scdc_dataset *dataset, scdc_result &result)
{
  SCDC_TRACE(__func__ << ": dataset: " << dataset);

  bool ret = dataset->get_dataprov()->dataset_path_close(dataset, result);

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

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0x2ddf6
movq -0x10(%rbp), %rdi
callq 0x2ebc0
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq (%rdi), %rax
callq *0x30(%rax)
andb $0x1, %al
movb %al, -0x19(%rbp)
jmp 0x2de17
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
jmp 0x2e13a
movq -0x10(%rbp), %rdi
callq 0x2ebc0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2ec80
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2eca0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x28(%rbp), %rcx
leaq 0x783f1(%rip), %rdx     # 0xa6565
movb $0x0, %al
callq 0xcaf0
cltq
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x38(%rbp), %rax
jle 0x2e242
jmp 0x2e191
leaq 0xa6510(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e8e0
cmpq $0x0, %rax
je 0x2e23e
leaq 0xa64f7(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e900
leaq 0xa64e8(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e8e0
movq %rax, %rdi
leaq 0x78397(%rip), %rsi     # 0xa6569
callq 0xc670
movq %rax, %rdi
leaq 0x78396(%rip), %rsi     # 0xa6577
callq 0xc670
movq %rax, %rdi
leaq 0x78174(%rip), %rsi     # 0xa6364
callq 0xc670
movq %rax, %rdi
movl $0x198, %esi            # imm = 0x198
callq 0xcb80
movq %rax, %rdi
leaq 0x78385(%rip), %rsi     # 0xa6591
callq 0xc670
movq %rax, %rdi
leaq 0x79cf1(%rip), %rsi     # 0xa7f0c
callq 0xc670
movq %rax, %rdi
movq 0xa5d96(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0xa6472(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e920
jmp 0x2e240
jmp 0x2e242
jmp 0x2e244
movq -0x40(%rbp), %rax
cmpq -0x38(%rbp), %rax
jle 0x2e256
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x2ecc0
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq (%rdi), %rax
callq *0x50(%rax)
andb $0x1, %al
movb %al, -0x41(%rbp)
jmp 0x2e280
movb -0x41(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/../include/common.hh
// Function: rtrim(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, char const*)
static inline std::string &rtrim(std::string &s, const char *t = 0)
{
  size_t p = s.find_last_not_of(t?t:" \t");
  if (std::string::npos != p) s.erase(p + 1);
  else s.clear();

  return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2e3e9
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x2e3f6
leaq 0x781b2(%rip), %rax     # 0xa65a2
movq %rax, -0x28(%rbp)
jmp 0x2e3f6
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq $-0x1, %rdx
callq 0xcc10
movq %rax, -0x18(%rbp)
movq $-0x1, %rax
cmpq -0x18(%rbp), %rax
je 0x2e435
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
movq $-0x1, %rdx
callq 0xc110
jmp 0x2e43e
movq -0x8(%rbp), %rdi
callq 0xc8f0
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movb $0x0, -0x15(%rbp)
callq 0xc960
movq -0x60(%rbp), %rdi
callq 0x268d0
movq %rax, -0x20(%rbp)
movq -0x60(%rbp), %rdi
callq 0x26140
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2ee00
testb $0x1, %al
jne 0x2ed3c
jmp 0x2ed9f
leaq -0x20(%rbp), %rdi
callq 0x2eeb0
movq %rax, %rsi
movsbl -0x14(%rbp), %edx
leaq -0x48(%rbp), %rdi
callq 0x2ee30
jmp 0x2ed57
movq -0x70(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xc8a0
jmp 0x2ed66
leaq -0x48(%rbp), %rdi
callq 0xc3e0
leaq -0x20(%rbp), %rdi
callq 0x2eed0
jmp 0x2ed1c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x2ede7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xc3e0
jmp 0x2ede7
movq -0x70(%rbp), %rdi
callq 0xc460
cmpq $0x0, %rax
jbe 0x2edca
movq -0x70(%rbp), %rdi
callq 0xc460
movq -0x70(%rbp), %rdi
movq %rax, %rsi
decq %rsi
callq 0xc940
jmp 0x2edc8
jmp 0x2edca
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x2eddd
movq -0x70(%rbp), %rdi
callq 0xc3e0
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0xc3e0
movq -0x50(%rbp), %rdi
callq 0xcba0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x3052e
movl $0x38, %edi
callq 0xc690
movq -0x38(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x31400
jmp 0x3054d
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x30557
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x38, %esi
callq 0xc6a0
movq -0x28(%rbp), %rdi
callq 0xcba0
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_register.cc
// Function: scdc_dataprov_register::dataset_close(scdc_dataset*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov_register::dataset_close(scdc_dataset *dataset, scdc_result &result)
{
  SCDC_TRACE("dataset_close: dataset: " << dataset);

  bool ret = true;

  delete dataset;

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

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0x305a6
movb $0x1, -0x19(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x305c2
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x305c4
jmp 0x305c6
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xf0(%rbp)
jmp 0x30ac0
movq -0xf0(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x108(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x100(%rbp)
leaq -0xc8(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x31480
movq -0x100(%rbp), %rsi
movq -0xf8(%rbp), %rdx
leaq -0x88(%rbp), %rdi
callq 0x314b0
jmp 0x30b0c
movq -0x108(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x31440
movb %dl, -0x111(%rbp)
movq %rax, -0x110(%rbp)
jmp 0x30b2e
movb -0x111(%rbp), %al
movq -0x110(%rbp), %rcx
movq %rcx, -0xe8(%rbp)
movb %al, -0xe0(%rbp)
movq -0xe8(%rbp), %rax
movq %rax, -0x28(%rbp)
movb -0xe0(%rbp), %al
movb %al, -0x20(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x314f0
leaq -0xc8(%rbp), %rdi
callq 0x31520
testb $0x1, -0x20(%rbp)
jne 0x30c67
jmp 0x30b80
leaq 0xa3b21(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
cmpq $0x0, %rax
je 0x30c5f
leaq 0xa3b08(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25800
leaq 0xa3af9(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
movq %rax, %rdi
leaq 0x755ef(%rip), %rsi     # 0xa61b0
callq 0xc670
movq %rax, %rdi
leaq 0x75c39(%rip), %rsi     # 0xa6809
callq 0xc670
movq %rax, %rdi
leaq 0x75c3e(%rip), %rsi     # 0xa681d
callq 0xc670
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0xc5b0
movq %rax, %rdi
leaq 0x77312(%rip), %rsi     # 0xa7f0c
callq 0xc670
movq %rax, %rdi
movq 0xa33b7(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0xa3a93(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25820
jmp 0x30c5f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
jmp 0x30c51
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x314f0
leaq -0xc8(%rbp), %rdi
callq 0x31520
jmp 0x30c79
jmp 0x30c61
movb $0x0, -0x1(%rbp)
jmp 0x30c6b
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq -0xd0(%rbp), %rdi
callq 0xcba0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1f8(%rbp)
jmp 0x30fc4
leaq -0x1a8(%rbp), %rdi
callq 0xc470
movq -0x18(%rbp), %rdi
leaq 0x755c9(%rip), %rsi     # 0xa65a4
callq 0x25b80
movb %al, -0x1f9(%rbp)
jmp 0x30fe8
movb -0x1f9(%rbp), %al
testb $0x1, %al
jne 0x30ff4
jmp 0x31067
movq -0x1f8(%rbp), %rdi
leaq -0x198(%rbp), %rax
movq %rax, -0x210(%rbp)
addq $0x68, %rdi
callq 0x315e0
movq -0x210(%rbp), %rdi
movq %rax, %rsi
callq 0xc120
movq %rax, -0x208(%rbp)
jmp 0x3102a
movq -0x208(%rbp), %rdi
leaq 0x75809(%rip), %rsi     # 0xa6841
callq 0xc670
jmp 0x3103f
jmp 0x3114a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
leaq -0x1a8(%rbp), %rdi
callq 0xc4b0
jmp 0x311a3
movq -0x1f8(%rbp), %rdi
addq $0x68, %rdi
movq -0x18(%rbp), %rsi
callq 0x31580
movq %rax, -0x218(%rbp)
jmp 0x31084
movq -0x1f8(%rbp), %rdi
movq -0x218(%rbp), %rax
movq %rax, -0x1c0(%rbp)
addq $0x68, %rdi
callq 0x315b0
movq %rax, -0x1c8(%rbp)
leaq -0x1c0(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x31600
testb $0x1, %al
jne 0x310c2
jmp 0x310d5
movb $0x0, -0x1(%rbp)
movl $0x1, -0x1cc(%rbp)
jmp 0x31189
leaq -0x198(%rbp), %rax
movq %rax, -0x228(%rbp)
leaq -0x1c0(%rbp), %rdi
callq 0x31630
movq -0x228(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0xc5b0
movq %rax, -0x220(%rbp)
jmp 0x3110b
movq -0x220(%rbp), %rdi
leaq 0x7524b(%rip), %rsi     # 0xa6364
callq 0xc670
movq %rax, -0x230(%rbp)
jmp 0x31127
leaq -0x1c0(%rbp), %rdi
callq 0x31630
movq -0x230(%rbp), %rdi
movq %rax, %rsi
addq $0x40, %rsi
callq 0xc5b0
jmp 0x31148
jmp 0x3114a
leaq -0x1f0(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0xc650
jmp 0x3115f
movq -0x20(%rbp), %rdi
leaq -0x1f0(%rbp), %rsi
callq 0xc850
leaq -0x1f0(%rbp), %rdi
callq 0xc3e0
movb $0x1, -0x1(%rbp)
movl $0x1, -0x1cc(%rbp)
leaq -0x1a8(%rbp), %rdi
callq 0xc4b0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
movq -0x1b0(%rbp), %rdi
callq 0xcba0
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x311ca
movq -0x20(%rbp), %rdi
addq $0x68, %rdi
movq -0x18(%rbp), %rsi
callq 0x31650
cmpq $0x1, %rax
je 0x3128c
jmp 0x311e7
leaq 0xa34ba(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
cmpq $0x0, %rax
je 0x31284
leaq 0xa34a1(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25800
leaq 0xa3492(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
movq %rax, %rdi
leaq 0x74f88(%rip), %rsi     # 0xa61b0
callq 0xc670
movq %rax, %rdi
leaq 0x755d2(%rip), %rsi     # 0xa6809
callq 0xc670
movq %rax, %rdi
leaq 0x75603(%rip), %rsi     # 0xa6849
callq 0xc670
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0xc5b0
movq %rax, %rdi
leaq 0x76cab(%rip), %rsi     # 0xa7f0c
callq 0xc670
movq %rax, %rdi
movq 0xa2d50(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0xa342c(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25820
jmp 0x31286
movb $0x0, -0x1(%rbp)
jmp 0x31290
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x312be
movq -0x18(%rbp), %rdi
leaq 0x752db(%rip), %rsi     # 0xa65a4
callq 0xc920
movq -0x60(%rbp), %rdi
addq $0x68, %rdi
callq 0x31680
movq %rax, -0x20(%rbp)
movq -0x60(%rbp), %rdi
addq $0x68, %rdi
callq 0x315b0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x31550
testb $0x1, %al
jne 0x31306
jmp 0x3139a
movq -0x10(%rbp), %rdi
leaq 0x75293(%rip), %rsi     # 0xa65a4
callq 0x25b80
testb $0x1, %al
jne 0x31339
leaq -0x20(%rbp), %rdi
callq 0x31630
movq %rax, %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
callq 0x316b0
testb $0x1, %al
jne 0x31339
jmp 0x3138a
leaq -0x20(%rbp), %rdi
callq 0x31630
movq %rax, %rsi
leaq 0x7551d(%rip), %rdx     # 0xa6869
leaq -0x48(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x31740
movq -0x68(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0xc8a0
jmp 0x31368
leaq -0x48(%rbp), %rdi
callq 0xc3e0
jmp 0x3138a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xc3e0
jmp 0x313d4
jmp 0x3138c
leaq -0x20(%rbp), %rdi
callq 0x317c0
jmp 0x312df
movq -0x18(%rbp), %rdi
callq 0xc460
cmpq $0x0, %rax
jbe 0x313ca
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rdi
callq 0xc460
movq -0x70(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0xc940
movb $0x1, %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0xcba0
nopl (%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_relay.cc
// Function: scdc_dataprov_relay::dataset_close(scdc_dataset*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov_relay::dataset_close(scdc_dataset *dataset, scdc_result &result)
{
  SCDC_TRACE("dataset_close: dataset: " << dataset);

  bool ret = true;

  scdc_dataset_relay *dataset_relay = static_cast<scdc_dataset_relay *>(dataset);

  scdc_dataset_t ds = dataset_relay->get_dataset();

  scdc_dataset_close(ds);

  delete dataset;

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

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0x33256
movb $0x1, -0x19(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x34b30
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x22fc0
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x33290
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x33292
jmp 0x33294
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_relay.cc
// Function: scdc_dataprov_relay::dataset_cmds_do_cmd(scdc_dataset*, 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>> const&, _scdc_dataset_inout_t*, _scdc_dataset_inout_t*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov_relay::dataset_cmds_do_cmd(scdc_dataset *dataset, const std::string &cmd, const std::string &params, scdc_dataset_input_t *input, scdc_dataset_output_t *output, scdc_result &result)
{
  SCDC_TRACE("dataset_cmds_do_cmd: cmd: '" << cmd << "', params: '" << params << "'");

  bool ret = scdc_dataprov::dataset_cmds_do_cmd(dataset, cmd, params, input, output, result);

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

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x33f6e
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movq 0x10(%rbp), %rax
movq %rax, (%rsp)
callq 0x5fc30
andb $0x1, %al
movb %al, -0x31(%rbp)
jmp 0x33f9a
movb -0x31(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x3423e
movq -0x38(%rbp), %rdi
addq $0x98, %rdi
movq -0x18(%rbp), %rsi
callq 0x34e40
movq -0x38(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x98, %rdi
callq 0x349b0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x34ab0
testb $0x1, %al
jne 0x3427d
jmp 0x34283
movb $0x0, -0x1(%rbp)
jmp 0x342a0
leaq -0x28(%rbp), %rdi
callq 0x349e0
movq %rax, %rsi
addq $0x20, %rsi
movq -0x20(%rbp), %rdi
callq 0xc070
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1f8(%rbp)
jmp 0x342d4
leaq -0x1a8(%rbp), %rdi
callq 0xc470
movq -0x18(%rbp), %rdi
leaq 0x722b9(%rip), %rsi     # 0xa65a4
callq 0x25b80
movb %al, -0x1f9(%rbp)
jmp 0x342f8
movb -0x1f9(%rbp), %al
testb $0x1, %al
jne 0x34304
jmp 0x3437a
movq -0x1f8(%rbp), %rdi
leaq -0x198(%rbp), %rax
movq %rax, -0x210(%rbp)
addq $0x98, %rdi
callq 0x34f40
movq -0x210(%rbp), %rdi
movq %rax, %rsi
callq 0xc120
movq %rax, -0x208(%rbp)
jmp 0x3433d
movq -0x208(%rbp), %rdi
leaq 0x72637(%rip), %rsi     # 0xa6982
callq 0xc670
jmp 0x34352
jmp 0x34449
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b0(%rbp)
movl %eax, -0x1b4(%rbp)
leaq -0x1a8(%rbp), %rdi
callq 0xc4b0
jmp 0x344a2
movq -0x1f8(%rbp), %rdi
addq $0x98, %rdi
movq -0x18(%rbp), %rsi
callq 0x34e40
movq %rax, -0x218(%rbp)
jmp 0x3439a
movq -0x1f8(%rbp), %rdi
movq -0x218(%rbp), %rax
movq %rax, -0x1c0(%rbp)
addq $0x98, %rdi
callq 0x349b0
movq %rax, -0x1c8(%rbp)
leaq -0x1c0(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x34ab0
testb $0x1, %al
jne 0x343db
jmp 0x343ee
movb $0x0, -0x1(%rbp)
movl $0x1, -0x1cc(%rbp)
jmp 0x34488
leaq -0x1c0(%rbp), %rdi
callq 0x349e0
movq -0x1f8(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
movq -0x20(%rbp), %rdx
callq 0x30fa0
movb %al, -0x219(%rbp)
jmp 0x34419
movb -0x219(%rbp), %al
testb $0x1, %al
jne 0x34435
jmp 0x34425
movb $0x0, -0x1(%rbp)
movl $0x1, -0x1cc(%rbp)
jmp 0x34488
leaq -0x198(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xc5b0
jmp 0x34447
jmp 0x34449
leaq -0x1f0(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0xc650
jmp 0x3445e
movq -0x20(%rbp), %rdi
leaq -0x1f0(%rbp), %rsi
callq 0xc850
leaq -0x1f0(%rbp), %rdi
callq 0xc3e0
movb $0x1, -0x1(%rbp)
movl $0x1, -0x1cc(%rbp)
leaq -0x1a8(%rbp), %rdi
callq 0xc4b0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
movq -0x1b0(%rbp), %rdi
callq 0xcba0
nop