LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_output_destroy
void scdc_dataset_output_destroy(scdc_dataset_output_t *output)
{
  SCDC_TRACE_DATASET_OUTPUT(output, "scdc_dataset_output_destroy: ");

  if (!output)
  {
    SCDC_FAIL("scdc_dataset_output_destroy: no output given");
    return;
  }

  if (!output->intern) return;

  INOUT_INTERN_RESTORE(output);

  if (output->intern->destroy) output->intern->destroy(output);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
jmp 0x46bce
cmpq $0x0, -0x8(%rbp)
jne 0x46c5d
jmp 0x46bdb
leaq 0x8dac6(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
cmpq $0x0, %rax
je 0x46c59
leaq 0x8dab1(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25800
leaq 0x8daa2(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
movq %rax, %rdi
leaq 0x5f598(%rip), %rsi     # 0xa61b0
callq 0xc670
movq %rax, %rdi
leaq 0x60455(%rip), %rsi     # 0xa707c
callq 0xc670
movq %rax, %rdi
leaq 0x604b9(%rip), %rsi     # 0xa70ef
callq 0xc670
movq %rax, %rdi
movq 0x8d37b(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x8da57(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25820
jmp 0x46c5b
jmp 0x46cc2
movq -0x8(%rbp), %rax
cmpq $0x0, 0x48(%rax)
jne 0x46c6a
jmp 0x46cc2
jmp 0x46c6c
movq -0x8(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x46c9f
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
jmp 0x46ca1
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
cmpq $0x0, 0x20(%rax)
je 0x46cc2
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_input_redirect_intern
scdcint_t scdc_dataset_input_redirect_intern(scdc_dataset_input_t *input, const char *conf, scdc_args_t *args)
{
  SCDC_TRACE("scdc_dataset_input_redirect_intern: conf: '" << conf << "'");

  if (!input)
  {
    SCDC_FAIL("scdc_dataset_input_redirect_intern: no input given");
    return SCDC_FAILURE;
  }

  return scdc_dataset_inout_redirect_intern(input, conf, args);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
jmp 0x46d86
cmpq $0x0, -0x10(%rbp)
jne 0x46e1d
jmp 0x46d93
leaq 0x8d90e(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
cmpq $0x0, %rax
je 0x46e11
leaq 0x8d8f9(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25800
leaq 0x8d8ea(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
movq %rax, %rdi
leaq 0x5f3e0(%rip), %rsi     # 0xa61b0
callq 0xc670
movq %rax, %rdi
leaq 0x6029d(%rip), %rsi     # 0xa707c
callq 0xc670
movq %rax, %rdi
leaq 0x6032e(%rip), %rsi     # 0xa711c
callq 0xc670
movq %rax, %rdi
movq 0x8d1c3(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x8d89f(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25820
jmp 0x46e13
movq $0x0, -0x8(%rbp)
jmp 0x46e32
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x46e40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_inout_redirect_intern(_scdc_dataset_inout_t*, char const*, _scdc_args_t*)
static scdcint_t scdc_dataset_inout_redirect_intern(scdc_dataset_inout_t *inout, const char *conf, scdc_args_t *args)
{
  stringlist confs(':', conf);
  if (confs.front() == "from")
  {
    confs.front_pop();
    conf += confs.offset();
    
    return scdc_dataset_inout_redirect_from(inout, conf, args);
  }

  if (confs.front() == "to")
  {
    confs.front_pop();
    conf += confs.offset();
  }

  return scdc_dataset_inout_redirect_to(inout, conf, args);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdx
leaq -0x48(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
movl $0x3a, %esi
movq $-0x1, %rcx
callq 0x25a70
movq -0xe8(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x267a0
jmp 0x46e89
leaq 0x60843(%rip), %rsi     # 0xa76d3
leaq -0x68(%rbp), %rdi
callq 0x25b80
movb %al, -0xe9(%rbp)
jmp 0x46ea1
leaq -0x68(%rbp), %rdi
callq 0xc3e0
movb -0xe9(%rbp), %al
testb $0x1, %al
jne 0x46eb9
jmp 0x46f5a
leaq -0x98(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x25b00
jmp 0x46ecb
leaq -0x98(%rbp), %rdi
callq 0xc3e0
leaq -0x48(%rbp), %rdi
callq 0x4d120
movq %rax, -0xf8(%rbp)
jmp 0x46ee9
movq -0xf8(%rbp), %rcx
movq -0x18(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4c740
movq %rax, -0x100(%rbp)
jmp 0x46f15
movq -0x100(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x9c(%rbp)
jmp 0x47029
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x4703f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xc3e0
jmp 0x4703f
leaq -0xc0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x267a0
jmp 0x46f6c
leaq 0x60765(%rip), %rsi     # 0xa76d8
leaq -0xc0(%rbp), %rdi
callq 0x25b80
movb %al, -0x101(%rbp)
jmp 0x46f87
leaq -0xc0(%rbp), %rdi
callq 0xc3e0
movb -0x101(%rbp), %al
testb $0x1, %al
jne 0x46f9f
jmp 0x46ffa
leaq -0xe0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x25b00
jmp 0x46fb1
leaq -0xe0(%rbp), %rdi
callq 0xc3e0
leaq -0x48(%rbp), %rdi
callq 0x4d120
movq %rax, -0x110(%rbp)
jmp 0x46fcf
movq -0x110(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x46ffa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0xc3e0
jmp 0x4703f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x4cb30
movq %rax, -0x118(%rbp)
jmp 0x47014
movq -0x118(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x9c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x25c90
movq -0x8(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
leaq -0x48(%rbp), %rdi
callq 0x25c90
movq -0x70(%rbp), %rdi
callq 0xcba0
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_input_redirect
scdcint_t scdc_dataset_input_redirect(scdc_dataset_input_t *input, const char *conf, ...)
{
  va_list ap;
  va_start(ap, conf);

  scdc_args_t args;

  scdc_args_va_init(&args, &ap);

  scdcint_t ret = scdc_dataset_input_redirect_intern(input, conf, &args);

  scdc_args_va_release(&args);
  va_end(ap);

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
testb %al, %al
je 0x470a1
movaps %xmm0, -0xe0(%rbp)
movaps %xmm1, -0xd0(%rbp)
movaps %xmm2, -0xc0(%rbp)
movaps %xmm3, -0xb0(%rbp)
movaps %xmm4, -0xa0(%rbp)
movaps %xmm5, -0x90(%rbp)
movaps %xmm6, -0x80(%rbp)
movaps %xmm7, -0x70(%rbp)
movq %r9, -0xe8(%rbp)
movq %r8, -0xf0(%rbp)
movq %rcx, -0xf8(%rbp)
movq %rdx, -0x100(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x110(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x30, -0x2c(%rbp)
movl $0x10, -0x30(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x118(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x45590
movq -0x118(%rbp), %rdx
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x46d70
movq -0x118(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0x45600
movq -0x58(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
nopl (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_output_redirect_intern
scdcint_t scdc_dataset_output_redirect_intern(scdc_dataset_output_t *output, const char *conf, scdc_args_t *args)
{
  SCDC_TRACE("scdc_dataset_output_redirect_intern: conf: '" << conf << "'");

  if (!output)
  {
    SCDC_FAIL("scdc_dataset_output_redirect_intern: no output given");
    return SCDC_FAILURE;
  }

  return scdc_dataset_inout_redirect_intern(output, conf, args);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
jmp 0x47146
cmpq $0x0, -0x10(%rbp)
jne 0x471dd
jmp 0x47153
leaq 0x8d54e(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
cmpq $0x0, %rax
je 0x471d1
leaq 0x8d539(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25800
leaq 0x8d52a(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x257e0
movq %rax, %rdi
leaq 0x5f020(%rip), %rsi     # 0xa61b0
callq 0xc670
movq %rax, %rdi
leaq 0x5fedd(%rip), %rsi     # 0xa707c
callq 0xc670
movq %rax, %rdi
leaq 0x5ffa1(%rip), %rsi     # 0xa714f
callq 0xc670
movq %rax, %rdi
movq 0x8ce03(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x8d4df(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x25820
jmp 0x471d3
movq $0x0, -0x8(%rbp)
jmp 0x471f2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x46e40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_inout_alloc_create(_scdc_dataset_inout_t*, char const*, _scdc_args_t*)
static scdc_dataset_inout_t *scdc_dataset_inout_alloc_create(scdc_dataset_inout_t *inout, const char *conf, scdc_args_t *args)
{
  scdcint_t size = DEFAULT_DATASET_INOUT_BUF_SIZE;

  stringlist confs(':', conf);
  scdc_args xargs(args);

  if (confs.front() == "size")
  {
    xargs.get<scdcint_t>(SCDC_ARGS_TYPE_SCDCINT, &size);
    confs.front_pop();
  }

  if (!scdc_dataset_inout_alloc(inout, size, 0)) return 0;

  inout->intern->type = SCDC_DATASET_INOUT_TYPE_ALLOC;
  inout->intern->destroy = scdc_dataset_inout_alloc_destroy;

  return inout;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x4000, -0x28(%rbp)    # imm = 0x4000
movq -0x18(%rbp), %rdx
leaq -0x50(%rbp), %rdi
movl $0x3a, %esi
movq $-0x1, %rcx
callq 0x25a70
movq -0x20(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x25660
jmp 0x4734a
leaq -0xb8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x267a0
jmp 0x4735c
leaq 0x60211(%rip), %rsi     # 0xa7574
leaq -0xb8(%rbp), %rdi
callq 0x25b80
movb %al, -0xdd(%rbp)
jmp 0x47377
leaq -0xb8(%rbp), %rdi
callq 0xc3e0
movb -0xdd(%rbp), %al
testb $0x1, %al
jne 0x47392
jmp 0x4741c
leaq -0x88(%rbp), %rdi
movl $0x2, %esi
leaq -0x28(%rbp), %rdx
xorl %ecx, %ecx
callq 0x4d170
jmp 0x473ab
leaq -0xd8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x25b00
jmp 0x473bd
leaq -0xd8(%rbp), %rdi
callq 0xc3e0
jmp 0x4741c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x474b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x474ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0xc3e0
jmp 0x474ac
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x47500
movb %al, -0xde(%rbp)
jmp 0x47435
movb -0xde(%rbp), %al
testb $0x1, %al
jne 0x47455
jmp 0x47441
movq $0x0, -0x8(%rbp)
movl $0x1, -0xdc(%rbp)
jmp 0x4748a
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq $0x2, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
leaq 0x16c(%rip), %rcx       # 0x475e0
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0xdc(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x256b0
leaq -0x50(%rbp), %rdi
callq 0x25c90
movq -0x8(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x88(%rbp), %rdi
callq 0x256b0
leaq -0x50(%rbp), %rdi
callq 0x25c90
movq -0x90(%rbp), %rdi
callq 0xcba0
nopl (%rax)
// File: mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_inout_alloc(_scdc_dataset_inout_t*, long long, long long)
static bool scdc_dataset_inout_alloc(scdc_dataset_inout_t *inout, scdcint_t buf_size, scdcint_t data_size)
{
  if (!inout) return false;

  if (inout->intern) return true;

  scdcint_t alloc_size = sizeof(scdc_dataset_inout_intern_t) + data_size + buf_size;

#if USE_DEBUG
  char *b = static_cast<char *>(calloc(alloc_size, 1));
#else
  char *b = static_cast<char *>(malloc(alloc_size));
#endif

  if (!b) return false;

  inout->intern = (scdc_dataset_inout_intern_t *) b;
  b += sizeof(scdc_dataset_inout_intern_t);

  inout->intern->alloc_size = alloc_size;

  if (data_size > 0)
  {
    inout->data = b;
    b += data_size;
  }

  if (buf_size > 0)
  {
    SCDC_DATASET_INOUT_BUF_PTR(inout) = b;
    SCDC_DATASET_INOUT_BUF_SIZE(inout) = buf_size;
  }

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x47524
movb $0x0, -0x1(%rbp)
jmp 0x475d0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x47538
movb $0x1, -0x1(%rbp)
jmp 0x475d0
movq -0x20(%rbp), %rax
addq $0x28, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0xc420
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x47567
movb $0x0, -0x1(%rbp)
jmp 0x475d0
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x30(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x20(%rbp)
jle 0x475ad
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x20(%rbp), %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
jle 0x475cc
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_inout_free(_scdc_dataset_inout_t*)
static void scdc_dataset_inout_free(scdc_dataset_inout_t *inout)
{
  free(inout->intern);
  
  inout->intern = 0;
  
  SCDC_DATASET_INOUT_BUF_PTR(inout) = 0;

  inout->data = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0xc830
movq -0x8(%rbp), %rax
movq $0x0, 0x48(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: long long input_FX_next<int>(_scdc_dataset_inout_t*, _scdc_result_t*)
static scdcint_t input_FX_next(scdc_dataset_input_t *input, scdc_result_t *result)
{
  inout_FX_data_t<T> *data = static_cast<inout_FX_data_t<T> *>(input->data);

  size_t n = SCDC_DATASET_INOUT_BUF_SIZE(input);

  if (data->chunk_size >= 0) n = z_min(static_cast<scdcint_t>(n), data->chunk_size);

  if (data->size_left >= 0) n = z_min(static_cast<scdcint_t>(n), data->size_left);

  n = data->read(SCDC_DATASET_INOUT_BUF_PTR(input), n);

  data->size_left -= n;

  /* set to the number of bytes read in buf */
  SCDC_DATASET_INOUT_BUF_CURRENT(input) = n;

  if (input->total_size_given == SCDC_DATASET_INOUT_TOTAL_SIZE_GIVEN_AT_LEAST) input->total_size += n;

  if (data->eof(n) || data->size_left == 0)
  {
    input->total_size_given = SCDC_DATASET_INOUT_TOTAL_SIZE_GIVEN_EXACT;
    input->next = 0;
  }

  return SCDC_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jl 0x4839f
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x4838b
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x48397
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jl 0x483d6
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jge 0x483c2
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x483ce
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x43440
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movsbl 0x30(%rax), %eax
cmpl $0x6c, %eax
jne 0x4842b
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
addq 0x28(%rax), %rcx
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x43500
cmpq $0x0, %rax
jne 0x48449
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x4845d
movq -0x8(%rbp), %rax
movb $0x78, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_input_streamdup_destroy(_scdc_dataset_inout_t*)
static void scdc_dataset_input_streamdup_destroy(scdc_dataset_input_t *input)
{
  if (!input) return;

  FILE *stream;

  scdc_dataset_input_FX_destroy<FILE *>(input, &stream);

  int fddup = fileno(stream);
  fclose(stream);
  close(fddup);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x49335
jmp 0x4935f
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x492d0
movq -0x10(%rbp), %rdi
callq 0xc6f0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc680
movl -0x14(%rbp), %edi
callq 0xccd0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_input_fslist_destroy(_scdc_dataset_inout_t*)
static void scdc_dataset_input_fslist_destroy(scdc_dataset_input_t *input)
{
  if (!input) return;

  if (input->intern->type == SCDC_DATASET_INOUT_TYPE_FSLIST_DIR)
    scdc_dataset_input_fslist_dir_destroy(input);
  else if (input->intern->type == SCDC_DATASET_INOUT_TYPE_FSLIST_FILE)
    scdc_dataset_input_fslist_file_destroy(input);
  else if (input->intern->type == SCDC_DATASET_INOUT_TYPE_FSLIST_LINK)
    scdc_dataset_input_fslist_link_destroy(input);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x49e05
jmp 0x49e55
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
cmpq $0xa, 0x8(%rax)
jne 0x49e1f
movq -0x8(%rbp), %rdi
callq 0x4a260
jmp 0x49e55
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
cmpq $0xb, 0x8(%rax)
jne 0x49e39
movq -0x8(%rbp), %rdi
callq 0x4a2a0
jmp 0x49e53
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
cmpq $0xc, 0x8(%rax)
jne 0x49e51
movq -0x8(%rbp), %rdi
callq 0x4a2d0
jmp 0x49e53
jmp 0x49e55
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_input_fslist_dir_destroy(_scdc_dataset_inout_t*)
static void scdc_dataset_input_fslist_dir_destroy(scdc_dataset_input_t *input)
{
  if (!input) return;

  input_fslist_dir_data_t *data = static_cast<input_fslist_dir_data_t *>(input->data);

  closedir(data->dir);
  
  scdc_dataset_inout_free(input);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x4a275
jmp 0x4a29a
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x108(%rax), %rdi
callq 0xcb00
movq -0x8(%rbp), %rdi
callq 0x47610
addq $0x10, %rsp
popq %rbp
retq
// File: mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: input_produce_next(_scdc_dataset_inout_t*, _scdc_result_t*)
static scdcint_t input_produce_next(scdc_dataset_input_t *input, scdc_result_t *result)
{
  input_produce_data_t *data = static_cast<input_produce_data_t *>(input->data);

  SCDC_DATASET_INOUT_BUF_CURRENT(input) = min(data->total_size_left, SCDC_DATASET_INOUT_BUF_SIZE(input));

  memset(SCDC_DATASET_INOUT_BUF_PTR(input), 0, SCDC_DATASET_INOUT_BUF_CURRENT(input));

  data->total_size_left -= SCDC_DATASET_INOUT_BUF_CURRENT(input);

  if (data->total_size_left <= 0) input->next = 0;

  return SCDC_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
addq $0x18, %rsi
callq 0x2b080
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdx
xorl %esi, %esi
callq 0xc350
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rcx
subq %rdx, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jg 0x4a3aa
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
movl $0x1, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: autodestroy_un_pack(_scdc_dataset_inout_t*, long long (*)(_scdc_dataset_inout_t*, _scdc_result_t*))
static void autodestroy_un_pack(scdc_dataset_inout_t *inout, scdc_dataset_inout_next_f *next)
{
  SCDC_TRACE("autodestroy_un_pack: " << (next?"pack":"unpack") << ", IN next: " << reinterpret_cast<void *>(inout->next) << ", data: " << inout->data);

  if (next)
  {
    autodestroy_data_t *data = new autodestroy_data_t();

    data->next = inout->next;
    data->data = inout->data;

    inout->next = next;
    inout->data = data;

  } else
  {
    autodestroy_data_t *data = static_cast<autodestroy_data_t *>(inout->data);

    inout->next = data->next;
    inout->data = data->data;

    delete data;
  }

  SCDC_TRACE("autodestroy_un_pack: " << (next?"pack":"unpack") << ", OUT next: " << reinterpret_cast<void *>(inout->next) << ", data: " << inout->data);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
jmp 0x4a3d2
cmpq $0x0, -0x10(%rbp)
je 0x4a437
movl $0x10, %edi
callq 0xc690
movq %rax, %rdi
movq %rdi, -0x28(%rbp)
xorl %esi, %esi
movl $0x10, %edx
callq 0xc350
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
jmp 0x4a480
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x4a47e
movq -0x30(%rbp), %rdi
movl $0x10, %esi
callq 0xc6a0
jmp 0x4a480
jmp 0x4a482
jmp 0x4a484
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: autodestroy_next(_scdc_dataset_inout_t*, _scdc_result_t*)
static scdcint_t autodestroy_next(scdc_dataset_input_t *inout, scdc_result_t *result)
{
  autodestroy_un_pack(inout, 0);

  scdcint_t ret;

  if (inout->next)
  {
    ret = inout->next(inout, 0);
    autodestroy_un_pack(inout, autodestroy_next);

  } else
  {
    if (inout->intern && inout->intern->destroy) inout->intern->destroy(inout);
    SCDC_DATASET_INOUT_BUF_CURRENT(inout) = 0;
    ret = SCDC_SUCCESS;
  }

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4a3c0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x4a4e0
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x8(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %esi
callq *%rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x49(%rip), %rsi       # 0x4a490
callq 0x4a3c0
jmp 0x4a520
movq -0x8(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x4a50c
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
cmpq $0x0, 0x20(%rax)
je 0x4a50c
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq $0x1, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: long long output_FX_next<int>(_scdc_dataset_inout_t*, _scdc_result_t*)
static scdcint_t output_FX_next(scdc_dataset_output_t *output, scdc_result_t *result)
{
  inout_FX_data_t<T> *data = static_cast<inout_FX_data_t<T> *>(output->data);

  size_t n = SCDC_DATASET_INOUT_BUF_CURRENT(output);

  if (data->chunk_size >= 0) n = z_min(static_cast<scdcint_t>(n), data->chunk_size);

  if (data->size_left >= 0) n = z_min(static_cast<scdcint_t>(n), data->size_left);

  n = data->write(SCDC_DATASET_INOUT_BUF_PTR(output), n);

#if SYNC_AFTER_WRITE
  data->sync();
#endif

  data->size_left -= n;

  /* set to the nuber of bytes that have been written */
  SCDC_DATASET_INOUT_BUF_CURRENT(output) = n;

  if (data->size_left == 0)
  {
    output->next = 0;
  }

  return SCDC_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jl 0x4b6df
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jge 0x4b6cb
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x4b6d7
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jl 0x4b716
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jge 0x4b702
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x4b70e
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x43470
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x4b765
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
movl $0x1, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_dataset_output_streamdup_destroy(_scdc_dataset_inout_t*)
static void scdc_dataset_output_streamdup_destroy(scdc_dataset_output_t *output)
{
  if (!output) return;

  FILE *stream;

  scdc_dataset_output_FX_destroy<FILE *>(output, &stream);

  int fddup = fileno(stream);
  fclose(stream);
  close(fddup);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x4c635
jmp 0x4c65f
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x4c5d0
movq -0x10(%rbp), %rdi
callq 0xc6f0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0xc680
movl -0x14(%rbp), %edi
callq 0xccd0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: inout2inout(_scdc_dataset_inout_t*, _scdc_dataset_inout_t*, bool)
static void inout2inout(scdc_dataset_inout_t *src, scdc_dataset_inout_t *dst, bool copy)
{
  strncpy(dst->format, src->format, SCDC_FORMAT_MAX_SIZE);

  scdcint_t size = SCDC_DATASET_INOUT_BUF_CURRENT(src);

  if (copy)
  {
    size = min(size, SCDC_DATASET_INOUT_BUF_SIZE(dst));
    memcpy(SCDC_DATASET_INOUT_BUF_PTR(dst), SCDC_DATASET_INOUT_BUF_PTR(src), size);

  } else
  {
    SCDC_DATASET_INOUT_BUF_PTR(dst) = SCDC_DATASET_INOUT_BUF_PTR(src);
    SCDC_DATASET_INOUT_BUF_SIZE(dst) = SCDC_DATASET_INOUT_BUF_SIZE(src);
  }

  dst->total_size = src->total_size;
  dst->total_size_given = src->total_size_given;

  SCDC_DATASET_INOUT_BUF_CURRENT(dst) = size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x10, %edx
callq 0xc320
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
testb $0x1, -0x11(%rbp)
je 0x4d05e
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
leaq -0x20(%rbp), %rdi
callq 0x2b080
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0xc530
jmp 0x4d07e
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movb 0x30(%rax), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x30(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: mh0fm4[P]SCDC/src/components/dataset/dataset_inout.cc
// Function: scdc_args_get_ior(void*, long long, void*)
static scdc_arg_ref_t scdc_args_get_ior(void *data, scdcint_t type, void *v)
{
  scdc_args_data_ior_t *data_ior = static_cast<scdc_args_data_ior_t *>(data);

  SCDC_TRACE("scdc_args_get_ior: data: " << data << " (inout: <...>, args: " << data_ior->args << "), type: " << type << ", v: " << v);

  if (type == SCDC_ARGS_TYPE_DATASET_INOUT_REDIRECT_PTR)
  {
    *((scdc_dataset_inout_t **) v) = data_ior->inout;
    return SCDC_ARG_REF_NONE;
  }

  return data_ior->args->get(data_ior->args->data, type, v);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x4d0ce
cmpq $0xe, -0x18(%rbp)
jne 0x4d0ee
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x1, %eax
movq %rax, -0x8(%rbp)
jmp 0x4d113
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq (%rcx), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq *%rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: mh0fm4[P]SCDC/src/components/../include/args.hh
// Function: void* scdc_args::get<long long>(long long, long long*, 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
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, 0x8(%rax)
jne 0x4d1a4
movq $0x0, -0x8(%rbp)
jmp 0x4d1f1
movq -0x38(%rbp), %rcx
movq 0x8(%rcx), %rax
movq (%rcx), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq *%rax
movq %rax, -0x30(%rbp)
testb $0x1, -0x21(%rbp)
je 0x4d1e9
cmpq $0x0, -0x30(%rbp)
je 0x4d1e9
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x20(%rbp), %r8
movl $0x1, %ecx
xorl %eax, %eax
movl %eax, %r9d
callq 0x4d200
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/../include/args.hh
// Function: void* scdc_args_string::get<long long>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, long long, long long*)
static scdc_arg_ref_t get(std::string &s_, scdcint_t type, T *v) {
      scdc_arg_ref_t r = SCDC_ARG_REF_NULL;
      if (type == SCDC_ARGS_TYPE_SCDCINT)
      {
        if (sscanf(s_.c_str(), "%" scdcint_fmt, v) == 1) r = SCDC_ARG_REF_NONE;
      }
      return r;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x2, -0x10(%rbp)
jne 0x4d621
movq -0x8(%rbp), %rdi
callq 0xc260
movq %rax, %rdi
movq -0x18(%rbp), %rdx
leaq 0x5b6ae(%rip), %rsi     # 0xa8cb8
movb $0x0, %al
callq 0xc640
cmpl $0x1, %eax
jne 0x4d61f
movl $0x1, %eax
movq %rax, -0x20(%rbp)
jmp 0x4d621
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/common/log.cc
// Function: scdc_log::scdc_log(char const*, ...)
scdc_log::scdc_log(const char *conf, ...)
  :cout_default(0), cout(0), cerr_default(0), cerr(0)
{
#if SCDC_LOG_LOCK
  pthread_mutex_t static_mutex = PTHREAD_MUTEX_INITIALIZER;
  lock = static_mutex;
#endif

  va_list ap;
  va_start(ap, conf);

  default_init_intern(conf, ap);

  va_end(ap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
testb %al, %al
je 0x4d8e1
movaps %xmm0, -0xe0(%rbp)
movaps %xmm1, -0xd0(%rbp)
movaps %xmm2, -0xc0(%rbp)
movaps %xmm3, -0xb0(%rbp)
movaps %xmm4, -0xa0(%rbp)
movaps %xmm5, -0x90(%rbp)
movaps %xmm6, -0x80(%rbp)
movaps %xmm7, -0x70(%rbp)
movq %r9, -0xe8(%rbp)
movq %r8, -0xf0(%rbp)
movq %rcx, -0xf8(%rbp)
movq %rdx, -0x100(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq $0x0, (%rdi)
movq $0x0, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
movaps %xmm0, -0x40(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, 0x40(%rdi)
movaps -0x40(%rbp), %xmm0
movaps -0x30(%rbp), %xmm1
movups %xmm1, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
leaq -0x110(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x30, -0x5c(%rbp)
movl $0x10, -0x60(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0x4d990
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopw (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/common/log.cc
// Function: scdc_log::default_init_intern(char const*, __va_list_tag*)
bool scdc_log::default_init_intern(const char *conf, va_list aq)
{
  SCDC_TRACE("default_init_intern: conf: '" << conf << "'");

  scdc_args_t args;

  va_list ap;
  va_copy(ap, aq);

  scdc_args_va_init(&args, &ap);

  bool ret = init(conf, &args);

  scdc_args_va_release(&args);

  va_end(ap);

  if (cout_default) cout_default->flush();
  delete cout_default;
  cout_default = cout;

  if (cerr_default) cerr_default->flush();
  delete cerr_default;
  cerr_default = cerr;

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

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
jmp 0x4d9ae
leaq -0x50(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movups (%rcx), %xmm0
movups %xmm0, (%rax)
leaq -0x38(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x4db80
movq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x4dc00
andb $0x1, %al
movb %al, -0x51(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4e980
movq -0x60(%rbp), %rax
leaq -0x50(%rbp), %rcx
cmpq $0x0, (%rax)
je 0x4da0a
movq -0x60(%rbp), %rax
movq (%rax), %rdi
callq 0xc430
movq -0x60(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
je 0x4da25
movq -0x68(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x60(%rbp), %rax
movq 0x8(%rax), %rcx
movq %rcx, (%rax)
cmpq $0x0, 0x10(%rax)
je 0x4da44
movq -0x60(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xc430
movq -0x60(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, %rax
je 0x4da60
movq -0x70(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x60(%rbp), %rax
movq 0x18(%rax), %rcx
movq %rcx, 0x10(%rax)
jmp 0x4da6e
movb -0x51(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: mh0fm4[P]SCDC/src/components/common/log.cc
// Function: scdc_log::~scdc_log()
scdc_log::~scdc_log()
{
  release();

  cout = 0;
  cerr = 0;

  default_release();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x4dad0
jmp 0x4da9b
movq -0x10(%rbp), %rdi
movq $0x0, 0x8(%rdi)
movq $0x0, 0x18(%rdi)
callq 0x4db10
jmp 0x4dab6
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x25a60
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/common/log.cc
// Function: scdc_log::release()
void scdc_log::release()
{
  SCDC_TRACE("release:");

  set_cout(cout_default);

  set_cerr(cerr_default);

  SCDC_TRACE("release: return");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x4dae6
movq -0x10(%rbp), %rdi
movq (%rdi), %rsi
callq 0x4ea80
movq -0x10(%rbp), %rdi
movq 0x10(%rdi), %rsi
callq 0x4eaf0
jmp 0x4db01
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/common/log.cc
// Function: scdc_log::default_release()
void scdc_log::default_release()
{
  SCDC_TRACE("default_release:");

  delete cout_default;
  cout_default = 0;

  delete cerr_default;
  cerr_default =  0;

  SCDC_TRACE("default_release: return");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x4db26
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x4db41
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x4db64
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
jmp 0x4db72
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/common/log.cc
// Function: scdc_args_va_init(_scdc_args_t*, __va_list_tag (*) [1])
static void scdc_args_va_init(scdc_args_t *args, va_list *ap)
{
  scdc_args_data_va_t *data_va;


  data_va = new scdc_args_data_va_t;

  data_va->arg = 0;
  data_va->ap = ap;

  args->data = data_va;
  args->get = scdc_args_get_va;
  args->set = scdc_args_set_va;
  args->free = scdc_args_free_va;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x10, %edi
callq 0xc690
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
leaq 0x13c5(%rip), %rcx      # 0x4ef90
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
leaq 0x15b6(%rip), %rcx      # 0x4f190
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
leaq 0x15c7(%rip), %rcx      # 0x4f1b0
movq %rcx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/common/log.cc
// Function: scdc_log::default_init(char const*, ...)
bool scdc_log::default_init(const char *conf, ...)
{
  SCDC_TRACE("default_init: conf: '" << conf << "'");

  va_list ap;
  va_start(ap, conf);

  bool ret = default_init_intern(conf, ap);

  va_end(ap);

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

  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
testb %al, %al
je 0x4e9fb
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 %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xf8(%rbp)
jmp 0x4ea2c
movq -0xf8(%rbp), %rdi
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x4d990
andb $0x1, %al
movb %al, -0x31(%rbp)
leaq -0x30(%rbp), %rax
jmp 0x4ea6f
movb -0x31(%rbp), %al
andb $0x1, %al
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopl (%rax)
// File: mh0fm4[P]SCDC/src/components/common/log.cc
// Function: ostream_printf(std::ostream*, char const*, __va_list_tag*, bool)
static int ostream_printf(ostream *os, const char *format, va_list ap, bool nl)
{
  int n;
  char ss[OSTREAM_PRINTF_DEFAULT_SIZE], *s = ss;


  if (!os) return -1;

  va_list ap1;
  va_copy(ap1, ap);
  n = vsnprintf(s, OSTREAM_PRINTF_DEFAULT_SIZE, format, ap1);
  va_end(ap1);

  if (n >= OSTREAM_PRINTF_DEFAULT_SIZE)
  {
    char *s = new char[n + 1];

    va_list ap2;
    va_copy(ap2, ap);
    n = vsnprintf(s, OSTREAM_PRINTF_DEFAULT_SIZE, format, ap2);
    va_end(ap2);
  }

  *os << s;

  if (nl) *os << endl;

  if (s != ss) delete[] s;

  return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x480, %rsp            # imm = 0x480
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
leaq -0x430(%rbp), %rax
movq %rax, -0x438(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4ec4f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4ed4c
leaq -0x450(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movups (%rcx), %xmm0
movups %xmm0, (%rax)
movq -0x438(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x450(%rbp), %rcx
movl $0x400, %esi            # imm = 0x400
callq 0xc400
movl %eax, -0x28(%rbp)
leaq -0x450(%rbp), %rax
cmpl $0x400, -0x28(%rbp)     # imm = 0x400
jl 0x4eceb
movl -0x28(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0xc040
movq %rax, -0x458(%rbp)
leaq -0x470(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%rax)
movups (%rcx), %xmm0
movups %xmm0, (%rax)
movq -0x458(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x470(%rbp), %rcx
movl $0x400, %esi            # imm = 0x400
callq 0xc400
movl %eax, -0x28(%rbp)
leaq -0x470(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x438(%rbp), %rsi
callq 0xc670
testb $0x1, -0x21(%rbp)
je 0x4ed11
movq -0x10(%rbp), %rdi
movq 0x852b4(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
movq -0x438(%rbp), %rax
leaq -0x430(%rbp), %rcx
cmpq %rcx, %rax
je 0x4ed46
movq -0x438(%rbp), %rax
movq %rax, -0x478(%rbp)
cmpq $0x0, %rax
je 0x4ed44
movq -0x478(%rbp), %rdi
callq 0xc8b0
jmp 0x4ed46
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x480, %rsp            # imm = 0x480
popq %rbp
retq
nopl (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/common/log.cc
// Function: ostreambuf_buf_write::overflow(int)
int_type overflow(int_type ch)
    {
      if (ch == traits_type::eof()) return traits_type::eof();

      sync();

      *pptr() = ch;
      pbump(1);

      return ch;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
callq 0x501b0
movl %eax, %ecx
movl -0x18(%rbp), %eax
cmpl %ecx, %eax
jne 0x4f605
callq 0x501b0
movl %eax, -0x4(%rbp)
jmp 0x4f637
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movb %al, -0x21(%rbp)
callq 0xc180
movb -0x21(%rbp), %cl
movq -0x20(%rbp), %rdi
movb %cl, (%rax)
movl $0x1, %esi
callq 0xc9b0
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: mh0fm4[P]SCDC/src/components/node/nodeconn_pool.cc
// Function: scdc_nodeconn_pool::add(char const*, char const*, scdc_nodeconn*)
void scdc_nodeconn_pool::add(const char *scheme, const char *authority, scdc_nodeconn *nodeconn)
{
  SCDC_TRACE("add: scheme: '" << scheme << "', authority: '" << authority << "', nodeconn: '" << nodeconn << "'");

  join_uri(scheme, authority, 0, nodeconn->key);

  (*this)[nodeconn->key].insert(nodeconn);

  SCDC_TRACE("add: key: '" << nodeconn->key << "'");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x50432
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rcx
addq $0x8, %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0x2ab30
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
callq 0x50f90
movq %rax, %rdi
leaq -0x20(%rbp), %rsi
callq 0x51070
movq %rax, -0x30(%rbp)
movb %dl, -0x28(%rbp)
jmp 0x50471
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/node/nodeconn_pool.cc
// Function: scdc_nodeconn_pool::close(scdc_nodeconn*)
void scdc_nodeconn_pool::close(scdc_nodeconn *nodeconn)
{
  SCDC_TRACE("close: nodeconn: '" << nodeconn << "'");

  bool is_idle = nodeconn->is_idle();

  if (is_idle)
  {
    SCDC_TRACE("close: closing idle connection");

    close_idle(nodeconn);

  } else
  {
    SCDC_TRACE("close: enable closing on idle");

    scdc_nodeconn_on_idle_close(nodeconn);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x50d6a
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
andb $0x1, %al
movb %al, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
je 0x50d92
jmp 0x50d81
jmp 0x50d83
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x50db0
jmp 0x50d9f
jmp 0x50d94
jmp 0x50d96
movq -0x10(%rbp), %rdi
callq 0x95eb0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/node/nodeconn_pool.cc
// Function: scdc_nodeconn_pool::close_idle(scdc_nodeconn*)
void scdc_nodeconn_pool::close_idle(scdc_nodeconn *nodeconn)
{
  SCDC_TRACE("close_idle: nodeconn: '" << nodeconn << "', ref: " << nodeconn->ref);

  SCDC_ASSERT(nodeconn->ref > 0);

  --nodeconn->ref;

  if (nodeconn->ref <= 0)
  {
#if NODECONN_CACHE_CONNECTIONS
    if (cache_add(nodeconn))
    {
      SCDC_TRACE("close_idle: caching unreferenced connection '" << nodeconn << "'");

    } else
#endif
    {
      SCDC_TRACE("close_idle: closing unreferenced connection '" << nodeconn << "'");

      close_real(nodeconn);
    }

  } else
  {
    SCDC_TRACE("close_idle: keeping connection '" << nodeconn << "' with " << nodeconn->ref << " reference(s)");
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x50dca
jmp 0x50dcc
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jg 0x50e8e
jmp 0x50ddd
leaq 0x838c4(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e8e0
cmpq $0x0, %rax
je 0x50e8a
leaq 0x838ab(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e900
leaq 0x8389c(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e8e0
movq %rax, %rdi
leaq 0x5574b(%rip), %rsi     # 0xa6569
callq 0xc670
movq %rax, %rdi
leaq 0x56b53(%rip), %rsi     # 0xa7980
callq 0xc670
movq %rax, %rdi
leaq 0x55528(%rip), %rsi     # 0xa6364
callq 0xc670
movq %rax, %rdi
movl $0x116, %esi            # imm = 0x116
callq 0xcb80
movq %rax, %rdi
leaq 0x56be0(%rip), %rsi     # 0xa7a38
callq 0xc670
movq %rax, %rdi
leaq 0x570a5(%rip), %rsi     # 0xa7f0c
callq 0xc670
movq %rax, %rdi
movq 0x8314a(%rip), %rsi     # 0xd3fc0
callq 0xc6d0
leaq 0x83826(%rip), %rax     # 0xd46a8
movq (%rax), %rdi
callq 0x2e920
jmp 0x50e8c
jmp 0x50e8e
jmp 0x50e90
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jg 0x50ebe
jmp 0x50ead
jmp 0x50eaf
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x50ed0
jmp 0x50ec4
jmp 0x50ec0
jmp 0x50ec2
jmp 0x50ec4
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: mh0fm4[P]SCDC/src/components/node/nodeconn_pool.cc
// Function: scdc_nodeconn_pool::close_real(scdc_nodeconn*)
void scdc_nodeconn_pool::close_real(scdc_nodeconn *nodeconn)
{
  SCDC_TRACE("close_real: nodeconn: '" << nodeconn << "'");

  del(nodeconn);

  nodeconn->close();

  delete nodeconn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x50eea
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x50480
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x50f19
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop