LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/esheldon[P]xshear/src/config.c
// Function: copy_quoted_string
static size_t copy_quoted_string(struct cfg_field *field,
                                 const struct cfg_string *str,
                                 size_t current,
                                 enum cfg_status *status)
{
    size_t sbeg=0, endquote=0, send=0, size=0, isrc=0, idst=0;
    int c=0, cold=0;
    char *tmp=NULL;

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

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

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

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

    return endquote;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0x6, (%rcx)
movq (%rsi), %rax
decq %rax
cmpq %rdx, %rax
jne 0x687e
xorl %ebx, %ebx
jmp 0x6914
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, (%rsp)
pushq $0x22
popq %rbp
movq %rdx, %rbx
incq %rbx
movq %r13, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movq %r12, %rcx
callq 0x682c
movq %rax, %rbx
cmpl $0x0, (%r12)
jne 0x6914
movq 0x8(%r13), %r15
cmpb $0x5c, -0x1(%r15,%rbx)
je 0x6891
movq %rbx, %rdi
subq %r14, %rdi
pushq $0x1
popq %rsi
callq 0x2170
incq %r14
xorl %ecx, %ecx
xorl %esi, %esi
cmpq %r14, %rbx
je 0x6904
movb (%r15,%r14), %dl
cmpl $0x5c, %esi
sete %sil
cmpb $0x22, %dl
sete %dil
andb %sil, %dil
cmpb $0x1, %dil
jne 0x68f6
movb $0x22, -0x1(%rax,%rcx)
jmp 0x68fc
movb %dl, (%rax,%rcx)
incq %rcx
movsbl %dl, %esi
incq %r14
jmp 0x68cf
movq (%rsp), %rcx
movq 0x10(%rcx), %rdi
movq %rax, %rsi
callq 0x69e1
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rcx
leaq (%rcx,%r13), %r14
cmpq %r12, %r14
ja 0x69cf
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 0x699a
movzbl %bpl, %eax
cmpl $0x2c, %eax
je 0x699a
cmpl $0x7d, %eax
je 0x699a
leaq 0x1(%r15), %rcx
cmpl $0x5d, %eax
jne 0x6954
movq (%rsp), %rax
andl $0x0, (%rax)
leaq 0x1(%r15), %rdi
pushq $0x1
popq %rsi
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 0x69e1
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_O2/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 0x6a33
testq %r15, %r15
jle 0x6a33
movq 0x10(%r14), %rdi
movq %r15, %rsi
shlq $0x4, %rsi
callq 0x2230
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x6a4e
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
movq 0x75a3(%rip), %rax      # 0xdff8
movq (%rax), %rcx
leaq 0x3380(%rip), %rdi      # 0x9ddf
pushq $0x1d
popq %rsi
pushq $0x1
popq %rdx
callq 0x2290
pushq $0x1
popq %rdi
callq 0x2280
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x6a84
popq %rbx
retq
movq 0x756d(%rip), %rax      # 0xdff8
movq (%rax), %rdi
leaq 0x3217(%rip), %rsi      # 0x9cac
movq %rbx, %rdx
xorl %eax, %eax
callq 0x21a0
pushq $0x1
popq %rdi
callq 0x2280
// File: /workspace/github_c_makefile_star2_O2/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 0x6aa7
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_O2/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
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0x2170
movq %rax, %rbx
testq %rax, %rax
je 0x6b55
movq $0x1, 0x8(%rbx)
pushq $0x1
popq %rdi
pushq $0x8
popq %rsi
callq 0x2170
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x6b73
movq %rbx, %rax
popq %rbx
retq
movq 0x749c(%rip), %rax      # 0xdff8
movq (%rax), %rcx
leaq 0x339e(%rip), %rdi      # 0x9f04
pushq $0x1c
popq %rsi
pushq $0x1
popq %rdx
callq 0x2290
jmp 0x6b50
movq 0x747e(%rip), %rax      # 0xdff8
movq (%rax), %rcx
leaq 0x339d(%rip), %rdi      # 0x9f21
pushq $0x23
popq %rsi
pushq $0x1
popq %rdx
callq 0x2290
pushq $0x1
popq %rdi
callq 0x2280
// File: /workspace/github_c_makefile_star2_O2/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 0x6b20
movq %rax, %rbx
movq (%r14), %r15
movq 0x8(%rax), %r13
movq %r15, %r12
subq %r13, %r12
jbe 0x6bed
movq 0x10(%rbx), %rdi
leaq (,%r15,8), %rsi
callq 0x2230
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x6c16
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 0x6c09
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
movq 0x73db(%rip), %rax      # 0xdff8
movq (%rax), %rcx
leaq 0x24ca(%rip), %rdi      # 0x90f1
pushq $0x15
popq %rsi
pushq $0x1
popq %rdx
callq 0x2290
pushq $0x1
popq %rdi
callq 0x2280
// File: /workspace/github_c_makefile_star2_O2/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 0x6b20
movq %rax, %rbx
movq 0x8(%rax), %r14
movq %r15, %rbp
subq %r14, %rbp
jbe 0x6c9e
movq %r12, (%rsp)
movq 0x10(%rbx), %rdi
leaq (,%r15,8), %r12
movq %r12, %rsi
callq 0x2230
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x6cd6
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 0x6cb5
movq %r15, (%rbx)
testq %r15, %r15
je 0x6cc4
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
movq 0x731b(%rip), %rax      # 0xdff8
movq (%rax), %rcx
leaq 0x240a(%rip), %rdi      # 0x90f1
pushq $0x15
popq %rsi
pushq $0x1
popq %rdx
callq 0x2290
pushq $0x1
popq %rdi
callq 0x2280
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
callq 0x6b20
movq %rax, %r14
pushq $0x1
popq %rcx
subq $0x1, %rbx
jb 0x6e2d
movq (%r14), %r13
cmpq 0x8(%r14), %r13
jne 0x6e11
leaq (,%r13,2), %rbp
testq %r13, %r13
cmoveq %rcx, %rbp
cmpq %r13, %rbp
movq %r13, %r12
cmovbq %rbp, %r12
cmpq $0x1, %rbp
adcq $0x0, %rbp
movq 0x10(%r14), %r15
cmpq %r13, %rbp
je 0x6e18
leaq (,%rbp,8), %rsi
movq %r15, %rdi
callq 0x2230
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x6e3f
movq %rax, %r15
movq %rbp, %rdx
subq %r13, %rdx
jbe 0x6e08
shlq $0x3, %rdx
leaq (%r15,%r13,8), %rdi
xorl %esi, %esi
callq 0x2120
movq %rbp, 0x8(%r14)
pushq $0x1
popq %rcx
jmp 0x6e18
movq 0x10(%r14), %r15
movq %r13, %r12
leaq 0x1(%r12), %rax
movq %rax, (%r14)
movq $0x1, (%r15,%r12,8)
jmp 0x6d98
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x71b2(%rip), %rax      # 0xdff8
movq (%rax), %rcx
leaq 0x22a1(%rip), %rdi      # 0x90f1
pushq $0x15
popq %rsi
pushq $0x1
popq %rdx
callq 0x2290
pushq $0x1
popq %rdi
callq 0x2280
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movq %rdi, %r14
callq 0x6b20
movq %rbx, %rcx
movq %rax, %r15
pushq $0x1
popq %rdx
movq %rbx, (%rsp)
cmpq %rcx, %r14
jge 0x6f1c
movq (%r15), %rbp
cmpq 0x8(%r15), %rbp
jne 0x6f02
leaq (,%rbp,2), %r13
testq %rbp, %rbp
cmoveq %rdx, %r13
cmpq %rbp, %r13
movq %rbp, %rbx
cmovbq %r13, %rbx
cmpq $0x1, %r13
adcq $0x0, %r13
movq 0x10(%r15), %r12
cmpq %rbp, %r13
je 0x6f09
leaq (,%r13,8), %rsi
movq %r12, %rdi
callq 0x2230
movq %rax, 0x10(%r15)
testq %rax, %rax
je 0x6f2e
movq %rax, %r12
movq %r13, %rdx
subq %rbp, %rdx
jbe 0x6ef5
shlq $0x3, %rdx
leaq (%r12,%rbp,8), %rdi
xorl %esi, %esi
callq 0x2120
movq %r13, 0x8(%r15)
movq (%rsp), %rcx
pushq $0x1
popq %rdx
jmp 0x6f09
movq 0x10(%r15), %r12
movq %rbp, %rbx
leaq 0x1(%rbx), %rax
movq %rax, (%r15)
movq %r14, (%r12,%rbx,8)
incq %r14
jmp 0x6e86
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x70c3(%rip), %rax      # 0xdff8
movq (%rax), %rcx
leaq 0x21b2(%rip), %rdi      # 0x90f1
pushq $0x15
popq %rsi
pushq $0x1
popq %rdx
callq 0x2290
pushq $0x1
popq %rdi
callq 0x2280
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0x2170
movq %rax, %rbx
testq %rax, %rax
je 0x6fd6
movq $0x1, 0x8(%rbx)
pushq $0x1
popq %rdi
pushq $0x8
popq %rsi
callq 0x2170
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x6ff4
movq %rbx, %rax
popq %rbx
retq
movq 0x701b(%rip), %rax      # 0xdff8
movq (%rax), %rcx
leaq 0x2f5e(%rip), %rdi      # 0x9f45
pushq $0x1b
popq %rsi
pushq $0x1
popq %rdx
callq 0x2290
jmp 0x6fd1
movq 0x6ffd(%rip), %rax      # 0xdff8
movq (%rax), %rcx
leaq 0x2f1c(%rip), %rdi      # 0x9f21
pushq $0x23
popq %rsi
pushq $0x1
popq %rdx
callq 0x2290
pushq $0x1
popq %rdi
callq 0x2280
// File: /workspace/github_c_makefile_star2_O2/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 0x6fa1
movq %rax, %rbx
movq (%r14), %r15
movq 0x8(%rax), %r13
movq %r15, %r12
subq %r13, %r12
jbe 0x706e
movq 0x10(%rbx), %rdi
leaq (,%r15,8), %rsi
callq 0x2230
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x7097
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 0x708a
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
movq 0x6f5a(%rip), %rax      # 0xdff8
movq (%rax), %rcx
leaq 0x2049(%rip), %rdi      # 0x90f1
pushq $0x15
popq %rsi
pushq $0x1
popq %rdx
callq 0x2290
pushq $0x1
popq %rdi
callq 0x2280
// File: /workspace/github_c_makefile_star2_O2/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 0x6fa1
movq %rax, %rbx
movq 0x8(%rax), %r14
movq %r15, %rbp
subq %r14, %rbp
jbe 0x711f
movq %r12, (%rsp)
movq 0x10(%rbx), %rdi
leaq (,%r15,8), %r12
movq %r12, %rsi
callq 0x2230
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x7157
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 0x7136
movq %r15, (%rbx)
testq %r15, %r15
je 0x7145
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
movq 0x6e9a(%rip), %rax      # 0xdff8
movq (%rax), %rcx
leaq 0x1f89(%rip), %rdi      # 0x90f1
pushq $0x15
popq %rsi
pushq $0x1
popq %rdx
callq 0x2290
pushq $0x1
popq %rdi
callq 0x2280
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
callq 0x6fa1
movq %rax, %r14
pushq $0x1
popq %rcx
movabsq $0x3ff0000000000000, %rdx # imm = 0x3FF0000000000000
subq $0x1, %rbx
jb 0x72bd
movq (%r14), %rbp
cmpq 0x8(%r14), %rbp
jne 0x72a6
leaq (,%rbp,2), %r12
testq %rbp, %rbp
cmoveq %rcx, %r12
cmpq %rbp, %r12
movq %rbp, %r13
cmovbq %r12, %r13
cmpq $0x1, %r12
adcq $0x0, %r12
movq 0x10(%r14), %r15
cmpq %rbp, %r12
je 0x72ad
leaq (,%r12,8), %rsi
movq %r15, %rdi
callq 0x2230
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x72cf
movq %rax, %r15
movq %r12, %rdx
subq %rbp, %rdx
jbe 0x7293
shlq $0x3, %rdx
leaq (%r15,%rbp,8), %rdi
xorl %esi, %esi
callq 0x2120
movq %r12, 0x8(%r14)
pushq $0x1
popq %rcx
movabsq $0x3ff0000000000000, %rdx # imm = 0x3FF0000000000000
jmp 0x72ad
movq 0x10(%r14), %r15
movq %rbp, %r13
leaq 0x1(%r13), %rax
movq %rax, (%r14)
movq %rdx, (%r15,%r13,8)
jmp 0x7223
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x6d22(%rip), %rax      # 0xdff8
movq (%rax), %rcx
leaq 0x1e11(%rip), %rdi      # 0x90f1
pushq $0x15
popq %rsi
pushq $0x1
popq %rdx
callq 0x2290
pushq $0x1
popq %rdi
callq 0x2280
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movq %rdi, %r14
callq 0x6fa1
movq %rbx, %rcx
movq %rax, %r15
pushq $0x1
popq %rdx
movq %rbx, (%rsp)
cmpq %rcx, %r14
jge 0x73b3
movq (%r15), %rbp
cmpq 0x8(%r15), %rbp
jne 0x7392
leaq (,%rbp,2), %r13
testq %rbp, %rbp
cmoveq %rdx, %r13
cmpq %rbp, %r13
movq %rbp, %rbx
cmovbq %r13, %rbx
cmpq $0x1, %r13
adcq $0x0, %r13
movq 0x10(%r15), %r12
cmpq %rbp, %r13
je 0x7399
leaq (,%r13,8), %rsi
movq %r12, %rdi
callq 0x2230
movq %rax, 0x10(%r15)
testq %rax, %rax
je 0x73c5
movq %rax, %r12
movq %r13, %rdx
subq %rbp, %rdx
jbe 0x7385
shlq $0x3, %rdx
leaq (%r12,%rbp,8), %rdi
xorl %esi, %esi
callq 0x2120
movq %r13, 0x8(%r15)
movq (%rsp), %rcx
pushq $0x1
popq %rdx
jmp 0x7399
movq 0x10(%r15), %r12
movq %rbp, %rbx
leaq 0x1(%rbx), %rax
movq %rax, (%r15)
cvtsi2sd %r14, %xmm0
movsd %xmm0, (%r12,%rbx,8)
incq %r14
jmp 0x7316
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x6c2c(%rip), %rax      # 0xdff8
movq (%rax), %rcx
leaq 0x1d1b(%rip), %rdi      # 0x90f1
pushq $0x15
popq %rsi
pushq $0x1
popq %rdx
callq 0x2290
pushq $0x1
popq %rdi
callq 0x2280
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdi
pushq $0x18
popq %rsi
callq 0x2170
movq %rax, %rbx
testq %rax, %rax
je 0x7479
movq $0x1, 0x8(%rbx)
pushq $0x1
popq %rdi
pushq $0x8
popq %rsi
callq 0x2170
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x7497
movq %rbx, %rax
popq %rbx
retq
movq 0x6b78(%rip), %rax      # 0xdff8
movq (%rax), %rcx
leaq 0x2ad7(%rip), %rdi      # 0x9f61
pushq $0x1b
popq %rsi
pushq $0x1
popq %rdx
callq 0x2290
jmp 0x7474
movq 0x6b5a(%rip), %rax      # 0xdff8
movq (%rax), %rcx
leaq 0x2a79(%rip), %rdi      # 0x9f21
pushq $0x23
popq %rsi
pushq $0x1
popq %rdx
callq 0x2290
pushq $0x1
popq %rdi
callq 0x2280
// File: /workspace/github_c_makefile_star2_O2/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 0x7444
movq %rax, %rbx
movq (%r14), %r15
movq 0x8(%rax), %r13
movq %r15, %r12
subq %r13, %r12
jbe 0x7511
movq 0x10(%rbx), %rdi
leaq (,%r15,8), %rsi
callq 0x2230
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x753a
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 0x752d
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
movq 0x6ab7(%rip), %rax      # 0xdff8
movq (%rax), %rcx
leaq 0x1ba6(%rip), %rdi      # 0x90f1
pushq $0x15
popq %rsi
pushq $0x1
popq %rdx
callq 0x2290
pushq $0x1
popq %rdi
callq 0x2280
// File: /workspace/github_c_makefile_star2_O2/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 0x7444
movq %rax, %rbx
movq 0x8(%rax), %r14
movq %r15, %rbp
subq %r14, %rbp
jbe 0x75c2
movq %r12, (%rsp)
movq 0x10(%rbx), %rdi
leaq (,%r15,8), %r12
movq %r12, %rsi
callq 0x2230
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x75fa
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 0x75d9
movq %r15, (%rbx)
testq %r15, %r15
je 0x75e8
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
movq 0x69f7(%rip), %rax      # 0xdff8
movq (%rax), %rcx
leaq 0x1ae6(%rip), %rdi      # 0x90f1
pushq $0x15
popq %rsi
pushq $0x1
popq %rdx
callq 0x2290
pushq $0x1
popq %rdi
callq 0x2280
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
callq 0x7444
movq %rax, %r14
pushq $0x1
popq %rcx
subq $0x1, %rbx
jb 0x7751
movq (%r14), %r13
cmpq 0x8(%r14), %r13
jne 0x7735
leaq (,%r13,2), %rbp
testq %r13, %r13
cmoveq %rcx, %rbp
cmpq %r13, %rbp
movq %r13, %r12
cmovbq %rbp, %r12
cmpq $0x1, %rbp
adcq $0x0, %rbp
movq 0x10(%r14), %r15
cmpq %r13, %rbp
je 0x773c
leaq (,%rbp,8), %rsi
movq %r15, %rdi
callq 0x2230
movq %rax, 0x10(%r14)
testq %rax, %rax
je 0x7763
movq %rax, %r15
movq %rbp, %rdx
subq %r13, %rdx
jbe 0x772c
shlq $0x3, %rdx
leaq (%r15,%r13,8), %rdi
xorl %esi, %esi
callq 0x2120
movq %rbp, 0x8(%r14)
pushq $0x1
popq %rcx
jmp 0x773c
movq 0x10(%r14), %r15
movq %r13, %r12
leaq 0x1(%r12), %rax
movq %rax, (%r14)
movq $0x1, (%r15,%r12,8)
jmp 0x76bc
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x688e(%rip), %rax      # 0xdff8
movq (%rax), %rcx
leaq 0x197d(%rip), %rdi      # 0x90f1
pushq $0x15
popq %rsi
pushq $0x1
popq %rdx
callq 0x2290
pushq $0x1
popq %rdi
callq 0x2280
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movq %rdi, %r14
callq 0x7444
movq %rbx, %rcx
movq %rax, %r15
pushq $0x1
popq %rdx
movq %rbx, (%rsp)
cmpq %rcx, %r14
jge 0x7840
movq (%r15), %rbp
cmpq 0x8(%r15), %rbp
jne 0x7826
leaq (,%rbp,2), %r13
testq %rbp, %rbp
cmoveq %rdx, %r13
cmpq %rbp, %r13
movq %rbp, %rbx
cmovbq %r13, %rbx
cmpq $0x1, %r13
adcq $0x0, %r13
movq 0x10(%r15), %r12
cmpq %rbp, %r13
je 0x782d
leaq (,%r13,8), %rsi
movq %r12, %rdi
callq 0x2230
movq %rax, 0x10(%r15)
testq %rax, %rax
je 0x7852
movq %rax, %r12
movq %r13, %rdx
subq %rbp, %rdx
jbe 0x7819
shlq $0x3, %rdx
leaq (%r12,%rbp,8), %rdi
xorl %esi, %esi
callq 0x2120
movq %r13, 0x8(%r15)
movq (%rsp), %rcx
pushq $0x1
popq %rdx
jmp 0x782d
movq 0x10(%r15), %r12
movq %rbp, %rbx
leaq 0x1(%rbx), %rax
movq %rax, (%r15)
movq %r14, (%r12,%rbx,8)
incq %r14
jmp 0x77aa
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x679f(%rip), %rax      # 0xdff8
movq (%rax), %rcx
leaq 0x188e(%rip), %rdi      # 0x90f1
pushq $0x15
popq %rsi
pushq $0x1
popq %rdx
callq 0x2290
pushq $0x1
popq %rdi
callq 0x2280
// File: /workspace/github_c_makefile_star2_O2/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 0x7921
setns %r15b
movq %rsi, %r14
negq %r14
cmovsq %rsi, %r14
movzbl %r15b, %r12d
cvtsi2sd %r14, %xmm0
callq 0x2190
callq 0x2260
mulsd 0x267c(%rip), %xmm0     # 0x9f80
divsd 0x170c(%rip), %xmm0     # 0x9018
leaq 0x2675(%rip), %rax      # 0x9f88
addsd (%rax,%r12,8), %xmm0
cvttsd2si %xmm0, %eax
cltq
jmp 0x792a
movb $0x1, %r15b
pushq $0x2
popq %rax
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)
pushq $-0x1
popq %r8
pushq $0xa
popq %rsi
incl %r8d
cmpl $0x3, %r8d
jne 0x7960
movb $0x2c, (%rcx)
decq %rcx
xorl %r8d, %r8d
movq %r14, %rax
xorl %edx, %edx
divq %rsi
orb $0x30, %dl
movb %dl, (%rcx)
decq %rcx
cmpq $0x9, %r14
movq %rax, %r14
ja 0x794e
testb %r15b, %r15b
jne 0x7981
movb $0x2d, (%rcx)
movq %rbx, %rsi
callq 0x2110
leaq -0x20(%rbp), %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x7afb
movq %rsi, %rcx
shrq $0x20, %rcx
movl $0xff000000, %eax       # imm = 0xFF000000
andl %eax, %ecx
movq %rsi, %rdx
shrq $0x18, %rdx
sarl $0x8, %edx
movl $0xffff0000, %r8d       # imm = 0xFFFF0000
andl %r8d, %edx
addl %ecx, %edx
movq %rsi, %rcx
shrq $0x10, %rcx
sarl $0x10, %ecx
movl $0xffffff00, %r9d       # imm = 0xFFFFFF00
andl %r9d, %ecx
addl %edx, %ecx
movq %rsi, %rdx
shrq $0x8, %rdx
sarl $0x18, %edx
addl %edx, %ecx
addl $0x9e3779b9, %ecx       # imm = 0x9E3779B9
andl %esi, %eax
movl %esi, %edx
shll $0x8, %edx
sarl $0x8, %edx
andl %r8d, %edx
movswl %si, %r8d
andl %r9d, %r8d
addl %edx, %r8d
movsbl %sil, %edx
subl %ecx, %eax
addl %r8d, %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 0x7ac9
subq 0x20(%rcx), %rax
jmp 0x7af6
xorl %eax, %eax
jmp 0x7af6
cmpl $0x8, 0x38(%rax)
jne 0x7ae1
movq 0x30(%rax), %rdx
movq (%rdx), %rdx
cmpq -0x8(%rsp), %rdx
je 0x7afd
movq 0x28(%rax), %rdx
movl $0x0, %eax
testq %rdx, %rdx
je 0x7af6
subq 0x20(%rcx), %rdx
movq %rdx, %rax
testq %rax, %rax
jne 0x7acd
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movsd 0x1074(%rip), %xmm3     # 0x9098
ucomisd %xmm0, %xmm1
jbe 0x8030
addsd %xmm3, %xmm0
jmp 0x8024
movsd 0x2028(%rip), %xmm1     # 0xa060
ucomisd %xmm2, %xmm0
jbe 0x8044
addsd %xmm1, %xmm0
jmp 0x8038
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x104a(%rip), %xmm0     # 0x90a8
mulsd %xmm0, %xmm2
mulsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
addsd 0x1ff4(%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 0xfd6(%rip), %xmm0      # 0x90b0
movlps %xmm0, (%r14)
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
callq 0x2210
addsd 0x1f79(%rip), %xmm0     # 0xa070
movsd 0x1f79(%rip), %xmm1     # 0xa078
mulsd %xmm1, %xmm0
movsd %xmm0, (%rbx)
mulsd (%r14), %xmm1
movsd %xmm1, (%r14)
movsd (%rbx), %xmm0
movsd 0x1f63(%rip), %xmm1     # 0xa080
movsd 0x1f63(%rip), %xmm2     # 0xa088
callq 0x801c
movsd %xmm0, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x8045
movsd 0xf3b(%rip), %xmm1      # 0x90a8
movsd (%r13), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
mulsd (%rbp), %xmm1
movsd %xmm1, 0x8(%rsp)
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_O2/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 0xeb0(%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 0xe80(%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 0xe4a(%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 0xd8e(%rip), %xmm2      # 0x9038
maxsd %xmm1, %xmm2
movsd 0xd6a(%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 0xd47(%rip), %xmm0      # 0x9040
movsd %xmm0, (%rbx)
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xcf3(%rip), %xmm0      # 0x9040
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xcd9(%rip), %xmm1      # 0x9030
subsd %xmm0, %xmm1
mulsd 0x1d15(%rip), %xmm1     # 0xa078
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jb 0x837e
xorl %eax, %eax
movsd 0xd29(%rip), %xmm0      # 0x90a0
ucomisd %xmm1, %xmm0
jbe 0x837e
retq
ucomisd 0xd1a(%rip), %xmm1      # 0x90a0
jb 0x839a
movsd 0x1cf8(%rip), %xmm0     # 0xa088
ucomisd %xmm1, %xmm0
jbe 0x839a
pushq $0x1
popq %rax
retq
movsd 0x1cee(%rip), %xmm0     # 0xa090
movsd 0x1cde(%rip), %xmm2     # 0xa088
cmplepd %xmm1, %xmm2
cmpltpd %xmm0, %xmm1
andpd %xmm2, %xmm1
movd %xmm1, %eax
andl $0x1, %eax
xorl $0x3, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/ravenexp[P]aatrace/match.c
// Function: aatrace_match_tile
struct match_result
aatrace_match_tile(const unsigned char* tilebuf,
		   const unsigned char* fontbuf,
		   int nchars,
		   const struct aatrace_match_ctx* ctx)
{
	switch (ctx->method) {
	default:
	case AATRACE_MATCH_METHOD_MINSAD:
		return aatrace_match_tile_sad(tilebuf, fontbuf, nchars);
	case AATRACE_MATCH_METHOD_MINSADASD:
		return aatrace_match_tile_sadasd(tilebuf, fontbuf, nchars,
						 ctx->sad_weight, ctx->asd_weight);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpl $0x2, (%rcx)
jne 0x1cf5
movl 0x4(%rcx), %eax
movl 0x8(%rcx), %ecx
movq %rax, -0x8(%rsp)
movq %rcx, -0x10(%rsp)
addl %ecx, %eax
imull $0x7f80, %eax, %ecx     # imm = 0x7F80
xorl %r10d, %r10d
testl %edx, %edx
cmovlel %r10d, %edx
xorl %r11d, %r11d
xorl %eax, %eax
cmpq %rdx, %r11
je 0x1ce1
movslq %r10d, %r14
addq %rsi, %r14
xorl %r15d, %r15d
movq %rdi, %r12
xorl %ebx, %ebx
xorl %ebp, %ebp
cmpq $0x10, %r15
je 0x1cad
xorl %r13d, %r13d
cmpq $0x8, %r13
je 0x1ca0
movzbl (%r12,%r13), %r8d
movzbl (%r14,%r13), %r9d
subl %r9d, %r8d
addl %r8d, %ebp
movl %r8d, %r9d
negl %r9d
cmovsl %r8d, %r9d
movzbl %r9b, %r8d
addl %r8d, %ebx
incq %r13
jmp 0x1c74
incq %r15
addq $0x8, %r14
addq $0x8, %r12
jmp 0x1c6b
movl %ebp, %r8d
negl %r8d
cmovsl %ebp, %r8d
imull -0x8(%rsp), %ebx
imull -0x10(%rsp), %r8d
addl %ebx, %r8d
cmpl %ecx, %r8d
cmovbl %r11d, %eax
cmovbl %r8d, %ecx
incq %r11
subl $-0x80, %r10d
testl %ecx, %ecx
jne 0x1c52
xorl %ecx, %ecx
shlq $0x20, %rcx
movl %eax, %eax
orq %rcx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r8d, %r8d
testl %edx, %edx
cmovlel %r8d, %edx
movl $0x7f80, %ecx           # imm = 0x7F80
xorl %r9d, %r9d
xorl %eax, %eax
cmpq %rdx, %r9
je 0x1ce1
movslq %r8d, %r11
addq %rsi, %r11
xorl %ebx, %ebx
movq %rdi, %r14
xorl %r10d, %r10d
cmpq $0x10, %rbx
je 0x1d5a
xorl %r15d, %r15d
cmpq $0x8, %r15
je 0x1d4d
movzbl (%r14,%r15), %ebp
movzbl (%r11,%r15), %r12d
subl %r12d, %ebp
movl %ebp, %r12d
negl %r12d
cmovsl %ebp, %r12d
movzbl %r12b, %ebp
addl %ebp, %r10d
incq %r15
jmp 0x1d24
incq %rbx
addq $0x8, %r11
addq $0x8, %r14
jmp 0x1d1b
cmpl %ecx, %r10d
cmovbl %r9d, %eax
testl %r10d, %r10d
je 0x1cdf
cmpl %ecx, %r10d
cmovbl %r10d, %ecx
incq %r9
subl $-0x80, %r8d
jmp 0x1d08
nop
// File: /workspace/github_c_makefile_star2_O2/ravenexp[P]aatrace/cover.c
// Function: aatrace_cover_tile_score
unsigned int
aatrace_cover_tile_score(const struct aatrace_pic* pic,
			 const struct aatrace_font* font,
			 int tl, int tc, int dx, int dy,
			 const struct aatrace_match_ctx* ctx)
{
	const unsigned char* p =
		pic->buf + font->h*pic->ll*tl + font->w*tc;
	unsigned int score = 0;
	int i;

	if (dy > 0)
		for (i = 0; i < dy; i++)
			score += edge_score(p + i*pic->ll, FW, 1, ctx);
	if (dy < 0)
		for (i = dy; i < 0; i++)
			score += edge_score(p + (font->h + i)*pic->ll, FW, 1, ctx);

	if (dx > 0)
		for (i = 0; i < dx; i++)
			score += edge_score(p + i, FH, pic->ll, ctx);
	if (dx < 0)
		for (i = dx; i < 0; i++)
			score += edge_score(p + font->w + i, FH, pic->ll, ctx);

	return score;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, (%rsp)
movq 0x60(%rsp), %r12
movq (%rdi), %rax
movl 0x1c(%rsi), %ebx
movl 0x8(%rdi), %ebp
imull %ebx, %edx
imull %ebp, %edx
movslq 0x18(%rsi), %rsi
movq %rsi, 0x10(%rsp)
imull %esi, %ecx
movslq %ecx, %rcx
movq %rax, 0x20(%rsp)
movq %rcx, 0x8(%rsp)
leaq (%rax,%rcx), %r13
movq %rdx, 0x18(%rsp)
addq %rdx, %r13
testl %r9d, %r9d
jle 0x1e0a
movl %r9d, 0x4(%rsp)
movl %r9d, %r14d
xorl %r12d, %r12d
xorl %r15d, %r15d
subq $0x1, %r14
jb 0x1dfe
movl %r12d, %edi
addq %r13, %rdi
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
movq 0x60(%rsp), %rcx
callq 0x1ec2
addl %eax, %r15d
addl %ebp, %r12d
jmp 0x1dda
movq 0x60(%rsp), %r12
movl 0x4(%rsp), %r9d
jmp 0x1e0d
xorl %r15d, %r15d
testl %r9d, %r9d
js 0x1e5a
movl (%rsp), %eax
testl %eax, %eax
jle 0x1e3f
movl %eax, %r14d
pushq $0x10
popq %rbx
subq $0x1, %r14
jb 0x1e3c
movq %r13, %rdi
movl %ebx, %esi
movl %ebp, %edx
movq %r12, %rcx
callq 0x1ec2
addl %eax, %r15d
incq %r13
jmp 0x1e1f
movl (%rsp), %eax
testl %eax, %eax
movq 0x20(%rsp), %r13
js 0x1e85
movl %r15d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addl %r9d, %ebx
imull %ebp, %ebx
movl %r9d, %r14d
testl %r14d, %r14d
je 0x1e12
movl %ebx, %edi
addq %r13, %rdi
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
movq %r12, %rcx
callq 0x1ec2
addl %eax, %r15d
incl %r14d
addl %ebp, %ebx
jmp 0x1e63
movslq %eax, %r14
movq 0x10(%rsp), %rax
addq %r14, %rax
movq 0x8(%rsp), %rcx
addq 0x18(%rsp), %rcx
addq %rax, %rcx
addq %rcx, %r13
pushq $0x10
popq %rbx
testq %r14, %r14
je 0x1e48
movq %r13, %rdi
movl %ebx, %esi
movl %ebp, %edx
movq %r12, %rcx
callq 0x1ec2
addl %eax, %r15d
incq %r14
incq %r13
jmp 0x1ea3
// File: /workspace/github_c_makefile_star2_O2/ravenexp[P]aatrace/cover.c
// Function: edge_score
static
unsigned int edge_score(const unsigned char* p, int l,
			unsigned int stride,
			const struct aatrace_match_ctx* ctx)
{
	unsigned int score = 0;
	int i;

	for (i = 0; i < l; i++) {
		score += p[i*stride];
	}

	if (ctx->method == AATRACE_MATCH_METHOD_MINSADASD)
		score *= (ctx->sad_weight + ctx->asd_weight);

	return score;
}

// Assembly:
xorl %r8d, %r8d
testl %esi, %esi
cmovlel %r8d, %esi
xorl %eax, %eax
subq $0x1, %rsi
jb 0x1ee3
movl %r8d, %r9d
movzbl (%rdi,%r9), %r9d
addl %r9d, %eax
addl %edx, %r8d
jmp 0x1ecd
cmpl $0x2, (%rcx)
jne 0x1ef1
movl 0x8(%rcx), %edx
addl 0x4(%rcx), %edx
imull %edx, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/ravenexp[P]aatrace/convert.c
// Function: aatrace_convert_pic
void aatrace_convert_pic(struct aatrace_text* txt,
			 const struct aatrace_pic* src,
			 const struct aatrace_font* font,
			 const struct aatrace_convert_ctx* ctx)
{
	int tl, tc;

	txt->ll = txt->w = src->w/AATRACE_FONT_WIDTH;
	txt->h = src->h/AATRACE_FONT_HEIGHT;
	txt->buf = (char*)malloc(txt->ll*txt->h);

	for (tl = 0; (tl + 1)*font->h <= src->h; tl++) {
		for (tc = 0; (tc + 1)*font->w <= src->w; tc++) {
			txt->buf[tl*txt->ll + tc] =
				aatrace_search_tile(src, font, tl, tc, &ctx->match, &ctx->search)
				+ font->ascii_offset;
		}
	}
}

// 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
movl 0xc(%rsi), %ebp
pushq $0x8
popq %rcx
movl %ebp, %eax
cltd
idivl %ecx
movl %eax, %edi
movl %eax, 0xc(%r12)
movl %eax, 0x8(%r12)
movl 0x10(%rsi), %r13d
pushq $0x10
popq %rcx
movl %r13d, %eax
cltd
idivl %ecx
movl %eax, 0x10(%r12)
imull %eax, %edi
callq 0x1100
movq %r12, 0x18(%rsp)
movq %rax, (%r12)
movq %rbx, 0x20(%rsp)
leaq 0xc(%rbx), %rax
movq %rax, 0x10(%rsp)
xorl %ebx, %ebx
leal 0x1(%rbx), %ecx
movl 0x1c(%r14), %eax
imull %ecx, %eax
cmpl %r13d, %eax
jg 0x225f
movl %ecx, 0xc(%rsp)
xorl %r13d, %r13d
leal 0x1(%r13), %r12d
movl 0x18(%r14), %eax
imull %r12d, %eax
cmpl %ebp, %eax
jg 0x2253
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
movl %r13d, %ecx
movq 0x20(%rsp), %r8
movq 0x10(%rsp), %r9
callq 0x1eff
addl 0x24(%r14), %eax
movq 0x18(%rsp), %rdx
movq (%rdx), %rcx
movl 0x8(%rdx), %edx
imull %ebx, %edx
addl %r13d, %edx
movb %al, (%rcx,%rdx)
movl 0xc(%r15), %ebp
movl %r12d, %r13d
jmp 0x2208
movl 0x10(%r15), %r13d
movl 0xc(%rsp), %eax
movl %eax, %ebx
jmp 0x21f2
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/zpole[P]IICV/./vl/heap-def.h
// Function: vl_heap_float_pop
VL_INLINE vl_uindex
VL_HEAP_pop
(VL_HEAP_array array, vl_size *heapSize)
{
  assert (*heapSize) ;

  *heapSize -= 1 ;

  VL_HEAP_swap (array, 0, *heapSize) ;

  if (*heapSize > 1) {
    VL_HEAP_up (array, *heapSize, 0) ;
  }

  return *heapSize ;
}

// Assembly:
movq (%rsi), %rcx
leaq -0x1(%rcx), %rax
movq %rax, (%rsi)
movss (%rdi), %xmm0
movss -0x4(%rdi,%rcx,4), %xmm1
movss %xmm1, (%rdi)
movss %xmm0, -0x4(%rdi,%rcx,4)
cmpq $0x2, %rax
jb 0x16b4
pushq %rbx
movq %rsi, %rbx
movq %rax, %rsi
xorl %edx, %edx
callq 0x16e0
movq (%rbx), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/converters/strrem/strrem.c
// Function: main
int main (int argc, char *argv[])
{
int i, slen;
char *ppos, *fpos, *tpos, oname[256], line[256];
FILE *ifile, *ofile;

if ((argc < 2) || (argv[0] == NULL)) {
	printf ("Usage is: strrem file [file...]\n");
	exit (0);  }

slen = strlen (srem);
for (i = 1; i < argc; i++) {
	strcpy (oname, argv[i]);
        if (ppos = strrchr (oname, '.')) strcpy (ppos, ".new");
            else strcat (oname, ".new");
	ifile = fopen (argv[i], "r");
	if (ifile == NULL) {
	    printf ("Error opening file: %s\n", argv[i]);
	    exit (0);  }
	ofile = fopen (oname, "w");
	if (ofile == NULL) {
	    printf ("Error opening file: %s\n", oname);
	    exit (0);  }

	printf ("Processing file %s\n", argv[i]);
	while (fgets (line, 255, ifile) != NULL) {
	    tpos = strstr (line, srem);
	    if (tpos) {
		    fpos = tpos + slen;
		    while (*fpos) *tpos++ = *fpos++;
            *tpos = 0;
		    }
	    fputs (line, ofile);
	    }
	fclose (ifile);
	fclose (ofile);
	}
return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
cmpl $0x2, %edi
jl 0x1376
movq %rsi, %rbx
cmpq $0x0, (%rsi)
je 0x1376
movl %edi, %ebp
movq 0x2e74(%rip), %rdi      # 0x4080
callq 0x1060
movslq %eax, %r13
movl %ebp, %eax
movq %rax, 0x8(%rsp)
pushq $0x1
popq %rax
leaq 0x10(%rsp), %r12
leaq 0x110(%rsp), %rbp
cmpq 0x8(%rsp), %rax
je 0x1337
movq (%rbx,%rax,8), %r15
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %r14
callq 0x1030
movq %r12, %rdi
pushq $0x2e
popq %rsi
callq 0x1080
testq %rax, %rax
movq %r14, (%rsp)
je 0x126c
movb $0x0, 0x4(%rax)
movl $0x77656e2e, (%rax)     # imm = 0x77656E2E
movq (%rbx,%r14,8), %r15
jmp 0x1281
movq %r12, %rdi
callq 0x1060
movl $0x77656e2e, 0x10(%rsp,%rax) # imm = 0x77656E2E
movb $0x0, 0x14(%rsp,%rax)
movq %r15, %rdi
leaq 0xd87(%rip), %rsi       # 0x2012
callq 0x10b0
testq %rax, %rax
je 0x134b
movq %rax, %r15
movq %r12, %r14
movq %r12, %rdi
leaq 0xd67(%rip), %rsi       # 0x2010
callq 0x10b0
testq %rax, %rax
je 0x135c
movq %rax, %r12
movq (%rsp), %rax
movq (%rbx,%rax,8), %rsi
leaq 0xd63(%rip), %rdi       # 0x202c
xorl %eax, %eax
callq 0x1070
movq %rbp, %rdi
movl $0xff, %esi
movq %r15, %rdx
callq 0x10a0
testq %rax, %rax
je 0x1318
movq 0x2d94(%rip), %rsi      # 0x4080
movq %rbp, %rdi
callq 0x10d0
testq %rax, %rax
jne 0x1300
jmp 0x130b
movb %cl, (%rax)
incq %rax
movb (%rax,%r13), %cl
testb %cl, %cl
jne 0x12fb
movb $0x0, (%rax)
movq %rbp, %rdi
movq %r12, %rsi
callq 0x1090
jmp 0x12d0
movq %r15, %rdi
callq 0x1050
movq %r12, %rdi
callq 0x1050
movq (%rsp), %rax
incq %rax
movq %r14, %r12
jmp 0x122b
xorl %eax, %eax
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rsp), %rax
movq (%rbx,%rax,8), %rsi
leaq 0xcba(%rip), %rdi       # 0x2014
jmp 0x1368
leaq 0xcb1(%rip), %rdi       # 0x2014
leaq 0x10(%rsp), %rsi
xorl %eax, %eax
callq 0x1070
xorl %edi, %edi
callq 0x10c0
leaq 0xcc3(%rip), %rdi       # 0x2040
callq 0x1040
jmp 0x136f