LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/esheldon[P]xshear/src/sconfig.c
// Function: get_weight_style
static int get_weight_style(struct cfg *cfg) {
    enum cfg_status status=0;
    int weight_style=0;

    char *mstr = cfg_get_string(cfg,"weight_style", &status);
    if (status) {
        wlog("    weight style not sent, defaulting to optimal\n");
        // not sent, default to Mpc
        return WEIGHT_STYLE_OPTIMAL;
    }

    if (0 == do_strncmp(mstr,WEIGHT_STYLE_OPTIMAL_STR)) {
        weight_style=WEIGHT_STYLE_OPTIMAL;
    } else if (0 == do_strncmp(mstr,WEIGHT_STYLE_UNIFORM_STR)) {
        weight_style=WEIGHT_STYLE_UNIFORM;
    } else {
        fprintf(stderr, "Config Error: bad weight_style: '%s'\n", mstr);
        exit(1);
    }

    free(mstr);

    return weight_style;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0xc(%rsp), %r14
movl $0x0, (%r14)
leaq 0x35e3(%rip), %rsi      # 0x9ba8
movq %r14, %rdx
callq 0x7251
cmpl $0x0, (%r14)
jne 0x6621
movq %rax, %rbx
leaq 0x360a(%rip), %rsi      # 0x9be7
movq %rax, %rdi
callq 0x667d
testl %eax, %eax
je 0x6609
leaq 0x35ff(%rip), %rsi      # 0x9bef
movq %rbx, %rdi
callq 0x667d
movl $0x2, %ebp
testl %eax, %eax
je 0x660e
movq %rbx, %rdi
callq 0x3631
movl $0x1, %ebp
movq %rbx, %rdi
callq 0x2030
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x360f
movl $0x1, %ebp
jmp 0x6616
// File: /workspace/github_c_makefile_star2_O3/esheldon[P]xshear/src/sconfig.c
// Function: sconfig_free
ShearConfig* sconfig_free(ShearConfig* self) {
    if (self != NULL) {
        free(self->zl);
    }
    free(self);
    return NULL;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x663f
movq 0x38(%rbx), %rdi
callq 0x2030
movq %rbx, %rdi
callq 0x2030
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/esheldon[P]xshear/src/sconfig.c
// Function: sconfig_open_pair_url
void sconfig_open_pair_url(ShearConfig* c, const char* url) {
    c->pair_fd = fopen(url, "w");
    if(!c->pair_fd) {
        fprintf(stderr,"Could not open pair log file %s\n", url);
        exit(1);
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x32a7(%rip), %rsi      # 0x9903
movq %rbx, %rdi
callq 0x2240
movq %rax, 0x60(%r14)
testq %rax, %rax
je 0x6675
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x3655
// File: /workspace/github_c_makefile_star2_O3/esheldon[P]xshear/src/config.c
// Function: cfg_strarr_free
char **cfg_strarr_free(char **arr, size_t size)
{
    size_t i=0;
    if (arr) {
        for (i=0; i<size; i++) {
            free(arr[i]);
            arr[i]=NULL;
        }
        free(arr); arr=NULL;
    }
    return NULL;
}

// Assembly:
testq %rdi, %rdi
je 0x66f2
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x66e5
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdi
callq 0x2030
movq $0x0, (%rbx,%r15,8)
incq %r15
cmpq %r15, %r14
jne 0x66cc
movq %rbx, %rdi
callq 0x2030
popq %rbx
popq %r14
popq %r15
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/esheldon[P]xshear/src/config.c
// Function: cfg_free
struct cfg *cfg_free(struct cfg *self)
{
    if (self) {
        if (self->fields) {
            size_t i=0;
            for (i=0; i<self->size; i++) {
                self->fields[i] = cfg_field_free(self->fields[i]);
            }
        }
        free(self->fields); self->fields=NULL;
        free(self);
    }
    return NULL;
}

// Assembly:
testq %rdi, %rdi
je 0x6769
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x6753
cmpq $0x0, (%rbx)
je 0x6755
xorl %r14d, %r14d
movq 0x10(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x676c
movq 0x10(%rbx), %rax
movq $0x0, (%rax,%r14,8)
incq %r14
cmpq (%rbx), %r14
jb 0x672c
movq 0x10(%rbx), %rdi
jmp 0x6755
xorl %edi, %edi
callq 0x2030
movq %rbx, %rdi
callq 0x2030
addq $0x8, %rsp
popq %rbx
popq %r14
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/esheldon[P]xshear/src/config.c
// Function: cfg_field_free
static struct cfg_field *cfg_field_free(struct cfg_field *self)
{
    if (self) {
        // We always zero memory on creation, so this is OK
        free(self->name);
        self->strvec = cfg_strvec_free(self->strvec);
        self->sub = cfg_free(self->sub);
        free(self);
    }
    return NULL;
}

// Assembly:
testq %rdi, %rdi
je 0x67c3
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x2030
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0x67a3
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x679b
movq 0x8(%r14), %rsi
callq 0x66b4
movq %r14, %rdi
callq 0x2030
movq $0x0, 0x10(%rbx)
movq 0x18(%rbx), %rdi
callq 0x670e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2030
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x67fc
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
cmpq $0x0, (%rdi)
je 0x67f7
movq %rsi, %rbx
xorl %r15d, %r15d
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x67fd
incq %r15
cmpq (%r14), %r15
jb 0x67dd
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/esheldon[P]xshear/src/config.c
// Function: cfg_field_print
static void cfg_field_print(struct cfg_field *self, int n_indent, FILE* stream)
{
    size_t el=0;
    if (!self)
        return;

    // scalars not allowed to be "empty"
    if (CFG_TYPE_SCALAR == CFG_FIELD_TYPE(self) && 0==CFG_FIELD_ARR_SIZE(self))
        return;

    print_spaces(n_indent, stream);
    fprintf(stream, "%s", CFG_FIELD_NAME(self));
    fprintf(stream," %c ", CFG_ASSIGN);
    if (CFG_TYPE_ARRAY==CFG_FIELD_TYPE(self)) {

        fprintf(stream,"%c", CFG_ARRAY_BEG);
        for (el=0; el<CFG_FIELD_ARR_SIZE(self); el++) {
            cfg_field_print_data(self, el, stream);
            /*
            if (el < (CFG_FIELD_ARR_SIZE(self)-1)) {
                fprintf(stream,"%c", CFG_ARRAY_SEP);
            }
            */
            if (el < (CFG_FIELD_ARR_SIZE(self)-1)) {
                fprintf(stream," ");
            }
        }
        fprintf(stream,"%c", CFG_ARRAY_END);

    } else if (CFG_TYPE_CFG == CFG_FIELD_TYPE(self)) {

        fprintf(stream,"%c\n", CFG_CFG_BEG);
        _cfg_print(CFG_FIELD_GET_SUB(self),n_indent+4,stream);
        print_spaces(n_indent, stream);
        fprintf(stream,"%c", CFG_CFG_END);

    } else {
        cfg_field_print_data(self, 0, stream);
    }
    fprintf(stream,"\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x68d2
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
cmpl $0x0, 0x8(%rdi)
jne 0x682b
movq 0x10(%r14), %rax
cmpq $0x0, (%rax)
je 0x68d2
testl %r15d, %r15d
jle 0x6844
movl %r15d, %ebp
movl $0x20, %edi
movq %rbx, %rsi
callq 0x2150
decl %ebp
jne 0x6833
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x2110
leaq 0x345a(%rip), %rsi      # 0x9cb0
movq %rbx, %rdi
movl $0x3d, %edx
xorl %eax, %eax
callq 0x21a0
movl 0x8(%r14), %eax
cmpl $0x2, %eax
je 0x68db
cmpl $0x1, %eax
jne 0x6947
movl $0x5b, %edi
movq %rbx, %rsi
callq 0x2150
movq 0x10(%r14), %rax
cmpq $0x0, (%rax)
je 0x68cb
xorl %r15d, %r15d
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x736e
movq 0x10(%r14), %rax
movq (%rax), %rax
leaq -0x1(%rax), %rcx
cmpq %rcx, %r15
jae 0x68c3
movl $0x20, %edi
movq %rbx, %rsi
callq 0x2150
movq 0x10(%r14), %rax
movq (%rax), %rax
incq %r15
cmpq %rax, %r15
jb 0x6891
movl $0x5d, %edi
jmp 0x693d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x33d3(%rip), %rsi      # 0x9cb5
movq %rbx, %rdi
movl $0x7b, %edx
xorl %eax, %eax
callq 0x21a0
movq 0x18(%r14), %r14
testq %r14, %r14
je 0x6921
cmpq $0x0, (%r14)
je 0x6921
leal 0x4(%r15), %ebp
xorl %r12d, %r12d
movq 0x10(%r14), %rax
movq (%rax,%r12,8), %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x67fd
incq %r12
cmpq (%r14), %r12
jb 0x6907
testl %r15d, %r15d
jle 0x6938
movl $0x20, %edi
movq %rbx, %rsi
callq 0x2150
decl %r15d
jne 0x6926
movl $0x7d, %edi
movq %rbx, %rsi
callq 0x2150
jmp 0x6954
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x736e
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2150
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq $0x0, 0x8(%rsp)
leaq 0x31f0(%rip), %rsi      # 0x9b7c
callq 0x2240
testq %rax, %rax
je 0x6a5f
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x2220
movq %r14, %rdi
callq 0x21b0
movq %rax, %r12
movq %r14, %rdi
callq 0x2100
leaq 0x1(%r12), %rsi
movl $0x1, %edi
callq 0x2170
testq %rax, %rax
je 0x6a91
movq %rax, %r15
movl $0x1, %esi
movq %rax, %rdi
movq %r12, %rdx
movq %r14, %rcx
callq 0x20b0
movq %rax, %r13
movq %r14, %rdi
callq 0x2090
cmpq %r12, %r13
jne 0x6a7c
testl %eax, %eax
jne 0x6a7c
movl $0x1, %edi
movl $0x10, %esi
callq 0x2170
testq %rax, %rax
je 0x6a99
movq %rax, %r13
movq %r12, (%rax)
movq %r15, 0x8(%rax)
movq %r14, %rdi
callq 0x20d0
leaq 0x8(%rsp), %rsi
movq %r13, %rdi
movq %rbx, %rdx
callq 0x6a9e
movq %rax, %rbx
movq %r15, %rdi
callq 0x2030
movq %r13, %rdi
callq 0x2030
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x7592(%rip), %rax      # 0xdff8
movq (%rax), %rdi
leaq 0x324c(%rip), %rsi      # 0x9cbc
movq %r15, %rdx
xorl %eax, %eax
callq 0x21a0
jmp 0x6a87
movq %r15, %rdi
movq %r14, %rsi
callq 0x3679
movl $0x2, (%rbx)
xorl %ebx, %ebx
jmp 0x6a4e
movq %r12, %rdi
callq 0x36db
callq 0x36b6
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0x7, (%rdx)
testq %rdi, %rdi
je 0x6fe7
movq (%rdi), %r12
testq %r12, %r12
je 0x6fe7
movq %rdx, %rbx
movq %rsi, %r14
movq 0x10(%rdi), %r13
xorl %ebp, %ebp
movq (%r13,%rbp,8), %r15
movq (%r15), %rsi
movq %r14, %rdi
callq 0x2180
testl %eax, %eax
je 0x6ffc
incq %rbp
cmpq %rbp, %r12
jne 0x6fcb
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x0, (%rbx)
jmp 0x6fea
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl $0x0, (%rsi)
leaq 0x8(%rsp), %r15
movq %rdi, (%r15)
movq %r15, %rsi
callq 0x20c0
cmpq %r14, (%r15)
je 0x7038
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x6fb9(%rip), %rax      # 0xdff8
movq (%rax), %rdi
leaq 0x2dde(%rip), %rsi      # 0x9e27
movq %r14, %rdx
xorl %eax, %eax
movsd %xmm0, (%rsp)
callq 0x21a0
movsd (%rsp), %xmm0
movl $0x9, (%rbx)
jmp 0x702e
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rcx, %rdx
callq 0x6fa1
cmpl $0x0, (%rbx)
jne 0x70f1
movq %rax, %r12
cmpl $0x1, 0x8(%rax)
jne 0x70eb
movq $0x0, (%r14)
movl $0x0, (%rbx)
movq 0x10(%r12), %r13
testq %r13, %r13
je 0x70f1
movq (%r13), %rdi
testq %rdi, %rdi
je 0x70f1
movl $0x8, %esi
callq 0x2170
testq %rax, %rax
je 0x710b
movq %rax, %r15
xorl %r12d, %r12d
movq 0x10(%r13), %rax
movq (%rax,%r12,8), %rdi
movq %rbx, %rsi
callq 0x7004
cmpl $0x0, (%rbx)
jne 0x7101
movsd %xmm0, (%r15,%r12,8)
incq %r12
movq (%r13), %rax
cmpq %rax, %r12
jb 0x70bf
movq %rax, (%r14)
jmp 0x70f4
movl $0x9, (%rbx)
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r15, %rdi
callq 0x2030
jmp 0x70f1
movq %r12, %rdi
callq 0x37dd
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x0, (%rsi)
movq %rsp, %r12
movq %rdi, (%r12)
movq %r12, %rsi
movl $0xa, %edx
callq 0x21c0
movq %rax, %r15
cmpq %r14, (%r12)
je 0x7182
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x6e6f(%rip), %rax      # 0xdff8
movq (%rax), %rdi
leaq 0x2cf3(%rip), %rsi      # 0x9e86
movq %r14, %rdx
xorl %eax, %eax
callq 0x21a0
movl $0x9, (%rbx)
jmp 0x7173
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rcx, %rdx
callq 0x6fa1
cmpl $0x0, (%rbx)
jne 0x722f
movq %rax, %r12
cmpl $0x1, 0x8(%rax)
jne 0x7229
movq $0x0, (%r14)
movl $0x0, (%rbx)
movq 0x10(%r12), %r13
testq %r13, %r13
je 0x722f
movq (%r13), %rdi
testq %rdi, %rdi
je 0x722f
movl $0x8, %esi
callq 0x2170
testq %rax, %rax
je 0x7249
movq %rax, %r15
xorl %r12d, %r12d
movq 0x10(%r13), %rax
movq (%rax,%r12,8), %rdi
movq %rbx, %rsi
callq 0x7142
cmpl $0x0, (%rbx)
jne 0x723f
movq %rax, (%r15,%r12,8)
incq %r12
movq (%r13), %rax
cmpq %rax, %r12
jb 0x71ff
movq %rax, (%r14)
jmp 0x7232
movl $0x9, (%rbx)
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r15, %rdi
callq 0x2030
jmp 0x722f
movq %r12, %rdi
callq 0x3804
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdx, %rbx
callq 0x6fa1
cmpl $0x0, (%rbx)
jne 0x726b
cmpl $0x0, 0x8(%rax)
je 0x726f
movl $0x9, (%rbx)
xorl %eax, %eax
popq %rbx
retq
movq 0x10(%rax), %rax
cmpq $0x0, (%rax)
je 0x7283
movq 0x10(%rax), %rax
movq (%rax), %rdi
popq %rbx
jmp 0x728b
movl $0x8, (%rbx)
jmp 0x726b
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
callq 0x20e0
leaq 0x1(%rax), %rdi
callq 0x2200
testq %rax, %rax
je 0x72ae
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x2060
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %rbx
movq %rcx, %rdx
callq 0x6fa1
cmpl $0x0, (%r14)
jne 0x732a
movl $0x9, %ecx
cmpl $0x1, 0x8(%rax)
jne 0x7327
movq 0x10(%rax), %r15
movq $0x0, (%rbx)
movl $0x8, %ecx
testq %r15, %r15
je 0x7327
movq (%r15), %rdi
testq %rdi, %rdi
je 0x7327
movq %rdi, (%rbx)
movl $0x8, %esi
callq 0x2170
testq %rax, %rax
je 0x733c
movq %rax, %r14
xorl %r12d, %r12d
movq 0x10(%r15), %rax
movq (%rax,%r12,8), %rdi
callq 0x728b
movq %rax, (%r14,%r12,8)
incq %r12
cmpq (%rbx), %r12
jb 0x730c
jmp 0x732d
movl %ecx, (%r14)
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x382b
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
cmpl $0x1, 0xc(%rdi)
movq 0x10(%rdi), %rax
movq 0x10(%rax), %rax
movq (%rax,%rsi,8), %r14
jne 0x73fa
movq %r14, %rdi
callq 0x20e0
movq %rax, %r15
movl $0x22, %edi
movq %rbx, %rsi
callq 0x2150
testq %r15, %r15
je 0x73e4
xorl %r13d, %r13d
leaq 0x2906(%rip), %r12      # 0x9cb9
movsbl (%r14,%r13), %edi
cmpl $0x22, %edi
jne 0x73d4
movl $0x2, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %rbx, %rcx
callq 0x2290
jmp 0x73dc
movq %rbx, %rsi
callq 0x2150
incq %r13
cmpq %r13, %r15
jne 0x73b3
movl $0x22, %edi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2150
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2110
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movl $0x6, (%rdx)
movq (%rdi), %r12
cmpq %rsi, %r12
jbe 0x747e
movq %rdx, %rbx
movq %rdi, %r15
callq 0x22c0
movq (%rax), %rax
movq 0x8(%r15), %rdx
movq %r14, %rcx
movsbq (%rdx,%rcx), %rsi
testb $0x20, 0x1(%rax,%rsi,2)
jne 0x746d
cmpb $0x23, %sil
jne 0x748d
movl $0x6, (%rbx)
cmpb $0xa, (%rdx,%rcx)
je 0x7464
incq %rcx
cmpq %rcx, %r12
jne 0x7454
jmp 0x7477
movl $0x0, (%rbx)
movq %rcx, %r14
incq %rcx
cmpq %r12, %rcx
jb 0x743c
jmp 0x747e
movq $-0x1, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0x0, (%rbx)
movq %rcx, %r14
jmp 0x747e
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
movl $0x6, (%rcx)
movq (%rsi), %rdx
leaq -0x1(%rdx), %rdi
cmpq %r14, %rdi
jne 0x74c5
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r14, %r8
movq $-0x1, %rax
leaq 0x1(%r8), %r9
movl $0x6, (%rcx)
cmpq %r9, %rdx
jbe 0x74bb
movq 0x8(%rsi), %r13
movq %r8, %r15
cmpb $0x22, 0x1(%r13,%r15)
je 0x74f7
incq %r15
cmpq %r15, %rdi
jne 0x74e5
jmp 0x74bb
movl $0x0, (%rcx)
leaq 0x1(%r15), %r8
cmpb $0x5c, (%r15,%r13)
je 0x74cf
movq %r15, %r12
subq %r14, %r12
leaq 0x1(%r12), %rdi
movl $0x1, %esi
callq 0x2170
testq %r12, %r12
je 0x7562
leaq (%r14,%r13), %rcx
incq %rcx
xorl %esi, %esi
xorl %edx, %edx
movb (%rcx), %dil
cmpl $0x5c, %esi
sete %sil
cmpb $0x22, %dil
sete %r8b
andb %sil, %r8b
cmpb $0x1, %r8b
jne 0x754f
movb $0x22, -0x1(%rax,%rdx)
jmp 0x7556
movb %dil, (%rax,%rdx)
incq %rdx
movsbl %dil, %esi
incq %rcx
decq %r12
jne 0x752d
incq %r15
movq 0x10(%rbx), %rdi
movq %rax, %rsi
callq 0x763b
movq %r15, %rax
jmp 0x74bb
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r13
movq %rdi, 0x8(%rsp)
movq %rcx, (%rsp)
movl $0x6, (%rcx)
movq %rsi, 0x10(%rsp)
movq (%rsi), %r12
decq %r12
movl $0x1, %ecx
leaq (%rcx,%r13), %r14
cmpq %r12, %r14
ja 0x7629
movq %rcx, %r15
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rbx
addq %r13, %rbx
movsbq (%rcx,%rbx), %rbp
callq 0x22c0
movq (%rax), %rax
movzwl (%rax,%rbp,2), %eax
btl $0xd, %eax
jb 0x75ef
movzbl %bpl, %eax
cmpl $0x2c, %eax
je 0x75ef
cmpl $0x7d, %eax
je 0x75ef
leaq 0x1(%r15), %rcx
cmpl $0x5d, %eax
jne 0x75a9
movq (%rsp), %rax
movl $0x0, (%rax)
leaq 0x1(%r15), %rdi
movl $0x1, %esi
callq 0x2170
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2040
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movq %r12, %rsi
callq 0x763b
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/esheldon[P]xshear/src/config.c
// Function: cfg_strvec_append_nocopy
static void cfg_strvec_append_nocopy(struct cfg_strvec* vec, char *str)
{
    size_t size=0;
    size = vec->size;

    if (size == vec->capacity) {
        cfg_strvec_realloc(vec, vec->capacity*2);
    }
    vec->size++;
    vec->data[vec->size-1] = str;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %r15
cmpq 0x8(%rdi), %r15
jne 0x768d
testq %r15, %r15
jle 0x768d
movq 0x10(%r14), %rdi
movq %r15, %rsi
shlq $0x4, %rsi
callq 0x2230
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x76a8
leaq (%r15,%r15), %r12
leaq (%rax,%r15,8), %rdi
shlq $0x3, %r15
xorl %esi, %esi
movq %r15, %rdx
callq 0x2120
movq %r12, 0x8(%r14)
movq (%r14), %r15
leaq 0x1(%r15), %rax
movq %rax, (%r14)
movq 0x10(%r14), %rax
movq %rbx, (%rax,%r15,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x3850
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/esheldon[P]xshear/src/urls.c
// Function: open_url
FILE* open_url(const char* filename, const char* mode) {
    FILE* stream=fopen(filename,mode);
    if (stream==NULL) {
        wlog("Could not open file: %s\n", filename);
        exit(EXIT_FAILURE);
    }
    return stream;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x2240
testq %rax, %rax
je 0x76c0
popq %rbx
retq
movq %rbx, %rdi
callq 0x3875
// File: /workspace/github_c_makefile_star2_O3/esheldon[P]xshear/src/urls.c
// Function: count_lines_and_rewind
size_t count_lines_and_rewind(FILE* stream)
{
    rewind(stream);

    size_t nlines=count_lines(stream);

    rewind(stream);
    return nlines;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2100
movq %rbx, %rdi
callq 0x76c8
movq %rax, %r14
movq %rbx, %rdi
callq 0x2100
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/esheldon[P]xshear/src/vector.c
// Function: szvector_new
szvector* szvector_new() {
    szvector* self = calloc(1,sizeof(szvector));
    if (self == NULL) {
        fprintf(stderr,"Could not allocate szvector\n");
        return NULL;
    }

    self->capacity = VECTOR_INITCAP;

    self->data = calloc(self->capacity, sizeof(size_t));
    if (self->data == NULL) {
        fprintf(stderr,"Could not allocate data for vector\n");
        exit(1);
    }

    return self;
}

// Assembly:
pushq %rbx
movl $0x1, %edi
movl $0x18, %esi
callq 0x2170
movq %rax, %rbx
testq %rax, %rax
je 0x7781
movq $0x1, 0x8(%rbx)
movl $0x1, %edi
movl $0x8, %esi
callq 0x2170
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x7788
movq %rbx, %rax
popq %rbx
retq
callq 0x38be
jmp 0x777c
callq 0x3899
// File: /workspace/github_c_makefile_star2_O3/esheldon[P]xshear/src/vector.c
// Function: szvector_copy
szvector* szvector_copy(szvector* self) {
    szvector* vcopy=szvector_new();
    vector_resize(vcopy, self->size);

    if (self->size > 0) {
        memcpy(vcopy->data, self->data, self->size*sizeof(size_t));
    }

    return vcopy;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
callq 0x7744
movq %rax, %rbx
movq (%r14), %r15
movq 0x8(%rax), %r13
movq %r15, %r12
subq %r13, %r12
jbe 0x77e3
movq 0x10(%rbx), %rdi
leaq (,%r15,8), %rsi
callq 0x2230
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x780c
shlq $0x3, %r12
leaq (%rax,%r13,8), %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x2120
movq %r15, 0x8(%rbx)
movq (%r14), %r15
movq %r15, (%rbx)
testq %r15, %r15
je 0x77ff
movq 0x10(%rbx), %rdi
movq 0x10(%r14), %rsi
shlq $0x3, %r15
movq %r15, %rdx
callq 0x21d0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x38da
// File: /workspace/github_c_makefile_star2_O3/esheldon[P]xshear/src/vector.c
// Function: szvector_fromarray
szvector* szvector_fromarray(size_t* data, size_t size) {
    szvector* self=szvector_new();
    vector_resize(self, size);

    if (self->size > 0) {
        memcpy(self->data, data, size*sizeof(size_t));
    }

    return self;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r12
callq 0x7744
movq %rax, %rbx
movq 0x8(%rax), %r14
movq %r15, %rbp
subq %r14, %rbp
jbe 0x7875
movq %r12, (%rsp)
movq 0x10(%rbx), %rdi
leaq (,%r15,8), %r12
movq %r12, %rsi
callq 0x2230
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x78ad
movq %rax, %r13
shlq $0x3, %rbp
leaq (%rax,%r14,8), %rdi
xorl %esi, %esi
movq %rbp, %rdx
callq 0x2120
movq %r15, 0x8(%rbx)
movq %r15, (%rbx)
jmp 0x788c
movq %r15, (%rbx)
testq %r15, %r15
je 0x789b
movq %r12, (%rsp)
movq 0x10(%rbx), %r13
shlq $0x3, %r15
movq %r15, %r12
movq %r13, %rdi
movq (%rsp), %rsi
movq %r12, %rdx
callq 0x21d0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x38ff
// File: /workspace/github_c_makefile_star2_O3/esheldon[P]xshear/src/vector.c
// Function: szvector_ones
szvector* szvector_ones(size_t num) {

    szvector* self=szvector_new();
    for (size_t i=0; i<num; i++) {
        vector_push(self,1);
    }
    return self;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x7744
movq %rax, %rbx
testq %r14, %r14
je 0x79dd
movq %rbx, %rax
addq $0x8, %rax
movq %rax, (%rsp)
movq (%rbx), %r12
movq 0x8(%rbx), %r15
movl $0x1, %eax
cmpq %r15, %r12
jne 0x79bd
leaq (%r15,%r15), %r13
testq %r15, %r15
cmoveq %rax, %r13
cmpq %r15, %r13
movq %r15, %r12
cmovbq %r13, %r12
cmpq $0x1, %r13
adcq $0x0, %r13
movq 0x10(%rbx), %rbp
cmpq %r15, %r13
je 0x79c1
leaq (,%r13,8), %rsi
movq %rbp, %rdi
callq 0x2230
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x79ef
movq %rax, %rbp
movq %r13, %rdx
subq %r15, %rdx
jbe 0x79b3
shlq $0x3, %rdx
leaq (,%r15,8), %rdi
addq %rbp, %rdi
xorl %esi, %esi
callq 0x2120
movq %r13, %r15
movl $0x1, %eax
jmp 0x79c1
movq 0x10(%rbx), %rbp
movq $0x1, (%rbp,%r12,8)
incq %r12
decq %r14
jne 0x794e
movq %r12, (%rbx)
movq %r15, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq (%rsp), %rcx
callq 0x3949
// File: /workspace/github_c_makefile_star2_O3/esheldon[P]xshear/src/vector.c
// Function: szvector_range
szvector* szvector_range(long min, long max) {

    szvector* self=szvector_new();
    for (long i=min; i<max; i++) {
        vector_push(self,i);
    }
    
    return self;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r15
callq 0x7744
cmpq %rbx, %r15
jge 0x7ad4
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x10(%rsp)
movq (%rax), %r13
movq 0x8(%rax), %r14
movl $0x1, %edx
movq %rbx, 0x8(%rsp)
cmpq %r14, %r13
jne 0x7ab6
leaq (%r14,%r14), %rbp
testq %r14, %r14
cmoveq %rdx, %rbp
cmpq %r14, %rbp
movq %r14, %r13
cmovbq %rbp, %r13
cmpq $0x1, %rbp
adcq $0x0, %rbp
movq 0x10(%rax), %r12
cmpq %r14, %rbp
je 0x7aba
leaq (,%rbp,8), %rsi
movq %r12, %rdi
movq %rax, %rbx
callq 0x2230
movq %rax, %r12
movq %rbx, %rax
movq %r12, 0x10(%rbx)
testq %r12, %r12
je 0x7ae3
movq %rbp, %rdx
subq %r14, %rdx
jbe 0x7aa7
shlq $0x3, %rdx
leaq (%r12,%r14,8), %rdi
xorl %esi, %esi
callq 0x2120
movq %rbx, %rax
movq %rbp, %r14
movq 0x8(%rsp), %rbx
movl $0x1, %edx
jmp 0x7aba
movq 0x10(%rax), %r12
movq %r15, (%r12,%r13,8)
incq %r13
incq %r15
cmpq %r15, %rbx
jne 0x7a40
movq %r13, (%rax)
movq %r14, 0x8(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %rdi
movq %rax, %rsi
movq %r14, %rdx
movq 0x10(%rsp), %rcx
callq 0x3974
// File: /workspace/github_c_makefile_star2_O3/esheldon[P]xshear/src/vector.c
// Function: dvector_new
dvector* dvector_new() {
    dvector* self = calloc(1,sizeof(dvector));
    if (self == NULL) {
        fprintf(stderr,"Could not allocate dvector\n");
        return NULL;
    }

    self->capacity = VECTOR_INITCAP;

    self->data = calloc(self->capacity, sizeof(double));
    if (self->data == NULL) {
        fprintf(stderr,"Could not allocate data for vector\n");
        exit(1);
    }

    return self;
}

// Assembly:
pushq %rbx
movl $0x1, %edi
movl $0x18, %esi
callq 0x2170
movq %rax, %rbx
testq %rax, %rax
je 0x7b88
movq $0x1, 0x8(%rbx)
movl $0x1, %edi
movl $0x8, %esi
callq 0x2170
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x7b8f
movq %rbx, %rax
popq %rbx
retq
callq 0x39c4
jmp 0x7b83
callq 0x399f
// File: /workspace/github_c_makefile_star2_O3/esheldon[P]xshear/src/vector.c
// Function: dvector_copy
dvector* dvector_copy(dvector* self) {
    dvector* vcopy=dvector_new();
    vector_resize(vcopy, self->size);

    if (self->size > 0) {
        memcpy(vcopy->data, self->data, self->size*sizeof(double));
    }

    return vcopy;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
callq 0x7b4b
movq %rax, %rbx
movq (%r14), %r15
movq 0x8(%rax), %r13
movq %r15, %r12
subq %r13, %r12
jbe 0x7bea
movq 0x10(%rbx), %rdi
leaq (,%r15,8), %rsi
callq 0x2230
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x7c13
shlq $0x3, %r12
leaq (%rax,%r13,8), %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x2120
movq %r15, 0x8(%rbx)
movq (%r14), %r15
movq %r15, (%rbx)
testq %r15, %r15
je 0x7c06
movq 0x10(%rbx), %rdi
movq 0x10(%r14), %rsi
shlq $0x3, %r15
movq %r15, %rdx
callq 0x21d0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x39e0
// File: /workspace/github_c_makefile_star2_O3/esheldon[P]xshear/src/vector.c
// Function: dvector_fromarray
dvector* dvector_fromarray(double* data, size_t size) {
    dvector* self=dvector_new();
    vector_resize(self, size);

    if (self->size > 0) {
        memcpy(self->data, data, size*sizeof(double));
    }

    return self;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r12
callq 0x7b4b
movq %rax, %rbx
movq 0x8(%rax), %r14
movq %r15, %rbp
subq %r14, %rbp
jbe 0x7c7c
movq %r12, (%rsp)
movq 0x10(%rbx), %rdi
leaq (,%r15,8), %r12
movq %r12, %rsi
callq 0x2230
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x7cb4
movq %rax, %r13
shlq $0x3, %rbp
leaq (%rax,%r14,8), %rdi
xorl %esi, %esi
movq %rbp, %rdx
callq 0x2120
movq %r15, 0x8(%rbx)
movq %r15, (%rbx)
jmp 0x7c93
movq %r15, (%rbx)
testq %r15, %r15
je 0x7ca2
movq %r12, (%rsp)
movq 0x10(%rbx), %r13
shlq $0x3, %r15
movq %r15, %r12
movq %r13, %rdi
movq (%rsp), %rsi
movq %r12, %rdx
callq 0x21d0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x3a05
// File: /workspace/github_c_makefile_star2_O3/esheldon[P]xshear/src/vector.c
// Function: dvector_ones
dvector* dvector_ones(size_t num) {

    dvector* self=dvector_new();
    for (size_t i=0; i<num; i++) {
        vector_push(self,1);
    }
    return self;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x7b4b
movq %rax, %rsi
testq %r14, %r14
je 0x7dfd
movq %rsi, %rax
addq $0x8, %rax
movq %rax, (%rsp)
movq (%rsi), %r12
movq 0x8(%rsi), %r15
movl $0x1, %eax
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
cmpq %r15, %r12
jne 0x7de1
leaq (%r15,%r15), %r13
testq %r15, %r15
cmoveq %rax, %r13
cmpq %r15, %r13
movq %r15, %r12
cmovbq %r13, %r12
cmpq $0x1, %r13
adcq $0x0, %r13
movq 0x10(%rsi), %rbp
cmpq %r15, %r13
je 0x7de5
movq %rsi, %rbx
leaq (,%r13,8), %rsi
movq %rbp, %rdi
callq 0x2230
movq %rbx, %rsi
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x7e0f
movq %rax, %rbp
movq %r13, %rdx
subq %r15, %rdx
jbe 0x7dcd
shlq $0x3, %rdx
leaq (,%r15,8), %rdi
addq %rbp, %rdi
xorl %esi, %esi
callq 0x2120
movq %rbx, %rsi
movq %r13, %r15
movl $0x1, %eax
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
jmp 0x7de5
movq 0x10(%rsi), %rbp
movq %rcx, (%rbp,%r12,8)
incq %r12
decq %r14
jne 0x7d5f
movq %r12, (%rsi)
movq %r15, 0x8(%rsi)
movq %rsi, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
movq %r15, %rdx
movq (%rsp), %rcx
callq 0x3a4f
// File: /workspace/github_c_makefile_star2_O3/esheldon[P]xshear/src/vector.c
// Function: dvector_range
dvector* dvector_range(long min, long max) {

    dvector* self=dvector_new();
    for (long i=min; i<max; i++) {
        vector_push(self,i);
    }
    
    return self;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r15
callq 0x7b4b
cmpq %rbx, %r15
jge 0x7efb
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x10(%rsp)
movq (%rax), %r13
movq 0x8(%rax), %r14
movl $0x1, %edx
movq %rbx, 0x8(%rsp)
cmpq %r14, %r13
jne 0x7ed3
leaq (%r14,%r14), %rbp
testq %r14, %r14
cmoveq %rdx, %rbp
cmpq %r14, %rbp
movq %r14, %r13
cmovbq %rbp, %r13
cmpq $0x1, %rbp
adcq $0x0, %rbp
movq 0x10(%rax), %r12
cmpq %r14, %rbp
je 0x7ed7
leaq (,%rbp,8), %rsi
movq %r12, %rdi
movq %rax, %rbx
callq 0x2230
movq %rax, %r12
movq %rbx, %rax
movq %r12, 0x10(%rbx)
testq %r12, %r12
je 0x7f0a
movq %rbp, %rdx
subq %r14, %rdx
jbe 0x7ec4
shlq $0x3, %rdx
leaq (%r12,%r14,8), %rdi
xorl %esi, %esi
callq 0x2120
movq %rbx, %rax
movq %rbp, %r14
movq 0x8(%rsp), %rbx
movl $0x1, %edx
jmp 0x7ed7
movq 0x10(%rax), %r12
xorps %xmm0, %xmm0
cvtsi2sd %r15, %xmm0
movsd %xmm0, (%r12,%r13,8)
incq %r13
incq %r15
cmpq %r15, %rbx
jne 0x7e5d
movq %r13, (%rax)
movq %r14, 0x8(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %rdi
movq %rax, %rsi
movq %r14, %rdx
movq 0x10(%rsp), %rcx
callq 0x3a7a
// File: /workspace/github_c_makefile_star2_O3/esheldon[P]xshear/src/vector.c
// Function: lvector_new
lvector* lvector_new() {
    lvector* self = calloc(1,sizeof(lvector));
    if (self == NULL) {
        fprintf(stderr,"Could not allocate lvector\n");
        return NULL;
    }

    self->capacity = VECTOR_INITCAP;

    self->data = calloc(self->capacity, sizeof(int64_t));
    if (self->data == NULL) {
        fprintf(stderr,"Could not allocate data for vector\n");
        exit(1);
    }

    return self;
}

// Assembly:
pushq %rbx
movl $0x1, %edi
movl $0x18, %esi
callq 0x2170
movq %rax, %rbx
testq %rax, %rax
je 0x7fbb
movq $0x1, 0x8(%rbx)
movl $0x1, %edi
movl $0x8, %esi
callq 0x2170
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x7fc2
movq %rbx, %rax
popq %rbx
retq
callq 0x3aca
jmp 0x7fb6
callq 0x3aa5
// File: /workspace/github_c_makefile_star2_O3/esheldon[P]xshear/src/vector.c
// Function: lvector_copy
lvector* lvector_copy(lvector* self) {
    lvector* vcopy=lvector_new();
    vector_resize(vcopy, self->size);

    if (self->size > 0) {
        memcpy(vcopy->data, self->data, self->size*sizeof(int64_t));
    }

    return vcopy;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
callq 0x7f7e
movq %rax, %rbx
movq (%r14), %r15
movq 0x8(%rax), %r13
movq %r15, %r12
subq %r13, %r12
jbe 0x801d
movq 0x10(%rbx), %rdi
leaq (,%r15,8), %rsi
callq 0x2230
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x8046
shlq $0x3, %r12
leaq (%rax,%r13,8), %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x2120
movq %r15, 0x8(%rbx)
movq (%r14), %r15
movq %r15, (%rbx)
testq %r15, %r15
je 0x8039
movq 0x10(%rbx), %rdi
movq 0x10(%r14), %rsi
shlq $0x3, %r15
movq %r15, %rdx
callq 0x21d0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x3ae6
// File: /workspace/github_c_makefile_star2_O3/esheldon[P]xshear/src/vector.c
// Function: lvector_fromarray
lvector* lvector_fromarray(int64_t* data, size_t size) {
    lvector* self=lvector_new();
    vector_resize(self, size);

    if (self->size > 0) {
        memcpy(self->data, data, size*sizeof(int64_t));
    }

    return self;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r12
callq 0x7f7e
movq %rax, %rbx
movq 0x8(%rax), %r14
movq %r15, %rbp
subq %r14, %rbp
jbe 0x80af
movq %r12, (%rsp)
movq 0x10(%rbx), %rdi
leaq (,%r15,8), %r12
movq %r12, %rsi
callq 0x2230
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x80e7
movq %rax, %r13
shlq $0x3, %rbp
leaq (%rax,%r14,8), %rdi
xorl %esi, %esi
movq %rbp, %rdx
callq 0x2120
movq %r15, 0x8(%rbx)
movq %r15, (%rbx)
jmp 0x80c6
movq %r15, (%rbx)
testq %r15, %r15
je 0x80d5
movq %r12, (%rsp)
movq 0x10(%rbx), %r13
shlq $0x3, %r15
movq %r15, %r12
movq %r13, %rdi
movq (%rsp), %rsi
movq %r12, %rdx
callq 0x21d0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x3b0b
// File: /workspace/github_c_makefile_star2_O3/esheldon[P]xshear/src/vector.c
// Function: lvector_ones
lvector* lvector_ones(size_t num) {

    lvector* self=lvector_new();
    for (size_t i=0; i<num; i++) {
        vector_push(self,1);
    }
    return self;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x7f7e
movq %rax, %rbx
testq %r14, %r14
je 0x8217
movq %rbx, %rax
addq $0x8, %rax
movq %rax, (%rsp)
movq (%rbx), %r12
movq 0x8(%rbx), %r15
movl $0x1, %eax
cmpq %r15, %r12
jne 0x81f7
leaq (%r15,%r15), %r13
testq %r15, %r15
cmoveq %rax, %r13
cmpq %r15, %r13
movq %r15, %r12
cmovbq %r13, %r12
cmpq $0x1, %r13
adcq $0x0, %r13
movq 0x10(%rbx), %rbp
cmpq %r15, %r13
je 0x81fb
leaq (,%r13,8), %rsi
movq %rbp, %rdi
callq 0x2230
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x8229
movq %rax, %rbp
movq %r13, %rdx
subq %r15, %rdx
jbe 0x81ed
shlq $0x3, %rdx
leaq (,%r15,8), %rdi
addq %rbp, %rdi
xorl %esi, %esi
callq 0x2120
movq %r13, %r15
movl $0x1, %eax
jmp 0x81fb
movq 0x10(%rbx), %rbp
movq $0x1, (%rbp,%r12,8)
incq %r12
decq %r14
jne 0x8188
movq %r12, (%rbx)
movq %r15, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq (%rsp), %rcx
callq 0x3b55
// File: /workspace/github_c_makefile_star2_O3/esheldon[P]xshear/src/vector.c
// Function: lvector_range
lvector* lvector_range(long min, long max) {

    lvector* self=lvector_new();
    for (long i=min; i<max; i++) {
        vector_push(self,i);
    }
    
    return self;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r15
callq 0x7f7e
cmpq %rbx, %r15
jge 0x830e
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x10(%rsp)
movq (%rax), %r13
movq 0x8(%rax), %r14
movl $0x1, %edx
movq %rbx, 0x8(%rsp)
cmpq %r14, %r13
jne 0x82f0
leaq (%r14,%r14), %rbp
testq %r14, %r14
cmoveq %rdx, %rbp
cmpq %r14, %rbp
movq %r14, %r13
cmovbq %rbp, %r13
cmpq $0x1, %rbp
adcq $0x0, %rbp
movq 0x10(%rax), %r12
cmpq %r14, %rbp
je 0x82f4
leaq (,%rbp,8), %rsi
movq %r12, %rdi
movq %rax, %rbx
callq 0x2230
movq %rax, %r12
movq %rbx, %rax
movq %r12, 0x10(%rbx)
testq %r12, %r12
je 0x831d
movq %rbp, %rdx
subq %r14, %rdx
jbe 0x82e1
shlq $0x3, %rdx
leaq (%r12,%r14,8), %rdi
xorl %esi, %esi
callq 0x2120
movq %rbx, %rax
movq %rbp, %r14
movq 0x8(%rsp), %rbx
movl $0x1, %edx
jmp 0x82f4
movq 0x10(%rax), %r12
movq %r15, (%r12,%r13,8)
incq %r13
incq %r15
cmpq %r15, %rbx
jne 0x827a
movq %r13, (%rax)
movq %r14, 0x8(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %rdi
movq %rax, %rsi
movq %r14, %rdx
movq 0x10(%rsp), %rcx
callq 0x3b80
// File: /workspace/github_c_makefile_star2_O3/esheldon[P]xshear/src/util.c
// Function: comma_print
void comma_print(FILE* stream, long long n)
{
    int i = -1, len, negative = 0;
    char *c=NULL, *p=NULL;

    if (n == 0) {
        len = 2;
    } else if (n < 0) {
        negative = 1;
        n = -n;
        len = 4 * floor(log10(n)) / 3 + 3;
    } else {
        len = 4 * floor(log10(n)) / 3 + 2;
    }

    c = alloca(len);
    p = c + len - 1;
    *p-- = 0;

    do {
        if (++i == 3) {
            *p-- = ',';
            i = 0;
        }
        *p-- = '0' + n % 10;
        n /= 10;
    } while (n);

    if (negative) *p = '-';

    fprintf(stream, "%s", c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0x83e1
setns %r15b
movq %rsi, %r14
negq %r14
cmovsq %rsi, %r14
movzbl %r15b, %r12d
cvtsi2sd %r14, %xmm0
callq 0x2190
callq 0x2260
mulsd 0x1bcc(%rip), %xmm0     # 0x9f90
divsd 0xc4c(%rip), %xmm0      # 0x9018
leaq 0x1bc5(%rip), %rax      # 0x9f98
addsd (%rax,%r12,8), %xmm0
cvttsd2si %xmm0, %eax
cltq
jmp 0x83ec
movb $0x1, %r15b
movl $0x2, %eax
xorl %r14d, %r14d
movq %rsp, %rdi
leaq 0xf(%rax), %rcx
andq $-0x10, %rcx
subq %rcx, %rdi
movq %rdi, %rsp
leaq (%rax,%rdi), %rcx
addq $-0x2, %rcx
movb $0x0, 0x1(%rcx)
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movabsq $-0x3333333333333333, %rsi # imm = 0xCCCCCCCCCCCCCCCD
incl %r8d
cmpl $0x3, %r8d
jne 0x842b
movb $0x2c, (%rcx)
decq %rcx
xorl %r8d, %r8d
movq %r14, %rax
mulq %rsi
shrq $0x3, %rdx
leal (%rdx,%rdx), %eax
leal (%rax,%rax,4), %eax
movl %r14d, %r9d
subl %eax, %r9d
orb $0x30, %r9b
movb %r9b, (%rcx)
decq %rcx
cmpq $0x9, %r14
movq %rdx, %r14
ja 0x8419
testb %r15b, %r15b
jne 0x845c
movb $0x2d, (%rcx)
movq %rbx, %rsi
callq 0x2110
leaq -0x20(%rbp), %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)