LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x3303(%rip), %rsi      # 0x9b6c
callq 0x2240
testq %rax, %rax
je 0x6954
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x2220
movq %r14, %rdi
callq 0x21b0
movq %rax, %r15
movq %r14, %rdi
callq 0x2100
leaq 0x1(%r15), %rsi
movl $0x1, %edi
callq 0x2170
testq %rax, %rax
je 0x6981
movq %rax, %r13
movl $0x1, %esi
movq %rax, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x20b0
movq %rax, %r12
movq %r14, %rdi
callq 0x2090
cmpq %r15, %r12
jne 0x6974
testl %eax, %eax
jne 0x6974
movl $0x1, %edi
movl $0x10, %esi
callq 0x2170
testq %rax, %rax
je 0x6989
movq %rax, %r12
movq %r15, (%rax)
movq %r13, 0x8(%rax)
movq %r14, %rdi
callq 0x20d0
testq %r12, %r12
je 0x693b
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
movq %rbx, %rdx
callq 0x698e
movq %rax, %rbx
movq 0x8(%r12), %rdi
callq 0x2030
movq %r12, %rdi
callq 0x2030
jmp 0x6943
movl $0x2, (%rbx)
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x769d(%rip), %rax      # 0xdff8
movq (%rax), %rdi
leaq 0x3347(%rip), %rsi      # 0x9cac
xorl %r12d, %r12d
movq %r15, %rdx
xorl %eax, %eax
callq 0x21a0
jmp 0x690f
movq %r13, %rdi
callq 0x3627
xorl %r12d, %r12d
jmp 0x6907
movq %r15, %rdi
callq 0x3675
callq 0x3650
// File: /workspace/github_c_makefile_star2_O1/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 0x6eb1
movq (%rdi), %r12
testq %r12, %r12
je 0x6eb1
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 0x6ec6
incq %rbp
cmpq %rbp, %r12
jne 0x6e95
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 0x6eb4
// File: /workspace/github_c_makefile_star2_O1/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
leaq 0x8(%rsp), %r15
movq $0x0, (%r15)
movl $0x0, (%rsi)
movq %rdi, (%r15)
movq %r15, %rsi
callq 0x20c0
cmpq %r14, (%r15)
je 0x6f09
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x70e8(%rip), %rax      # 0xdff8
movq (%rax), %rdi
leaq 0x2efd(%rip), %rsi      # 0x9e17
movq %r14, %rdx
xorl %eax, %eax
movsd %xmm0, (%rsp)
callq 0x21a0
movsd (%rsp), %xmm0
movl $0x9, (%rbx)
jmp 0x6eff
// File: /workspace/github_c_makefile_star2_O1/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, %r15
movq %rcx, %rdx
callq 0x6e6b
cmpl $0x0, (%rbx)
jne 0x6fe3
movq %rax, %r12
cmpl $0x1, 0x8(%rax)
jne 0x6fc5
movq $0x0, (%r15)
movl $0x0, (%rbx)
testq %r12, %r12
je 0x6fcd
movq 0x10(%r12), %r13
testq %r13, %r13
je 0x6fd3
movq (%r13), %rdi
testq %rdi, %rdi
je 0x6fd3
movl $0x8, %esi
callq 0x2170
testq %rax, %rax
je 0x6ff3
movq %rax, %r14
xorl %r12d, %r12d
movq 0x10(%r13), %rax
movq (%rax,%r12,8), %rdi
movq %rbx, %rsi
callq 0x6ece
cmpl $0x0, (%rbx)
jne 0x6fd6
movsd %xmm0, (%r14,%r12,8)
incq %r12
movq (%r13), %rax
cmpq %rax, %r12
jb 0x6f99
movq %rax, (%r15)
jmp 0x6fd6
movl $0x9, (%rbx)
jmp 0x6fe3
movl $0x8, (%rbx)
xorl %r14d, %r14d
cmpl $0x0, (%rbx)
je 0x6fe6
movq %r14, %rdi
callq 0x2030
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r12, %rdi
callq 0x3777
// File: /workspace/github_c_makefile_star2_O1/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
movq %rsp, %r12
movq $0x0, (%r12)
movl $0x0, (%rsi)
movq %rdi, (%r12)
movq %r12, %rsi
movl $0xa, %edx
callq 0x21c0
movq %rax, %r15
cmpq %r14, (%r12)
je 0x7072
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x6f7f(%rip), %rax      # 0xdff8
movq (%rax), %rdi
leaq 0x2df3(%rip), %rsi      # 0x9e76
movq %r14, %rdx
xorl %eax, %eax
callq 0x21a0
movl $0x9, (%rbx)
jmp 0x7063
// File: /workspace/github_c_makefile_star2_O1/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, %r15
movq %rcx, %rdx
callq 0x6e6b
cmpl $0x0, (%rbx)
jne 0x7140
movq %rax, %r12
cmpl $0x1, 0x8(%rax)
jne 0x7122
movq $0x0, (%r15)
movl $0x0, (%rbx)
testq %r12, %r12
je 0x712a
movq 0x10(%r12), %r13
testq %r13, %r13
je 0x7130
movq (%r13), %rdi
testq %rdi, %rdi
je 0x7130
movl $0x8, %esi
callq 0x2170
testq %rax, %rax
je 0x7150
movq %rax, %r14
xorl %r12d, %r12d
movq 0x10(%r13), %rax
movq (%rax,%r12,8), %rdi
movq %rbx, %rsi
callq 0x702a
cmpl $0x0, (%rbx)
jne 0x7133
movq %rax, (%r14,%r12,8)
incq %r12
movq (%r13), %rax
cmpq %rax, %r12
jb 0x70f8
movq %rax, (%r15)
jmp 0x7133
movl $0x9, (%rbx)
jmp 0x7140
movl $0x8, (%rbx)
xorl %r14d, %r14d
cmpl $0x0, (%rbx)
je 0x7143
movq %r14, %rdi
callq 0x2030
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r12, %rdi
callq 0x379e
// File: /workspace/github_c_makefile_star2_O1/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 0x6e6b
cmpl $0x0, (%rbx)
jne 0x7172
cmpl $0x0, 0x8(%rax)
je 0x7176
movl $0x9, (%rbx)
xorl %eax, %eax
popq %rbx
retq
movq 0x10(%rax), %rax
cmpq $0x0, (%rax)
je 0x718a
movq 0x10(%rax), %rax
movq (%rax), %rdi
popq %rbx
jmp 0x7192
movl $0x8, (%rbx)
jmp 0x7172
// File: /workspace/github_c_makefile_star2_O1/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 0x71b5
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x2060
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rcx, %rdx
callq 0x6e6b
cmpl $0x0, (%rbx)
jne 0x723a
movl $0x9, %ecx
cmpl $0x1, 0x8(%rax)
jne 0x7238
movq 0x10(%rax), %r12
movq $0x0, (%r14)
testq %r12, %r12
je 0x722b
movq (%r12), %rdi
testq %rdi, %rdi
je 0x722b
movq %rdi, (%r14)
movl $0x8, %esi
callq 0x2170
testq %rax, %rax
je 0x724a
movq %rax, %r15
xorl %r13d, %r13d
movq 0x10(%r12), %rax
movq (%rax,%r13,8), %rdi
callq 0x7192
movq %rax, (%r15,%r13,8)
incq %r13
cmpq (%r14), %r13
jb 0x720f
jmp 0x722e
xorl %r15d, %r15d
testq %r15, %r15
jne 0x723d
movl $0x8, %ecx
movl %ecx, (%rbx)
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x37c5
// File: /workspace/github_c_makefile_star2_O1/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 0x7308
movq %r14, %rdi
callq 0x20e0
movq %rax, %r15
movl $0x22, %edi
movq %rbx, %rsi
callq 0x2150
testq %r15, %r15
je 0x72f2
xorl %r13d, %r13d
leaq 0x29e8(%rip), %r12      # 0x9ca9
movsbl (%r14,%r13), %edi
cmpl $0x22, %edi
jne 0x72e2
movl $0x2, %esi
movl $0x1, %edx
movq %r12, %rdi
movq %rbx, %rcx
callq 0x2290
jmp 0x72ea
movq %rbx, %rsi
callq 0x2150
incq %r13
cmpq %r13, %r15
jne 0x72c1
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_O1/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 0x739a
movq %rdx, %rbx
movq %rdi, %r15
callq 0x22c0
movq (%rax), %rax
movq 0x8(%r15), %rcx
movq %r14, %rdx
movsbq (%rcx,%rdx), %rsi
testb $0x20, 0x1(%rax,%rsi,2)
jne 0x7387
cmpb $0x23, %sil
jne 0x7391
movl $0x6, (%rbx)
cmpb $0xa, (%rcx,%rdx)
je 0x7379
incq %rdx
cmpq %rdx, %r12
jne 0x7362
movq $-0x1, %rdx
jmp 0x737f
movl $0x0, (%rbx)
cmpl $0x6, (%rbx)
movq %rdx, %r14
je 0x739a
incq %rdx
cmpq %r12, %rdx
jb 0x734a
jmp 0x739a
movl $0x0, (%rbx)
movq %rdx, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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, %rbx
movq %rsi, %r12
movq %rdi, %r14
movl $0x6, (%rcx)
movq (%rsi), %rax
leaq -0x1(%rax), %rdx
cmpq %rbx, %rdx
jne 0x73d2
xorl %r15d, %r15d
jmp 0x7422
movq %rbx, %r15
movq %r15, %rdx
incq %rdx
movl $0x6, (%rcx)
movq $-0x1, %r15
cmpq %rdx, %rax
jbe 0x7400
movq 0x8(%r12), %rsi
cmpb $0x22, (%rsi,%rdx)
je 0x7404
incq %rdx
cmpq %rdx, %rax
jne 0x73f2
xorl %esi, %esi
jmp 0x7410
movl $0x0, (%rcx)
movb $0x1, %sil
movq %rdx, %r15
testb %sil, %sil
je 0x7422
movq 0x8(%r12), %rdx
cmpb $0x5c, -0x1(%rdx,%r15)
je 0x73d5
cmpl $0x0, (%rcx)
jne 0x7490
movq %rbx, %r13
notq %r13
movq %r15, %rdi
subq %rbx, %rdi
movl $0x1, %esi
callq 0x2170
addq %r15, %r13
je 0x7484
movq 0x8(%r12), %rcx
incq %rbx
xorl %edi, %edi
xorl %edx, %edx
movb (%rcx,%rbx), %sil
cmpl $0x5c, %edi
sete %dil
cmpb $0x22, %sil
sete %r8b
andb %dil, %r8b
cmpb $0x1, %r8b
jne 0x7471
movb $0x22, -0x1(%rax,%rdx)
jmp 0x7478
movb %sil, (%rax,%rdx)
incq %rdx
movsbl %sil, %edi
incq %rbx
cmpq %rbx, %r15
jne 0x744e
movq 0x10(%r14), %rdi
movq %rax, %rsi
callq 0x755f
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x754d
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 0x7513
movzbl %bpl, %eax
cmpl $0x2c, %eax
je 0x7513
cmpl $0x7d, %eax
je 0x7513
leaq 0x1(%r15), %rcx
cmpl $0x5d, %eax
jne 0x74cd
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 0x755f
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_O1/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 0x8(%rdi), %r15
cmpq %r15, (%rdi)
jne 0x75ae
testq %r15, %r15
jle 0x75ae
movq 0x10(%r14), %rdi
movq %r15, %rsi
shlq $0x4, %rsi
callq 0x2230
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x75cc
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), %rax
movq 0x10(%r14), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, (%r14)
movq %rbx, (%rcx,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x37ea
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x75e4
popq %rbx
retq
movq %rbx, %rdi
callq 0x380f
// File: /workspace/github_c_makefile_star2_O1/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 0x75ec
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_O1/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
testq %rax, %rax
je 0x76a5
movq %rax, %rbx
movq $0x1, 0x8(%rax)
movl $0x1, %edi
movl $0x8, %esi
callq 0x2170
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x76ae
movq %rbx, %rax
popq %rbx
retq
callq 0x3858
xorl %ebx, %ebx
jmp 0x76a0
callq 0x3833
// File: /workspace/github_c_makefile_star2_O1/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 0x7668
movq %rax, %rbx
movq (%r14), %r12
movq 0x8(%rax), %r13
cmpq %r13, %r12
jbe 0x7713
cmpq (%rbx), %r12
jae 0x76db
movq %r12, (%rbx)
movq %r12, %r15
subq %r13, %r15
je 0x7713
movq 0x10(%rbx), %rdi
leaq (,%r12,8), %rsi
callq 0x2230
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x773c
shlq $0x3, %r15
leaq (%rax,%r13,8), %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x2120
movq %r12, 0x8(%rbx)
movq (%r14), %rdx
movq %rdx, (%rbx)
testq %rdx, %rdx
je 0x772f
movq 0x10(%rbx), %rdi
movq 0x10(%r14), %rsi
shlq $0x3, %rdx
callq 0x21d0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x3874
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
callq 0x7668
movq %rax, %r14
movq 0x8(%rax), %r13
cmpq %r13, %rbx
jbe 0x77a1
cmpq %rbx, (%r14)
jbe 0x7769
movq %rbx, (%r14)
movq %rbx, %r12
subq %r13, %r12
je 0x77a1
movq 0x10(%r14), %rdi
leaq (,%rbx,8), %rsi
callq 0x2230
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x77c9
shlq $0x3, %r12
leaq (%rax,%r13,8), %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x2120
movq %rbx, 0x8(%r14)
movq %rbx, (%r14)
testq %rbx, %rbx
je 0x77bc
movq 0x10(%r14), %rdi
shlq $0x3, %rbx
movq %r15, %rsi
movq %rbx, %rdx
callq 0x21d0
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x3899
// File: /workspace/github_c_makefile_star2_O1/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 0x7668
movq %rax, %rbx
testq %r14, %r14
je 0x78ea
movq %rbx, %rax
addq $0x8, %rax
movq %rax, (%rsp)
movq (%rbx), %r12
movq 0x8(%rbx), %r15
movl $0x1, %ebp
cmpq %r15, %r12
jne 0x78cf
leaq (%r15,%r15), %r13
testq %r15, %r15
cmoveq %rbp, %r13
cmpq %r12, %r13
cmovbq %r13, %r12
cmpq $0x1, %r13
adcq $0x0, %r13
cmpq %r15, %r13
je 0x78cf
movq 0x10(%rbx), %rdi
leaq (,%r13,8), %rsi
callq 0x2230
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x78fc
movq %r13, %rdx
subq %r15, %rdx
jbe 0x78cc
shlq $0x3, %rdx
leaq (%rax,%r15,8), %rdi
xorl %esi, %esi
callq 0x2120
movq %r13, %r15
movq 0x10(%rbx), %rax
movq $0x1, (%rax,%r12,8)
incq %r12
decq %r14
jne 0x7877
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 0x38e3
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
callq 0x7668
movq %rax, %rbx
cmpq %r14, %r15
jge 0x79be
movq %rbx, %rax
addq $0x8, %rax
movq %rax, (%rsp)
movq (%rbx), %r13
movq 0x8(%rbx), %r12
movl $0x1, %ecx
cmpq %r12, %r13
jne 0x79a4
leaq (%r12,%r12), %rbp
testq %r12, %r12
cmoveq %rcx, %rbp
cmpq %r13, %rbp
cmovbq %rbp, %r13
cmpq $0x1, %rbp
adcq $0x0, %rbp
cmpq %r12, %rbp
je 0x79a4
movq 0x10(%rbx), %rdi
leaq (,%rbp,8), %rsi
callq 0x2230
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x79d0
movq %rbp, %rdx
subq %r12, %rdx
jbe 0x799c
shlq $0x3, %rdx
leaq (%rax,%r12,8), %rdi
xorl %esi, %esi
callq 0x2120
movq %rbp, %r12
movl $0x1, %ecx
movq 0x10(%rbx), %rax
movq %r15, (%rax,%r13,8)
incq %r13
incq %r15
cmpq %r15, %r14
jne 0x7947
movq %r13, (%rbx)
movq %r12, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq (%rsp), %rcx
callq 0x390e
// File: /workspace/github_c_makefile_star2_O1/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
testq %rax, %rax
je 0x7a74
movq %rax, %rbx
movq $0x1, 0x8(%rax)
movl $0x1, %edi
movl $0x8, %esi
callq 0x2170
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x7a7d
movq %rbx, %rax
popq %rbx
retq
callq 0x395e
xorl %ebx, %ebx
jmp 0x7a6f
callq 0x3939
// File: /workspace/github_c_makefile_star2_O1/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 0x7a37
movq %rax, %rbx
movq (%r14), %r12
movq 0x8(%rax), %r13
cmpq %r13, %r12
jbe 0x7ae2
cmpq (%rbx), %r12
jae 0x7aaa
movq %r12, (%rbx)
movq %r12, %r15
subq %r13, %r15
je 0x7ae2
movq 0x10(%rbx), %rdi
leaq (,%r12,8), %rsi
callq 0x2230
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x7b0b
shlq $0x3, %r15
leaq (%rax,%r13,8), %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x2120
movq %r12, 0x8(%rbx)
movq (%r14), %rdx
movq %rdx, (%rbx)
testq %rdx, %rdx
je 0x7afe
movq 0x10(%rbx), %rdi
movq 0x10(%r14), %rsi
shlq $0x3, %rdx
callq 0x21d0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x397a
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
callq 0x7a37
movq %rax, %r14
movq 0x8(%rax), %r13
cmpq %r13, %rbx
jbe 0x7b70
cmpq %rbx, (%r14)
jbe 0x7b38
movq %rbx, (%r14)
movq %rbx, %r12
subq %r13, %r12
je 0x7b70
movq 0x10(%r14), %rdi
leaq (,%rbx,8), %rsi
callq 0x2230
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x7b98
shlq $0x3, %r12
leaq (%rax,%r13,8), %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x2120
movq %rbx, 0x8(%r14)
movq %rbx, (%r14)
testq %rbx, %rbx
je 0x7b8b
movq 0x10(%r14), %rdi
shlq $0x3, %rbx
movq %r15, %rsi
movq %rbx, %rdx
callq 0x21d0
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x399f
// File: /workspace/github_c_makefile_star2_O1/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 0x7a37
movq %rax, %rbx
testq %r14, %r14
je 0x7cc8
movq %rbx, %rax
addq $0x8, %rax
movq %rax, (%rsp)
movq (%rbx), %r12
movq 0x8(%rbx), %rbp
movl $0x1, %ecx
movabsq $0x3ff0000000000000, %r15 # imm = 0x3FF0000000000000
cmpq %rbp, %r12
jne 0x7cb1
leaq (,%rbp,2), %r13
testq %rbp, %rbp
cmoveq %rcx, %r13
cmpq %r12, %r13
cmovbq %r13, %r12
cmpq $0x1, %r13
adcq $0x0, %r13
cmpq %rbp, %r13
je 0x7cb1
movq 0x10(%rbx), %rdi
leaq (,%r13,8), %rsi
callq 0x2230
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x7cda
movq %r13, %rdx
subq %rbp, %rdx
jbe 0x7ca9
shlq $0x3, %rdx
leaq (%rax,%rbp,8), %rdi
xorl %esi, %esi
callq 0x2120
movq %r13, %rbp
movl $0x1, %ecx
movq 0x10(%rbx), %rax
movq %r15, (%rax,%r12,8)
incq %r12
decq %r14
jne 0x7c50
movq %r12, (%rbx)
movq %rbp, 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 %rbp, %rdx
movq (%rsp), %rcx
callq 0x39e9
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
callq 0x7a37
movq %rax, %rbx
cmpq %r14, %r15
jge 0x7da6
movq %rbx, %rax
addq $0x8, %rax
movq %rax, (%rsp)
movq (%rbx), %r13
movq 0x8(%rbx), %r12
movl $0x1, %ecx
cmpq %r12, %r13
jne 0x7d82
leaq (%r12,%r12), %rbp
testq %r12, %r12
cmoveq %rcx, %rbp
cmpq %r13, %rbp
cmovbq %rbp, %r13
cmpq $0x1, %rbp
adcq $0x0, %rbp
cmpq %r12, %rbp
je 0x7d82
movq 0x10(%rbx), %rdi
leaq (,%rbp,8), %rsi
callq 0x2230
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x7db8
movq %rbp, %rdx
subq %r12, %rdx
jbe 0x7d7a
shlq $0x3, %rdx
leaq (%rax,%r12,8), %rdi
xorl %esi, %esi
callq 0x2120
movq %rbp, %r12
movl $0x1, %ecx
xorps %xmm0, %xmm0
cvtsi2sd %r15, %xmm0
movq 0x10(%rbx), %rax
movsd %xmm0, (%rax,%r13,8)
incq %r13
incq %r15
cmpq %r15, %r14
jne 0x7d25
movq %r13, (%rbx)
movq %r12, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq (%rsp), %rcx
callq 0x3a14
// File: /workspace/github_c_makefile_star2_O1/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
testq %rax, %rax
je 0x7e68
movq %rax, %rbx
movq $0x1, 0x8(%rax)
movl $0x1, %edi
movl $0x8, %esi
callq 0x2170
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x7e71
movq %rbx, %rax
popq %rbx
retq
callq 0x3a64
xorl %ebx, %ebx
jmp 0x7e63
callq 0x3a3f
// File: /workspace/github_c_makefile_star2_O1/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 0x7e2b
movq %rax, %rbx
movq (%r14), %r12
movq 0x8(%rax), %r13
cmpq %r13, %r12
jbe 0x7ed6
cmpq (%rbx), %r12
jae 0x7e9e
movq %r12, (%rbx)
movq %r12, %r15
subq %r13, %r15
je 0x7ed6
movq 0x10(%rbx), %rdi
leaq (,%r12,8), %rsi
callq 0x2230
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x7eff
shlq $0x3, %r15
leaq (%rax,%r13,8), %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x2120
movq %r12, 0x8(%rbx)
movq (%r14), %rdx
movq %rdx, (%rbx)
testq %rdx, %rdx
je 0x7ef2
movq 0x10(%rbx), %rdi
movq 0x10(%r14), %rsi
shlq $0x3, %rdx
callq 0x21d0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x3a80
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
callq 0x7e2b
movq %rax, %r14
movq 0x8(%rax), %r13
cmpq %r13, %rbx
jbe 0x7f64
cmpq %rbx, (%r14)
jbe 0x7f2c
movq %rbx, (%r14)
movq %rbx, %r12
subq %r13, %r12
je 0x7f64
movq 0x10(%r14), %rdi
leaq (,%rbx,8), %rsi
callq 0x2230
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x7f8c
shlq $0x3, %r12
leaq (%rax,%r13,8), %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x2120
movq %rbx, 0x8(%r14)
movq %rbx, (%r14)
testq %rbx, %rbx
je 0x7f7f
movq 0x10(%r14), %rdi
shlq $0x3, %rbx
movq %r15, %rsi
movq %rbx, %rdx
callq 0x21d0
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x3aa5
// File: /workspace/github_c_makefile_star2_O1/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 0x7e2b
movq %rax, %rbx
testq %r14, %r14
je 0x80ad
movq %rbx, %rax
addq $0x8, %rax
movq %rax, (%rsp)
movq (%rbx), %r12
movq 0x8(%rbx), %r15
movl $0x1, %ebp
cmpq %r15, %r12
jne 0x8092
leaq (%r15,%r15), %r13
testq %r15, %r15
cmoveq %rbp, %r13
cmpq %r12, %r13
cmovbq %r13, %r12
cmpq $0x1, %r13
adcq $0x0, %r13
cmpq %r15, %r13
je 0x8092
movq 0x10(%rbx), %rdi
leaq (,%r13,8), %rsi
callq 0x2230
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x80bf
movq %r13, %rdx
subq %r15, %rdx
jbe 0x808f
shlq $0x3, %rdx
leaq (%rax,%r15,8), %rdi
xorl %esi, %esi
callq 0x2120
movq %r13, %r15
movq 0x10(%rbx), %rax
movq $0x1, (%rax,%r12,8)
incq %r12
decq %r14
jne 0x803a
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 0x3aef
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
callq 0x7e2b
movq %rax, %rbx
cmpq %r14, %r15
jge 0x8181
movq %rbx, %rax
addq $0x8, %rax
movq %rax, (%rsp)
movq (%rbx), %r13
movq 0x8(%rbx), %r12
movl $0x1, %ecx
cmpq %r12, %r13
jne 0x8167
leaq (%r12,%r12), %rbp
testq %r12, %r12
cmoveq %rcx, %rbp
cmpq %r13, %rbp
cmovbq %rbp, %r13
cmpq $0x1, %rbp
adcq $0x0, %rbp
cmpq %r12, %rbp
je 0x8167
movq 0x10(%rbx), %rdi
leaq (,%rbp,8), %rsi
callq 0x2230
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x8193
movq %rbp, %rdx
subq %r12, %rdx
jbe 0x815f
shlq $0x3, %rdx
leaq (%rax,%r12,8), %rdi
xorl %esi, %esi
callq 0x2120
movq %rbp, %r12
movl $0x1, %ecx
movq 0x10(%rbx), %rax
movq %r15, (%rax,%r13,8)
incq %r13
incq %r15
cmpq %r15, %r14
jne 0x810a
movq %r13, (%rbx)
movq %r12, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq (%rsp), %rcx
callq 0x3b1a
// File: /workspace/github_c_makefile_star2_O1/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 0x8255
setns %r15b
movq %rsi, %r14
negq %r14
cmovsq %rsi, %r14
movzbl %r15b, %r12d
cvtsi2sd %r14, %xmm0
callq 0x2190
callq 0x2260
mulsd 0x1d48(%rip), %xmm0     # 0x9f80
divsd 0xdd8(%rip), %xmm0      # 0x9018
leaq 0x1d41(%rip), %rax      # 0x9f88
addsd (%rax,%r12,8), %xmm0
cvttsd2si %xmm0, %eax
cltq
jmp 0x8260
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 0x829f
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 0x828d
testb %r15b, %r15b
jne 0x82d0
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)
// File: /workspace/github_c_makefile_star2_O1/esheldon[P]xshear/src/redshear.c
// Function: find_lens
LensumHash* find_lens(LensumHash* lensums, int64 id) {
    // a single file reference, don't allocate
    LensumHash* alensum=NULL;
    HASH_FIND_INT64(lensums, &id, alensum);
    return alensum;
}

