LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/config.c
// Function: cfg_print
void cfg_print(struct cfg *self, FILE* stream)
{
    size_t el=0;
    int n_indent=0;

    if (!self)
        return;

    for (el=0; el<self->size; el++) {
        cfg_field_print(self->fields[el], n_indent, stream);
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x7f38
jmp 0x7f77
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x7f77
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl -0x1c(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x7f80
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x7f40
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/config.c
// Function: cfg_read
struct cfg *cfg_read(const char* filename, enum cfg_status *status) 
{
    struct cfg *cfg=NULL;
    struct cfg_string *str=NULL;
    size_t current=0;

    str = read_whole_file(filename);
    if (!str) {
        *status = CFG_READ_ERROR;
        return NULL;
    }

    cfg=cfg_parse(str, &current, status);
    str=cfg_string_free(str);
    return cfg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x81d0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x8190
movq -0x18(%rbp), %rax
movl $0x2, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x81ba
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0x30(%rbp), %rsi
callq 0x8380
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rdi
callq 0x8500
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/config.c
// Function: read_whole_file
static struct cfg_string *read_whole_file(const char* filename)
{
    FILE* fp=NULL;
    char *data=NULL;
    size_t nchar=0, nread=0;
    struct cfg_string *str=NULL;

    fp = fopen(filename,"r");
    if (fp==NULL) {
        fprintf(stderr,"Could not open file: %s\n", filename);
        return NULL;
    }

    fseek(fp, 0, SEEK_END);
    nchar = ftell(fp);
    rewind(fp);

    data = calloc(sizeof(char), nchar + 1);
    if (!data) {
        fprintf(stderr,"Could not allocate %lu bytes for whole file read\n", nchar);
        exit(1);
    }

    nread=fread(data, 1, nchar, fp);
    if(ferror(fp) || nread!=nchar){
        fprintf(stderr,"Error reading file\n");
        free(data);
        goto _read_whole_file_bail;
    }

    str = calloc(1, sizeof(struct cfg_string));
    if (str == NULL) {
        fprintf(stderr,"Could not allocate cfg_string container for file string\n");
        exit(1);
    }

    str->size = nchar;
    str->data = data;
_read_whole_file_bail:
    fclose(fp);
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x695d(%rip), %rsi      # 0xeb6c
callq 0x2210
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x8248
movq 0x9dd2(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x6a50(%rip), %rsi      # 0xec84
movb $0x0, %al
callq 0x2170
movq $0x0, -0x8(%rbp)
jmp 0x836c
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x21f0
movq -0x18(%rbp), %rdi
callq 0x2180
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x20f0
movq -0x28(%rbp), %rsi
addq $0x1, %rsi
movl $0x1, %edi
callq 0x2140
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x82b3
movq 0x9d64(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq -0x28(%rbp), %rdx
leaq 0x69fb(%rip), %rsi      # 0xec9d
movb $0x0, %al
callq 0x2170
movl $0x1, %edi
callq 0x2250
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rcx
movl $0x1, %esi
callq 0x20a0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2080
cmpl $0x0, %eax
jne 0x82e5
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x8308
movq 0x9d0c(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x69d9(%rip), %rsi      # 0xeccf
movb $0x0, %al
callq 0x2170
movq -0x20(%rbp), %rdi
callq 0x2030
jmp 0x835b
movl $0x1, %edi
movl $0x10, %esi
callq 0x2140
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x8344
movq 0x9ccf(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x69b0(%rip), %rsi      # 0xece3
movb $0x0, %al
callq 0x2170
movl $0x1, %edi
callq 0x2250
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdi
callq 0x20c0
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/config.c
// Function: cfg_string_free
static struct cfg_string *cfg_string_free(struct cfg_string *str)
{
    if (str) {
        free(str->data);
        free(str);
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x8529
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rdi
callq 0x2030
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/config.c
// Function: cfg_get_double
double cfg_get_double(const struct cfg *self,
                      const char *name,
                      enum cfg_status *status)
{
    double val=0;
    const struct cfg_field *field=NULL;
    char *str=NULL;

    field = cfg_find(self, name, status);
    if (*status==CFG_SUCCESS) {
        if (CFG_TYPE_SCALAR != CFG_FIELD_TYPE(field)) {
            *status = CFG_TYPE_ERROR;
        } else {
            str = CFG_FIELD_GET_DATA(field, 0);
            val = extract_double(str, status);
        }
    }
    return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x85e0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x85c8
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpl 0x8(%rcx), %eax
je 0x85a1
movq -0x18(%rbp), %rax
movl $0x9, (%rax)
jmp 0x85c6
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x86a0
movsd %xmm0, -0x20(%rbp)
jmp 0x85c8
movsd -0x20(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/config.c
// Function: cfg_find
static const struct cfg_field *cfg_find(const struct cfg *self, 
                                        const char* name, 
                                        enum cfg_status *status)
{
    size_t i=0;
    const struct cfg_field *field=NULL, *tmp=NULL;

    *status=CFG_NOT_FOUND;
    if (!self) {
        return field;
    }
    for (i=0; i<CFG_SIZE(self); i++) {
        tmp = CFG_FIELD(self,i);
        if (0 == strcmp(name, CFG_FIELD_NAME(tmp))) {
            *status=CFG_SUCCESS;
            field=tmp;
            break;
        }
    }

    return field;
}

// 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 $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x20(%rbp), %rax
movl $0x7, (%rax)
cmpq $0x0, -0x10(%rbp)
jne 0x8627
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8694
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x868c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rax
movq (%rax), %rsi
callq 0x2150
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x867c
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x868c
jmp 0x867e
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x862f
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/config.c
// Function: extract_double
static double extract_double(const char *str, enum cfg_status *status)
{
    char *endptr=NULL;
    double val=0;

    *status = CFG_SUCCESS;

    endptr=(char*) str;
    val = strtod(str, &endptr);
    if (endptr == str) {
        fprintf(stderr,"Failed to convert data to a double: '%s'\n", str);
        *status=CFG_TYPE_ERROR;
    }
    return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x20b0
movsd %xmm0, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x8(%rbp), %rax
jne 0x8714
movq 0x9903(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x66ec(%rip), %rsi      # 0xedef
movb $0x0, %al
callq 0x2170
movq -0x10(%rbp), %rax
movl $0x9, (%rax)
movsd -0x20(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/config.c
// Function: cfg_get_dblarr
double *cfg_get_dblarr(const struct cfg *self,
                       const char *name,
                       size_t *size,
                       enum cfg_status *status)
{
    double *arr=NULL;
    const struct cfg_field *field=NULL;

    field = cfg_find(self, name, status);
    if (*status==CFG_SUCCESS) {
        if (CFG_TYPE_ARRAY != CFG_FIELD_TYPE(field)) {
            *status = CFG_TYPE_ERROR;
        } else {
            arr = extract_dblarr(field, size, status);
        }
    }
    return arr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x85e0
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x8797
movq -0x30(%rbp), %rcx
movl $0x1, %eax
cmpl 0x8(%rcx), %eax
je 0x8780
movq -0x20(%rbp), %rax
movl $0x9, (%rax)
jmp 0x8795
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x87b0
movq %rax, -0x28(%rbp)
jmp 0x8797
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/config.c
// Function: extract_dblarr
static double *extract_dblarr(const struct cfg_field *self,
                              size_t *size,
                              enum cfg_status *status)
{
    double *out=NULL, tmp=0;
    struct cfg_strvec *vec=NULL;
    size_t i=0;

    *size=0;

    *status = CFG_SUCCESS;
    if (!self) {
        // not OK to have null field!
        *status = CFG_EMPTY;
        goto _extract_dblarr_bail;
    }

    vec = CFG_FIELD_GET_VEC(self);

    if (!vec || vec->size==0) {
        // ok to have empty array, just exit
        goto _extract_dblarr_bail;
    }

    out = calloc(vec->size, sizeof(double));

    if (!out){
        fprintf(stderr,"Failed to allocate double array copy for field '%s'\n", 
                CFG_FIELD_NAME(self));
        exit(1);
    }

    for (i=0; i<vec->size; i++) {
        tmp = extract_double(vec->data[i], status);
        if (*status) {
            goto _extract_dblarr_bail;
        }
        out[i] = tmp;
    }
    *size = vec->size;

_extract_dblarr_bail:
    if (*status) {
        free(out);
        out=NULL;
    }

    return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
cmpq $0x0, -0x8(%rbp)
jne 0x880f
movq -0x18(%rbp), %rax
movl $0x8, (%rax)
jmp 0x88e2
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x882c
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x8831
jmp 0x88e2
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movl $0x8, %esi
callq 0x2140
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x8876
movq 0x97a4(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
leaq 0x65b4(%rip), %rsi      # 0xee19
movb $0x0, %al
callq 0x2170
movl $0x1, %edi
callq 0x2250
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x88d4
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x86a0
movsd %xmm0, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x88b4
jmp 0x88e2
movsd -0x28(%rbp), %xmm0
movq -0x20(%rbp), %rax
movq -0x38(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x887e
movq -0x30(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x88fc
movq -0x20(%rbp), %rdi
callq 0x2030
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/config.c
// Function: cfg_get_long
long cfg_get_long(const struct cfg *self,
                  const char *name,
                  enum cfg_status *status)
{
    long val=0;
    const struct cfg_field *field=NULL;
    char *str=NULL;

    field = cfg_find(self, name, status);
    if (*status==CFG_SUCCESS) {
        if (CFG_TYPE_SCALAR != CFG_FIELD_TYPE(field)) {
            *status = CFG_TYPE_ERROR;
        } else {
            str = CFG_FIELD_GET_DATA(field, 0);
            val = extract_long(str, status);
        }
    }
    return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x85e0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x8997
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpl 0x8(%rcx), %eax
je 0x8971
movq -0x18(%rbp), %rax
movl $0x9, (%rax)
jmp 0x8995
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x89b0
movq %rax, -0x20(%rbp)
jmp 0x8997
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/config.c
// Function: extract_long
static long extract_long(const char *str, enum cfg_status *status)
{
    char *endptr=NULL;
    long val=0;

    *status = CFG_SUCCESS;

    endptr=(char*) str;
    val = strtol(str, &endptr, 10);
    if (endptr == str) {
        fprintf(stderr,"Failed to convert data to a long : '%s'\n", str);
        *status=CFG_TYPE_ERROR;
    }
    return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movl $0xa, %edx
callq 0x2190
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x8(%rbp), %rax
jne 0x8a28
movq 0x95ef(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x6437(%rip), %rsi      # 0xee4e
movb $0x0, %al
callq 0x2170
movq -0x10(%rbp), %rax
movl $0x9, (%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/config.c
// Function: cfg_get_lonarr
long *cfg_get_lonarr(const struct cfg *self,
                       const char *name,
                       size_t *size,
                       enum cfg_status *status)
{
    long *arr=NULL;
    const struct cfg_field *field=NULL;

    field = cfg_find(self, name, status);
    if (*status==CFG_SUCCESS) {
        if (CFG_TYPE_ARRAY != CFG_FIELD_TYPE(field)) {
            *status = CFG_TYPE_ERROR;
        } else {
            arr = extract_lonarr(field, size, status);
        }
    }
    return arr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x85e0
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x8ab7
movq -0x30(%rbp), %rcx
movl $0x1, %eax
cmpl 0x8(%rcx), %eax
je 0x8aa0
movq -0x20(%rbp), %rax
movl $0x9, (%rax)
jmp 0x8ab5
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x8ad0
movq %rax, -0x28(%rbp)
jmp 0x8ab7
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/config.c
// Function: extract_lonarr
static long *extract_lonarr(const struct cfg_field *self,
                            size_t *size,
                            enum cfg_status *status)
{
    long *out=NULL, tmp=0;
    struct cfg_strvec *vec=NULL;
    size_t i=0;

    *size=0;

    *status = CFG_SUCCESS;
    if (!self) {
        // not OK to have null field!
        *status = CFG_EMPTY;
        goto _extract_lonarr_bail;
    }

    vec = CFG_FIELD_GET_VEC(self);

    if (!vec || vec->size==0) {
        // ok to have empty array, just exit
        goto _extract_lonarr_bail;
    }

    out = calloc(vec->size, sizeof(long));

    if (!out){
        fprintf(stderr,"Failed to allocate long array copy for field '%s'\n", 
                CFG_FIELD_NAME(self));
        exit(1);
    }

    for (i=0; i<vec->size; i++) {
        tmp = extract_long(vec->data[i], status);
        if (*status) {
            goto _extract_lonarr_bail;
        }
        out[i] = tmp;
    }
    *size = vec->size;

_extract_lonarr_bail:
    if (*status) {
        free(out);
        out=NULL;
    }

    return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
cmpq $0x0, -0x8(%rbp)
jne 0x8b2f
movq -0x18(%rbp), %rax
movl $0x8, (%rax)
jmp 0x8bff
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x8b4c
movq -0x30(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x8b51
jmp 0x8bff
movq -0x30(%rbp), %rax
movq (%rax), %rdi
movl $0x8, %esi
callq 0x2140
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x8b96
movq 0x9484(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
leaq 0x62f2(%rip), %rsi      # 0xee77
movb $0x0, %al
callq 0x2170
movl $0x1, %edi
callq 0x2250
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x8bf1
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x89b0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x8bd3
jmp 0x8bff
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x8b9e
movq -0x30(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x8c19
movq -0x20(%rbp), %rdi
callq 0x2030
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/config.c
// Function: cfg_get_string
char *cfg_get_string(const struct cfg *self,
                     const char *name,
                     enum cfg_status *status)
{
    char *str=NULL;
    const struct cfg_field *field=NULL;

    field = cfg_find(self, name, status);
    if (*status==CFG_SUCCESS) {
        if (CFG_TYPE_SCALAR != CFG_FIELD_TYPE(field)) {
            *status = CFG_TYPE_ERROR;
        } else {
            if (0==CFG_FIELD_ARR_SIZE(field)) {
                *status = CFG_EMPTY;
            } else {
                str = cfg_strdup( CFG_FIELD_GET_DATA(field, 0) );
            }
        }
    }
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x85e0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x8cc0
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpl 0x8(%rcx), %eax
je 0x8c89
movq -0x18(%rbp), %rax
movl $0x9, (%rax)
jmp 0x8cbe
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
jne 0x8ca4
movq -0x18(%rbp), %rax
movl $0x8, (%rax)
jmp 0x8cbc
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
callq 0x8cd0
movq %rax, -0x20(%rbp)
jmp 0x8cbe
jmp 0x8cc0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/config.c
// Function: cfg_strdup
static char *cfg_strdup(const char *s) {
    char *p = malloc(strlen(s) + 1);
    if(p) {
        strcpy(p, s);
    }
    return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20d0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x21d0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x8d09
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x2060
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/config.c
// Function: cfg_get_strarr
char **cfg_get_strarr(const struct cfg *self,
                      const char *name,
                      size_t *size,
                      enum cfg_status *status)
{
    char **sarr=NULL;
    const struct cfg_field *field=NULL;

    field = cfg_find(self, name, status);
    if (*status==CFG_SUCCESS) {
        if (CFG_TYPE_ARRAY != CFG_FIELD_TYPE(field)) {
            *status = CFG_TYPE_ERROR;
        } else {
            sarr = cfg_strvec2arr(CFG_FIELD_GET_VEC(field), size);
            if (!sarr) {
                *status=CFG_EMPTY;
            }
        }
    }
    return sarr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x85e0
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x8daa
movq -0x30(%rbp), %rcx
movl $0x1, %eax
cmpl 0x8(%rcx), %eax
je 0x8d80
movq -0x20(%rbp), %rax
movl $0x9, (%rax)
jmp 0x8da8
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x8dc0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x8da6
movq -0x20(%rbp), %rax
movl $0x8, (%rax)
jmp 0x8da8
jmp 0x8daa
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/config.c
// Function: cfg_strvec2arr
static char **cfg_strvec2arr(struct cfg_strvec *vec, size_t *size)
{
    char **sarr=NULL;
    size_t i=0;

    *size=0;
    if (!vec || vec->size == 0) {
        return sarr;
    }

    *size=vec->size;
    sarr=calloc((*size), sizeof(char*));
    if (!sarr) {
        fprintf(stderr,"could not allocate for copy of strvec\n");
        exit(1);
    }
    for (i=0; i<(*size); i++) {
        sarr[i] = cfg_strdup(vec->data[i]);
    }

    return sarr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
cmpq $0x0, -0x10(%rbp)
je 0x8dfc
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x8e09
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x8ea4
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x8, %esi
callq 0x2140
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x8e55
movq 0x91be(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x6066(%rip), %rsi      # 0xeeaa
movb $0x0, %al
callq 0x2170
movl $0x1, %edi
callq 0x2250
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x8e9c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x8cd0
movq %rax, %rdx
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x8e5d
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/config.c
// Function: cfg_get_sub
struct cfg *cfg_get_sub(const struct cfg *self,
                        const char *name,
                        enum cfg_status *status)
{
    struct cfg *sub=NULL;
    const struct cfg_field *field=NULL;

    field = cfg_find(self, name, status);
    if (*status==CFG_SUCCESS) {
        if (CFG_TYPE_CFG != CFG_FIELD_TYPE(field)) {
            *status = CFG_TYPE_ERROR;
        } else {
            sub = CFG_FIELD_GET_SUB(field);
            if (!sub) {
                *status=CFG_EMPTY;
            }
        }
    }
    return sub;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x85e0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x8f2d
movq -0x28(%rbp), %rcx
movl $0x2, %eax
cmpl 0x8(%rcx), %eax
je 0x8f0c
movq -0x18(%rbp), %rax
movl $0x9, (%rax)
jmp 0x8f2b
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x8f29
movq -0x18(%rbp), %rax
movl $0x8, (%rax)
jmp 0x8f2b
jmp 0x8f2d
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/config.c
// Function: cfg_strvec_free
static struct cfg_strvec *cfg_strvec_free(struct cfg_strvec* vec)
{
    if (vec) {
        if (vec->data) {
            vec->data = cfg_strarr_free(vec->data, vec->capacity);
        }
        free(vec);
    }
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x8f87
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x8f7e
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x7d40
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
callq 0x2030
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/config.c
// Function: cfg_field_print_data
static void cfg_field_print_data(struct cfg_field *self, size_t el, FILE* stream)
{
    char *tmp=NULL;
    size_t len=0, i=0;
    int c=0;
    if (CFG_ELTYPE_QUOTED_STRING==CFG_FIELD_ELTYPE(self)) {
        tmp = CFG_FIELD_GET_DATA(self,el);
        len=strlen(tmp);
        fprintf(stream,"\"");
        for (i=0; i<len; i++) {
            c=tmp[i];
            if (c == '"') {
                fprintf(stream,"\\\"");
            } else {
                fprintf(stream,"%c", c);
            }
        }
        fprintf(stream,"\"");
    } else {
        fprintf(stream, "%s", CFG_FIELD_GET_DATA(self,el));
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x8(%rbp), %rcx
movl $0x1, %eax
cmpl 0xc(%rcx), %eax
jne 0x90d0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x20d0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x5c2d(%rip), %rsi      # 0xec82
movb $0x0, %al
callq 0x2170
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x90bc
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x34(%rbp)
cmpl $0x22, -0x34(%rbp)
jne 0x9097
movq -0x18(%rbp), %rdi
leaq 0x5bf3(%rip), %rsi      # 0xec81
movb $0x0, %al
callq 0x2170
jmp 0x90ac
movq -0x18(%rbp), %rdi
movl -0x34(%rbp), %edx
leaq 0x5129(%rip), %rsi      # 0xe1ce
movb $0x0, %al
callq 0x2170
jmp 0x90ae
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x9064
movq -0x18(%rbp), %rdi
leaq 0x5bbb(%rip), %rsi      # 0xec82
movb $0x0, %al
callq 0x2170
jmp 0x90f6
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
leaq 0x5b86(%rip), %rsi      # 0xec75
movb $0x0, %al
callq 0x2170
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/config.c
// Function: cfg_print
static void _cfg_print(struct cfg *self, int n_indent, FILE* stream)
{
    size_t el=0;

    if (!self)
        return;

    for (el=0; el<self->size; el++) {
        cfg_field_print(self->fields[el], n_indent, stream);
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x9124
jmp 0x9163
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x9163
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x7f80
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x912c
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/config.c
// Function: find_nonwhite
static size_t find_nonwhite(const struct cfg_string *str, size_t current, enum cfg_status *status)
{
    size_t i=0, loc=0;

    loc=current;

    *status=CFG_EOF;
    // this accounts for case where current is out of bounds
    for (i=current; i<str->size; i++) {
        if (!isspace(str->data[i])) {

            if (str->data[i] == CFG_COMMENT) {
                // found a comment, skip to next EOL
                i = skip_comment(str, i, status);
                // also set loc in case we exit the loop
                loc=i;
                if (*status==CFG_EOF) { // EOF, loc remains at current
                    break;
                }
                continue;
            }

            *status=CFG_SUCCESS;
            loc=i;
            break;
        }
    }
    return loc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl $0x6, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x924e
callq 0x2280
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x20(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
jne 0x923b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x23, %eax
jne 0x9227
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x95a0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x6, (%rax)
jne 0x9225
jmp 0x924e
jmp 0x923d
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x924e
jmp 0x923d
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x91ae
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/config.c
// Function: cfg_append
static void cfg_append(struct cfg *self, struct cfg_field *field)
{
    size_t size=0;
    size = self->size;

    if (size == self->capacity) {
        cfg_realloc(self, self->capacity*2);
    }
    self->size++;
    self->fields[self->size-1] = field;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x94e5
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
shlq %rsi
callq 0xa010
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
subq $0x1, %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/config.c
// Function: cfg_new
static struct cfg *cfg_new()
{
    struct cfg *self=NULL;

    self=calloc(1, sizeof(struct cfg));
    if (NULL == self) {
        fprintf(stderr,"Failed to create config struct\n");
        exit(1);
    }

    self->fields = calloc(1, sizeof(struct cfg_field*));
    self->capacity=1;
    return self;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq $0x0, -0x8(%rbp)
movl $0x1, %edi
movl $0x18, %esi
callq 0x2140
movq %rax, -0x8(%rbp)
xorl %eax, %eax
cmpq -0x8(%rbp), %rax
jne 0x956d
movq 0x8aa6(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x57c0(%rip), %rsi      # 0xed1c
movb $0x0, %al
callq 0x2170
movl $0x1, %edi
callq 0x2250
movl $0x1, %edi
movl $0x8, %esi
callq 0x2140
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x1, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/config.c
// Function: find_char
static size_t find_char(const struct cfg_string *str, size_t current, int ch, 
                        enum cfg_status *status)
{
    size_t i=0, loc=-1;

    *status=CFG_EOF;
    // this accounts for case where current is out of bounds
    for (i=current; i<str->size; i++) {
        if (str->data[i] == ch) {
            *status=CFG_SUCCESS;
            loc=i;
            break;
        }
    }
    return loc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $-0x1, -0x30(%rbp)
movq -0x20(%rbp), %rax
movl $0x6, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x965b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl -0x14(%rbp), %eax
jne 0x964b
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x965b
jmp 0x964d
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x9615
movq -0x30(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/config.c
// Function: copy_next_identifier
static char *copy_next_identifier(const struct cfg_string *str, 
                           size_t current, 
                           size_t *end, 
                           enum cfg_status *status)
{
    char *name=NULL;
    size_t sbeg=0, send=0, size=0;
    find_next_identifier(str, current, &sbeg, end, status);
    if (*status) {
        return NULL;
    }

    send=*end-1;
    size=(send-sbeg+1);
    name=calloc(size+1, sizeof(char));
    if (!name) {
        fprintf(stderr,"could not allocate for name\n");
        exit(1);
    }
    strncpy(name, &str->data[sbeg], size);

    rstrip_inplace(name,size);
    return name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
leaq -0x38(%rbp), %rdx
callq 0x9ba0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x96d7
movq $0x0, -0x8(%rbp)
jmp 0x9763
movq -0x20(%rbp), %rax
movq (%rax), %rax
subq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
subq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
addq $0x1, %rdi
movl $0x1, %esi
callq 0x2140
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x9735
movq 0x88de(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x5618(%rip), %rsi      # 0xed3c
movb $0x0, %al
callq 0x2170
movl $0x1, %edi
callq 0x2250
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
addq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x2040
movq -0x30(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x9c30
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/config.c
// Function: copy_quoted_string
static size_t copy_quoted_string(struct cfg_field *field,
                                 const struct cfg_string *str,
                                 size_t current,
                                 enum cfg_status *status)
{
    size_t sbeg=0, endquote=0, send=0, size=0, isrc=0, idst=0;
    int c=0, cold=0;
    char *tmp=NULL;

    // skip past opening quote
    sbeg = current+1;
    endquote = find_end_of_quoted_string(str,current,status);
    if (*status) {
        return endquote;
    }

    // step back from final quote
    send = endquote-1;

    size=(send-sbeg+1);
    tmp=calloc(size+1, sizeof(char));

    // now copy but skip leading \ for \" imbedded quotes
    for (isrc=0; isrc<size; isrc++) {
        c=str->data[sbeg+isrc];
        if (cold == '\\' && c == '"') {
            tmp[idst-1] = '"';
        } else {
            tmp[idst] = c;
            idst++;
        }
        cold=c;
    }
    // ownership given to the vector
    cfg_strvec_append_nocopy(field->strvec, tmp);

    return endquote;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
movl $0x0, -0x5c(%rbp)
movl $0x0, -0x60(%rbp)
movq $0x0, -0x68(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x9e00
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9975
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9a37
movq -0x38(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
subq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
addq $0x1, %rdi
movl $0x1, %esi
callq 0x2140
movq %rax, -0x68(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x50(%rbp), %rax
cmpq -0x48(%rbp), %rax
jae 0x9a1e
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x30(%rbp), %rcx
addq -0x50(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x5c(%rbp)
cmpl $0x5c, -0x60(%rbp)
jne 0x99ee
cmpl $0x22, -0x5c(%rbp)
jne 0x99ee
movq -0x68(%rbp), %rax
movq -0x58(%rbp), %rcx
subq $0x1, %rcx
movb $0x22, (%rax,%rcx)
jmp 0x9a0a
movl -0x5c(%rbp), %eax
movb %al, %dl
movq -0x68(%rbp), %rax
movq -0x58(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x58(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x58(%rbp)
movl -0x5c(%rbp), %eax
movl %eax, -0x60(%rbp)
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x99af
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x68(%rbp), %rsi
callq 0x9eb0
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/config.c
// Function: copy_bare_array_token
static size_t copy_bare_array_token(struct cfg_field *field,
                                    const struct cfg_string *str,
                                    size_t current,
                                    enum cfg_status *status)
{
    size_t beg=0, end=0, size=0;
    int c=0;
    char *tmp=NULL;
    // single token expected now.  no need to check status

    beg=current;
    end=current;
    *status=CFG_EOF;
    do {
        current++;
        if (current > (str->size-1)) {
            goto _copy_bare_array_token_bail;
        }
        c=str->data[current];
    } while (!isspace(c) && c != CFG_ARRAY_SEP && c != CFG_ARRAY_END && c != CFG_CFG_END);

    *status=CFG_SUCCESS;

    end=current-1;
    size=(end-beg+1);

    tmp=calloc(size+1, sizeof(char));

    strncpy(tmp, &str->data[beg], size);
    // ownership transferred to vector
    cfg_strvec_append_nocopy(field->strvec, tmp);

_copy_bare_array_token_bail:
    return current;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movl $0x6, (%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jbe 0x9ace
jmp 0x9b8e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x3c(%rbp)
callq 0x2280
movq (%rax), %rax
movslq -0x3c(%rbp), %rcx
movzwl (%rax,%rcx,2), %ecx
andl $0x2000, %ecx           # imm = 0x2000
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x49(%rbp)
jne 0x9b21
xorl %eax, %eax
cmpl $0x2c, -0x3c(%rbp)
movb %al, -0x49(%rbp)
je 0x9b21
xorl %eax, %eax
cmpl $0x5d, -0x3c(%rbp)
movb %al, -0x49(%rbp)
je 0x9b21
cmpl $0x7d, -0x3c(%rbp)
setne %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x9aa9
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movq -0x18(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
subq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
addq $0x1, %rdi
movl $0x1, %esi
callq 0x2140
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
addq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x48(%rbp), %rsi
callq 0x9eb0
movq -0x18(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/config.c
// Function: find_next_identifier
static void find_next_identifier(const struct cfg_string *str, 
                                 size_t current, 
                                 size_t *beg, 
                                 size_t *end, 
                                 enum cfg_status *status)
{
    while (1) {
        // skip any whitespace and comments
        current = find_nonwhite(str, current, status);
        if (*status) { // EOF
            return;
        }

        *beg=current;

        // now find the assignment character
        current = find_char(str, current, CFG_ASSIGN, status);
        if (*status) {
            // this can't be good; must have left off the assignment char
            return;
        }
        *status = CFG_SUCCESS;
        *end=current;
        break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x9170
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9bdc
jmp 0x9c21
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rcx
movl $0x3d, %edx
callq 0x95e0
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x9c0c
jmp 0x9c21
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/config.c
// Function: rstrip_inplace
static void rstrip_inplace(char *str, size_t len)
{
    size_t i=0;
    
    for (i=0;i<len;i++) {
        if (isspace(str[i])) {
            str[i] = '\0';
	    break;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x9c9d
callq 0x2280
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x9c8d
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x9c9d
jmp 0x9c8f
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x9c50
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/config.c
// Function: cfg_field_new
static struct cfg_field *cfg_field_new()
{
    struct cfg_field *self=NULL;

    self=calloc(1, sizeof(struct cfg_field));
    if (NULL == self) {
        fprintf(stderr,"Failed to create config field\n");
        exit(1);
    }

    self->strvec = cfg_strvec_new();
    if (!self->strvec) {
        fprintf(stderr,"Failed to create config field\n");
        exit(1);
    }
    return self;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq $0x0, -0x8(%rbp)
movl $0x1, %edi
movl $0x20, %esi
callq 0x2140
movq %rax, -0x8(%rbp)
xorl %eax, %eax
cmpq -0x8(%rbp), %rax
jne 0x9cfd
movq 0x8316(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x506d(%rip), %rsi      # 0xed59
movb $0x0, %al
callq 0x2170
movl $0x1, %edi
callq 0x2250
callq 0x9d50
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x9d3a
movq 0x82d9(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x5030(%rip), %rsi      # 0xed59
movb $0x0, %al
callq 0x2170
movl $0x1, %edi
callq 0x2250
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/config.c
// Function: cfg_strvec_new
static struct cfg_strvec *cfg_strvec_new()
{
    struct cfg_strvec *vec=NULL;
    vec=calloc(1, sizeof(struct cfg_strvec));
    if (vec==NULL) {
        fprintf(stderr,"Could not allocate cfg_strarr\n");
        exit(1);
    }
    vec->data = calloc(1, sizeof(char*));
    if (vec->data == NULL) {
        fprintf(stderr,"Failed to allocate config list\n");
        exit(1);
    }
    vec->capacity=1;
    return vec;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq $0x0, -0x8(%rbp)
movl $0x1, %edi
movl $0x18, %esi
callq 0x2140
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x9d9c
movq 0x8277(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x4fed(%rip), %rsi      # 0xed78
movb $0x0, %al
callq 0x2170
movl $0x1, %edi
callq 0x2250
movl $0x1, %edi
movl $0x8, %esi
callq 0x2140
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x9de3
movq 0x8230(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x4fc5(%rip), %rsi      # 0xed97
movb $0x0, %al
callq 0x2170
movl $0x1, %edi
callq 0x2250
movq -0x8(%rbp), %rax
movq $0x1, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)