LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/node/nodeport_timer.cc
// Function: scdc_nodeport_timer::open(char const*, scdc_args*)
bool scdc_nodeport_timer::open(const char *conf, scdc_args *args)
{
  SCDC_TRACE("open: conf: '" << conf << "'");

  bool ret = true;

  args = open_args_init(args);

  if (args->get<double>(SCDC_ARGS_TYPE_DOUBLE, &timeout) == SCDC_ARG_REF_NULL)
  {
    SCDC_ERROR("open: getting timeout");
    ret = false;
    goto do_quit;
  }

  if (args->get<scdc_nodeport_timer_handler_args_t>(SCDC_ARGS_TYPE_NODEPORT_TIMER_HANDLER, &timer_handler_args, true) == SCDC_ARG_REF_NULL)
  {
    SCDC_ERROR("open: getting timer handler");
    ret = false;
    goto do_quit;
  }

  if (!scdc_nodeport::open(conf, args))
  {
    SCDC_FAIL("open: opening base");
    ret = false;
  }

  open_args_clear();

do_quit:
  if (!ret) open_args_release();

  return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rsi
callq 0x2c94c
movq %rax, %r15
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x2c5ea
leaq 0x98(%rbx), %rdx
movq (%r15), %rdi
pushq $0x3
popq %rsi
callq *%rax
testq %rax, %rax
je 0x2c5ea
leaq 0xa0(%rbx), %rdx
pushq $0x13
popq %rsi
pushq $0x1
popq %rcx
movq %r15, %rdi
callq 0x2c99e
testq %rax, %rax
je 0x2c652
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x48b8c
testb %al, %al
je 0x2c69b
movq 0x38(%rbx), %rax
andq $0x0, (%rax)
movb $0x1, %al
jmp 0x2c70c
leaq 0x48f8f(%rip), %r14     # 0x75580
movq (%r14), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x2c702
addq $0x20, %rdi
callq 0xb800
movq (%r14), %rax
movq 0x18(%rax), %rdi
leaq 0x24e72(%rip), %rsi     # 0x51488
callq 0xb520
leaq 0x26453(%rip), %rsi     # 0x52a75
movq %rax, %rdi
callq 0xb520
leaq 0x2647a(%rip), %rsi     # 0x52aab
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
movq (%r14), %rdi
addq $0x20, %rdi
callq 0xb3e0
jmp 0x2c702
leaq 0x48f27(%rip), %r14     # 0x75580
movq (%r14), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x2c702
addq $0x20, %rdi
callq 0xb800
movq (%r14), %rax
movq 0x18(%rax), %rdi
leaq 0x24e0a(%rip), %rsi     # 0x51488
callq 0xb520
leaq 0x263eb(%rip), %rsi     # 0x52a75
movq %rax, %rdi
callq 0xb520
leaq 0x26428(%rip), %rsi     # 0x52ac1
jmp 0x2c631
leaq 0x48ede(%rip), %r14     # 0x75580
movq (%r14), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x2c6fa
addq $0x20, %rdi
callq 0xb800
movq (%r14), %rax
movq 0x8(%rax), %rdi
leaq 0x24ac5(%rip), %rsi     # 0x51188
callq 0xb520
leaq 0x263a6(%rip), %rsi     # 0x52a75
movq %rax, %rdi
callq 0xb520
leaq 0x263ff(%rip), %rsi     # 0x52add
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
movq (%r14), %rdi
addq $0x20, %rdi
callq 0xb3e0
movq 0x38(%rbx), %rax
andq $0x0, (%rax)
movq %rbx, %rdi
callq 0x2c9fa
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x48ce2
movl %eax, %ebx
testb %al, %al
je 0x2c7a6
callq 0x2c7ae
movsd %xmm0, 0x90(%r14)
andq $0x0, 0xb0(%r14)
movw $0x1, 0xc0(%r14)
leaq 0xd0(%r14), %rdi
xorl %esi, %esi
callq 0xb810
leaq 0xf8(%r14), %rdi
xorl %esi, %esi
callq 0xb680
testb $0x1, %r15b
jne 0x2c79e
movb $0x1, 0xc1(%r14)
leaq 0xc8(%r14), %rdi
leaq 0x129(%rip), %rdx       # 0x2c8bb
xorl %esi, %esi
movq %r14, %rcx
callq 0xb9f0
jmp 0x2c7a6
movq %r14, %rdi
callq 0x2c7de
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0xd0(%rdi), %rbx
movq %rbx, %rdi
callq 0xb800
leaq 0xf8(%r14), %r15
leaq 0x8(%rsp), %r12
cmpb $0x1, 0xc0(%r14)
jne 0x2c8a7
movsd 0x90(%r14), %xmm1
movsd 0x98(%r14), %xmm0
movq %r12, %rdi
callq 0x1b0db
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0xb840
cmpl $0x6e, %eax
jne 0x2c807
callq 0x2c7ae
movsd %xmm0, 0x90(%r14)
movq %rbx, %rdi
callq 0xb3e0
movq 0xa8(%r14), %rdi
callq *0xa0(%r14)
movq %rbx, %rdi
callq 0xb800
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 0x2c807
movb $0x0, 0xc0(%r14)
jmp 0x2c807
movq %rbx, %rdi
callq 0xb3e0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2c8e9
movq 0xc8(%rbx), %rdi
xorl %esi, %esi
callq 0xb4a0
leaq 0xf8(%rbx), %rdi
callq 0xba60
leaq 0xd0(%rbx), %rdi
callq 0xb640
movq %rbx, %rdi
callq 0x48d0a
movb $0x1, %al
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xb800
movb $0x0, 0xc0(%rbx)
movq %r14, %rdi
callq 0xb3e0
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_O2/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 %r12
pushq %rbx
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x2c9ea
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movq (%rdi), %rdi
callq *%rax
movq %rax, %r14
testq %rax, %rax
sete %al
xorb $0x1, %bpl
orb %al, %bpl
jne 0x2c9ed
pushq $0x1
popq %rcx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %r8
xorl %r9d, %r9d
callq 0x2ca32
jmp 0x2c9ed
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2cb8d
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 0x2cb19
roll %r9d
roll $0x7, %r8d
addl %r9d, %r8d
roll $0xc, %eax
roll $0x12, %edi
addl %eax, %edi
addl %r8d, %edi
popq %rbx
jmp 0x2cb94
addl $0x165667b1, %eax       # imm = 0x165667B1
movl %eax, %edi
addl %edx, %edi
andl $0xf, %edx
jmp 0x2d26e
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, (%rdi)
leal -0x7a143589(%rsi), %ecx
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)
andl $0x0, 0x28(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2cdfd
movdqu 0x8(%rsi), %xmm0
movdqa 0x25d7d(%rip), %xmm1    # 0x52b30
pshufd $0xf5, %xmm0, %xmm2     # xmm2 = xmm0[1,1,3,3]
pmuludq %xmm1, %xmm0
pshufd $0xed, %xmm0, %xmm3     # xmm3 = xmm0[1,3,2,3]
pshufd $0xf5, %xmm1, %xmm1     # xmm1 = xmm1[1,1,3,3]
pmuludq %xmm2, %xmm1
pshufd $0xed, %xmm1, %xmm2     # xmm2 = xmm1[1,3,2,3]
punpckldq %xmm2, %xmm3    # xmm3 = xmm3[0],xmm2[0],xmm3[1],xmm2[1]
pshufd $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3]
pshufd $0xe8, %xmm1, %xmm1     # xmm1 = xmm1[0,2,2,3]
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
por %xmm3, %xmm0
pshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
paddd %xmm0, %xmm1
pshufd $0x55, %xmm1, %xmm0     # xmm0 = xmm1[1,1,1,1]
paddd %xmm1, %xmm0
movd %xmm0, %edi
jmp 0x2ce05
movl $0x165667b1, %edi       # imm = 0x165667B1
addl 0x10(%rsi), %edi
addl (%rsi), %edi
movl 0x28(%rsi), %edx
addq $0x18, %rsi
jmp 0x2d26e
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, (%rdi)
addq %rsi, %rdx
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)
andq $0x0, 0x48(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl %edi, %eax
shrl $0xf, %eax
xorl %edi, %eax
imull $0x85ebca77, %eax, %eax # imm = 0x85EBCA77
movl %eax, %ecx
shrl $0xd, %ecx
xorl %eax, %ecx
imull $0xc2b2ae3d, %ecx, %ecx # imm = 0xC2B2AE3D
movl %ecx, %eax
shrl $0x10, %eax
xorl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movq %rdi, %rax
shrq $0x21, %rax
xorq %rdi, %rax
movabsq $-0x3d4d51c2d82b14b1, %rcx # imm = 0xC2B2AE3D27D4EB4F
imulq %rax, %rcx
movq %rcx, %rax
shrq $0x1d, %rax
xorq %rcx, %rax
movabsq $0x165667b19e3779f9, %rcx # imm = 0x165667B19E3779F9
imulq %rax, %rcx
movq %rcx, %rax
shrq $0x20, %rax
xorq %rcx, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xba70
testl %eax, %eax
je 0x2da4d
xorl %eax, %eax
jmp 0x2da8d
movl $0xf000, %eax           # imm = 0xF000
andl 0x18(%rsp), %eax
movd %eax, %xmm0
pshufd $0x40, %xmm0, %xmm0     # xmm0 = xmm0[0,0,0,1]
pcmpeqd 0x25199(%rip), %xmm0    # 0x52c00
pand 0x251a1(%rip), %xmm0    # 0x52c10
movdqu %xmm0, (%rbx)
xorl %ecx, %ecx
cmpl $0xa000, %eax           # imm = 0xA000
sete %cl
movq %rcx, 0x10(%rbx)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rbx)
pushq $0x1
popq %rax
addq $0x90, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0xba00
movq %rax, %rbx
pushq $0x1
popq %r13
pushq $0x2f
popq %rbp
movq %rax, %r12
movq %r13, %r14
testq %r14, %r14
je 0x2db16
testq %r12, %r12
je 0x2db16
movq %r12, %rdi
movl %ebp, %esi
callq 0xb1e0
movq %rax, %r15
movq %r13, %r14
cmpq %r12, %rax
je 0x2db09
testq %r15, %r15
je 0x2daf5
movb $0x0, (%r15)
movq %rbx, %rdi
callq 0x2da96
movq %rax, %r14
testq %r15, %r15
je 0x2db09
movb $0x2f, (%r15)
leaq 0x1(%r15), %r12
testq %r15, %r15
cmoveq %r15, %r12
jmp 0x2dacd
movq %rbx, %rdi
callq 0xb670
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_O2/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 %rbx
subq $0x30, %rsp
testq %rsi, %rsi
je 0x2df63
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0x1a132
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2dc2a
movl %eax, %ebx
testb %al, %al
jne 0x2df57
leaq 0x47681(%rip), %r14     # 0x75580
movq (%r14), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x2df57
addq $0x20, %rdi
callq 0xb800
movq (%r14), %rax
movq 0x8(%rax), %rdi
leaq 0x23268(%rip), %rsi     # 0x51188
callq 0xb520
leaq 0x24cf4(%rip), %rsi     # 0x52c20
movq %rax, %rdi
callq 0xb520
leaq 0x24d46(%rip), %rsi     # 0x52c81
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
movq (%r14), %rdi
addq $0x20, %rdi
callq 0xb3e0
leaq 0x10(%rsp), %rdi
callq 0xb230
jmp 0x2df65
movb $0x1, %bl
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x38
popq %rdi
callq 0xb540
movq %rbx, 0x8(%rax)
leaq 0x28(%rax), %rcx
movq %rcx, 0x18(%rax)
andq $0x0, 0x20(%rax)
movb $0x0, 0x28(%rax)
leaq 0x456b6(%rip), %rcx     # 0x73938
movq %rcx, (%rax)
movb $0x1, 0x10(%rax)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
testq %rsi, %rsi
je 0x2e2f8
movq %rsi, %rbx
movq (%rsi), %rax
movq -0x8(%rax), %rdi
leaq 0x455a5(%rip), %rsi     # 0x73880
callq 0x2f09a
movl %eax, %ebp
testb %al, %al
je 0x2e2ef
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0xb5e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
pushq $0x7c
popq %rbp
movq 0x20(%r14), %rdx
movq 0x28(%r14), %rax
movq 0x8(%r14), %r15
addq %rax, %r15
subq %rax, %rdx
movq %r15, %rdi
movl %ebp, %esi
callq 0xb5f0
testq %rax, %rax
jne 0x2e346
movq 0x38(%r14), %rax
testq %rax, %rax
je 0x2e315
movq %r14, %rdi
callq *%rax
jmp 0x2e315
leaq 0x20(%rsp), %r12
andq $0x0, (%r12)
movq %rax, %rbp
subq %r15, %rbp
leaq 0x10(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rsp, %r13
movq %r13, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x1a1f2
movq (%r13), %rdi
leaq 0x22165(%rip), %rsi     # 0x504e0
movq %r12, %rdx
xorl %eax, %eax
callq 0xb510
movq 0x28(%r14), %rax
addq %rbp, %rax
incq %rax
movq %rax, 0x28(%r14)
movq (%r12), %r14
testq %r14, %r14
jne 0x2e415
leaq 0x2493a(%rip), %rsi     # 0x52cdd
movq %rbx, %rdi
callq 0xba40
leaq 0x471ce(%rip), %r15     # 0x75580
movq (%r15), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x2e415
addq $0x20, %rdi
callq 0xb800
movq (%r15), %rax
movq 0x8(%rax), %rdi
leaq 0x22db5(%rip), %rsi     # 0x51188
callq 0xb520
leaq 0x24841(%rip), %rsi     # 0x52c20
movq %rax, %rdi
callq 0xb520
leaq 0x24905(%rip), %rsi     # 0x52cf3
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
movq %rbx, %rsi
callq 0xb490
movq %rax, %rdi
callq 0xb270
movq (%r15), %rdi
addq $0x20, %rdi
callq 0xb3e0
movq %rsp, %rdi
callq 0xb230
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
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 0x230dc(%rip), %rdx     # 0x51545
movq %r14, %rsi
xorl %eax, %eax
callq 0xb900
movslq %eax, %r15
cmpq %r15, %r14
jge 0x2e50c
leaq 0x470fa(%rip), %r12     # 0x75580
movq (%r12), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x2e50c
addq $0x20, %rdi
callq 0xb800
movq (%r12), %rax
movq 0x18(%rax), %rdi
leaq 0x230a0(%rip), %rsi     # 0x51549
callq 0xb520
leaq 0x24858(%rip), %rsi     # 0x52d0d
movq %rax, %rdi
callq 0xb520
leaq 0x22e80(%rip), %rsi     # 0x51344
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
movl $0xe3, %esi
callq 0xb990
leaq 0x23091(%rip), %rsi     # 0x51571
movq %rax, %rdi
callq 0xb520
leaq 0x249a1(%rip), %rsi     # 0x52e90
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
movq (%r12), %rdi
addq $0x20, %rdi
callq 0xb3e0
cmpq %r15, %r14
cmovlq %r14, %r15
addq %r15, 0x20(%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x8(%rsp), %rbp
movq %rbp, %rdi
movq %rcx, %rsi
callq 0xb750
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
leaq 0x8(%rsp), %rdi
callq 0xb230
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov.cc
// Function: scdc_dataprov::dataset_cmds_do_cmd(scdc_dataset*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, _scdc_dataset_inout_t*, _scdc_dataset_inout_t*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool scdc_dataprov::dataset_cmds_do_cmd(scdc_dataset *dataset, const std::string &cmd, const std::string &params, scdc_dataset_input_t *input, scdc_dataset_output_t *output, scdc_result &result)
{
  SCDC_TRACE("dataset_cmds_do_cmd: cmd: '" << cmd << "', params: '" << params << "'");

  dataset_cmds_t::iterator i = dataset_cmds.find(string(cmd));

  if (i == dataset_cmds.end())
  {
    result = "command '" + cmd + "' not implemented";
    SCDC_FAIL(__func__ << ": " << result);
    return false;
  }

  dataset_cmds_do_cmd_f do_cmd = i->second;

  bool ret = (dataset->*do_cmd)(params, input, output, result);

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

  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movq %rcx, %r12
movq %rdx, %rbp
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x28(%rdi), %r14
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0xb750
movq %r14, %rdi
movq %r15, %rsi
callq 0x2f182
movq %rax, %r14
movq 0x90(%rsp), %r15
leaq 0x18(%rsp), %rdi
callq 0xb230
addq $0x30, %rbx
cmpq %rbx, %r14
je 0x2ef22
movq 0x40(%r14), %rax
addq 0x48(%r14), %r13
testb $0x1, %al
je 0x2ef08
movq (%r13), %rcx
movq -0x1(%rcx,%rax), %rax
movq %r13, %rdi
movq %r12, %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq %r15, %r8
callq *%rax
jmp 0x2efea
leaq 0x24d08(%rip), %rsi     # 0x53c31
leaq 0x38(%rsp), %rbx
movq %rbx, %rdi
movq %rbp, %rdx
callq 0x19ae2
leaq 0x23e41(%rip), %rdx     # 0x52d81
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x1cb18
leaq 0x18(%rsp), %rbx
movq %r15, %rdi
movq %rbx, %rsi
callq 0xb690
movq %rbx, %rdi
callq 0xb230
leaq 0x38(%rsp), %rdi
callq 0xb230
leaq 0x4660a(%rip), %rbx     # 0x75580
movq (%rbx), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x2efe8
addq $0x20, %rdi
callq 0xb800
movq (%rbx), %rax
movq 0x8(%rax), %rdi
leaq 0x221f1(%rip), %rsi     # 0x51188
callq 0xb520
leaq 0x23c7d(%rip), %rsi     # 0x52c20
movq %rax, %rdi
callq 0xb520
leaq 0x23de1(%rip), %rsi     # 0x52d93
movq %rax, %rdi
callq 0xb520
leaq 0x25ae2(%rip), %rsi     # 0x54aa3
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
movq %r15, %rsi
callq 0xb490
movq %rax, %rdi
callq 0xb270
movq (%rbx), %rdi
addq $0x20, %rdi
callq 0xb3e0
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
jmp 0x2f00b
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
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 0x1a132
leaq 0x2231d(%rip), %rsi     # 0x52f16
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x218cd
leaq 0x22756(%rip), %rdx     # 0x53363
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1cb18
leaq 0x48(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb690
movq %r14, %rdi
callq 0xb230
leaq 0x8(%rsp), %rdi
callq 0xb230
leaq 0x28(%rsp), %rdi
callq 0xb230
movb $0x1, %al
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xb230
jmp 0x30c64
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_bench.cc
// Function: scdc_dataset_bench::do_cmd_put(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_put(const string &params, scdc_dataset_input_t *input, scdc_dataset_output_t *output, scdc_result &result)
    {
      SCDC_TRACE("dataset_bench: do_cmd_put: '" << params << "'");

      string p = trim(params);

      scdcint_t total_size = (p.size() > 0)?atoll(p.c_str()):-1;

      FILE *file = 0;

      if (mode == "file") file = fopen("/dev/null", "w");

      bool ret = true;

      while (ret)
      {
        /* min of data left and current size */
        scdcint_t size = min(total_size, SCDC_DATASET_INOUT_BUF_CURRENT(input));

        SCDC_TRACE("do_cmd_put: put data of size = " << size);

        if (file) size = fwrite(SCDC_DATASET_INOUT_BUF_PTR(input), 1, size, file);

        total_size -= size;

        if (!input->next || total_size == 0) break;

        ret = input->next(input, 0);
      }

      if (file) fclose(file);

      return true;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rdi, %r15
movq %rsp, %r12
movq %r12, %rdi
callq 0xb750
leaq 0x21304(%rip), %rsi     # 0x524bb
pushq $-0x1
popq %r14
movq %r12, %rdi
movq %r14, %rdx
callq 0xb9e0
cmpq $-0x1, %rax
je 0x311df
incq %rax
movq %rsp, %rdi
pushq $-0x1
popq %rdx
movq %rax, %rsi
callq 0xb0e0
jmp 0x311ec
andq $0x0, 0x8(%rsp)
movq (%rsp), %rax
movb $0x0, (%rax)
leaq 0x212c8(%rip), %rsi     # 0x524bb
movq %rsp, %r12
movq %r12, %rdi
xorl %edx, %edx
callq 0xb300
movq %r12, %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0xb0e0
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0xb750
movq %rsp, %rdi
callq 0xb230
cmpq $0x0, 0x28(%rsp)
je 0x31237
movq 0x20(%rsp), %rdi
callq 0xb410
movq %rax, %r14
addq $0x78, %r15
leaq 0x213cc(%rip), %rsi     # 0x5260e
movq %r15, %rdi
callq 0x19be0
testb %al, %al
je 0x31266
leaq 0x211be(%rip), %rdi     # 0x52413
leaq 0x213e9(%rip), %rsi     # 0x52645
callq 0xb660
movq %rax, %r15
jmp 0x31269
xorl %r15d, %r15d
movb $0x1, %al
pushq $0x1
popq %r12
testb $0x1, %al
je 0x312b8
movq 0x20(%rbx), %r13
cmpq %r14, %r13
cmovgeq %r14, %r13
testq %r15, %r15
je 0x31298
movq 0x10(%rbx), %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r15, %rcx
callq 0xba80
movq %rax, %r13
movq 0x38(%rbx), %rax
testq %rax, %rax
je 0x312b8
cmpq %r13, %r14
je 0x312b8
movq %rbx, %rdi
xorl %esi, %esi
callq *%rax
subq %r13, %r14
testq %rax, %rax
setne %al
jmp 0x3126f
testq %r15, %r15
je 0x312c5
movq %r15, %rdi
callq 0xb530
leaq 0x20(%rsp), %rdi
callq 0xb230
movb $0x1, %al
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
jmp 0x312ef
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x18
popq %rdx
movq %r14, %rdi
callq 0xb8e0
movq %rsp, %rsi
movq %r14, %rdi
callq 0xb780
leaq 0x8(%rsp), %rdi
callq 0xb3d0
movq (%rsp), %r12
movq %r12, 0x28(%rbx)
movb $0x78, 0x30(%rbx)
pushq $0x50
popq %rdi
callq 0xb540
movq %rax, %r14
xorps %xmm0, %xmm0
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
movb %al, 0x18(%r14)
leaq 0x28(%r14), %r13
leaq 0x38(%r14), %rcx
movq %rcx, 0x28(%r14)
movb %al, 0x38(%r14)
movq %r12, (%r14)
leaq 0x38(%r15), %rsi
callq 0xb2e0
leaq 0x58(%r15), %r12
movq %r13, %rdi
movq %r12, %rsi
callq 0xb2e0
addq $0x78, %r15
leaq 0x21265(%rip), %rsi     # 0x5260e
movq %r15, %rdi
callq 0x19be0
testb %al, %al
je 0x313fb
leaq 0x21bd4(%rip), %rsi     # 0x52f90
movq %r12, %rdi
callq 0x19be0
testb %al, %al
je 0x313d1
leaq 0x21bbc(%rip), %rdi     # 0x52f8b
jmp 0x313eb
leaq 0x21bc3(%rip), %rsi     # 0x52f9b
movq %r12, %rdi
callq 0x19be0
testb %al, %al
je 0x313fb
leaq 0x21baa(%rip), %rdi     # 0x52f95
leaq 0x1f415(%rip), %rsi     # 0x50807
callq 0xb660
movq %rax, 0x48(%r14)
leaq -0x4b6(%rip), %rax      # 0x30f4c
movq %rax, 0x38(%rbx)
movq %r14, 0x40(%rbx)
movq %rbx, %rdi
callq 0x30f4c
movb $0x1, %al
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xb3d0
movq %rbx, %rdi
callq 0xb9a0
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_fs2.cc
// Function: scdc_dataprov_fs2::open(char const*, scdc_args*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool do_cmd_cd(const string &params, scdc_dataset_input_t *input, scdc_dataset_output_t *output, scdc_result &result)
    {
      SCDC_TRACE("do_cmd_cd: params: '" << params << "'");

#if SCDC_DATASET_FS_LEAVE_PWD_OPEN
      close_pwd_file();
#endif

      bool ret = scdc_dataset::do_cmd_cd(params, input, output, result);

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

      return ret;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x8(%rdx), %rax
testq %rax, %rax
je 0x372f6
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdx), %rdi
pushq $0x4
popq %rsi
leaq 0x10(%rsp), %rdx
callq *%rax
testq %rax, %rax
je 0x372f6
movq 0x10(%rsp), %rdi
callq 0x2d93f
testq %rax, %rax
je 0x37363
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x2deba
testb %al, %al
je 0x373c7
movq 0x10(%rsp), %rsi
leaq 0x18(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
callq 0x1a132
movq %rbx, %rdi
movq %r14, %rsi
callq 0x37428
leaq 0x18(%rsp), %rdi
callq 0xb230
movb $0x1, %al
jmp 0x37357
leaq 0x3e283(%rip), %rbx     # 0x75580
movq (%rbx), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x37355
addq $0x20, %rdi
callq 0xb800
movq (%rbx), %rax
movq 0x18(%rax), %rdi
leaq 0x1a16a(%rip), %rsi     # 0x51488
callq 0xb520
leaq 0x1bf36(%rip), %rsi     # 0x53260
movq %rax, %rdi
callq 0xb520
leaq 0x1bf35(%rip), %rsi     # 0x5326e
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
movq (%rbx), %rdi
addq $0x20, %rdi
callq 0xb3e0
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x3e216(%rip), %rbx     # 0x75580
movq (%rbx), %rdi
cmpq $0x0, 0x18(%rdi)
je 0x37355
addq $0x20, %rdi
callq 0xb800
movq (%rbx), %rax
movq 0x18(%rax), %rdi
leaq 0x1a0fd(%rip), %rsi     # 0x51488
callq 0xb520
leaq 0x1bec9(%rip), %rsi     # 0x53260
movq %rax, %rdi
callq 0xb520
leaq 0x1bee5(%rip), %rsi     # 0x5328b
movq %rax, %rdi
callq 0xb520
movq 0x10(%rsp), %rsi
movq %rax, %rdi
callq 0xb520
leaq 0x1bee6(%rip), %rsi     # 0x532a8
jmp 0x37339
leaq 0x3e1b2(%rip), %rbx     # 0x75580
movq (%rbx), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x37355
addq $0x20, %rdi
callq 0xb800
movq (%rbx), %rax
movq 0x8(%rax), %rdi
leaq 0x19d95(%rip), %rsi     # 0x51188
callq 0xb520
leaq 0x1be61(%rip), %rsi     # 0x53260
movq %rax, %rdi
callq 0xb520
leaq 0x1b6cf(%rip), %rsi     # 0x52add
jmp 0x37339
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x40, %rsp
movq %rcx, %rbx
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
cmpq $0x0, 0x8(%rdx)
je 0x37779
movq %rdx, %r14
movq (%rdx), %rax
cmpb $0x2f, (%rax)
je 0x3776c
leaq 0x19c03(%rip), %rdx     # 0x5134d
leaq 0x20(%rsp), %rdi
callq 0x1d867
movq %rsp, %rdi
leaq 0x20(%rsp), %r15
movq %r15, %rsi
callq 0xb690
movq %r15, %rdi
callq 0xb230
movq %rsp, %rdi
movq %r14, %rsi
callq 0xba90
jmp 0x37781
movq %rsp, %rdi
callq 0xb2e0
movq (%rsp), %rdi
movq %rbx, %rsi
callq 0x1af63
cmpq $0x0, 0x8(%rbx)
je 0x377b4
movq (%rbx), %rax
cmpb $0x2f, (%rax)
jne 0x377b4
pushq $0x1
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xb0e0
movq %rbx, %rdi
movq %rax, %rsi
callq 0xb2e0
leaq 0x19b94(%rip), %rsi     # 0x5134f
movq %rbx, %rdi
callq 0xb130
testl %eax, %eax
setne %bl
movq %rsp, %rdi
callq 0xb230
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x377de
movq %rax, %rbx
movq %rsp, %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %rax
movq %rdi, %r14
leaq 0x18(%rsp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
movb $0x0, (%rcx)
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x1af63
leaq 0x19a53(%rip), %rsi     # 0x5134d
leaq 0x8(%rsp), %rdi
callq 0xba30
movq 0x8(%rsp), %r15
movq 0x68(%r14), %rsi
movq 0x70(%r14), %r14
movq %r15, %rdi
movq %r14, %rdx
callq 0xb260
movl %eax, %ebp
testl %eax, %eax
je 0x3793e
testl %ebp, %ebp
sete %bl
leaq 0x8(%rsp), %rdi
callq 0xb230
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
addq %r14, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0xba40
pushq $0x1
popq %r14
movq 0x8(%rbx), %rsi
cmpq $0x2, %rsi
jb 0x37922
movq (%rbx), %rax
cmpb $0x2f, -0x1(%rax,%rsi)
jne 0x37922
decq %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xb0e0
jmp 0x37950
jmp 0x37976
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xb230
movq %rbx, %rdi
callq 0xb9a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
cmpq $0x0, 0x40(%rdi)
je 0x3a5c4
leaq 0x48(%rbx), %rdi
movq %r14, %rsi
callq 0x1d83e
testb %al, %al
je 0x3a5c4
testl %ebp, %ebp
je 0x3a5b9
movl 0x68(%rbx), %eax
cmpl %eax, %ebp
setne %cl
cmpl $0x3, %eax
setne %dl
testb %dl, %cl
jne 0x3a5c2
movq 0x40(%rbx), %r15
jmp 0x3a66b
orl %eax, %ebp
movq %rbx, %rdi
callq 0x3a67a
cmpl $0x3, %ebp
ja 0x3a641
movl %ebp, %eax
leaq 0x18c76(%rip), %rcx     # 0x53250
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1621d(%rip), %rsi     # 0x50807
pushq $0x1
jmp 0x3a635
movq (%r14), %rdi
callq 0x2d91c
xorl %ebp, %ebp
testq %rax, %rax
sete %bpl
leaq 0x1803f(%rip), %rax     # 0x52645
leaq 0x18035(%rip), %rsi     # 0x52642
cmoveq %rax, %rsi
xorl $0x3, %ebp
jmp 0x3a643
movq (%r14), %rdi
callq 0x2d91c
testq %rax, %rax
leaq 0x18dfc(%rip), %rax     # 0x53424
leaq 0x18013(%rip), %rsi     # 0x52642
cmoveq %rax, %rsi
pushq $0x3
popq %rbp
jmp 0x3a643
leaq 0x161c8(%rip), %rsi     # 0x50807
jmp 0x3a643
xorl %esi, %esi
movq (%r14), %rdi
callq 0xb660
testq %rax, %rax
je 0x3a668
movq %rax, %r15
movq %rax, 0x40(%rbx)
leaq 0x48(%rbx), %rdi
movq %r14, %rsi
callq 0xb2e0
movl %ebp, 0x68(%rbx)
jmp 0x3a66b
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/mh0fm4[P]SCDC/src/components/dataprov/dataprov_fs2.cc
// Function: scdc_dataset_fs2::close_pwd_file()
void close_pwd_file()
    {
      if (pwd_FILE) fclose(pwd_FILE);

      pwd_FILE = 0;
      pwd_FILE_path.clear();
      pwd_FILE_mode = 0;
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0x3a68c
callq 0xb530
andq $0x0, 0x40(%rbx)
andq $0x0, 0x50(%rbx)
movq 0x48(%rbx), %rax
movb $0x0, (%rax)
andl $0x0, 0x68(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x70(%rdi), %rax
testq %rax, %rax
je 0x3b158
movq 0xb8(%r14), %rdi
callq *%rax
cmpq $0x1, %rax
je 0x3b158
leaq 0x3a480(%rip), %r15     # 0x75580
movq (%r15), %rdi
cmpq $0x0, 0x8(%rdi)
je 0x3b158
addq $0x20, %rdi
callq 0xb800
movq (%r15), %rax
movq 0x8(%rax), %rdi
leaq 0x16067(%rip), %rsi     # 0x51188
callq 0xb520
leaq 0x186f5(%rip), %rsi     # 0x53822
movq %rax, %rdi
callq 0xb520
leaq 0x18742(%rip), %rsi     # 0x5387e
movq %rax, %rdi
callq 0xb520
movq %rax, %rdi
callq 0xb270
movq (%r15), %rdi
addq $0x20, %rdi
callq 0xb3e0
movq %r14, %rdi
callq 0x21786
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x2df86