// Assembly:
movq %rsi, -0x8(%rsp)
testq %rdi, %rdi
je 0x8420
movzbl -0x1(%rsp), %eax
shll $0x18, %eax
movsbl -0x2(%rsp), %ecx
shll $0x10, %ecx
addl %eax, %ecx
movsbl -0x3(%rsp), %eax
shll $0x8, %eax
addl %ecx, %eax
movsbl -0x4(%rsp), %ecx
addl %eax, %ecx
addl $0x9e3779b9, %ecx       # imm = 0x9E3779B9
movzbl -0x5(%rsp), %eax
shll $0x18, %eax
movsbl -0x6(%rsp), %edx
shll $0x10, %edx
movsbl -0x7(%rsp), %esi
shll $0x8, %esi
addl %edx, %esi
movsbl -0x8(%rsp), %edx
subl %ecx, %eax
addl %esi, %eax
addl %eax, %edx
addl $0x9f49bac2, %edx       # imm = 0x9F49BAC2
xorl $0x7f76d, %edx          # imm = 0x7F76D
subl %edx, %ecx
addl $0x1124109, %ecx        # imm = 0x1124109
movl %edx, %eax
shll $0x8, %eax
xorl %ecx, %eax
movl $0xfeedbef7, %esi       # imm = 0xFEEDBEF7
subl %edx, %esi
subl %eax, %esi
movl %eax, %ecx
shrl $0xd, %ecx
xorl %esi, %ecx
subl %eax, %edx
subl %ecx, %edx
movl %ecx, %esi
shrl $0xc, %esi
xorl %edx, %esi
subl %ecx, %eax
subl %esi, %eax
movl %esi, %edx
shll $0x10, %edx
xorl %eax, %edx
subl %esi, %ecx
subl %edx, %ecx
movl %edx, %eax
shrl $0x5, %eax
xorl %ecx, %eax
subl %edx, %esi
subl %eax, %esi
movl %eax, %ecx
shrl $0x3, %ecx
xorl %esi, %ecx
subl %eax, %edx
subl %ecx, %edx
movl %ecx, %esi
shll $0xa, %esi
xorl %edx, %esi
addl %esi, %ecx
subl %ecx, %eax
shrl $0xf, %esi
xorl %eax, %esi
movq 0x8(%rdi), %rcx
movl 0x8(%rcx), %eax
decl %eax
andl %esi, %eax
movq (%rcx), %rdx
shlq $0x4, %rax
movq (%rdx,%rax), %rax
testq %rax, %rax
je 0x83ff
subq 0x20(%rcx), %rax
jmp 0x8401
xorl %eax, %eax
testq %rax, %rax
je 0x8420
cmpl $0x8, 0x38(%rax)
jne 0x841a
movq 0x30(%rax), %rdx
movq (%rdx), %rdx
cmpq -0x8(%rsp), %rdx
je 0x8422
movq 0x28(%rax), %rax
jmp 0x83f4
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/esheldon[P]xshear/src/sdss-survey.c
// Function: lon_bound
double lon_bound(double lon, double minval, double maxval) {
    while (lon < minval) {
        lon += 360.;
    }

    while (lon > maxval) {
        lon -= 360.;
    }
    return lon;
}

