LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movb $0x1, (%rcx)
leaq 0x3749d(%rip), %rsi     # 0x6babb
movq %r12, %rdi
callq 0xb110
testl %eax, %eax
je 0x3464a
movb $0x0, (%r15)
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r15, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5e2d6
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x34675
addq $0xb8, %rbx
movq (%r14), %rdi
movl $0x2, %esi
movq %rbx, %rdx
callq *%rax
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x34707
leaq 0x57ef4(%rip), %r14     # 0x8c570
movq (%r14), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x34705
addq $0x20, %rdi
callq 0xb7d0
movq (%r14), %rax
movq 0x18(%rax), %rbx
leaq 0x35deb(%rip), %rsi     # 0x6a488
movl $0xc, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x37414(%rip), %rsi     # 0x6bac5
movl $0x10, %edx
movq %rbx, %rdi
callq 0xb5f0
leaq 0x37411(%rip), %rsi     # 0x6bad6
movl $0x24, %edx
movq %rbx, %rdi
callq 0xb5f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq (%r14), %rdi
addq $0x20, %rdi
callq 0xb3b0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %r14
callq 0x5ea44
movl %eax, %ebx
testb %al, %al
je 0x349fb
leaq 0x8(%rsp), %r12
movl $0x1, %edi
movq %r12, %rsi
callq 0xb480
cvtsi2sdq (%r12), %xmm0
cvtsi2sdq 0x8(%r12), %xmm1
mulsd 0x3468b(%rip), %xmm1    # 0x69018
addsd %xmm0, %xmm1
movsd %xmm1, 0x90(%r14)
movq $0x0, 0xb0(%r14)
movw $0x1, 0xc0(%r14)
leaq 0xd0(%r14), %rdi
xorl %esi, %esi
callq 0xb7e0
leaq 0xf8(%r14), %rdi
xorl %esi, %esi
callq 0xb660
testb $0x1, %r15b
jne 0x349f3
movb $0x1, 0xc1(%r14)
leaq 0xc8(%r14), %rdi
leaq 0x137(%rip), %rdx       # 0x34b1e
xorl %esi, %esi
movq %r14, %rcx
callq 0xba00
jmp 0x349fb
movq %r14, %rdi
callq 0x34a0a
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
leaq 0xd0(%rdi), %rbx
movq %rbx, %rdi
callq 0xb7d0
cmpb $0x1, 0xc0(%r14)
jne 0x34b08
leaq 0xf8(%r14), %r15
leaq 0x10(%rsp), %r12
movq %rsp, %r13
movsd 0x90(%r14), %xmm1
movsd 0x98(%r14), %xmm0
movq %r12, %rdi
callq 0x1cdfe
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0xb810
cmpl $0x6e, %eax
jne 0x34afa
movl $0x1, %edi
movq %r13, %rsi
callq 0xb480
xorps %xmm0, %xmm0
cvtsi2sdq (%rsp), %xmm0
xorps %xmm1, %xmm1
cvtsi2sdq 0x8(%rsp), %xmm1
mulsd 0x34579(%rip), %xmm1    # 0x69018
addsd %xmm0, %xmm1
movsd %xmm1, 0x90(%r14)
movq %rbx, %rdi
callq 0xb3b0
movq 0xa8(%r14), %rdi
callq *0xa0(%r14)
movq %rbx, %rdi
callq 0xb7d0
movq 0xb0(%r14), %rax
movq 0xb8(%r14), %rcx
incq %rax
movq %rax, 0xb0(%r14)
testq %rcx, %rcx
sets %dl
cmpq %rcx, %rax
setl %al
orb %dl, %al
jne 0x34afa
movb $0x0, 0xc0(%r14)
cmpb $0x0, 0xc0(%r14)
jne 0x34a46
movq %rbx, %rdi
callq 0xb3b0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movq (%rdi), %rax
xorl %esi, %esi
callq *0x38(%rax)
cmpb $0x1, 0xc1(%rbx)
jne 0x34b4b
movq 0xc8(%rbx), %rdi
xorl %esi, %esi
callq 0xb460
leaq 0xf8(%rbx), %rdi
callq 0xba70
leaq 0xd0(%rbx), %rdi
callq 0xb620
movq %rbx, %rdi
callq 0x5ea6c
movb $0x1, %al
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xd0(%rdi), %r14
movq %r14, %rdi
callq 0xb7d0
movb $0x0, 0xc0(%rbx)
movq %r14, %rdi
callq 0xb3b0
addq $0xf8, %rbx
movq %rbx, %rdi
callq 0xb030
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/../include/args.hh
// Function: void* scdc_args::get<scdc_nodeport_timer_handler_args_t>(long long, scdc_nodeport_timer_handler_args_t*, bool)
scdc_arg_ref_t get(scdcint_t type, T *v, bool long_ref = false) {
      if (!args.get) return SCDC_ARG_REF_NULL;
      scdc_arg_ref_t r = args.get(args.data, type, static_cast<void *>(v));
      if (long_ref && r != SCDC_ARG_REF_NULL) add_get(type, r, 1, v, 0);
      return r;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x34c73
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdi), %rdi
callq *%rax
movq %rax, %r14
testq %rax, %rax
sete %al
xorb $0x1, %bpl
orb %al, %bpl
jne 0x34c76
leaq 0x20(%rbx), %r13
movl $0x38, %edi
callq 0xb500
movq %r12, 0x10(%rax)
movq %r14, 0x18(%rax)
movq $0x1, 0x20(%rax)
movq %r15, 0x28(%rax)
movq $0x0, 0x30(%rax)
movq %rax, %rdi
movq %r13, %rsi
callq 0xb090
incq 0x30(%rbx)
jmp 0x34c76
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/extra/xxhash/xxhash.c
// Function: XXH32
XXH_PUBLIC_API unsigned int XXH32 (const void* input, size_t len, unsigned int seed)
{
#if 0
    /* Simple version, good for code maintenance, but unfortunately slow for small inputs */
    XXH32_state_t state;
    XXH32_reset(&state, seed);
    XXH32_update(&state, input, len);
    return XXH32_digest(&state);
#else
    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;

    if (XXH_FORCE_ALIGN_CHECK) {
        if ((((size_t)input) & 3) == 0) {   /* Input is 4-bytes aligned, leverage the speed benefit */
            if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
                return XXH32_endian_align(input, len, seed, XXH_littleEndian, XXH_aligned);
            else
                return XXH32_endian_align(input, len, seed, XXH_bigEndian, XXH_aligned);
    }   }

    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
        return XXH32_endian_align(input, len, seed, XXH_littleEndian, XXH_unaligned);
    else
        return XXH32_endian_align(input, len, seed, XXH_bigEndian, XXH_unaligned);
#endif
}

