LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/general/tril.c
// Function: fillTRIL
void fillTRIL(element theElement, FILE *fp)
{ char theKeyword[80];
  while (1)
  { read_keyword(fp,theKeyword);
    if (!strcmp(theKeyword,"END_ELEMENTS")) return;
    theElement=(element)element_dll(theElement,APPEND,0);
    theElement->type =  TRIL;
    theElement->label = atoi(theKeyword); 
    read_keyword(fp,theKeyword); theElement->p1 = atoi(theKeyword);
    read_keyword(fp,theKeyword); theElement->p2 = atoi(theKeyword);
    read_keyword(fp,theKeyword); theElement->p3 = atoi(theKeyword);
  }
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x58(%rsp), %rdi
movq %rsp, %rsi
callq 0x8f80
movq %rsp, %rdi
leaq 0x383b(%rip), %rsi      # 0x1b500
callq 0x10c0
cmpl $0x0, %eax
jne 0x17cd4
addq $0x68, %rsp
retq
movq 0x60(%rsp), %rdi
movl $0x3, %esi
xorl %edx, %edx
callq 0x14570
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
movl $0x2, 0x10(%rax)
movq %rsp, %rdi
callq 0x1130
movl %eax, %ecx
movq 0x60(%rsp), %rax
movl %ecx, 0x14(%rax)
movq 0x58(%rsp), %rdi
movq %rsp, %rsi
callq 0x8f80
movq %rsp, %rdi
callq 0x1130
movl %eax, %ecx
movq 0x60(%rsp), %rax
movl %ecx, 0x18(%rax)
movq 0x58(%rsp), %rdi
movq %rsp, %rsi
callq 0x8f80
movq %rsp, %rdi
callq 0x1130
movl %eax, %ecx
movq 0x60(%rsp), %rax
movl %ecx, 0x1c(%rax)
movq 0x58(%rsp), %rdi
movq %rsp, %rsi
callq 0x8f80
movq %rsp, %rdi
callq 0x1130
movl %eax, %ecx
movq 0x60(%rsp), %rax
movl %ecx, 0x20(%rax)
jmp 0x17cae
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/general/tril.c
// Function: fastTRILnormal
void fastTRILnormal(const element e)
{ double x2213;
  double x3312;
  double x3213;
  double x2312;
  double x1312;
  double x1213;
  double c;

  x2213 = (e->p2y - e->p1y) / e->z3;
  x3312 = (e->p3z - e->p1z) / e->z2;
  x3213 = (e->p2z - e->p1z) / e->z3;
  x2312 = (e->p3y - e->p1y) / e->z2;
  x1312 = (e->p3x - e->p1x) / e->z2;
  x1213 = (e->p2x - e->p1x) / e->z3;

  c = 1.0/sin(e->alpha1);

  e->nx = x2213 * x3312 - x3213 * x2312; e->nx = c * e->nx;
  e->ny = x3213 * x1312 - x1213 * x3312; e->ny = c * e->ny;
  e->nz = x1213 * x2312 - x2213 * x1312; e->nz = c * e->nz;

}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movsd 0x48(%rax), %xmm0
movq 0x40(%rsp), %rax
subsd 0x30(%rax), %xmm0
movq 0x40(%rsp), %rax
divsd 0x98(%rax), %xmm0
movsd %xmm0, 0x38(%rsp)
movq 0x40(%rsp), %rax
movsd 0x68(%rax), %xmm0
movq 0x40(%rsp), %rax
subsd 0x38(%rax), %xmm0
movq 0x40(%rsp), %rax
divsd 0x90(%rax), %xmm0
movsd %xmm0, 0x30(%rsp)
movq 0x40(%rsp), %rax
movsd 0x50(%rax), %xmm0
movq 0x40(%rsp), %rax
subsd 0x38(%rax), %xmm0
movq 0x40(%rsp), %rax
divsd 0x98(%rax), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x40(%rsp), %rax
movsd 0x60(%rax), %xmm0
movq 0x40(%rsp), %rax
subsd 0x30(%rax), %xmm0
movq 0x40(%rsp), %rax
divsd 0x90(%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x40(%rsp), %rax
movsd 0x58(%rax), %xmm0
movq 0x40(%rsp), %rax
subsd 0x28(%rax), %xmm0
movq 0x40(%rsp), %rax
divsd 0x90(%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x40(%rsp), %rax
movsd 0x40(%rax), %xmm0
movq 0x40(%rsp), %rax
subsd 0x28(%rax), %xmm0
movq 0x40(%rsp), %rax
divsd 0x98(%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x40(%rsp), %rax
movsd 0x70(%rax), %xmm0
callq 0x1120
movaps %xmm0, %xmm1
movsd 0x118b(%rip), %xmm0     # 0x19008
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x38(%rsp), %xmm0
movsd 0x30(%rsp), %xmm2
movsd 0x28(%rsp), %xmm1
mulsd 0x20(%rsp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x40(%rsp), %rax
movsd %xmm0, 0xa0(%rax)
movsd 0x8(%rsp), %xmm0
movq 0x40(%rsp), %rax
mulsd 0xa0(%rax), %xmm0
movq 0x40(%rsp), %rax
movsd %xmm0, 0xa0(%rax)
movsd 0x28(%rsp), %xmm0
movsd 0x18(%rsp), %xmm2
movsd 0x10(%rsp), %xmm1
mulsd 0x30(%rsp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x40(%rsp), %rax
movsd %xmm0, 0xa8(%rax)
movsd 0x8(%rsp), %xmm0
movq 0x40(%rsp), %rax
mulsd 0xa8(%rax), %xmm0
movq 0x40(%rsp), %rax
movsd %xmm0, 0xa8(%rax)
movsd 0x10(%rsp), %xmm0
movsd 0x20(%rsp), %xmm2
movsd 0x38(%rsp), %xmm1
mulsd 0x18(%rsp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x40(%rsp), %rax
movsd %xmm0, 0xb0(%rax)
movsd 0x8(%rsp), %xmm0
movq 0x40(%rsp), %rax
mulsd 0xb0(%rax), %xmm0
movq 0x40(%rsp), %rax
movsd %xmm0, 0xb0(%rax)
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markpeerdeman[P]mbemm/src/general/tril.c
// Function: TRILcopy
void TRILcopy( const element source, const element dest )
{
  dest->type=source->type;              
  dest->label=source->label;             
  dest->p1=source->p1;
  dest->p2=source->p2;
  dest->p3=source->p3;
  dest->alpha1=source->alpha1;           
  dest->alpha2=source->alpha2;
  dest->alpha3=source->alpha3;
  dest->z1=source->z1;               
  dest->z2=source->z2;
  dest->z3=source->z3;
  dest->nx=source->nx;
  dest->ny=source->ny;
  dest->nz=source->nz;
  dest->p1x=source->p1x;
  dest->p1y=source->p1y;
  dest->p1z=source->p1z;
  dest->p2x=source->p2x;
  dest->p2y=source->p2y;
  dest->p2z=source->p2z;
  dest->p3x=source->p3x;
  dest->p3y=source->p3y;
  dest->p3z=source->p3z;
  dest->area=source->area;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movl 0x10(%rax), %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x10(%rax)
movq -0x8(%rsp), %rax
movl 0x14(%rax), %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x14(%rax)
movq -0x8(%rsp), %rax
movl 0x18(%rax), %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rsp), %rax
movl 0x1c(%rax), %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x1c(%rax)
movq -0x8(%rsp), %rax
movl 0x20(%rax), %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x20(%rax)
movq -0x8(%rsp), %rax
movsd 0x70(%rax), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, 0x70(%rax)
movq -0x8(%rsp), %rax
movsd 0x78(%rax), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, 0x78(%rax)
movq -0x8(%rsp), %rax
movsd 0x80(%rax), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, 0x80(%rax)
movq -0x8(%rsp), %rax
movsd 0x88(%rax), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, 0x88(%rax)
movq -0x8(%rsp), %rax
movsd 0x90(%rax), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, 0x90(%rax)
movq -0x8(%rsp), %rax
movsd 0x98(%rax), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, 0x98(%rax)
movq -0x8(%rsp), %rax
movsd 0xa0(%rax), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, 0xa0(%rax)
movq -0x8(%rsp), %rax
movsd 0xa8(%rax), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, 0xa8(%rax)
movq -0x8(%rsp), %rax
movsd 0xb0(%rax), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, 0xb0(%rax)
movq -0x8(%rsp), %rax
movsd 0x28(%rax), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, 0x28(%rax)
movq -0x8(%rsp), %rax
movsd 0x30(%rax), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, 0x30(%rax)
movq -0x8(%rsp), %rax
movsd 0x38(%rax), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, 0x38(%rax)
movq -0x8(%rsp), %rax
movsd 0x40(%rax), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, 0x40(%rax)
movq -0x8(%rsp), %rax
movsd 0x48(%rax), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, 0x48(%rax)
movq -0x8(%rsp), %rax
movsd 0x50(%rax), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, 0x50(%rax)
movq -0x8(%rsp), %rax
movsd 0x58(%rax), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, 0x58(%rax)
movq -0x8(%rsp), %rax
movsd 0x60(%rax), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, 0x60(%rax)
movq -0x8(%rsp), %rax
movsd 0x68(%rax), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, 0x68(%rax)
movq -0x8(%rsp), %rax
movsd 0xb8(%rax), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, 0xb8(%rax)
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xapi-project[P]rrd-client-lib/rrdclient.c
// Function: cleanup
static void
cleanup(int signal)
{
    fprintf(stderr, "caught signal %d, cleaning up\n", signal);
    if (plugin) {
        rrd_close(plugin);
    }
    exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0xb9d6(%rip), %rax      # 0xcff8
movq (%rax), %rdi
movl -0x4(%rbp), %edx
leaq 0x7a73(%rip), %rsi      # 0x90a2
movb $0x0, %al
callq 0x11e0
cmpq $0x0, 0xbb52(%rip)      # 0xd190
je 0x164c
movq 0xbb49(%rip), %rdi      # 0xd190
callq 0x1d40
movl $0x1, %edi
callq 0x12a0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xapi-project[P]rrd-client-lib/librrd.c
// Function: invalidate
static void
invalidate(RRD_PLUGIN * plugin)
{
    assert(plugin);

    free(plugin->buf);
    plugin->buf = NULL;
    plugin->buf_size = 0;
    json_value_free(plugin->meta);
    plugin->meta = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1c35
jmp 0x1c54
leaq 0x74ea(%rip), %rdi      # 0x9126
leaq 0x74a2(%rip), %rsi      # 0x90e5
movl $0x6d, %edx
leaq 0x7700(%rip), %rcx      # 0x934f
callq 0x1170
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq $0x0, 0x98(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0xa8(%rax)
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rdi
callq 0x34b0
movq -0x8(%rbp), %rax
movq $0x0, 0x90(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xapi-project[P]rrd-client-lib/librrd.c
// Function: write_exact
static int
write_exact(int fd, const void *data, size_t size)
{
    size_t          offset = 0;
    ssize_t         len;
    while (offset < size) {
        len = write(fd, (const char *)data + offset, size - offset);
        if ((len == -1) && (errno == EINTR))
            continue;
        if (len <= 0)
            return -1;
        offset += len;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x1d22
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
addq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
subq -0x20(%rbp), %rdx
callq 0x10e0
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
jne 0x1d04
callq 0x1050
cmpl $0x4, (%rax)
jne 0x1d04
jmp 0x1ccb
cmpq $0x0, -0x28(%rbp)
jg 0x1d14
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1d29
movq -0x28(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x1ccb
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xapi-project[P]rrd-client-lib/librrd.c
// Function: rrd_close
int
rrd_close(RRD_PLUGIN * plugin)
{
    assert(plugin);
    int             rc;


    rc = close(plugin->file);
    if (rc == 0)
        rc = unlink(plugin->path);
    invalidate(plugin);
    free(plugin);
    return (rc == 0 ? RRD_OK : RRD_FILE_ERROR);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1d55
jmp 0x1d74
leaq 0x73ca(%rip), %rdi      # 0x9126
leaq 0x7382(%rip), %rsi      # 0x90e5
movl $0x16d, %edx            # imm = 0x16D
leaq 0x73be(%rip), %rcx      # 0x912d
callq 0x1170
movq -0x8(%rbp), %rax
movl 0xb0(%rax), %edi
callq 0x11a0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x1d9c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1060
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1c20
movq -0x8(%rbp), %rdi
callq 0x1030
movl -0xc(%rbp), %edx
movl $0x3, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xapi-project[P]rrd-client-lib/librrd.c
// Function: rrd_add_src
int
rrd_add_src(RRD_PLUGIN * plugin, RRD_SOURCE * source)
{
    assert(plugin);
    assert(source);

    /*
     * find free slot
     */
    size_t          i;
    for (i = 0; i < RRD_MAX_SOURCES; i++) {
        if (plugin->sources[i] == NULL)
            break;
    }
    if (i >= RRD_MAX_SOURCES) {
        return RRD_TOO_MANY_SOURCES;
    }
    plugin->sources[i] = source;
    plugin->n++;
    invalidate(plugin);

    return RRD_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1de9
jmp 0x1e08
leaq 0x7336(%rip), %rdi      # 0x9126
leaq 0x72ee(%rip), %rsi      # 0x90e5
movl $0x17f, %edx            # imm = 0x17F
leaq 0x7346(%rip), %rcx      # 0x9149
callq 0x1170
cmpq $0x0, -0x18(%rbp)
je 0x1e11
jmp 0x1e30
leaq 0x735d(%rip), %rdi      # 0x9175
leaq 0x72c6(%rip), %rsi      # 0x90e5
movl $0x180, %edx            # imm = 0x180
leaq 0x731e(%rip), %rcx      # 0x9149
callq 0x1170
movq $0x0, -0x20(%rbp)
cmpq $0x10, -0x20(%rbp)
jae 0x1e61
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq $0x0, 0x10(%rax,%rcx,8)
jne 0x1e51
jmp 0x1e61
jmp 0x1e53
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1e38
cmpq $0x10, -0x20(%rbp)
jb 0x1e71
movl $0x1, -0x4(%rbp)
jmp 0x1ea5
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rdx, 0x10(%rax,%rcx,8)
movq -0x10(%rbp), %rax
movl 0xa4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xa4(%rax)
movq -0x10(%rbp), %rdi
callq 0x1c20
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/xapi-project[P]rrd-client-lib/librrd.c
// Function: rrd_del_src
int
rrd_del_src(RRD_PLUGIN * plugin, RRD_SOURCE * source)
{
    assert(source);
    size_t          i;
    /*
     * find slot with source
     */
    for (i = 0; i < RRD_MAX_SOURCES; i++) {
        if (plugin->sources[i] == source)
            break;
    }
    if (i >= RRD_MAX_SOURCES) {
        return RRD_NO_SUCH_SOURCE;
    }
    plugin->sources[i] = NULL;
    plugin->n--;
    invalidate(plugin);

    return RRD_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1ec9
jmp 0x1ee8
leaq 0x72a5(%rip), %rdi      # 0x9175
leaq 0x720e(%rip), %rsi      # 0x90e5
movl $0x19a, %edx            # imm = 0x19A
leaq 0x7299(%rip), %rcx      # 0x917c
callq 0x1170
movq $0x0, -0x20(%rbp)
cmpq $0x10, -0x20(%rbp)
jae 0x1f1c
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rax
cmpq -0x18(%rbp), %rax
jne 0x1f0c
jmp 0x1f1c
jmp 0x1f0e
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1ef0
cmpq $0x10, -0x20(%rbp)
jb 0x1f2c
movl $0x2, -0x4(%rbp)
jmp 0x1f60
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq $0x0, 0x10(%rax,%rcx,8)
movq -0x10(%rbp), %rax
movl 0xa4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xa4(%rax)
movq -0x10(%rbp), %rdi
callq 0x1c20
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/xapi-project[P]rrd-client-lib/librrd.c
// Function: json_for_plugin
static JSON_Value *
json_for_plugin(RRD_PLUGIN * plugin)
{
    assert(plugin);

    JSON_Value     *root_json = json_value_init_object();
    JSON_Object    *root = json_value_get_object(root_json);

    JSON_Value     *ds_json = json_value_init_object();
    JSON_Object    *ds = json_value_get_object(ds_json);

    json_object_set_value(root, "datasources", ds_json);
    for (size_t i = 0; i < RRD_MAX_SOURCES; i++) {
        JSON_Value     *src;
        if (plugin->sources[i] == NULL)
            continue;
        src = json_for_source(plugin->sources[i]);
        json_object_set_value(ds, plugin->sources[i]->name, src);
    }
    return root_json;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2275
jmp 0x2294
leaq 0x6eaa(%rip), %rdi      # 0x9126
leaq 0x6e62(%rip), %rsi      # 0x90e5
movl $0xcb, %edx
leaq 0x6fef(%rip), %rcx      # 0x927e
callq 0x1170
callq 0x3640
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2e10
movq %rax, -0x18(%rbp)
callq 0x3640
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2e10
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x6fd9(%rip), %rsi      # 0x92a8
callq 0x5510
movq $0x0, -0x30(%rbp)
cmpq $0x10, -0x30(%rbp)
jae 0x2336
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
cmpq $0x0, 0x10(%rax,%rcx,8)
jne 0x22f5
jmp 0x2328
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rdi
callq 0x2340
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rax
movq -0x30(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rax
movq (%rax), %rsi
movq -0x38(%rbp), %rdx
callq 0x5510
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x22dc
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/xapi-project[P]rrd-client-lib/parson/parson.c
// Function: json_parse_file
JSON_Value * json_parse_file(const char *filename) {
    char *file_contents = read_file(filename);
    JSON_Value *output_value = NULL;
    if (file_contents == NULL) {
        return NULL;
    }
    output_value = json_parse_string(file_contents);
    parson_free(file_contents);
    return output_value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2650
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2622
movq $0x0, -0x8(%rbp)
jmp 0x2644
movq -0x18(%rbp), %rdi
callq 0x2780
movq %rax, -0x20(%rbp)
movq 0xab42(%rip), %rax      # 0xd178
movq -0x18(%rbp), %rdi
callq *%rax
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/xapi-project[P]rrd-client-lib/parson/parson.c
// Function: read_file
static char * read_file(const char * filename) {
    FILE *fp = fopen(filename, "r");
    size_t file_size;
    long pos;
    char *file_contents;
    if (!fp) {
        return NULL;
    }
    fseek(fp, 0L, SEEK_END);
    pos = ftell(fp);
    if (pos < 0) {
        fclose(fp);
        return NULL;
    }
    file_size = pos;
    rewind(fp);
    file_contents = (char*)parson_malloc(sizeof(char) * (file_size + 1));
    if (!file_contents) {
        fclose(fp);
        return NULL;
    }
    if (fread(file_contents, file_size, 1, fp) < 1) {
        if (ferror(fp)) {
            fclose(fp);
            parson_free(file_contents);
            return NULL;
        }
    }
    fclose(fp);
    file_contents[file_size] = '\0';
    return file_contents;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x721c(%rip), %rsi      # 0x9883
callq 0x1280
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2684
movq $0x0, -0x8(%rbp)
jmp 0x276d
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x1240
movq -0x18(%rbp), %rdi
callq 0x1200
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jge 0x26c0
movq -0x18(%rbp), %rdi
callq 0x10f0
movq $0x0, -0x8(%rbp)
jmp 0x276d
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1130
movq 0xaaa8(%rip), %rax      # 0xd180
movq -0x20(%rbp), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq *%rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x2704
movq -0x18(%rbp), %rdi
callq 0x10f0
movq $0x0, -0x8(%rbp)
jmp 0x276d
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rcx
movl $0x1, %edx
callq 0x10b0
cmpq $0x1, %rax
jae 0x2750
movq -0x18(%rbp), %rdi
callq 0x1090
cmpl $0x0, %eax
je 0x274e
movq -0x18(%rbp), %rdi
callq 0x10f0
movq 0xaa3a(%rip), %rax      # 0xd178
movq -0x30(%rbp), %rdi
callq *%rax
movq $0x0, -0x8(%rbp)
jmp 0x276d
jmp 0x2750
movq -0x18(%rbp), %rdi
callq 0x10f0
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xapi-project[P]rrd-client-lib/parson/parson.c
// Function: json_parse_string
JSON_Value * json_parse_string(const char *string) {
    if (string == NULL) {
        return NULL;
    }
    if (string[0] == '\xEF' && string[1] == '\xBB' && string[2] == '\xBF') {
        string = string + 3; /* Support for UTF-8 BOM */
    }
    return parse_value((const char**)&string, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x279d
movq $0x0, -0x8(%rbp)
jmp 0x27e0
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $-0x11, %eax
jne 0x27cf
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $-0x45, %eax
jne 0x27cf
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $-0x41, %eax
jne 0x27cf
movq -0x10(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2900
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xapi-project[P]rrd-client-lib/parson/parson.c
// Function: json_parse_file_with_comments
JSON_Value * json_parse_file_with_comments(const char *filename) {
    char *file_contents = read_file(filename);
    JSON_Value *output_value = NULL;
    if (file_contents == NULL) {
        return NULL;
    }
    output_value = json_parse_string_with_comments(file_contents);
    parson_free(file_contents);
    return output_value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2650
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2822
movq $0x0, -0x8(%rbp)
jmp 0x2844
movq -0x18(%rbp), %rdi
callq 0x2850
movq %rax, -0x20(%rbp)
movq 0xa942(%rip), %rax      # 0xd178
movq -0x18(%rbp), %rdi
callq *%rax
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/xapi-project[P]rrd-client-lib/parson/parson.c
// Function: json_parse_string_with_comments
JSON_Value * json_parse_string_with_comments(const char *string) {
    JSON_Value *result = NULL;
    char *string_mutable_copy = NULL, *string_mutable_copy_ptr = NULL;
    string_mutable_copy = parson_strdup(string);
    if (string_mutable_copy == NULL) {
        return NULL;
    }
    remove_comments(string_mutable_copy, "/*", "*/");
    remove_comments(string_mutable_copy, "//", "\n");
    string_mutable_copy_ptr = string_mutable_copy;
    result = parse_value((const char**)&string_mutable_copy_ptr, 0);
    parson_free(string_mutable_copy);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2a10
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2892
movq $0x0, -0x8(%rbp)
jmp 0x28ee
movq -0x20(%rbp), %rdi
leaq 0x6fa3(%rip), %rsi      # 0x9840
leaq 0x6f9f(%rip), %rdx      # 0x9843
callq 0x2a40
movq -0x20(%rbp), %rdi
leaq 0x6f92(%rip), %rsi      # 0x9846
leaq 0x6818(%rip), %rdx      # 0x90d3
callq 0x2a40
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2900
movq %rax, -0x18(%rbp)
movq 0xa898(%rip), %rax      # 0xd178
movq -0x20(%rbp), %rdi
callq *%rax
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xapi-project[P]rrd-client-lib/parson/parson.c
// Function: parse_value
static JSON_Value * parse_value(const char **string, size_t nesting) {
    if (nesting > MAX_NESTING) {
        return NULL;
    }
    SKIP_WHITESPACES(string);
    switch (**string) {
        case '{':
            return parse_object_value(string, nesting + 1);
        case '[':
            return parse_array_value(string, nesting + 1);
        case '\"':
            return parse_string_value(string);
        case 'f': case 't':
            return parse_boolean_value(string);
        case '-':
        case '0': case '1': case '2': case '3': case '4':
        case '5': case '6': case '7': case '8': case '9':
            return parse_number_value(string);
        case 'n':
            return parse_null_value(string);
        default:
            return NULL;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x800, -0x18(%rbp)     # imm = 0x800
jbe 0x2927
movq $0x0, -0x8(%rbp)
jmp 0x29fa
jmp 0x2929
callq 0x12c0
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x295c
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x2929
movq -0x10(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
addl $-0x22, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x59, %eax
ja 0x29f2
movq -0x20(%rbp), %rax
leaq 0x69f1(%rip), %rcx      # 0x9370
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
callq 0x63f0
movq %rax, -0x8(%rbp)
jmp 0x29fa
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
callq 0x6720
movq %rax, -0x8(%rbp)
jmp 0x29fa
movq -0x10(%rbp), %rdi
callq 0x6980
movq %rax, -0x8(%rbp)
jmp 0x29fa
movq -0x10(%rbp), %rdi
callq 0x69f0
movq %rax, -0x8(%rbp)
jmp 0x29fa
movq -0x10(%rbp), %rdi
callq 0x6aa0
movq %rax, -0x8(%rbp)
jmp 0x29fa
movq -0x10(%rbp), %rdi
callq 0x6b30
movq %rax, -0x8(%rbp)
jmp 0x29fa
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xapi-project[P]rrd-client-lib/parson/parson.c
// Function: json_object_nget_value
static JSON_Value * json_object_nget_value(const JSON_Object *object, const char *name, size_t n) {
    size_t i, name_length;
    for (i = 0; i < json_object_get_count(object); i++) {
        name_length = strlen(object->names[i]);
        if (name_length != n) {
            continue;
        }
        if (strncmp(object->names[i], name, n) == 0) {
            return object->values[i];
        }
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x30a0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x2ce9
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1100
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x2c9e
jmp 0x2cd8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1080
cmpl $0x0, %eax
jne 0x2cd6
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x2cf1
jmp 0x2cd8
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2c5c
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xapi-project[P]rrd-client-lib/parson/parson.c
// Function: json_object_dotget_value
JSON_Value * json_object_dotget_value(const JSON_Object *object, const char *name) {
    const char *dot_position = strchr(name, '.');
    if (!dot_position) {
        return json_object_get_value(object, name);
    }
    object = json_value_get_object(json_object_nget_value(object, name, dot_position - name));
    return json_object_dotget_value(object, dot_position + 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movl $0x2e, %esi
callq 0x1110
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x2f6c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2be0
movq %rax, -0x8(%rbp)
jmp 0x2fa5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
subq %rax, %rdx
callq 0x2c40
movq %rax, %rdi
callq 0x2e10
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x1, %rsi
callq 0x2f30
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/xapi-project[P]rrd-client-lib/parson/parson.c
// Function: json_value_free
void json_value_free(JSON_Value *value) {
    switch (json_value_get_type(value)) {
        case JSONObject:
            json_object_free(value->value.object);
            break;
        case JSONString:
            parson_free(value->value.string);
            break;
        case JSONArray:
            json_array_free(value->value.array);
            break;
        default:
            break;
    }
    parson_free(value);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3230
movl %eax, %ecx
movl %ecx, -0xc(%rbp)
subl $0x2, %eax
je 0x34f4
jmp 0x34d1
movl -0xc(%rbp), %eax
subl $0x4, %eax
je 0x34e5
jmp 0x34db
movl -0xc(%rbp), %eax
subl $0x5, %eax
je 0x3507
jmp 0x3516
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3530
jmp 0x3518
movq 0x9c7d(%rip), %rax      # 0xd178
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rdi
callq *%rax
jmp 0x3518
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x35d0
jmp 0x3518
jmp 0x3518
movq 0x9c59(%rip), %rax      # 0xd178
movq -0x8(%rbp), %rdi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xapi-project[P]rrd-client-lib/parson/parson.c
// Function: json_object_free
static void json_object_free(JSON_Object *object) {
    size_t i;
    for (i = 0; i < object->count; i++) {
        parson_free(object->names[i]);
        json_value_free(object->values[i]);
    }
    parson_free(object->names);
    parson_free(object->values);
    parson_free(object);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x358e
movq 0x9c1f(%rip), %rax      # 0xd178
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x34b0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x3544
movq 0x9be3(%rip), %rax      # 0xd178
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
callq *%rax
movq 0x9bd2(%rip), %rax      # 0xd178
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rdi
callq *%rax
movq 0x9bc1(%rip), %rax      # 0xd178
movq -0x8(%rbp), %rdi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xapi-project[P]rrd-client-lib/parson/parson.c
// Function: json_array_free
static void json_array_free(JSON_Array *array) {
    size_t i;
    for (i = 0; i < array->count; i++) {
        json_value_free(array->items[i]);
    }
    parson_free(array->items);
    parson_free(array);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x3615
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x34b0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x35e4
movq 0x9b5c(%rip), %rax      # 0xd178
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rdi
callq *%rax
movq 0x9b4b(%rip), %rax      # 0xd178
movq -0x8(%rbp), %rdi
callq *%rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/xapi-project[P]rrd-client-lib/parson/parson.c
// Function: json_value_init_object
JSON_Value * json_value_init_object(void) {
    JSON_Value *new_value = (JSON_Value*)parson_malloc(sizeof(JSON_Value));
    if (!new_value) {
        return NULL;
    }
    new_value->parent = NULL;
    new_value->type = JSONObject;
    new_value->value.object = json_object_init(new_value);
    if (!new_value->value.object) {
        parson_free(new_value);
        return NULL;
    }
    return new_value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x18, %edi
callq *0x9b2d(%rip)           # 0xd180
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3668
movq $0x0, -0x8(%rbp)
jmp 0x36bc
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movl $0x4, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x36d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x36b4
movq 0x9ad4(%rip), %rax      # 0xd178
movq -0x10(%rbp), %rdi
callq *%rax
movq $0x0, -0x8(%rbp)
jmp 0x36bc
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xapi-project[P]rrd-client-lib/parson/parson.c
// Function: json_object_init
static JSON_Object * json_object_init(JSON_Value *wrapping_value) {
    JSON_Object *new_obj = (JSON_Object*)parson_malloc(sizeof(JSON_Object));
    if (new_obj == NULL) {
        return NULL;
    }
    new_obj->wrapping_value = wrapping_value;
    new_obj->names = (char**)NULL;
    new_obj->values = (JSON_Value**)NULL;
    new_obj->capacity = 0;
    new_obj->count = 0;
    return new_obj;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x28, %edi
callq *0x9a99(%rip)           # 0xd180
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x36fc
movq $0x0, -0x8(%rbp)
jmp 0x373f
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/xapi-project[P]rrd-client-lib/parson/parson.c
// Function: json_value_init_array
JSON_Value * json_value_init_array(void) {
    JSON_Value *new_value = (JSON_Value*)parson_malloc(sizeof(JSON_Value));
    if (!new_value) {
        return NULL;
    }
    new_value->parent = NULL;
    new_value->type = JSONArray;
    new_value->value.array = json_array_init(new_value);
    if (!new_value->value.array) {
        parson_free(new_value);
        return NULL;
    }
    return new_value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x18, %edi
callq *0x9a1d(%rip)           # 0xd180
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3778
movq $0x0, -0x8(%rbp)
jmp 0x37cc
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movl $0x5, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x37e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x37c4
movq 0x99c4(%rip), %rax      # 0xd178
movq -0x10(%rbp), %rdi
callq *%rax
movq $0x0, -0x8(%rbp)
jmp 0x37cc
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xapi-project[P]rrd-client-lib/parson/parson.c
// Function: json_array_init
static JSON_Array * json_array_init(JSON_Value *wrapping_value) {
    JSON_Array *new_array = (JSON_Array*)parson_malloc(sizeof(JSON_Array));
    if (new_array == NULL) {
        return NULL;
    }
    new_array->wrapping_value = wrapping_value;
    new_array->items = (JSON_Value**)NULL;
    new_array->capacity = 0;
    new_array->count = 0;
    return new_array;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x20, %edi
callq *0x9989(%rip)           # 0xd180
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x380c
movq $0x0, -0x8(%rbp)
jmp 0x3843
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/xapi-project[P]rrd-client-lib/parson/parson.c
// Function: json_value_init_string
JSON_Value * json_value_init_string(const char *string) {
    char *copy = NULL;
    JSON_Value *value;
    size_t string_len = 0;
    if (string == NULL) {
        return NULL;
    }
    string_len = strlen(string);
    if (!is_valid_utf8(string, string_len)) {
        return NULL;
    }
    copy = parson_strndup(string, string_len);
    if (copy == NULL) {
        return NULL;
    }
    value = json_value_init_string_no_copy(copy);
    if (value == NULL) {
        parson_free(copy);
    }
    return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x387d
movq $0x0, -0x8(%rbp)
jmp 0x38f1
movq -0x10(%rbp), %rdi
callq 0x1100
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3900
cmpl $0x0, %eax
jne 0x38a6
movq $0x0, -0x8(%rbp)
jmp 0x38f1
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x3970
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x38c8
movq $0x0, -0x8(%rbp)
jmp 0x38f1
movq -0x18(%rbp), %rdi
callq 0x39e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x38e9
movq 0x9895(%rip), %rax      # 0xd178
movq -0x18(%rbp), %rdi
callq *%rax
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xapi-project[P]rrd-client-lib/parson/parson.c
// Function: is_valid_utf8
static int is_valid_utf8(const char *string, size_t string_len) {
    int len = 0;
    const char *string_end =  string + string_len;
    while (string < string_end) {
        if (!verify_utf8_sequence((const unsigned char*)string, &len)) {
            return 0;
        }
        string += len;
    }
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x395b
movq -0x10(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x75c0
cmpl $0x0, %eax
jne 0x3948
movl $0x0, -0x4(%rbp)
jmp 0x3962
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x3923
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xapi-project[P]rrd-client-lib/parson/parson.c
// Function: parson_strndup
static char * parson_strndup(const char *string, size_t n) {
    char *output_string = (char*)parson_malloc(n + 1);
    if (!output_string) {
        return NULL;
    }
    output_string[n] = '\0';
    strncpy(output_string, string, n);
    return output_string;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq 0x97f9(%rip), %rax      # 0xd180
movq -0x18(%rbp), %rdi
addq $0x1, %rdi
callq *%rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x39a6
movq $0x0, -0x8(%rbp)
jmp 0x39cb
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1070
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xapi-project[P]rrd-client-lib/parson/parson.c
// Function: json_value_init_string_no_copy
static JSON_Value * json_value_init_string_no_copy(char *string) {
    JSON_Value *new_value = (JSON_Value*)parson_malloc(sizeof(JSON_Value));
    if (!new_value) {
        return NULL;
    }
    new_value->parent = NULL;
    new_value->type = JSONString;
    new_value->value.string = string;
    return new_value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x18, %edi
callq *0x9789(%rip)           # 0xd180
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3a0c
movq $0x0, -0x8(%rbp)
jmp 0x3a36
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movl $0x2, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/xapi-project[P]rrd-client-lib/parson/parson.c
// Function: json_value_init_number
JSON_Value * json_value_init_number(double number) {
    JSON_Value *new_value = (JSON_Value*)parson_malloc(sizeof(JSON_Value));
    if (!new_value) {
        return NULL;
    }
    new_value->parent = NULL;
    new_value->type = JSONNumber;
    new_value->value.number = number;
    return new_value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x10(%rbp)
movl $0x18, %edi
callq *0x9728(%rip)           # 0xd180
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3a6d
movq $0x0, -0x8(%rbp)
jmp 0x3a99
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movl $0x3, 0x8(%rax)
movsd -0x10(%rbp), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xapi-project[P]rrd-client-lib/parson/parson.c
// Function: json_value_init_boolean
JSON_Value * json_value_init_boolean(int boolean) {
    JSON_Value *new_value = (JSON_Value*)parson_malloc(sizeof(JSON_Value));
    if (!new_value) {
        return NULL;
    }
    new_value->parent = NULL;
    new_value->type = JSONBoolean;
    new_value->value.boolean = boolean ? 1 : 0;
    return new_value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl $0x18, %edi
callq *0x96ba(%rip)           # 0xd180
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3adb
movq $0x0, -0x8(%rbp)
jmp 0x3b10
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movl $0x6, 0x8(%rax)
movl -0xc(%rbp), %edx
xorl %ecx, %ecx
movl $0x1, %eax
cmpl $0x0, %edx
cmovnel %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xapi-project[P]rrd-client-lib/parson/parson.c
// Function: json_value_init_null
JSON_Value * json_value_init_null(void) {
    JSON_Value *new_value = (JSON_Value*)parson_malloc(sizeof(JSON_Value));
    if (!new_value) {
        return NULL;
    }
    new_value->parent = NULL;
    new_value->type = JSONNull;
    return new_value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x18, %edi
callq *0x964d(%rip)           # 0xd180
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3b48
movq $0x0, -0x8(%rbp)
jmp 0x3b66
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/xapi-project[P]rrd-client-lib/parson/parson.c
// Function: json_array_add
static JSON_Status json_array_add(JSON_Array *array, JSON_Value *value) {
    if (array->count >= array->capacity) {
        size_t new_capacity = MAX(array->capacity * 2, STARTING_CAPACITY);
        if (new_capacity > ARRAY_MAX_CAPACITY) {
            return JSONFailure;
        }
        if (json_array_resize(array, new_capacity) == JSONFailure) {
            return JSONFailure;
        }
    }
    value->parent = json_array_get_wrapping_value(array);
    array->items[array->count] = value;
    array->count++;
    return JSONSuccess;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jb 0x3f37
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
shlq %rax
cmpq $0xf, %rax
jbe 0x3ef4
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
shlq %rax
movq %rax, -0x28(%rbp)
jmp 0x3eff
movl $0xf, %eax
movq %rax, -0x28(%rbp)
jmp 0x3eff
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x1e000, -0x20(%rbp)   # imm = 0x1E000
jbe 0x3f1a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3f79
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x7440
cmpl $-0x1, %eax
jne 0x3f35
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3f79
jmp 0x3f37
movq -0x10(%rbp), %rdi
callq 0x3460
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/xapi-project[P]rrd-client-lib/parson/parson.c
// Function: json_object_add
static JSON_Status json_object_add(JSON_Object *object, const char *name, JSON_Value *value) {
    size_t index = 0;
    if (object == NULL || name == NULL || value == NULL) {
        return JSONFailure;
    }
    if (json_object_get_value(object, name) != NULL) {
        return JSONFailure;
    }
    if (object->count >= object->capacity) {
        size_t new_capacity = MAX(object->capacity * 2, STARTING_CAPACITY);
        if (new_capacity > OBJECT_MAX_CAPACITY) {
            return JSONFailure;
        }
        if (json_object_resize(object, new_capacity) == JSONFailure) {
            return JSONFailure;
        }
    }
    index = object->count;
    object->names[index] = parson_strdup(name);
    if (object->names[index] == NULL) {
        return JSONFailure;
    }
    value->parent = json_object_get_wrapping_value(object);
    object->values[index] = value;
    object->count++;
    return JSONSuccess;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3fc1
cmpq $0x0, -0x18(%rbp)
je 0x3fc1
cmpq $0x0, -0x20(%rbp)
jne 0x3fcd
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x40eb
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2be0
cmpq $0x0, %rax
je 0x3fec
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x40eb
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jb 0x4069
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
shlq %rax
cmpq $0xf, %rax
jbe 0x4020
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
shlq %rax
movq %rax, -0x38(%rbp)
jmp 0x402b
movl $0xf, %eax
movq %rax, -0x38(%rbp)
jmp 0x402b
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x3c0, -0x30(%rbp)     # imm = 0x3C0
jbe 0x4049
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x40eb
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x6c00
cmpl $-0x1, %eax
jne 0x4067
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x40eb
jmp 0x4069
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2a10
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x40ad
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x40eb
movq -0x10(%rbp), %rdi
callq 0x3190
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)