LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: mh0fm4[P]SCDC/src/components/node/nodeconn_pool.cc
// Function: scdc_nodeconn_pool::close_all()
void scdc_nodeconn_pool::close_all()
{
  SCDC_TRACE("close_all:");

  while (size() > 0)
  {
    close_real(*begin()->second.begin());
  }

#if NODECONN_CACHE_CONNECTIONS
  cache.clear();
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x50f36
jmp 0x50f38
movq -0x20(%rbp), %rdi
callq 0x27ac0
cmpq $0x0, %rax
jbe 0x50f84
movq -0x20(%rbp), %rdi
callq 0x51230
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x51150
movq %rax, %rdi
addq $0x20, %rdi
callq 0x51260
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x51290
movq -0x20(%rbp), %rdi
movq (%rax), %rsi
callq 0x50ed0
jmp 0x50f38
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/node/nodeport_pool.cc
// Function: scdc_nodeport_pool::init()
bool scdc_nodeport_pool::init()
{
  bool ret = true;

#if USE_NODE_DIRECT
  ret = ret && scdc_nodeport_direct::init();
#endif
#if USE_NODE_TCP
  ret = ret && scdc_nodeport_tcp::init();
#endif
#if USE_NODE_UDS
  ret = ret && scdc_nodeport_uds::init();
#endif
#if USE_NODE_MPI
  ret = ret && scdc_nodeport_mpi::init();
#endif
#if USE_NODE_STREAM
  ret = ret && scdc_nodeport_stream::init();
#endif
#if USE_NODE_TIMER
  ret = ret && scdc_nodeport_timer::init();
#endif

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb $0x1, -0x1(%rbp)
xorl %eax, %eax
testb $0x1, -0x1(%rbp)
movb %al, -0x2(%rbp)
je 0x5310f
callq 0x95f20
movb %al, -0x2(%rbp)
movb -0x2(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
xorl %eax, %eax
testb $0x1, -0x1(%rbp)
movb %al, -0x3(%rbp)
je 0x5312a
callq 0x95f20
movb %al, -0x3(%rbp)
movb -0x3(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
xorl %eax, %eax
testb $0x1, -0x1(%rbp)
movb %al, -0x4(%rbp)
je 0x53145
callq 0x95f20
movb %al, -0x4(%rbp)
movb -0x4(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
xorl %eax, %eax
testb $0x1, -0x1(%rbp)
movb %al, -0x5(%rbp)
je 0x53160
callq 0x95f20
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
xorl %eax, %eax
testb $0x1, -0x1(%rbp)
movb %al, -0x6(%rbp)
je 0x5317b
callq 0x95f20
movb %al, -0x6(%rbp)
movb -0x6(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nop
// File: mh0fm4[P]SCDC/src/components/node/nodeport_pool.cc
// Function: scdc_nodeport_pool::supported(char const*, scdc_args*)
bool scdc_nodeport_pool::supported(const char *uri, scdc_args *args)
{
#if USE_NODE_DIRECT
  if (scdc_nodeport_direct::supported(uri, args)) return true;
#endif
#if USE_NODE_TCP
  if (scdc_nodeport_tcp::supported(uri, args)) return true;
#endif
#if USE_NODE_UDS
  if (scdc_nodeport_uds::supported(uri, args)) return true;
#endif
#if USE_NODE_MPI
  if (scdc_nodeport_mpi::supported(uri, args)) return true;
#endif
#if USE_NODE_STREAM
  if (scdc_nodeport_stream::supported(uri, args)) return true;
#endif
#if USE_NODE_TIMER
  if (scdc_nodeport_timer::supported(uri, args)) return true;
#endif

  return scdc_nodeport::supported(uri, args);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x92e60
testb $0x1, %al
jne 0x535a3
jmp 0x535a9
movb $0x1, -0x1(%rbp)
jmp 0x5361f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x93d90
testb $0x1, %al
jne 0x535bc
jmp 0x535c2
movb $0x1, -0x1(%rbp)
jmp 0x5361f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x94d20
testb $0x1, %al
jne 0x535d5
jmp 0x535db
movb $0x1, -0x1(%rbp)
jmp 0x5361f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x95f70
testb $0x1, %al
jne 0x535ee
jmp 0x535f4
movb $0x1, -0x1(%rbp)
jmp 0x5361f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x95f70
testb $0x1, %al
jne 0x53607
jmp 0x5360d
movb $0x1, -0x1(%rbp)
jmp 0x5361f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x95f70
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/node/nodeport_pool.cc
// Function: scdc_nodeport_pool::close(scdc_nodeport*)
void scdc_nodeport_pool::close(scdc_nodeport *nodeport)
{
  SCDC_TRACE("close: nodeport: '" << nodeport << "'");

  erase(nodeport);

  nodeport->close();

  delete nodeport;

  SCDC_TRACE("close: return");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x53bea
movq -0x18(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x53d10
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x53c19
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x53c1b
jmp 0x53c1d
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/node/nodeport_timer.cc
// Function: scdc_nodeport_timer::open_config_conf(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, scdc_args*, bool&)
bool scdc_nodeport_timer::open_config_conf(const std::string &conf, scdc_args *args, bool &done)
{
  done = true;
  bool ret = true;

  if (conf == "max_count")
  {
    if (args->get<scdcint_t>(SCDC_ARGS_TYPE_SCDCINT, &max_count) == SCDC_ARG_REF_NULL)
    {
      SCDC_ERROR("open_config_conf: getting max. count");
      ret = false;

    } else
    {
      SCDC_TRACE("open_config_conf: max_count: '" << max_count << "'");
    }

  } else
  {
    done = false;
    ret = scdc_nodeport::open_config_conf(conf, args, done);
  }

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movb $0x1, (%rax)
movb $0x1, -0x21(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x52e2d(%rip), %rsi     # 0xa7a93
callq 0x25b80
testb $0x1, %al
jne 0x54c74
jmp 0x54d29
movq -0x30(%rbp), %rdx
movq -0x18(%rbp), %rdi
addq $0xb8, %rdx
movl $0x2, %esi
xorl %ecx, %ecx
callq 0x4d170
cmpq $0x0, %rax
jne 0x54d21
jmp 0x54c9b
leaq 0x7fa06(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e8e0
cmpq $0x0, %rax
je 0x54d19
leaq 0x7f9f1(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e900
leaq 0x7f9e2(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e8e0
movq %rax, %rdi
leaq 0x517d0(%rip), %rsi     # 0xa64a8
callq 0xc670
movq %rax, %rdi
leaq 0x52db6(%rip), %rsi     # 0xa7a9d
callq 0xc670
movq %rax, %rdi
leaq 0x52db8(%rip), %rsi     # 0xa7aae
callq 0xc670
movq %rax, %rdi
movq 0x7f2bb(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x7f997(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e920
jmp 0x54d1b
movb $0x0, -0x21(%rbp)
jmp 0x54d27
jmp 0x54d23
jmp 0x54d25
jmp 0x54d27
jmp 0x54d4a
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x960e0
andb $0x1, %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/node/nodeport_timer.cc
// Function: scdc_nodeport_timer::start(long long)
bool scdc_nodeport_timer::start(scdcint_t mode)
{
  SCDC_TRACE("start: ");

  if (!scdc_nodeport::start(mode)) return false;

  last_time = z_time_wtime();
  current_count = 0;

  loop_run = true;

  loop_async = false;

  pthread_mutex_init(&loop_lock, NULL);
  pthread_cond_init(&loop_cond, NULL);

  if (mode & SCDC_NODEPORT_START_LOOP_UNTIL_CANCEL) loop();
  else
  {
    loop_async = true;
    pthread_create(&loop_thread, NULL, timer_server_run, this);
  }

  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 0x5500a
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x96b50
testb $0x1, %al
jne 0x55024
movb $0x0, -0x1(%rbp)
jmp 0x550b4
callq 0x550c0
movq -0x20(%rbp), %rdi
movsd %xmm0, 0x90(%rdi)
movq $0x0, 0xb0(%rdi)
movb $0x1, 0xc0(%rdi)
movb $0x0, 0xc1(%rdi)
addq $0xd0, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xca00
movq -0x20(%rbp), %rdi
addq $0xf8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xc840
movq -0x18(%rbp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x5508b
movq -0x20(%rbp), %rdi
callq 0x55100
jmp 0x550b0
movq -0x20(%rbp), %rcx
movb $0x1, 0xc1(%rcx)
movq %rcx, %rdi
addq $0xc8, %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x175(%rip), %rdx       # 0x55220
callq 0xcc20
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: mh0fm4[P]SCDC/src/components/node/nodeport_timer.cc
// Function: scdc_nodeport_timer::loop()
void scdc_nodeport_timer::loop()
{
  SCDC_TRACE("loop: ");

  pthread_mutex_lock(&loop_lock);
  while (loop_run)
  {
    struct timespec abstime;
    abstimeout(&abstime, timeout, last_time);

    if (pthread_cond_timedwait(&loop_cond, &loop_lock, &abstime) == ETIMEDOUT)
    {
      last_time = z_time_wtime();

      /* unlock, so that timer_handler can do cancel */
      pthread_mutex_unlock(&loop_lock);

      timer_handler_args.handler(timer_handler_args.data);

      pthread_mutex_lock(&loop_lock);

      ++current_count;

      if (max_count >= 0 && current_count >= max_count) loop_run = false;
    }
  }
  pthread_mutex_unlock(&loop_lock);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x55116
movq -0x20(%rbp), %rdi
addq $0xd0, %rdi
callq 0xc9f0
movq -0x20(%rbp), %rax
testb $0x1, 0xc0(%rax)
je 0x55202
movq -0x20(%rbp), %rax
movsd 0x98(%rax), %xmm0
movsd 0x90(%rax), %xmm1
leaq -0x18(%rbp), %rdi
callq 0x2af10
movq -0x20(%rbp), %rsi
movq %rsi, %rdi
addq $0xf8, %rdi
addq $0xd0, %rsi
leaq -0x18(%rbp), %rdx
callq 0xca30
cmpl $0x6e, %eax
jne 0x551fd
callq 0x550c0
movq -0x20(%rbp), %rdi
movsd %xmm0, 0x90(%rdi)
addq $0xd0, %rdi
callq 0xc4c0
movq -0x20(%rbp), %rcx
movq 0xa0(%rcx), %rax
movq 0xa8(%rcx), %rdi
callq *%rax
movq -0x20(%rbp), %rdi
addq $0xd0, %rdi
callq 0xc9f0
movq -0x20(%rbp), %rax
movq 0xb0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xb0(%rax)
cmpq $0x0, 0xb8(%rax)
jl 0x551fb
movq -0x20(%rbp), %rcx
movq 0xb0(%rcx), %rax
cmpq 0xb8(%rcx), %rax
jl 0x551fb
movq -0x20(%rbp), %rax
movb $0x0, 0xc0(%rax)
jmp 0x551fd
jmp 0x55126
movq -0x20(%rbp), %rdi
addq $0xd0, %rdi
callq 0xc4c0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/node/nodeport_timer.cc
// Function: scdc_nodeport_timer::stop()
bool scdc_nodeport_timer::stop()
{
  SCDC_TRACE("stop: ");

  cancel(false);

  if (loop_async) pthread_join(loop_thread, NULL);

  pthread_cond_destroy(&loop_cond);
  pthread_mutex_destroy(&loop_lock);

  scdc_nodeport::stop();

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x55266
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *0x38(%rax)
movq -0x10(%rbp), %rax
testb $0x1, 0xc1(%rax)
je 0x55293
movq -0x10(%rbp), %rax
movq 0xc8(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xc5c0
movq -0x10(%rbp), %rdi
addq $0xf8, %rdi
callq 0xcc90
movq -0x10(%rbp), %rdi
addq $0xd0, %rdi
callq 0xc7f0
movq -0x10(%rbp), %rdi
callq 0x96bc0
movb $0x1, %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/node/nodeport_timer.cc
// Function: scdc_nodeport_timer::cancel(bool)
bool scdc_nodeport_timer::cancel(bool interrupt)
{
  SCDC_TRACE("cancel: ");

  pthread_mutex_lock(&loop_lock);
  loop_run = false;
  pthread_mutex_unlock(&loop_lock);
  pthread_cond_signal(&loop_cond);

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x552ee
movq -0x18(%rbp), %rdi
addq $0xd0, %rdi
callq 0xc9f0
movq -0x18(%rbp), %rdi
movb $0x0, 0xc0(%rdi)
addq $0xd0, %rdi
callq 0xc4c0
movq -0x18(%rbp), %rdi
addq $0xf8, %rdi
callq 0xc030
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: mh0fm4[P]SCDC/src/extra/xxhash/xxhash.c
// Function: XXH32_reset
XXH_PUBLIC_API XXH_errorcode XXH32_reset(XXH32_state_t* statePtr, unsigned int seed)
{
    XXH32_state_t state;   /* using a local state to memcpy() in order to avoid strict-aliasing warnings */
    memset(&state, 0, sizeof(state));
    state.v1 = seed + PRIME32_1 + PRIME32_2;
    state.v2 = seed + PRIME32_2;
    state.v3 = seed + 0;
    state.v4 = seed - PRIME32_1;
    /* do not write into reserved, planned to be removed in a future version */
    memcpy(statePtr, &state, sizeof(state) - sizeof(state.reserved));
    return XXH_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x3c(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0xc350
movl -0xc(%rbp), %eax
addl $0x9e3779b1, %eax       # imm = 0x9E3779B1
addl $0x85ebca77, %eax       # imm = 0x85EBCA77
movl %eax, -0x34(%rbp)
movl -0xc(%rbp), %eax
addl $0x85ebca77, %eax       # imm = 0x85EBCA77
movl %eax, -0x30(%rbp)
movl -0xc(%rbp), %eax
addl $0x0, %eax
movl %eax, -0x2c(%rbp)
movl -0xc(%rbp), %eax
subl $0x9e3779b1, %eax       # imm = 0x9E3779B1
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
movl $0x2c, %edx
callq 0xc530
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mh0fm4[P]SCDC/src/extra/xxhash/xxhash.c
// Function: XXH32_digest
XXH_PUBLIC_API unsigned int XXH32_digest (const XXH32_state_t* state_in)
{
    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;

    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
        return XXH32_digest_endian(state_in, XXH_littleEndian);
    else
        return XXH32_digest_endian(state_in, XXH_bigEndian);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
callq 0x55f40
movl %eax, -0x34(%rbp)
cmpl $0x1, -0x34(%rbp)
jne 0x5764b
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x57609
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
shll %eax
movq -0x8(%rbp), %rcx
movl 0x8(%rcx), %ecx
shrl $0x1f, %ecx
orl %ecx, %eax
movq -0x8(%rbp), %rcx
movl 0xc(%rcx), %ecx
shll $0x7, %ecx
movq -0x8(%rbp), %rdx
movl 0xc(%rdx), %edx
shrl $0x19, %edx
orl %edx, %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
movl 0x10(%rcx), %ecx
shll $0xc, %ecx
movq -0x8(%rbp), %rdx
movl 0x10(%rdx), %edx
shrl $0x14, %edx
orl %edx, %ecx
addl %ecx, %eax
movq -0x8(%rbp), %rcx
movl 0x14(%rcx), %ecx
shll $0x12, %ecx
movq -0x8(%rbp), %rdx
movl 0x14(%rdx), %edx
shrl $0xe, %edx
orl %edx, %ecx
addl %ecx, %eax
movl %eax, -0x10(%rbp)
jmp 0x57618
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
addl $0x165667b1, %eax       # imm = 0x165667B1
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %edi
movq -0x8(%rbp), %rsi
addq $0x18, %rsi
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, %edx
movl -0xc(%rbp), %ecx
xorl %r8d, %r8d
callq 0x59e40
movl %eax, -0x24(%rbp)
jmp 0x57703
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x576c6
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
shll %eax
movq -0x18(%rbp), %rcx
movl 0x8(%rcx), %ecx
shrl $0x1f, %ecx
orl %ecx, %eax
movq -0x18(%rbp), %rcx
movl 0xc(%rcx), %ecx
shll $0x7, %ecx
movq -0x18(%rbp), %rdx
movl 0xc(%rdx), %edx
shrl $0x19, %edx
orl %edx, %ecx
addl %ecx, %eax
movq -0x18(%rbp), %rcx
movl 0x10(%rcx), %ecx
shll $0xc, %ecx
movq -0x18(%rbp), %rdx
movl 0x10(%rdx), %edx
shrl $0x14, %edx
orl %edx, %ecx
addl %ecx, %eax
movq -0x18(%rbp), %rcx
movl 0x14(%rcx), %ecx
shll $0x12, %ecx
movq -0x18(%rbp), %rdx
movl 0x14(%rdx), %edx
shrl $0xe, %edx
orl %edx, %ecx
addl %ecx, %eax
movl %eax, -0x20(%rbp)
jmp 0x576d5
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
addl $0x165667b1, %eax       # imm = 0x165667B1
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %edi
movq -0x18(%rbp), %rsi
addq $0x18, %rsi
movq -0x18(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, %edx
movl -0x1c(%rbp), %ecx
xorl %r8d, %r8d
callq 0x59e40
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: mh0fm4[P]SCDC/src/extra/xxhash/xxhash.c
// Function: XXH_swap32
static U32 XXH_swap32 (U32 x)
{
    return  ((x << 24) & 0xff000000 ) |
            ((x <<  8) & 0x00ff0000 ) |
            ((x >>  8) & 0x0000ff00 ) |
            ((x >> 24) & 0x000000ff );
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
shll $0x18, %eax
andl $0xff000000, %eax       # imm = 0xFF000000
movl -0x4(%rbp), %ecx
shll $0x8, %ecx
andl $0xff0000, %ecx         # imm = 0xFF0000
orl %ecx, %eax
movl -0x4(%rbp), %ecx
shrl $0x8, %ecx
andl $0xff00, %ecx           # imm = 0xFF00
orl %ecx, %eax
movl -0x4(%rbp), %ecx
shrl $0x18, %ecx
andl $0xff, %ecx
orl %ecx, %eax
popq %rbp
retq
nop
// File: mh0fm4[P]SCDC/src/extra/xxhash/xxhash.c
// Function: XXH64_reset
XXH_PUBLIC_API XXH_errorcode XXH64_reset(XXH64_state_t* statePtr, unsigned long long seed)
{
    XXH64_state_t state;   /* using a local state to memcpy() in order to avoid strict-aliasing warnings */
    memset(&state, 0, sizeof(state));
    state.v1 = seed + PRIME64_1 + PRIME64_2;
    state.v2 = seed + PRIME64_2;
    state.v3 = seed + 0;
    state.v4 = seed - PRIME64_1;
     /* do not write into reserved, planned to be removed in a future version */
    memcpy(statePtr, &state, sizeof(state) - sizeof(state.reserved));
    return XXH_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x68(%rbp), %rdi
xorl %esi, %esi
movl $0x58, %edx
callq 0xc350
movabsq $-0x61c8864e7a143579, %rax # imm = 0x9E3779B185EBCA87
addq -0x10(%rbp), %rax
movabsq $-0x3d4d51c2d82b14b1, %rcx # imm = 0xC2B2AE3D27D4EB4F
addq %rcx, %rax
movq %rax, -0x60(%rbp)
movabsq $-0x3d4d51c2d82b14b1, %rax # imm = 0xC2B2AE3D27D4EB4F
addq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rax
addq $0x0, %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
subq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
movl $0x50, %edx
callq 0xc530
xorl %eax, %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: mh0fm4[P]SCDC/src/extra/xxhash/xxhash.c
// Function: XXH_swap64
static U64 XXH_swap64 (U64 x)
{
    return  ((x << 56) & 0xff00000000000000ULL) |
            ((x << 40) & 0x00ff000000000000ULL) |
            ((x << 24) & 0x0000ff0000000000ULL) |
            ((x << 8)  & 0x000000ff00000000ULL) |
            ((x >> 8)  & 0x00000000ff000000ULL) |
            ((x >> 24) & 0x0000000000ff0000ULL) |
            ((x >> 40) & 0x000000000000ff00ULL) |
            ((x >> 56) & 0x00000000000000ffULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
shlq $0x38, %rax
movabsq $-0x100000000000000, %rcx # imm = 0xFF00000000000000
andq %rcx, %rax
movq -0x8(%rbp), %rcx
shlq $0x28, %rcx
movabsq $0xff000000000000, %rdx # imm = 0xFF000000000000
andq %rdx, %rcx
orq %rcx, %rax
movq -0x8(%rbp), %rcx
shlq $0x18, %rcx
movabsq $0xff0000000000, %rdx   # imm = 0xFF0000000000
andq %rdx, %rcx
orq %rcx, %rax
movq -0x8(%rbp), %rcx
shlq $0x8, %rcx
movabsq $0xff00000000, %rdx     # imm = 0xFF00000000
andq %rdx, %rcx
orq %rcx, %rax
movq -0x8(%rbp), %rcx
shrq $0x8, %rcx
movabsq $0xff000000, %rdx       # imm = 0xFF000000
andq %rdx, %rcx
orq %rcx, %rax
movq -0x8(%rbp), %rcx
shrq $0x18, %rcx
andq $0xff0000, %rcx         # imm = 0xFF0000
orq %rcx, %rax
movq -0x8(%rbp), %rcx
shrq $0x28, %rcx
andq $0xff00, %rcx           # imm = 0xFF00
orq %rcx, %rax
movq -0x8(%rbp), %rcx
shrq $0x38, %rcx
andq $0xff, %rcx
orq %rcx, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/extra/xxhash/xxhash.c
// Function: XXH32_round
static U32 XXH32_round(U32 seed, U32 input)
{
    seed += input * PRIME32_2;
    seed  = XXH_rotl32(seed, 13);
    seed *= PRIME32_1;
    return seed;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
imull $0x85ebca77, -0x8(%rbp), %eax # imm = 0x85EBCA77
addl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
shll $0xd, %eax
movl -0x4(%rbp), %ecx
shrl $0x13, %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
imull $0x9e3779b1, -0x4(%rbp), %eax # imm = 0x9E3779B1
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: mh0fm4[P]SCDC/src/extra/xxhash/xxhash.c
// Function: XXH32_avalanche
static U32 XXH32_avalanche(U32 h32)
{
    h32 ^= h32 >> 15;
    h32 *= PRIME32_2;
    h32 ^= h32 >> 13;
    h32 *= PRIME32_3;
    h32 ^= h32 >> 16;
    return(h32);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
shrl $0xf, %eax
xorl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
imull $0x85ebca77, -0x4(%rbp), %eax # imm = 0x85EBCA77
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
shrl $0xd, %eax
xorl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
imull $0xc2b2ae3d, -0x4(%rbp), %eax # imm = 0xC2B2AE3D
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
shrl $0x10, %eax
xorl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/extra/xxhash/xxhash.c
// Function: XXH64_round
static U64 XXH64_round(U64 acc, U64 input)
{
    acc += input * PRIME64_2;
    acc  = XXH_rotl64(acc, 31);
    acc *= PRIME64_1;
    return acc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movabsq $-0x3d4d51c2d82b14b1, %rax # imm = 0xC2B2AE3D27D4EB4F
imulq -0x10(%rbp), %rax
addq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shlq $0x1f, %rax
movq -0x8(%rbp), %rcx
shrq $0x21, %rcx
orq %rcx, %rax
movq %rax, -0x8(%rbp)
movabsq $-0x61c8864e7a143579, %rax # imm = 0x9E3779B185EBCA87
imulq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/extra/xxhash/xxhash.c
// Function: XXH64_mergeRound
static U64 XXH64_mergeRound(U64 acc, U64 val)
{
    val  = XXH64_round(0, val);
    acc ^= val;
    acc  = acc * PRIME64_1 + PRIME64_4;
    return acc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0x5ac70
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
xorq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movabsq $-0x61c8864e7a143579, %rax # imm = 0x9E3779B185EBCA87
imulq -0x8(%rbp), %rax
movabsq $-0x7a1435883d4d519d, %rcx # imm = 0x85EBCA77C2B2AE63
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mh0fm4[P]SCDC/src/extra/xxhash/xxhash.c
// Function: XXH64_avalanche
static U64 XXH64_avalanche(U64 h64)
{
    h64 ^= h64 >> 33;
    h64 *= PRIME64_2;
    h64 ^= h64 >> 29;
    h64 *= PRIME64_3;
    h64 ^= h64 >> 32;
    return h64;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x21, %rax
xorq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movabsq $-0x3d4d51c2d82b14b1, %rax # imm = 0xC2B2AE3D27D4EB4F
imulq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x1d, %rax
xorq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movabsq $0x165667b19e3779f9, %rax # imm = 0x165667B19E3779F9
imulq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
shrq $0x20, %rax
xorq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: mh0fm4[P]SCDC/src/extra/z_pack/z_pack.c
// Function: z_fs_get_link_target
z_int_t z_fs_get_link_target(const char *pathname, char *target, z_int_t size) /* z_proto, z_func z_fs_get_link_target */
{
  ssize_t n = readlink(pathname, target, size);

  if (n < 0) return -1;

  if (n < size) target[n] = '\0';

  return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xc710
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jge 0x5d60a
movq $-0x1, -0x8(%rbp)
jmp 0x5d628
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jge 0x5d620
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/extra/z_pack/z_pack.c
// Function: z_fs_stat
z_int_t z_fs_stat(const char *pathname, z_fs_stat_t *stat)
{
  struct stat s;


  if (lstat(pathname, &s) != 0) return 0;

  stat->is_directory = S_ISDIR(s.st_mode)?1:0;
  stat->is_file = S_ISREG(s.st_mode)?1:0;
  stat->is_link = S_ISLNK(s.st_mode)?1:0;
  stat->file_size = (z_int_t) s.st_size;

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0xcca0
cmpl $0x0, %eax
je 0x5d675
movq $0x0, -0x8(%rbp)
jmp 0x5d6fd
movl -0x90(%rbp), %edx
andl $0xf000, %edx           # imm = 0xF000
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x4000, %edx           # imm = 0x4000
cmovel %ecx, %eax
movslq %eax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0x90(%rbp), %edx
andl $0xf000, %edx           # imm = 0xF000
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x8000, %edx           # imm = 0x8000
cmovel %ecx, %eax
movslq %eax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x90(%rbp), %edx
andl $0xf000, %edx           # imm = 0xF000
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0xa000, %edx           # imm = 0xA000
cmovel %ecx, %eax
movslq %eax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x78(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq $0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mh0fm4[P]SCDC/src/extra/z_pack/z_pack.c
// Function: z_fs_mkdir_p
z_int_t z_fs_mkdir_p(const char *pathname) /* z_proto, z_func z_fs_mkdir_p */
{
  z_int_t ret = 1;
  char *p, *pb, *pe;


  pb = p = strdup(pathname);

  while (ret && pb != NULL)
  {
    pe = strchr(pb, '/');

    if (pe != pb)
    {
      if (pe) *pe = '\0';

      ret = z_fs_mkdir(p);

      if (pe) *pe = '/';
    }

    pb = pe;

    if (pb) ++pb;
  }

  free(p);

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x1, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xcc30
movq %rax, -0x18(%rbp)
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x29(%rbp)
je 0x5d78c
cmpq $0x0, -0x20(%rbp)
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x5d795
jmp 0x5d7fc
movq -0x20(%rbp), %rdi
movl $0x2f, %esi
callq 0xc220
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x5d7dc
cmpq $0x0, -0x28(%rbp)
je 0x5d7bf
movq -0x28(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rdi
callq 0x5d710
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x5d7da
movq -0x28(%rbp), %rax
movb $0x2f, (%rax)
jmp 0x5d7dc
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5d7f7
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x5d775
movq -0x18(%rbp), %rdi
callq 0xc830
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: mh0fm4[P]SCDC/src/extra/z_pack/z_pack.c
// Function: z_snscanf
int z_snscanf(const char *str, size_t size, const char *format, ...) /* z_proto, z_func z_snscanf */
{
  int n;
  char str2[size + 1];


  strncpy(str2, str, size);
  str2[size] = '\0';

  va_list argp;
  va_start(argp, format);

  n = vsscanf(str2, format, argp);

  va_end(argp);

  return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
testb %al, %al
je 0x5d8ee
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 %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, %rax
incq %rax
movq %rsp, %rdx
movq %rdx, -0x28(%rbp)
addq $0x10, %rcx
andq $-0x10, %rcx
movq %rsp, %rdi
subq %rcx, %rdi
movq %rdi, -0x108(%rbp)
movq %rdi, %rsp
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0xc320
movq -0x108(%rbp), %rdi
movq -0x10(%rbp), %rax
movb $0x0, (%rax,%rdi)
leaq -0x100(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x30, -0x4c(%rbp)
movl $0x18, -0x50(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0xc8d0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x28(%rbp), %rcx
movq %rcx, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov.cc
// Function: scdc_dataprov::open(char const*, scdc_args*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov::open(const char *conf, scdc_args *args, scdc_result &result)
{
  SCDC_TRACE("open: conf: '" << (conf?conf:"") << "'");

  bool ret = true;

  if (conf)
  {
    string confs(conf);

    if (!open_config(confs, args))
    {
      SCDC_FAIL("open: processing configuration failed");
      ret = false;
    }
  }

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
jmp 0x5df05
movb $0x1, -0x21(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5e077
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xcbc0
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x27820
jmp 0x5df3c
leaq -0x49(%rbp), %rdi
callq 0xc730
movq -0x68(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x48(%rbp), %rsi
callq 0x5d9d0
movb %al, -0x79(%rbp)
jmp 0x5df5b
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x5e06e
jmp 0x5df68
jmp 0x5df6a
leaq 0x76737(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
movq %rax, -0x88(%rbp)
jmp 0x5df82
movq -0x88(%rbp), %rax
cmpq $0x0, %rax
je 0x5e066
leaq 0x7670e(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25800
jmp 0x5dfa4
leaq 0x766fd(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
movq %rax, -0x90(%rbp)
jmp 0x5dfbc
movq -0x90(%rbp), %rdi
leaq 0x481e6(%rip), %rsi     # 0xa61b0
callq 0xc670
movq %rax, -0x98(%rbp)
jmp 0x5dfd8
movq -0x98(%rbp), %rdi
leaq 0x49cb6(%rip), %rsi     # 0xa7c9c
callq 0xc670
movq %rax, -0xa0(%rbp)
jmp 0x5dff4
movq -0xa0(%rbp), %rdi
leaq 0x49cfb(%rip), %rsi     # 0xa7cfd
callq 0xc670
movq %rax, -0xa8(%rbp)
jmp 0x5e010
movq -0xa8(%rbp), %rdi
movq 0x75fa2(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
jmp 0x5e025
leaq 0x7667c(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25820
jmp 0x5e036
jmp 0x5e066
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x49(%rbp), %rdi
callq 0xc730
jmp 0x5e085
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xc3e0
jmp 0x5e085
jmp 0x5e068
jmp 0x5e06a
movb $0x0, -0x21(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xc3e0
movb -0x21(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0xcba0
nop
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov.cc
// Function: scdc_dataprov::close(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov::close(scdc_result &result)
{
  SCDC_TRACE("close:");

  bool ret = true;

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

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x5e09e
movb $0x1, -0x11(%rbp)
jmp 0x5e0a4
movb -0x11(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov.cc
// Function: scdc_dataprov::config_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::config_open(std::string &path, scdc_result &result)
{
  SCDC_TRACE("config_open: path: '" << path << "'");

  scdc_dataset *dataset = new scdc_dataset_config(this);

  SCDC_TRACE("config_open: return: " << dataset);

  return dataset;
}

// 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 0x5e60e
movl $0x38, %edi
callq 0xc690
movq -0x38(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x60000
jmp 0x5e62d
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x5e637
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.cc
// Function: scdc_dataprov::dataset_path_close(scdc_dataset*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov::dataset_path_close(scdc_dataset *dataset, scdc_result &result)
{
  SCDC_TRACE(__func__ << ": dataset: " << dataset);

  bool ret = false;

  if (config_close(dataset, result))
  {
    ret = true;

  } else ret = dataset_close(dataset, result);

  SCDC_TRACE(__func__ << ": 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)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x5e68e
movq -0x28(%rbp), %rdi
movb $0x0, -0x19(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x5e6e0
testb $0x1, %al
jne 0x5e6a9
jmp 0x5e6af
movb $0x1, -0x19(%rbp)
jmp 0x5e6c6
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq (%rdi), %rax
callq *0x40(%rax)
andb $0x1, %al
movb %al, -0x19(%rbp)
jmp 0x5e6c8
jmp 0x5e6ca
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.cc
// Function: scdc_dataprov::config_close(scdc_dataset*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov::config_close(scdc_dataset *dataset, scdc_result &result)
{
  SCDC_TRACE("config_close: dataset: '" << dataset << "'");

  bool ret = false;

  if (typeid(*dataset) == typeid(scdc_dataset_config))
  {
    delete dataset;
    ret = true;
  }

  SCDC_TRACE("config_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 0x5e6f6
movb $0x0, -0x19(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x5e70d
callq 0xc770
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rax), %rdi
leaq 0x74151(%rip), %rsi     # 0xd2870
callq 0x60040
testb $0x1, %al
jne 0x5e72a
jmp 0x5e746
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x5e742
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movb $0x1, -0x19(%rbp)
jmp 0x5e748
jmp 0x5e74a
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.cc
// Function: scdc_dataprov::dataset_close_write_state(scdc_dataset*, scdc_data*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov::dataset_close_write_state(scdc_dataset *dataset, scdc_data *outgoing, scdc_result &result)
{
  SCDC_TRACE("dataset_close_write_state: '" << dataset << "'");

  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|", dataset);

  SCDC_ASSERT(n <= buf_size);

  if (n > buf_size) n = buf_size;

  outgoing->inc_write_pos(n);

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
jmp 0x5ea1a
movq -0x18(%rbp), %rdi
callq 0x2ec80
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2eca0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rcx
leaq 0x47b1e(%rip), %rdx     # 0xa6565
movb $0x0, %al
callq 0xcaf0
cltq
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
jle 0x5eb15
jmp 0x5ea64
leaq 0x75c3d(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e8e0
cmpq $0x0, %rax
je 0x5eb11
leaq 0x75c24(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e900
leaq 0x75c15(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e8e0
movq %rax, %rdi
leaq 0x47ac4(%rip), %rsi     # 0xa6569
callq 0xc670
movq %rax, %rdi
leaq 0x492d5(%rip), %rsi     # 0xa7d89
callq 0xc670
movq %rax, %rdi
leaq 0x478a1(%rip), %rsi     # 0xa6364
callq 0xc670
movq %rax, %rdi
movl $0xe3, %esi
callq 0xcb80
movq %rax, %rdi
leaq 0x47ab2(%rip), %rsi     # 0xa6591
callq 0xc670
movq %rax, %rdi
leaq 0x4941e(%rip), %rsi     # 0xa7f0c
callq 0xc670
movq %rax, %rdi
movq 0x754c3(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x75b9f(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e920
jmp 0x5eb13
jmp 0x5eb15
jmp 0x5eb17
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
jle 0x5eb29
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x2ecc0
movb $0x1, %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov.cc
// Function: scdc_dataprov::config_do_cmd_param_base(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&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, scdc_config_result&, bool&)
bool scdc_dataprov::config_do_cmd_param_base(const std::string &cmd, const std::string &param, std::string val, scdc_config_result &result, bool &done)
{
  SCDC_TRACE("config_do_cmd_param_base: cmd: '" << cmd << "', param: '" << param << "', val: '" << val << "', result: '" << result << "'");

/*  string c(cmd), p(param);*/
  bool ret = false;

  ret = config_do_cmd_param(cmd, param, val, result, done);

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rcx, -0x78(%rbp)
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, -0x70(%rbp)
jmp 0x5f7c1
movq -0x78(%rbp), %rsi
movb $0x0, -0x31(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0xc270
movq -0x70(%rbp), %rdi
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
movq -0x88(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movq (%rdi), %rax
movq 0x60(%rax), %rax
callq *%rax
movb %al, -0x79(%rbp)
jmp 0x5f81e
movb -0x79(%rbp), %al
andb $0x1, %al
movb %al, -0x31(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xc3e0
movb -0x31(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xc3e0
movq -0x60(%rbp), %rdi
callq 0xcba0
nopl (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_access_stub_handler.cc
// Function: scdc_dataprov_access_stub_handler::close(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov_access_stub_handler::close(scdc_result &result)
{
  SCDC_TRACE(__func__ << ":");

  bool ret = true;

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

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x6384e
movb $0x1, -0x11(%rbp)
jmp 0x63854
movb -0x11(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_access_stub_handler.cc
// Function: scdc_dataprov_access_stub_handler::dir_open(char const*)
scdc_dataprov_access_stub_handler::dir_t scdc_dataprov_access_stub_handler::dir_open(const char *path)
{
  SCDC_TRACE(__func__ << ": path: '" << path << "'");

  dir_t dir = dir_valid;

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

  return dir;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x6386e
movl $0x1, %eax
movq %rax, -0x18(%rbp)
jmp 0x63879
movq -0x18(%rbp), %rax
popq %rbp
retq
nop
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_access_stub_handler.cc
// Function: scdc_dataprov_access_stub_handler::dir_path(void*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov_access_stub_handler::dir_path(dir_t dir, std::string &path)
{
  SCDC_TRACE(__func__ << ": dir: '" << dir << "'");

  bool ret = true;
  path = "";

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

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0x638a6
movb $0x1, -0x19(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x42cef(%rip), %rsi     # 0xa65a4
callq 0xc920
jmp 0x638bc
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_access_stub_handler.cc
// Function: scdc_dataprov_access_stub_handler::ls_entries(void*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov_access_stub_handler::ls_entries(dir_t dir, std::string &result)
{
  SCDC_TRACE(__func__ << ": dir: '" << dir << "'");

  bool ret = true;
  result = "no entries in stub";

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

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0x638e6
movb $0x1, -0x19(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x435f4(%rip), %rsi     # 0xa6ee9
callq 0xc920
jmp 0x638fc
movb -0x19(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_access_stub_handler.cc
// Function: scdc_dataprov_access_stub_handler::info_entry(void*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov_access_stub_handler::info_entry(dir_t dir, const char *path, std::string &result)
{
  SCDC_TRACE(__func__ << ": dir: '" << dir << "', path: '" << path << "'");

  bool ret = true;
  result = "no info in stub for entry '" + std::string(path) + "'";

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

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
jmp 0x6392d
movb $0x1, -0x21(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x89(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0xcbc0
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
leaq -0x88(%rbp), %rdi
callq 0x27820
jmp 0x6396b
leaq 0x44620(%rip), %rsi     # 0xa7f92
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rdx
callq 0x3b040
jmp 0x63984
leaq 0x44a48(%rip), %rdx     # 0xa83d3
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x2eef0
jmp 0x6399a
movq -0x20(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xc850
leaq -0x48(%rbp), %rdi
callq 0xc3e0
leaq -0x68(%rbp), %rdi
callq 0xc3e0
leaq -0x88(%rbp), %rdi
callq 0xc3e0
leaq -0x89(%rbp), %rdi
callq 0xc730
jmp 0x639d3
movb -0x21(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x63a30
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0x63a24
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xc3e0
leaq -0x88(%rbp), %rdi
callq 0xc3e0
leaq -0x89(%rbp), %rdi
callq 0xc730
movq -0x98(%rbp), %rdi
callq 0xcba0
nopl (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_access_stub_handler.cc
// Function: scdc_dataprov_access_stub_handler::rm_entry(void*, char const*)
bool scdc_dataprov_access_stub_handler::rm_entry(dir_t dir, const char *path)
{
  SCDC_TRACE(__func__ << ": dir: '" << dir << "', path: '" << path << "'");

  bool ret = true;

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

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0x63a62
movb $0x1, -0x19(%rbp)
jmp 0x63a68
movb -0x19(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_access_stub_handler.cc
// Function: scdc_dataprov_access_stub_handler::mk_dir(void*, char const*)
bool scdc_dataprov_access_stub_handler::mk_dir(dir_t dir, const char *path)
{
  SCDC_TRACE(__func__ << ": dir: '" << dir << "', path: '" << path << "'");

  bool ret = true;

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

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
jmp 0x63a82
movb $0x1, -0x19(%rbp)
jmp 0x63a88
movb -0x19(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nop
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_access_stub_handler.cc
// Function: scdc_dataprov_access_stub_handler::file_reopen(void*, char const*, bool, bool, bool, void*)
scdc_dataprov_access_stub_handler::file_t scdc_dataprov_access_stub_handler::file_reopen(dir_t dir, const char *path, bool read, bool write, bool create, file_t file)
{
  SCDC_TRACE(__func__ << ": dir: '" << dir << "', path: '" << path << "', read: " << read << ", write: " << write << ", create: " << create << ", file: " << file);

  file = file_valid;

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

  return file;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %r8d, -0x38(%rbp)
movl %ecx, %eax
movl -0x38(%rbp), %ecx
movl %eax, -0x34(%rbp)
movq %rdx, %rax
movl -0x34(%rbp), %edx
movq %rax, -0x30(%rbp)
movq %rsi, %rax
movq -0x30(%rbp), %rsi
movq %rax, -0x28(%rbp)
movq %rdi, %r8
movq -0x28(%rbp), %rdi
movb %r9b, %al
movq 0x10(%rbp), %r9
movq %r8, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %dl
movb %dl, -0x19(%rbp)
andb $0x1, %cl
movb %cl, -0x1a(%rbp)
andb $0x1, %al
movb %al, -0x1b(%rbp)
jmp 0x63b42
movl $0x1, %eax
movq %rax, 0x10(%rbp)
jmp 0x63b4d
movq 0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_access_stub_handler.cc
// Function: scdc_dataprov_access_stub_handler::file_match(void*, void*, char const*)
bool scdc_dataprov_access_stub_handler::file_match(dir_t dir, file_t file, const char *path)
{
  SCDC_TRACE(__func__ << ": dir: '" << dir << "', file: '" << file << "', path: '" << path << "'");

  bool ret = (file != file_null);

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

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
jmp 0x63b96
cmpq $0x0, -0x18(%rbp)
setne %al
andb $0x1, %al
movb %al, -0x21(%rbp)
jmp 0x63ba5
movb -0x21(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: mh0fm4[P]SCDC/src/components/dataprov/dataprov_access_stub_handler.cc
// Function: scdc_dataprov_access_stub_handler::file_read_access_at(void*, void*, long long, long long, _scdc_buf_t&)
bool scdc_dataprov_access_stub_handler::file_read_access_at(dir_t dir, file_t file, scdcint_t size, scdcint_t pos, scdc_buf_t &buf)
{
  SCDC_TRACE(__func__ << ": dir: '" << dir << "', file: '" << file << "', size: " << size << ", pos: " << pos);

  bool ret = false;

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

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
jmp 0x63bce
movb $0x0, -0x31(%rbp)
jmp 0x63bd4
movb -0x31(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)