// Assembly:
movl %edx, %eax
movq %rsi, %rdx
movq %rdi, %rsi
cmpq $0x10, %rdx
jb 0x34d6d
pushq %rbx
leaq (%rsi,%rdx), %rcx
addq $-0xf, %rcx
leal 0x24234428(%rax), %r9d
leal -0x7a143589(%rax), %r8d
leal 0x61c8864f(%rax), %edi
imull $0x85ebca77, (%rsi), %r10d # imm = 0x85EBCA77
addl %r9d, %r10d
roll $0xd, %r10d
imull $0x85ebca77, 0x4(%rsi), %r11d # imm = 0x85EBCA77
addl %r8d, %r11d
roll $0xd, %r11d
imull $0x9e3779b1, %r10d, %r9d # imm = 0x9E3779B1
imull $0x85ebca77, 0x8(%rsi), %r10d # imm = 0x85EBCA77
addl %eax, %r10d
roll $0xd, %r10d
imull $0x85ebca77, 0xc(%rsi), %ebx # imm = 0x85EBCA77
imull $0x9e3779b1, %r11d, %r8d # imm = 0x9E3779B1
addl %edi, %ebx
roll $0xd, %ebx
imull $0x9e3779b1, %r10d, %eax # imm = 0x9E3779B1
imull $0x9e3779b1, %ebx, %edi # imm = 0x9E3779B1
addq $0x10, %rsi
cmpq %rcx, %rsi
jb 0x34cf9
roll %r9d
roll $0x7, %r8d
addl %r9d, %r8d
roll $0xc, %eax
roll $0x12, %edi
addl %eax, %edi
addl %r8d, %edi
popq %rbx
jmp 0x34d74
addl $0x165667b1, %eax       # imm = 0x165667B1
movl %eax, %edi
addl %edx, %edi
andl $0xf, %edx
jmp 0x35427
// File: /workspace/github_cpp_makefile_star2_O1/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:
leal 0x24234428(%rsi), %eax
leal -0x7a143589(%rsi), %ecx
movq $0x0, (%rdi)
movl %eax, 0x8(%rdi)
movl %ecx, 0xc(%rdi)
movl %esi, 0x10(%rdi)
addl $0x61c8864f, %esi       # imm = 0x61C8864F
movl %esi, 0x14(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movl $0x0, 0x28(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
movq %rdi, %rsi
cmpl $0x0, 0x4(%rdi)
je 0x34fa7
movl 0x8(%rsi), %eax
roll %eax
movl 0xc(%rsi), %ecx
roll $0x7, %ecx
addl %eax, %ecx
movl 0x10(%rsi), %eax
roll $0xc, %eax
movl 0x14(%rsi), %edi
roll $0x12, %edi
addl %eax, %edi
addl %ecx, %edi
jmp 0x34faf
movl $0x165667b1, %edi       # imm = 0x165667B1
addl 0x10(%rsi), %edi
addl (%rsi), %edi
movl 0x28(%rsi), %edx
addq $0x18, %rsi
jmp 0x35427
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/extra/xxhash/xxhash.c
// Function: XXH64
XXH_PUBLIC_API unsigned long long XXH64 (const void* input, size_t len, unsigned long long seed)
{
#if 0
    /* Simple version, good for code maintenance, but unfortunately slow for small inputs */
    XXH64_state_t state;
    XXH64_reset(&state, seed);
    XXH64_update(&state, input, len);
    return XXH64_digest(&state);
#else
    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;

    if (XXH_FORCE_ALIGN_CHECK) {
        if ((((size_t)input) & 7)==0) {  /* Input is aligned, let's leverage the speed advantage */
            if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
                return XXH64_endian_align(input, len, seed, XXH_littleEndian, XXH_aligned);
            else
                return XXH64_endian_align(input, len, seed, XXH_bigEndian, XXH_aligned);
    }   }

    if ((endian_detected==XXH_littleEndian) || XXH_FORCE_NATIVE_FORMAT)
        return XXH64_endian_align(input, len, seed, XXH_littleEndian, XXH_unaligned);
    else
        return XXH64_endian_align(input, len, seed, XXH_bigEndian, XXH_unaligned);
#endif
}

// Assembly:
movq %rdx, %rax
movq %rsi, %rdx
movq %rdi, %rsi
cmpq $0x20, %rdx
jb 0x35108
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movabsq $-0x3d4d51c2d82b14b1, %r15 # imm = 0xC2B2AE3D27D4EB4F
movabsq $-0x61c8864e7a143579, %rcx # imm = 0x9E3779B185EBCA87
leaq (%rsi,%rdx), %r12
addq $-0x20, %r12
movabsq $0x60ea27eeadc0b5d6, %r14 # imm = 0x60EA27EEADC0B5D6
addq %rax, %r14
leaq (%rax,%r15), %rbx
movabsq $0x61c8864e7a143579, %r11 # imm = 0x61C8864E7A143579
addq %rax, %r11
movq (%rsi), %r10
imulq %r15, %r10
addq %r14, %r10
rolq $0x1f, %r10
movq %r10, %r14
imulq %rcx, %r14
movq 0x8(%rsi), %r9
imulq %r15, %r9
addq %rbx, %r9
rolq $0x1f, %r9
movq %r9, %rbx
movq 0x10(%rsi), %r8
imulq %r15, %r8
addq %rax, %r8
rolq $0x1f, %r8
imulq %rcx, %rbx
movq %r8, %rax
imulq %rcx, %rax
movq 0x18(%rsi), %rdi
imulq %r15, %rdi
addq %r11, %rdi
rolq $0x1f, %rdi
movq %rdi, %r11
imulq %rcx, %r11
addq $0x20, %rsi
cmpq %r12, %rsi
jbe 0x3501b
rolq %r14
rolq $0x7, %rbx
addq %r14, %rbx
rolq $0xc, %rax
rolq $0x12, %r11
addq %rax, %r11
addq %rbx, %r11
movabsq $-0x210ca4fef0869357, %rax # imm = 0xDEF35B010F796CA9
imulq %rax, %r10
rolq $0x1f, %r10
imulq %rcx, %r10
xorq %r11, %r10
imulq %rcx, %r10
movabsq $-0x7a1435883d4d519d, %r11 # imm = 0x85EBCA77C2B2AE63
addq %r11, %r10
imulq %rax, %r9
rolq $0x1f, %r9
imulq %rcx, %r9
xorq %r10, %r9
imulq %rcx, %r9
imulq %rax, %r8
rolq $0x1f, %r8
addq %r11, %r9
imulq %rcx, %r8
xorq %r9, %r8
imulq %rcx, %r8
addq %r11, %r8
imulq %rax, %rdi
rolq $0x1f, %rdi
imulq %rcx, %rdi
xorq %r8, %rdi
imulq %rcx, %rdi
addq %r11, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x35118
movabsq $0x27d4eb2f165667c5, %rcx # imm = 0x27D4EB2F165667C5
addq %rcx, %rax
movq %rax, %rdi
addq %rdx, %rdi
jmp 0x355c8
// File: /workspace/github_cpp_makefile_star2_O1/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:
movabsq $0x60ea27eeadc0b5d6, %rax # imm = 0x60EA27EEADC0B5D6
addq %rsi, %rax
movabsq $-0x3d4d51c2d82b14b1, %rcx # imm = 0xC2B2AE3D27D4EB4F
addq %rsi, %rcx
movabsq $0x61c8864e7a143579, %rdx # imm = 0x61C8864E7A143579
addq %rsi, %rdx
xorl %r8d, %r8d
movq %r8, (%rdi)
movq %rax, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
movq %rsi, 0x18(%rdi)
movq %rdx, 0x20(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movq %r8, 0x48(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/extra/xxhash/xxhash.c
// Function: XXH64_digest
XXH_PUBLIC_API unsigned long long XXH64_digest (const XXH64_state_t* state_in)
{
    XXH_endianess endian_detected = (XXH_endianess)XXH_CPU_LITTLE_ENDIAN;

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

// Assembly:
movq %rdi, %rsi
movq (%rdi), %rdx
cmpq $0x20, %rdx
jb 0x353ff
pushq %rbx
movq 0x8(%rsi), %r10
movq 0x10(%rsi), %rcx
movq 0x18(%rsi), %rax
movq %r10, %r8
rolq %r8
movq 0x20(%rsi), %rdi
movq %rcx, %r11
rolq $0x7, %r11
addq %r8, %r11
movq %rax, %r8
rolq $0xc, %r8
movq %rdi, %rbx
rolq $0x12, %rbx
addq %r8, %rbx
movabsq $-0x3d4d51c2d82b14b1, %r9 # imm = 0xC2B2AE3D27D4EB4F
imulq %r9, %r10
rolq $0x1f, %r10
addq %r11, %rbx
movabsq $-0x61c8864e7a143579, %r8 # imm = 0x9E3779B185EBCA87
imulq %r8, %r10
xorq %rbx, %r10
imulq %r8, %r10
movabsq $-0x7a1435883d4d519d, %r11 # imm = 0x85EBCA77C2B2AE63
addq %r11, %r10
imulq %r9, %rcx
rolq $0x1f, %rcx
imulq %r8, %rcx
xorq %r10, %rcx
imulq %r8, %rcx
imulq %r9, %rax
rolq $0x1f, %rax
addq %r11, %rcx
imulq %r8, %rax
xorq %rcx, %rax
imulq %r8, %rax
addq %r11, %rax
imulq %r9, %rdi
rolq $0x1f, %rdi
imulq %r8, %rdi
xorq %rax, %rdi
imulq %r8, %rdi
addq %r11, %rdi
popq %rbx
jmp 0x3540d
movabsq $0x27d4eb2f165667c5, %rdi # imm = 0x27D4EB2F165667C5
addq 0x18(%rsi), %rdi
addq %rdx, %rdi
addq $0x28, %rsi
jmp 0x355c8
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x90, %rsp
movq %rsi, %rbx
movq %rsp, %rsi
callq 0xba80
testl %eax, %eax
je 0x35be5
xorl %eax, %eax
jmp 0x35c25
movl $0xf000, %eax           # imm = 0xF000
andl 0x18(%rsp), %eax
xorl %ecx, %ecx
cmpl $0x4000, %eax           # imm = 0x4000
sete %cl
movq %rcx, (%rbx)
xorl %ecx, %ecx
cmpl $0x8000, %eax           # imm = 0x8000
sete %cl
movq %rcx, 0x8(%rbx)
xorl %ecx, %ecx
cmpl $0xa000, %eax           # imm = 0xA000
sete %cl
movq %rcx, 0x10(%rbx)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rbx)
movl $0x1, %eax
addq $0x90, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
callq 0xba10
movq %rax, %rbx
testq %rax, %rax
je 0x35cb1
movq %rbx, %r15
movq %r15, %rdi
movl $0x2f, %esi
callq 0xb1e0
movq %rax, %r14
cmpq %r15, %rax
je 0x35c95
testq %r14, %r14
je 0x35c78
movb $0x0, (%r14)
movq %rbx, %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0xb220
testl %eax, %eax
sete %al
testq %r14, %r14
je 0x35c97
movb $0x2f, (%r14)
jmp 0x35c97
movb $0x1, %al
leaq 0x1(%r14), %r15
testq %r14, %r14
cmoveq %r14, %r15
testb %al, %al
je 0x35cab
testq %r14, %r14
jne 0x35c5a
movzbl %al, %r14d
jmp 0x35cb7
movl $0x1, %r14d
movq %rbx, %rdi
callq 0xb650
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rsi
leaq -0xf0(%rbp), %r12
movq %rcx, 0x18(%r12)
movq %r8, 0x20(%r12)
movq %r9, 0x28(%r12)
testb %al, %al
je 0x35d68
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %rsp, %r15
leaq 0x10(%r14), %rax
andq $-0x10, %rax
subq %rax, %r15
movq %r15, %rsp
movq %r15, %rdi
movq %r14, %rdx
callq 0xb2a0
movb $0x0, (%r14,%r15)
leaq -0x40(%rbp), %rdx
movq %r12, 0x10(%rdx)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000018, %rax     # imm = 0x3000000018
movq %rax, (%rdx)
movq %r15, %rdi
movq %rbx, %rsi
callq 0xb6d0
leaq -0x20(%rbp), %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
testq %rsi, %rsi
je 0x36278
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq %rsi, %rdi
callq 0xb200
leaq (%rax,%r15), %rdx
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x1bee6
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x35dc6
movl %eax, %ebx
testb %al, %al
jne 0x36260
leaq 0x56399(%rip), %r15     # 0x8c570
movq (%r15), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x36260
addq $0x20, %rdi
callq 0xb7d0
movq (%r15), %rax
movq 0x8(%rax), %r14
leaq 0x33f90(%rip), %rsi     # 0x6a188
movl $0xb, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x35a0c(%rip), %rsi     # 0x6bc18
movl $0xa, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x35a59(%rip), %rsi     # 0x6bc79
movl $0x25, %edx
movq %r14, %rdi
callq 0xb5f0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %r14, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq (%r15), %rdi
addq $0x20, %rdi
callq 0xb3b0
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x3627a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
jmp 0x3627a
movb $0x1, %bl
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x362a3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataprov/dataprov.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 %rbx
movq %rdi, %rbx
movl $0x38, %edi
callq 0xb500
movq %rbx, 0x8(%rax)
leaq 0x28(%rax), %rcx
movq %rcx, 0x18(%rax)
movq $0x0, 0x20(%rax)
movb $0x0, 0x28(%rax)
leaq 0x54207(%rip), %rcx     # 0x8a920
movq %rcx, (%rax)
movb $0x1, 0x10(%rax)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x367ae
movq %rsi, %rbx
movq (%rsi), %r14
movq -0x8(%r14), %rax
movq 0x8(%rax), %rdi
leaq 0x35629(%rip), %rax     # 0x6bd9f
cmpq %rax, %rdi
je 0x36784
cmpb $0x2a, (%rdi)
jne 0x36789
xorl %ebp, %ebp
jmp 0x3679b
movb $0x1, %bpl
jmp 0x3679b
leaq 0x3560f(%rip), %rsi     # 0x6bd9f
callq 0xb770
testl %eax, %eax
sete %bpl
testb %bpl, %bpl
je 0x367a7
movq %rbx, %rdi
callq *0x8(%r14)
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
callq 0xb5a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataprov/dataprov.cc
// Function: scdc_dataprov::dataset_open_read_state(scdc_data*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
scdc_dataset *scdc_dataprov::dataset_open_read_state(scdc_data *incoming, scdc_result &result)
{
  SCDC_TRACE("dataset_open_read_state:");

  char *buf;
  scdcint_t buf_size;
  const char *end;

  while (1)
  {
    buf = incoming->get_read_pos_buf();
    buf_size = incoming->get_read_pos_buf_size();
    end = memchr(buf, '|', buf_size);

    if (end) break;

    incoming->do_next();
  }

  buf_size = end - buf;

  scdc_dataset *dataset = 0;

  string dataset_str(buf, buf_size);
  sscanf(dataset_str.c_str(), "%p", &dataset);

  incoming->inc_read_pos(buf_size + 1);

  if (!dataset)
  {
    result = "dataset not available";
    SCDC_FAIL("dataset_open_read_state: " << result);
    return 0;
  }

  return dataset;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq 0x20(%rsi), %rdx
movq 0x28(%rsi), %rax
movq 0x8(%rsi), %r15
addq %rax, %r15
subq %rax, %rdx
movq %r15, %rdi
movl $0x7c, %esi
callq 0xb5b0
testq %rax, %rax
movq %rbx, 0x8(%rsp)
jne 0x36823
movq 0x38(%r14), %rax
testq %rax, %rax
je 0x367ff
movq %r14, %rdi
callq *%rax
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rax
movq 0x8(%r14), %r15
addq %rax, %r15
subq %rax, %rdx
movq %r15, %rdi
movl $0x7c, %esi
callq 0xb5b0
testq %rax, %rax
je 0x367f1
movq %rax, %rbp
subq %r15, %rbp
leaq 0x30(%rsp), %rbx
movq $0x0, (%rbx)
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x1bee6
movq (%r13), %rdi
leaq 0x32c83(%rip), %rsi     # 0x694e0
movq %rbx, %rdx
xorl %eax, %eax
callq 0xb4e0
movq 0x28(%r14), %rax
addq %rbp, %rax
incq %rax
movq %rax, 0x28(%r14)
movq (%rbx), %r14
testq %r14, %r14
jne 0x3694a
movq 0x8(%rsp), %rbx
movq 0x8(%rbx), %rdx
leaq 0x35444(%rip), %rcx     # 0x6bcd5
movl $0x15, %r8d
movq %rbx, %rdi
xorl %esi, %esi
callq 0xb870
leaq 0x55cc8(%rip), %r15     # 0x8c570
movq (%r15), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x36947
addq $0x20, %rdi
callq 0xb7d0
movq (%r15), %rax
movq 0x8(%rax), %r14
leaq 0x338bb(%rip), %rsi     # 0x6a188
movl $0xb, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x35337(%rip), %rsi     # 0x6bc18
movl $0xa, %edx
movq %r14, %rdi
callq 0xb5f0
leaq 0x353f6(%rip), %rsi     # 0x6bceb
movl $0x19, %edx
movq %r14, %rdi
callq 0xb5f0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0xb5f0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq (%r15), %rdi
addq $0x20, %rdi
callq 0xb3b0
xorl %r14d, %r14d
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x36961
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xb510
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x3698d
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataprov/dataprov.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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %rcx
movq 0x10(%rdx), %r14
movq 0x20(%rdx), %rax
movq 0x8(%rdx), %rdi
addq %rax, %rdi
subq %rax, %r14
leaq 0x33b87(%rip), %rdx     # 0x6a545
movq %r14, %rsi
xorl %eax, %eax
callq 0xb8e0
movslq %eax, %r12
cmpq %r12, %r14
jge 0x36aa3
leaq 0x55b95(%rip), %r13     # 0x8c570
movq (%r13), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x36aa3
addq $0x20, %rdi
callq 0xb7d0
movq (%r13), %rax
movq 0x18(%rax), %r15
leaq 0x33b47(%rip), %rsi     # 0x6a549
movl $0xd, %edx
movq %r15, %rdi
callq 0xb5f0
leaq 0x352ef(%rip), %rsi     # 0x6bd05
movl $0x14, %edx
movq %r15, %rdi
callq 0xb5f0
leaq 0x3391a(%rip), %rsi     # 0x6a344
movl $0x1, %edx
movq %r15, %rdi
callq 0xb5f0
movq %r15, %rdi
movl $0xe3, %esi
callq 0xb9a0
movq %rax, %r15
leaq 0x33b23(%rip), %rsi     # 0x6a571
movl $0x10, %edx
movq %rax, %rdi
callq 0xb5f0
leaq 0x35426(%rip), %rsi     # 0x6be88
movl $0x8, %edx
movq %r15, %rdi
callq 0xb5f0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %r15, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq (%r13), %rdi
addq $0x20, %rdi
callq 0xb3b0
cmpq %r12, %r14
cmovlq %r14, %r12
addq %r12, 0x20(%rbx)
movb $0x1, %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rbx
movq %r8, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%rcx), %rsi
movq 0x8(%rcx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
callq 0x1d19a
movq (%r13), %rax
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbp, %rcx
movq %r14, %r8
movq %rbx, %r9
callq *0x60(%rax)
movl %eax, %ebx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3780a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3783a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataprov/dataprov_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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %rbx
leaq 0x28(%rsp), %r14
leaq 0x7(%rsp), %rax
movq %r14, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x1bdd6
leaq 0x3171d(%rip), %rcx     # 0x6bf0e
movl $0x1b, %r8d
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xb5d0
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x3a82a
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x3a831
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x31b07(%rip), %rsi     # 0x6c35b
callq 0xba60
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x3a881
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
jmp 0x3a889
movups (%rcx), %xmm0
movups %xmm0, (%r12)
movq 0x8(%rax), %rdx
leaq 0x48(%rsp), %r14
movq %rdx, 0x8(%r14)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb670
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x3a8c5
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xb510
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x3a8dc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3a8f7
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb510
movb $0x1, %al
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x3a924
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb510
jmp 0x3a924
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3a93f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataprov/dataprov_bench.cc
// Function: scdc_dataset_bench::do_cmd_get(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 do_cmd_get(const string &params, scdc_dataset_input_t *input, scdc_dataset_output_t *output, scdc_result &result)
    {
      SCDC_TRACE("dataset_bench: do_cmd_get: '" << params << "'");

      scdcint_t total_size;

      stringstream(params) >> total_size;

      SCDC_TRACE("dataset_bench: do_cmd_get: start get of size = " << total_size);

      output->total_size = total_size;
      output->total_size_given = SCDC_DATASET_INOUT_TOTAL_SIZE_GIVEN_EXACT;

      dataset_output_next_data_t *data = new dataset_output_next_data_t();

      data->total_size_left = total_size;
      data->format = format;
      data->content = content;

      if (mode == "file")
      {
        if (content == "zero") data->file = fopen("/dev/zero", "r");
        else if (content == "random") data->file = fopen("/dev/urandom", "r");
      }

      output->next = dataset_output_next;
      output->data = data;

      /* get first chunk of data */
      output->next(output, 0);

      return true;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rcx, %rbx
movq %rdi, %r15
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x18, %edx
callq 0xb8d0
movq %rsp, %rsi
movq %r14, %rdi
callq 0xb750
movq 0x50d7e(%rip), %rsi     # 0x8bfb0
leaq 0x8(%rsp), %rdi
callq 0xb390
leaq 0x88(%rsp), %rdi
callq 0xb180
movq (%rsp), %r12
movq %r12, 0x28(%rbx)
movb $0x78, 0x30(%rbx)
movl $0x50, %edi
callq 0xb500
movq %rax, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x40(%rax)
leaq 0x8(%rax), %rdi
addq $0x18, %rax
movq %rax, 0x8(%r14)
xorl %eax, %eax
movq %rax, 0x10(%r14)
movb %al, 0x18(%r14)
leaq 0x28(%r14), %r13
leaq 0x38(%r14), %rcx
movq %rcx, 0x28(%r14)
movq %rax, 0x30(%r14)
movb %al, 0x38(%r14)
movq %r12, (%r14)
leaq 0x38(%r15), %rsi
callq 0xb2c0
leaq 0x58(%r15), %r12
movq %r13, %rdi
movq %r12, %rsi
callq 0xb2c0
addq $0x78, %r15
leaq 0x30396(%rip), %rsi     # 0x6b65e
movq %r15, %rdi
callq 0xb110
testl %eax, %eax
jne 0x3b31a
leaq 0x30cad(%rip), %rsi     # 0x6bf88
movq %r12, %rdi
callq 0xb110
testl %eax, %eax
je 0x3b303
leaq 0x30ca5(%rip), %rsi     # 0x6bf93
movq %r12, %rdi
callq 0xb110
testl %eax, %eax
jne 0x3b31a
leaq 0x30c8c(%rip), %rdi     # 0x6bf8d
jmp 0x3b30a
leaq 0x30c79(%rip), %rdi     # 0x6bf83
leaq 0x2e4f6(%rip), %rsi     # 0x69807
callq 0xb640
movq %rax, 0x48(%r14)
leaq -0x5f9(%rip), %rax      # 0x3ad28
movq %rax, 0x38(%rbx)
movq %r14, 0x40(%rbx)
movq %rbx, %rdi
callq 0x3ad28
movb $0x1, %al
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x50c62(%rip), %rsi     # 0x8bfb0
leaq 0x8(%rsp), %rdi
callq 0xb390
leaq 0x88(%rsp), %rdi
callq 0xb180
movq %rbx, %rdi
callq 0xb9c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataprov/dataprov_fs2.cc
// Function: scdc_dataprov_fs2::make_pwd_path(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>>&)
bool scdc_dataprov_fs2::make_pwd_path(const std::string &pwd, const std::string &sub, std::string &pwd_path)
{
  std::string p;

  if (!sub.empty())
  {
    if (sub[0] != '/') p = pwd + "/";
    p += sub;

  } else p = pwd;

  normalize_path(p.c_str(), pwd_path);

  if (!pwd_path.empty() && pwd_path[0] == '/') pwd_path = pwd_path.erase(0, 1);

  return (pwd_path.compare("..") != 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
cmpq $0x0, 0x8(%rdx)
je 0x45b7b
movq %rdx, %r14
movq (%rdx), %rax
cmpb $0x2f, (%rax)
je 0x45b6a
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x1d19a
leaq 0x24812(%rip), %rsi     # 0x6a34d
leaq 0x20(%rsp), %rdi
callq 0xba60
movq %rsp, %rdi
leaq 0x20(%rsp), %r15
movq %r15, %rsi
callq 0xb670
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x45b6a
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xb510
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rsp, %rdi
callq 0xb150
jmp 0x45b83
movq %rsp, %rdi
callq 0xb2c0
movq (%rsp), %rdi
movq %rbx, %rsi
callq 0x1cc32
cmpq $0x0, 0x8(%rbx)
je 0x45bb8
movq (%rbx), %rax
cmpb $0x2f, (%rax)
jne 0x45bb8
movl $0x1, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xb0e0
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb2c0
leaq 0x24790(%rip), %rsi     # 0x6a34f
movq %rbx, %rdi
callq 0xb110
movl %eax, %ebx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x45bdf
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
testl %ebx, %ebx
setne %al
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x45c13
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xb510
jmp 0x45c13
jmp 0x45c10
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x45c29
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataprov/dataprov_fs2.cc
// Function: scdc_dataprov_fs2::undo_full_path(char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov_fs2::undo_full_path(const char *full_path, std::string &path)
{
  string norm_full_path;

  normalize_path(full_path, norm_full_path);

  norm_full_path += "/";

  if (strncmp(norm_full_path.c_str(), root.c_str(), root.size()) != 0) return false;

  path = norm_full_path.c_str() + root.size();

  /* remove trailing '/' */
  while (path.size() > 1 && *(path.end() - 1) == '/') path.erase(path.size() - 1, 1);

  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %rax
movq %rdi, %r15
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq %rsp, %rsi
movq %rax, %rdi
callq 0x1cc32
leaq 0x245b4(%rip), %rsi     # 0x6a34d
movq %rsp, %rdi
callq 0xba60
movq (%rsp), %r14
movq 0x68(%r15), %rsi
movq 0x70(%r15), %r15
movq %r14, %rdi
movq %r15, %rdx
callq 0xb240
movl %eax, %ebp
testl %eax, %eax
je 0x45de6
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x45dd4
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
testl %ebp, %ebp
sete %al
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
addq %r15, %r14
movq 0x8(%rbx), %r15
movq %r14, %rdi
callq 0xb200
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0xb870
movq 0x8(%rbx), %rsi
cmpq $0x2, %rsi
jb 0x45dbe
movq (%rbx), %rax
cmpb $0x2f, -0x1(%rax,%rsi)
jne 0x45dbe
decq %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq 0xb0e0
jmp 0x45e08
jmp 0x45e30
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x45e49
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb510
movq %rbx, %rdi
callq 0xb9c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataprov/dataprov_fs2.cc
// Function: dir_count_stores(__dirstream*)
static scdcint_t dir_count_stores(DIR *dir)
{
  struct dirent *ent;
  scdcint_t c = 0;

  while ((ent = readdir(dir)) != NULL)
  {
    if (ent->d_type == DT_DIR && has_prefix(ent->d_name, DIR_STORE_PREFIX)) ++c;
  }

  return c;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0xb850
xorl %r14d, %r14d
testq %rax, %rax
je 0x466e6
leaq 0x25ed9(%rip), %r15     # 0x6c597
cmpb $0x4, 0x12(%rax)
jne 0x466d9
addq $0x13, %rax
movq %rax, %rdi
movq %r15, %rsi
callq 0x1c51e
movzbl %al, %eax
addq %rax, %r14
movq %rbx, %rdi
callq 0xb850
testq %rax, %rax
jne 0x466be
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataprov/dataprov_fs2.cc
// Function: scdc_dataset_fs2::open_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool, bool)
FILE *open_file(const string &path, bool read, bool write)
    {
      int mode = (read?1:0) + (write?2:0);

#if SCDC_DATASET_FS_LEAVE_PWD_OPEN
      if (pwd_FILE && pwd_FILE_path == path)
      {
        if (mode == 0 || mode == pwd_FILE_mode || pwd_FILE_mode == 3) return pwd_FILE;

        mode |= pwd_FILE_mode;
      }
#endif

#if SCDC_DATASET_FS_LEAVE_PWD_OPEN
      close_pwd_file();
#endif

      const char *m = 0;

      switch (mode)
      {
        case 0: m = "r"; mode = 1; break;
        case 1: m = "r"; break;
        case 2: if (z_fs_exists(path.c_str())) { m = "r+"; mode = 3; } else m = "w"; break;
        case 3: m = (z_fs_exists(path.c_str()))?"r+":"w+"; break;
      }

      FILE *file = fopen(path.c_str(), m);

#if SCDC_DATASET_FS_LEAVE_PWD_OPEN
      if (file)
      {
        pwd_FILE = file;
        pwd_FILE_path = path;
        pwd_FILE_mode = mode;
      }
#endif

      return file;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leal (%rdx,%rcx,2), %ebp
movq 0x40(%rdi), %r15
testq %r15, %r15
je 0x4a82a
movq 0x50(%rbx), %rdx
cmpq 0x8(%r14), %rdx
jne 0x4a82a
testq %rdx, %rdx
je 0x4a80a
movq (%r14), %rsi
movq 0x48(%rbx), %rdi
callq 0xb520
testl %eax, %eax
jne 0x4a82a
testl %ebp, %ebp
je 0x4a8ea
movl 0x68(%rbx), %eax
cmpl %eax, %ebp
sete %cl
cmpl $0x3, %eax
sete %dl
orb %cl, %dl
jne 0x4a8ea
orl %eax, %ebp
testq %r15, %r15
je 0x4a837
movq %r15, %rdi
callq 0xb4f0
xorl %esi, %esi
movq %rsi, 0x40(%rbx)
movq %rsi, 0x50(%rbx)
movq 0x48(%rbx), %rax
movb $0x0, (%rax)
movl $0x0, 0x68(%rbx)
cmpl $0x3, %ebp
ja 0x4a8c7
movl %ebp, %eax
leaq 0x219eb(%rip), %rcx     # 0x6c248
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1ef9a(%rip), %rsi     # 0x69807
movl $0x1, %ebp
jmp 0x4a8c7
movq (%r14), %rdi
callq 0x35ab0
xorl %ebp, %ebp
testq %rax, %rax
sete %bpl
leaq 0x20e09(%rip), %rax     # 0x6b695
leaq 0x20dff(%rip), %rsi     # 0x6b692
cmoveq %rax, %rsi
xorl $0x3, %ebp
jmp 0x4a8c7
movq (%r14), %rdi
callq 0x35ab0
testq %rax, %rax
leaq 0x21b6e(%rip), %rax     # 0x6c41c
leaq 0x20ddd(%rip), %rsi     # 0x6b692
cmoveq %rax, %rsi
movl $0x3, %ebp
jmp 0x4a8c7
leaq 0x1ef40(%rip), %rsi     # 0x69807
movq (%r14), %rdi
callq 0xb640
movq %rax, %r15
testq %rax, %rax
je 0x4a8ea
leaq 0x48(%rbx), %rdi
movq %r15, 0x40(%rbx)
movq %r14, %rsi
callq 0xb2c0
movl %ebp, 0x68(%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/mh0fm4[P]SCDC/src/components/dataprov/dataprov_hook.cc
// Function: scdc_dataprov_hook::close(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov_hook::close(scdc_result &result)
{
  SCDC_TRACE("close:");

  bool ret = true;

  if (hook_arg.hook.close)
  {
    if (hook_arg.hook.close(dataprov) != SCDC_SUCCESS)
    {
      SCDC_FAIL("close: closing data provider with hook");
      ret = false;
    }
  }

  open_args_release();

  ret = scdc_dataprov::close(result);

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

  return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x70(%rdi), %rax
testq %rax, %rax
je 0x4bac9
movq 0xb8(%r14), %rdi
callq *%rax
cmpq $0x1, %rax
je 0x4bac9
leaq 0x40b37(%rip), %r12     # 0x8c570
movq (%r12), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x4bac9
addq $0x20, %rdi
callq 0xb7d0
movq (%r12), %rax
movq 0x8(%rax), %r15
leaq 0x1e728(%rip), %rsi     # 0x6a188
movl $0xb, %edx
movq %r15, %rdi
callq 0xb5f0
leaq 0x20da6(%rip), %rsi     # 0x6c81a
movl $0xf, %edx
movq %r15, %rdi
callq 0xb5f0
leaq 0x20dee(%rip), %rsi     # 0x6c876
movl $0x26, %edx
movq %r15, %rdi
callq 0xb5f0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0xb4d0
movsbl %al, %esi
movq %r15, %rdi
callq 0xb050
movq %rax, %rdi
callq 0xb340
movq (%r12), %rdi
addq $0x20, %rdi
callq 0xb3b0
movq %r14, %rdi
callq 0x268bc
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x362ac
nop