// Assembly:
ucomisd %xmm0, %xmm1
jbe 0x8988
movsd 0x71a(%rip), %xmm3      # 0x9098
addsd %xmm3, %xmm0
ucomisd %xmm0, %xmm1
ja 0x897e
ucomisd %xmm2, %xmm0
jbe 0x89a0
movsd 0x16ca(%rip), %xmm1     # 0xa060
addsd %xmm1, %xmm0
ucomisd %xmm2, %xmm0
ja 0x8996
retq
// File: /workspace/github_c_makefile_star2_O1/esheldon[P]xshear/src/sdss-survey.c
// Function: eq2sdss
void eq2sdss(double ra, double dec, double* lam, double* eta) {

    // put everything in radians first
    ra *= D2R;
    dec *= D2R;

    // this is the SDSS node
    ra -= 1.6580627893946132;

    double cdec = cos(dec);
    
    double x = cos(ra)*cdec;
    double y = sin(ra)*cdec;
    double z = sin(dec);

    *lam = -asin(x);
    *eta = atan2(z, y);

    // this is the eta pole
    *eta -= 0.56723200689815712;

    *eta *= R2D;
    *lam *= R2D;

    *eta = lon_bound(*eta, -180., 180.);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movapd %xmm0, %xmm2
movsd 0x6ee(%rip), %xmm0      # 0x90a8
mulsd %xmm0, %xmm2
mulsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
addsd 0x1698(%rip), %xmm2     # 0xa068
movsd %xmm2, 0x8(%rsp)
callq 0x2140
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x2140
mulsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x2250
movsd 0x10(%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x10(%rsp)
movsd 0x20(%rsp), %xmm0
callq 0x2250
movsd %xmm0, 0x8(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x2270
xorps 0x67a(%rip), %xmm0      # 0x90b0
movlps %xmm0, (%r14)
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x2210
addsd 0x161d(%rip), %xmm0     # 0xa070
movsd 0x161d(%rip), %xmm1     # 0xa078
mulsd %xmm1, %xmm0
movsd %xmm0, (%rbx)
mulsd (%r14), %xmm1
movsd %xmm1, (%r14)
movsd (%rbx), %xmm0
movsd 0x1607(%rip), %xmm1     # 0xa080
ucomisd %xmm0, %xmm1
jbe 0x8a91
movsd 0x611(%rip), %xmm2      # 0x9098
addsd %xmm2, %xmm0
ucomisd %xmm0, %xmm1
ja 0x8a87
ucomisd 0x15ef(%rip), %xmm0     # 0xa088
jbe 0x8ab5
movsd 0x15bd(%rip), %xmm1     # 0xa060
movsd 0x15dd(%rip), %xmm2     # 0xa088
addsd %xmm1, %xmm0
ucomisd %xmm2, %xmm0
ja 0x8aab
movsd %xmm0, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/esheldon[P]xshear/src/sdss-survey.c
// Function: eq2sdss_sincos
void eq2sdss_sincos(double ra, double dec, 
                    double* sinlam, double* coslam, 
                    double* sineta, double* coseta) {
    double lam,eta;
    eq2sdss(ra, dec, &lam, &eta);

    lam *= D2R;
    eta *= D2R;
    *sinlam = sin(lam);
    *coslam = cos(lam);
    *sineta = sin(eta);
    *coseta = cos(eta);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x20(%rsp), %r13
leaq 0x18(%rsp), %rbp
movq %r13, %rdi
movq %rbp, %rsi
callq 0x89a1
movsd 0x5b0(%rip), %xmm1      # 0x90a8
movsd (%r13), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd %xmm0, (%r13)
mulsd (%rbp), %xmm1
movsd %xmm1, 0x8(%rsp)
movsd %xmm1, (%rbp)
callq 0x2250
movsd %xmm0, (%r12)
movsd 0x10(%rsp), %xmm0
callq 0x2140
movsd %xmm0, (%r15)
movsd 0x8(%rsp), %xmm0
callq 0x2250
movsd %xmm0, (%r14)
movsd 0x8(%rsp), %xmm0
callq 0x2140
movsd %xmm0, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/esheldon[P]xshear/src/sdss-survey.c
// Function: gcirc_survey
void gcirc_survey(
        double lam1, double eta1, 
        double lam2, double eta2,
        double* dis,  double* theta)
{

  double tlam1 = lam1*D2R;
  //sinlam1 = sin(tlam1);
  double coslam1 = cos(tlam1);
  double sinlam1 = sin(tlam1);

  double tlam2 = lam2*D2R;
  double coslam2 = cos(tlam2);
  double sinlam2 = sin(tlam2);

  double etadiff = (eta2-eta1)*D2R;
  double cosetadiff = cos(etadiff);
  double sinetadiff = sin(etadiff);

  double cosdis = sinlam1*sinlam2 + coslam1*coslam2*cosetadiff;

  if (cosdis < -1.0) cosdis=-1.0;
  if (cosdis >  1.0) cosdis= 1.0;

  *dis = acos(cosdis);

  *theta = atan2( sinetadiff, sinlam1*cosetadiff - coslam1*sinlam2/coslam2 );

  *theta -= M_PI_2;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movsd %xmm3, 0x10(%rsp)
movsd %xmm2, 0x8(%rsp)
movsd %xmm1, 0x18(%rsp)
mulsd 0x51a(%rip), %xmm0      # 0x90a8
movsd %xmm0, 0x20(%rsp)
callq 0x2140
movsd %xmm0, 0x30(%rsp)
movsd 0x20(%rsp), %xmm0
callq 0x2250
movsd %xmm0, 0x20(%rsp)
movsd 0x8(%rsp), %xmm0
mulsd 0x4ea(%rip), %xmm0      # 0x90a8
movsd %xmm0, 0x8(%rsp)
callq 0x2140
movsd %xmm0, 0x28(%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x2250
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
subsd 0x18(%rsp), %xmm0
mulsd 0x4b4(%rip), %xmm0      # 0x90a8
movsd %xmm0, 0x10(%rsp)
callq 0x2140
movsd %xmm0, 0x18(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x2250
movsd %xmm0, 0x10(%rsp)
movsd 0x30(%rsp), %xmm0
mulsd 0x28(%rsp), %xmm0
mulsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
mulsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd 0x3f8(%rip), %xmm2      # 0x9038
maxsd %xmm1, %xmm2
movsd 0x3d4(%rip), %xmm0      # 0x9020
minsd %xmm2, %xmm0
callq 0x2160
movsd %xmm0, (%r14)
movsd 0x8(%rsp), %xmm0
mulsd 0x30(%rsp), %xmm0
divsd 0x28(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
mulsd 0x18(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
callq 0x2210
addsd 0x3b1(%rip), %xmm0      # 0x9040
movsd %xmm0, (%rbx)
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/esheldon[P]xshear/src/sdss-survey.c
// Function: posangle_survey_sincos
double posangle_survey_sincos(double sinlam1, double coslam1,
                              double sineta1, double coseta1,
                              double sinlam2, double coslam2,
                              double sineta2, double coseta2) {

    double cosetadiff = coseta2*coseta1 + sineta2*sineta1;
    double sinetadiff = sineta2*coseta1 - coseta2*sineta2;

    double theta = atan2( sinetadiff, sinlam1*cosetadiff - coslam1*sinlam2/coslam2 );
    theta -= M_PI_2;

    return theta;
}

// Assembly:
pushq %rax
mulsd %xmm6, %xmm2
movapd %xmm7, %xmm8
mulsd %xmm3, %xmm8
addsd %xmm2, %xmm8
mulsd %xmm6, %xmm7
mulsd %xmm3, %xmm6
subsd %xmm7, %xmm6
mulsd %xmm4, %xmm1
divsd %xmm5, %xmm1
mulsd %xmm0, %xmm8
subsd %xmm1, %xmm8
movapd %xmm6, %xmm0
movapd %xmm8, %xmm1
callq 0x2210
addsd 0x35d(%rip), %xmm0      # 0x9040
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/esheldon[P]xshear/src/sdss-survey.c
// Function: survey_quad
int survey_quad(double theta) {
    theta = (M_PI_2 - theta)*R2D;
    if (theta >= 0. && theta < 90.) {
        return 0;
    } else if (theta >= 90. && theta < 180.) {
        return 1;
    } else if (theta >= 180. && theta < 270.) {
        return 2;
    } else {
        return 3;
    }
}

// Assembly:
movsd 0x343(%rip), %xmm1      # 0x9030
subsd %xmm0, %xmm1
mulsd 0x137f(%rip), %xmm1     # 0xa078
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jb 0x8d14
xorl %eax, %eax
movsd 0x393(%rip), %xmm0      # 0x90a0
ucomisd %xmm1, %xmm0
jbe 0x8d14
retq
ucomisd 0x384(%rip), %xmm1      # 0x90a0
jb 0x8d31
movl $0x1, %eax
movsd 0x135d(%rip), %xmm0     # 0xa088
ucomisd %xmm1, %xmm0
ja 0x8d13
movsd 0x1357(%rip), %xmm0     # 0xa090
movsd 0x1347(%rip), %xmm2     # 0xa088
cmplepd %xmm1, %xmm2
cmpltpd %xmm0, %xmm1
andpd %xmm2, %xmm1
movd %xmm1, %eax
andl $0x1, %eax
xorl $0x3, %eax
retq