LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/esheldon[P]xshear/src/cosmo.c
// Function: Dm
double Dm(Cosmo* c, double zmin, double zmax) {

    double d;

    d = Dc(c, zmin, zmax);

    if (!c->flat) {
        if (c->omega_k > 0) {
            d= sinh(d*c->tcfac)/c->tcfac;
        } else {
            d= sin(d*c->tcfac)/c->tcfac;
        }
    }
    return d;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsd 0x10(%rdi), %xmm2
movsd %xmm2, 0x8(%rsp)
callq 0x4bc8
mulsd 0x8(%rsp), %xmm0
cmpl $0x0, (%rbx)
jne 0x4c9c
movsd 0x28(%rbx), %xmm1
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm1
mulsd 0x30(%rbx), %xmm0
jbe 0x4c92
callq 0x21f0
jmp 0x4c97
callq 0x2250
divsd 0x30(%rbx), %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/esheldon[P]xshear/src/cosmo.c
// Function: Da
double Da(Cosmo* c, double zmin, double zmax) {
    double d;
    d = Dm(c, zmin, zmax);
    d /= (1.+zmax);
    return d;
}

// Assembly:
pushq %rax
movsd %xmm1, (%rsp)
callq 0x4c54
movsd (%rsp), %xmm1
addsd 0x4366(%rip), %xmm1     # 0x9020
divsd %xmm1, %xmm0
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/esheldon[P]xshear/src/cosmo.c
// Function: dV
double dV(Cosmo* c, double z) {
    double da, ezinv, oneplusz;
    double dv;

    oneplusz = 1.+z;

    da = Da(c, 0.0, z);
    ezinv = ez_inverse(c, z);
    dv = c->DH*da*da*ezinv*oneplusz*oneplusz;

    return dv;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movapd %xmm0, %xmm1
movsd %xmm0, 0x10(%rsp)
movq %rdi, %rbx
movsd 0x4328(%rip), %xmm0     # 0x9020
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
xorpd %xmm0, %xmm0
callq 0x4c54
divsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movq %rbx, %rdi
movsd 0x10(%rsp), %xmm0
callq 0x4d50
movsd 0x10(%rbx), %xmm1
movsd 0x18(%rsp), %xmm2
mulsd %xmm2, %xmm1
mulsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movsd 0x8(%rsp), %xmm1
mulsd %xmm1, %xmm0
mulsd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/esheldon[P]xshear/src/cosmo.c
// Function: ez_inverse
double ez_inverse(Cosmo* c, double z) {
    double oneplusz, oneplusz2;
    double ezi;

    oneplusz = 1.+z;
    if (c->flat) {
        ezi = c->omega_m*oneplusz*oneplusz*oneplusz + c->omega_l;
    } else {
        oneplusz2 = oneplusz*oneplusz;
        ezi = c->omega_m*oneplusz2*oneplusz + c->omega_k*oneplusz2 + c->omega_l;
    }
    ezi = sqrt(1.0/ezi);
    return ezi;
}

// Assembly:
addsd 0x42c8(%rip), %xmm0     # 0x9020
cmpl $0x0, (%rdi)
je 0x4d70
movsd 0x18(%rdi), %xmm1
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
mulsd %xmm0, %xmm1
jmp 0x4d8e
movapd %xmm0, %xmm2
mulsd %xmm0, %xmm2
movsd 0x18(%rdi), %xmm1
mulsd %xmm2, %xmm1
mulsd 0x28(%rdi), %xmm2
mulsd %xmm0, %xmm1
addsd %xmm2, %xmm1
addsd 0x20(%rdi), %xmm1
movsd 0x4285(%rip), %xmm0     # 0x9020
divsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x22b0
sqrtsd %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O1/esheldon[P]xshear/src/cosmo.c
// Function: V
double V(Cosmo* c, double zmin, double zmax) {
    int i;
    double f1,f2,z;
    double dv;
    double v=0;

    f1 = (zmax-zmin)/2.;
    f2 = (zmax+zmin)/2.;

    for (i=0; i<VNPTS; i++) {
        z = c->vx[i]*f1 + f2;
        dv = dV(c, z);
        v += f1*dv*c->vw[i];
    }

    return v;

}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movapd %xmm1, %xmm3
subsd %xmm0, %xmm3
movsd 0x42a4(%rip), %xmm2     # 0x9070
mulsd %xmm2, %xmm3
movsd %xmm3, 0x8(%rsp)
addsd %xmm1, %xmm0
mulsd %xmm2, %xmm0
movsd %xmm0, 0x10(%rsp)
xorpd %xmm0, %xmm0
movl $0x11, %r14d
movsd %xmm0, (%rsp)
movsd (%rbx,%r14,8), %xmm0
mulsd 0x8(%rsp), %xmm0
addsd 0x10(%rsp), %xmm0
movq %rbx, %rdi
callq 0x4cde
mulsd 0x8(%rsp), %xmm0
mulsd 0x50(%rbx,%r14,8), %xmm0
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
incq %r14
cmpq $0x1b, %r14
jne 0x4dee
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/esheldon[P]xshear/src/cosmo.c
// Function: scinv
double scinv(Cosmo* c, double zl, double zs) {
    double dl, ds, dls;

    if (zs <= zl) {
        return 0.0;
    }

    dl = Da(c, 0.0, zl);
    ds = Da(c, 0.0, zs);
    dls = Da(c, zl, zs);
    return dls*dl/ds*FOUR_PI_G_OVER_C_SQUARED;
}

// Assembly:
movapd %xmm0, %xmm2
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm2
jae 0x4eea
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movsd %xmm1, 0x8(%rsp)
movapd %xmm2, %xmm1
movsd %xmm2, 0x10(%rsp)
callq 0x4c54
movsd 0x10(%rsp), %xmm1
addsd 0x41a1(%rip), %xmm1     # 0x9020
divsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
xorpd %xmm0, %xmm0
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm1
callq 0x4c54
movsd 0x417d(%rip), %xmm2     # 0x9020
movsd 0x8(%rsp), %xmm1
addsd %xmm1, %xmm2
movsd %xmm2, 0x18(%rsp)
divsd %xmm2, %xmm0
movsd %xmm0, 0x20(%rsp)
movq %rbx, %rdi
movsd 0x10(%rsp), %xmm0
callq 0x4c54
divsd 0x18(%rsp), %xmm0
mulsd 0x28(%rsp), %xmm0
divsd 0x20(%rsp), %xmm0
mulsd 0x4293(%rip), %xmm0     # 0x9178
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/esheldon[P]xshear/src/tree.c
// Function: tree_insert
void tree_insert(TreeNode ** self, int64_t val, size_t index) {
    if(!(*self)) {
        *self = malloc(sizeof(TreeNode));
        (*self)->left = (*self)->right = NULL;
        (*self)->val=val;
        (*self)->indices = szvector_new();
        vector_push((*self)->indices, index);
        return;
    }
    if(val < (*self)->val) {
        tree_insert(&(*self)->left, val, index);
    } else if(val > (*self)->val) {
        tree_insert(&(*self)->right, val, index);
    } else {
        vector_push((*self)->indices, index);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%r14), %rax
testq %rax, %rax
je 0x4f5a
cmpq %r15, (%rax)
jle 0x4f4b
addq $0x18, %rax
movq %rax, %r14
jmp 0x4f35
jge 0x4ff1
addq $0x10, %rax
movq %rax, %r14
jmp 0x4f35
movl $0x20, %edi
callq 0x2200
movq %rax, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq %r15, (%rax)
xorl %eax, %eax
callq 0x7668
movq (%r14), %rcx
movq %rax, 0x8(%rcx)
movq (%r14), %rax
movq 0x8(%rax), %rax
movq (%rax), %rcx
movq 0x8(%rax), %r12
cmpq %r12, %rcx
jne 0x5075
leaq (%r12,%r12), %rdx
testq %r12, %r12
movl $0x1, %r15d
cmovneq %rdx, %r15
cmpq %rcx, %r15
jae 0x4faf
movq %r15, (%rax)
cmpq $0x1, %r15
adcq $0x0, %r15
cmpq %r12, %r15
je 0x5075
movq 0x10(%rax), %rdi
leaq (,%r15,8), %rsi
callq 0x2230
movq (%r14), %rcx
movq 0x8(%rcx), %rcx
movq %rax, 0x10(%rcx)
movq (%r14), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x5053
callq 0x2413
movq 0x8(%rax), %rax
movq (%rax), %rcx
movq 0x8(%rax), %r12
cmpq %r12, %rcx
jne 0x5075
leaq (%r12,%r12), %rdx
testq %r12, %r12
movl $0x1, %r15d
cmovneq %rdx, %r15
cmpq %rcx, %r15
jae 0x501a
movq %r15, (%rax)
cmpq $0x1, %r15
adcq $0x0, %r15
cmpq %r12, %r15
je 0x5075
movq 0x10(%rax), %rdi
leaq (,%r15,8), %rsi
callq 0x2230
movq (%r14), %rcx
movq 0x8(%rcx), %rcx
movq %rax, 0x10(%rcx)
movq (%r14), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x509a
movq %r15, %rdx
subq %r12, %rdx
jbe 0x506a
shlq $0x3, %rdx
leaq (%rax,%r12,8), %rdi
xorl %esi, %esi
callq 0x2120
movq (%r14), %rax
movq 0x8(%rax), %rax
movq %r15, 0x8(%rax)
movq (%r14), %rax
movq 0x8(%rax), %rax
movq (%rax), %rcx
movq 0x10(%rax), %rdx
leaq 0x1(%rcx), %rsi
movq %rsi, (%rax)
movq %rbx, (%rdx,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x23ee
// File: /workspace/github_c_makefile_star2_O1/esheldon[P]xshear/src/tree.c
// Function: tree_free
TreeNode* tree_free(TreeNode* self) {
    if (self != NULL) {
        vector_free(self->indices);
        self->left    = tree_free(self->left);
        self->right   = tree_free(self->right);
        free(self);
    }
    return NULL;
}

// Assembly:
testq %rdi, %rdi
je 0x50fa
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x50ce
movq 0x10(%rax), %rdi
callq 0x2030
movq 0x8(%rbx), %rdi
callq 0x2030
movq $0x0, 0x8(%rbx)
movq 0x18(%rbx), %rdi
callq 0x509f
xorl %r14d, %r14d
movq %r14, 0x18(%rbx)
movq 0x10(%rbx), %rdi
callq 0x509f
movq %r14, 0x10(%rbx)
movq %rbx, %rdi
callq 0x2030
addq $0x8, %rsp
popq %rbx
popq %r14
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/esheldon[P]xshear/src/tree.c
// Function: tree_find
TreeNode* tree_find(TreeNode* self, int64_t val) {
    if (!self) {
        return NULL;
    }
    if(val < self->val) {
        return tree_find(self->left, val);
    } else if(val > self->val) {
        return tree_find(self->right, val);
    } else {
        return self;
    }
}

// Assembly:
movq %rdi, %rax
testq %rax, %rax
je 0x511c
movl $0x18, %ecx
cmpq %rsi, (%rax)
jg 0x5116
movl $0x10, %ecx
jge 0x511e
movq (%rax,%rcx), %rax
jmp 0x5100
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/esheldon[P]xshear/src/tree.c
// Function: tree_print
void tree_print( TreeNode *self, int level )
{
    if ( self == NULL ) {
        tree_print_padding ( '\t', level );
        fprintf(stderr,"~");
    } else {
        tree_print( self->right, level + 1 );
        tree_print_padding ( '\t', level );
        fprintf(stderr,"%ld\n", self->val);
        tree_print( self->left, level + 1 );
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
leaq 0x4(%rsp), %r14
leaq 0x8(%rsp), %r15
testq %rdi, %rdi
je 0x5179
movl %ebx, %esi
movq %r14, %rdx
movq %r15, %rcx
callq 0x2438
movl 0x4(%rsp), %ebx
movq 0x8(%rsp), %rdi
jmp 0x515c
testl %ebx, %ebx
jle 0x5195
movq 0x8e74(%rip), %r14      # 0xdff8
movq (%r14), %rsi
movl $0x9, %edi
callq 0x2150
decl %ebx
jne 0x5184
movq 0x8e5c(%rip), %rax      # 0xdff8
movq (%rax), %rsi
movl $0x7e, %edi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x2150
// File: /workspace/github_c_makefile_star2_O1/esheldon[P]xshear/src/tree.c
// Function: tree_most_members
size_t tree_most_members( TreeNode *self )
{
    size_t max_ind=0, max_ind_left=0, max_ind_right=0;
    if (self != NULL) {
        max_ind = self->indices->size;

        max_ind_left = tree_most_members( self->left );
        max_ind_right = tree_most_members( self->right );

        max_ind = (max_ind > max_ind_left) ? max_ind : max_ind_left;
        max_ind = (max_ind > max_ind_right) ? max_ind : max_ind_right;
    }
    return max_ind;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
xorl %ebx, %ebx
testq %r14, %r14
je 0x51e5
movq 0x8(%r14), %rax
movq 0x18(%r14), %rdi
movq (%rax), %r15
callq 0x51b2
movq 0x10(%r14), %r14
cmpq %rax, %r15
cmovaq %r15, %rax
cmpq %rbx, %rax
cmovaq %rax, %rbx
jmp 0x51bc
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/esheldon[P]xshear/src/lens.c
// Function: lcat_new
LensCatalog* lcat_new(size_t n_lens) {

    if (n_lens == 0) {
        wlog("lcat_new: size must be > 0\n");
        exit(EXIT_FAILURE);
    }

    //LensCatalog* lcat = malloc(sizeof(LensCatalog));
    LensCatalog* lcat = calloc(1,sizeof(LensCatalog));
    if (lcat == NULL) {
        wlog("Could not allocate LensCatalog\n");
        exit(EXIT_FAILURE);
    }

    lcat->size = n_lens;

    //lcat->data = malloc(n_lens*sizeof(Lens));
    lcat->data = calloc(n_lens,sizeof(Lens));
    if (lcat->data == NULL) {
        wlog("Could not allocate %ld lenses in lcat\n", n_lens);
        exit(EXIT_FAILURE);
    }

    lcat->hpix_tree=NULL;

    return lcat;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x523f
movq %rdi, %rbx
movl $0x1, %edi
movl $0x18, %esi
callq 0x2170
testq %rax, %rax
je 0x5244
movq %rax, %r14
movq %rbx, (%rax)
movl $0x80, %esi
movq %rbx, %rdi
callq 0x2170
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x5249
movq $0x0, 0x10(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x28b6
callq 0x2891
movq %rbx, %rdi
callq 0x286d
// File: /workspace/github_c_makefile_star2_O1/esheldon[P]xshear/src/lens.c
// Function: lcat_add_search_angle
void lcat_add_search_angle(LensCatalog* lcat, double rmax) {
    for (size_t i=0; i<lcat->size; i++) {
        Lens* lens = &lcat->data[i];

        double search_angle = rmax/lens->da;
        lens->cos_search_angle = cos(search_angle);
    }
}

// Assembly:
cmpq $0x0, (%rdi)
je 0x52f3
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x58, %r14d
xorl %r15d, %r15d
movsd %xmm0, (%rsp)
movq 0x8(%rbx), %r12
movsd (%rsp), %xmm0
divsd -0x38(%r12,%r14), %xmm0
callq 0x2140
movsd %xmm0, (%r12,%r14)
incq %r15
subq $-0x80, %r14
cmpq (%rbx), %r15
jb 0x52c1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/esheldon[P]xshear/src/lens.c
// Function: lcat_disc_intersect
void lcat_disc_intersect(LensCatalog* lcat, HealPix* hpix, double rmax) {


    for (size_t i=0; i<lcat->size; i++) {

        Lens* lens = &lcat->data[i];

        lens->hpix = lvector_new();

        double search_angle = rmax/lens->da;
        hpix_disc_intersect(
                hpix, 
                lens->ra, lens->dec, 
                search_angle, 
                lens->hpix);

        // this should speed up initial checks of sources
        // since we can ask if within min/max pixel values
        lvector_sort(lens->hpix);

    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
cmpq $0x0, (%rdi)
je 0x5368
movq %rsi, %rbx
movq %rdi, %r14
movl $0x50, %r15d
xorl %r12d, %r12d
movq 0x8(%r14), %r13
xorl %eax, %eax
callq 0x7e2b
movq %rax, (%r13,%r15)
movsd 0x8(%rsp), %xmm2
divsd -0x30(%r13,%r15), %xmm2
movsd -0x48(%r13,%r15), %xmm0
movsd -0x40(%r13,%r15), %xmm1
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3d96
movq (%r13,%r15), %rdi
callq 0x81be
incq %r12
subq $-0x80, %r15
cmpq (%r14), %r12
jb 0x531c
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/esheldon[P]xshear/src/lens.c
// Function: lcat_build_hpix_tree
void lcat_build_hpix_tree(HealPix* hpix, LensCatalog* lcat) {
    int64* ptr=NULL;

    for (size_t i=0; i<lcat->size; i++) {

        Lens* lens = &lcat->data[i];

        // add to the tree
        for (size_t j=0; j<lens->hpix->size; j++) {
            ptr = &lens->hpix->data[j];
            tree_insert(&lcat->hpix_tree, (*ptr)-hpix->half_npix, i);
        }

    }

}

// Assembly:
cmpq $0x0, (%rsi)
je 0x53ed
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsi), %r15
xorl %r12d, %r12d
movq 0x8(%rbx), %rcx
movq %r12, %rdx
shlq $0x7, %rdx
movq 0x50(%rcx,%rdx), %rax
cmpq $0x0, (%rax)
je 0x53d7
leaq (%rcx,%rdx), %r13
addq $0x50, %r13
xorl %ebp, %ebp
movq 0x10(%rax), %rax
movq (%rax,%rbp,8), %rsi
subq 0x10(%r14), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x4f24
incq %rbp
movq (%r13), %rax
cmpq (%rax), %rbp
jb 0x53b4
incq %r12
cmpq (%rbx), %r12
jb 0x5394
addq $0x8, %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/lens.c
// Function: lcat_free
LensCatalog* lcat_free(LensCatalog* lcat) {

    if (lcat != NULL) {
        Lens* lens=&lcat->data[0];
        for (size_t i=0; i<lcat->size; i++) {
            vector_free(lens->hpix);
            lens++;
        }
        free(lcat->data);
        lcat->hpix_tree = tree_free(lcat->hpix_tree);
        free(lcat);
    }
    return NULL;
}

// Assembly:
testq %rdi, %rdi
je 0x545b
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x5438
movq 0x8(%rbx), %r14
addq $0x50, %r14
xorl %r15d, %r15d
movq (%r14), %rax
testq %rax, %rax
je 0x542c
movq 0x10(%rax), %rdi
callq 0x2030
movq (%r14), %rdi
callq 0x2030
movq $0x0, (%r14)
incq %r15
subq $-0x80, %r14
cmpq (%rbx), %r15
jb 0x540c
movq 0x8(%rbx), %rdi
callq 0x2030
movq 0x10(%rbx), %rdi
callq 0x509f
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
callq 0x2030
popq %rbx
popq %r14
popq %r15
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O1/esheldon[P]xshear/src/lensum.c
// Function: lensums_write
void lensums_write(Lensums* self, FILE* stream) {

    Lensum* lensum = &self->data[0];
    for (size_t i=0; i<self->size; i++) {
        lensum_write(lensum, stream);
        
        lensum++;
    }
}

// Assembly:
cmpq $0x0, (%rdi)
je 0x549d
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
xorl %r12d, %r12d
movq %r15, %rdi
movq %rbx, %rsi
callq 0x549e
subq $-0x80, %r15
incq %r12
cmpq (%r14), %r12
jb 0x547b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/esheldon[P]xshear/src/lensum.c
// Function: lensums_sum
Lensum* lensums_sum(Lensums* self) {
    Lensum* tsum=lensum_new(self->data[0].nbin,
                            self->data[0].shear_style, 
                            self->data[0].scstyle,
                            self->data[0].shear_units);


    for (size_t i=0; i<self->size; i++) {

        Lensum* lensum = &self->data[i];

        lensum_add(tsum, lensum);
    }
    return tsum;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x28(%rax), %rdi
movl 0x8(%rax), %edx
movl (%rax), %esi
movl 0x4(%rax), %ecx
callq 0x5783
movq %rax, %r14
cmpq $0x0, (%rbx)
je 0x5774
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%rbx), %rsi
addq %r15, %rsi
movq %r14, %rdi
callq 0x58ef
incq %r12
subq $-0x80, %r15
cmpq (%rbx), %r12
jb 0x5759
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/lensum.c
// Function: lensum_new
Lensum* lensum_new(size_t nbin, int shear_style, int scstyle, int shear_units) {
    Lensum* lensum=calloc(1,sizeof(Lensum));
    if (lensum == NULL) {
        wlog("failed to allocate lensum\n");
        exit(EXIT_FAILURE);
    }

    lensum->shear_style=shear_style;
    lensum->scstyle=scstyle;
    lensum->shear_units=shear_units;

    lensum->nbin = nbin;

    lensum->npair = calloc(nbin, sizeof(int64));
    lensum->rsum  = calloc(nbin, sizeof(double));
    lensum->wsum  = calloc(nbin, sizeof(double));
    lensum->ssum  = calloc(nbin, sizeof(double));
    lensum->dsum  = calloc(nbin, sizeof(double));
    lensum->osum  = calloc(nbin, sizeof(double));

    lensum->dsensum_w  = calloc(nbin, sizeof(double));
    lensum->osensum_w  = calloc(nbin, sizeof(double));
    lensum->dsensum_s  = calloc(nbin, sizeof(double));
    lensum->osensum_s  = calloc(nbin, sizeof(double));


    if (lensum->npair==NULL
            || lensum->wsum==NULL
            || lensum->ssum==NULL
            || lensum->dsum==NULL
            || lensum->osum==NULL
            || lensum->rsum==NULL
            || lensum->dsensum_w==NULL
            || lensum->osensum_w==NULL
            || lensum->dsensum_s==NULL
            || lensum->osensum_s==NULL
            ) {

        wlog("failed to allocate lensum\n");
        exit(EXIT_FAILURE);
    }

    return lensum;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %r14
movl $0x1, %edi
movl $0x80, %esi
callq 0x2170
testq %rax, %rax
je 0x58ea
movq %rax, %rbx
movl %r12d, (%rax)
movl %r15d, 0x8(%rax)
movl %ebp, 0x4(%rax)
movq %r14, 0x28(%rax)
movl $0x8, %esi
movq %r14, %rdi
callq 0x2170
movq %rax, 0x18(%rsp)
movq %rax, 0x30(%rbx)
movl $0x8, %esi
movq %r14, %rdi
callq 0x2170
movq %rax, 0x20(%rsp)
movq %rax, 0x38(%rbx)
movl $0x8, %esi
movq %r14, %rdi
callq 0x2170
movq %rax, 0x10(%rsp)
movq %rax, 0x40(%rbx)
movl $0x8, %esi
movq %r14, %rdi
callq 0x2170
movq %rax, 0x8(%rsp)
movq %rax, 0x48(%rbx)
movl $0x8, %esi
movq %r14, %rdi
callq 0x2170
movq %rax, (%rsp)
movq %rax, 0x50(%rbx)
movl $0x8, %esi
movq %r14, %rdi
callq 0x2170
movq %rax, %r12
movq %rax, 0x58(%rbx)
movl $0x8, %esi
movq %r14, %rdi
callq 0x2170
movq %rax, %r13
movq %rax, 0x60(%rbx)
movl $0x8, %esi
movq %r14, %rdi
callq 0x2170
movq %rax, %rbp
movq %rax, 0x68(%rbx)
movl $0x8, %esi
movq %r14, %rdi
callq 0x2170
movq %rax, %r15
movq %rax, 0x70(%rbx)
movl $0x8, %esi
movq %r14, %rdi
callq 0x2170
movq %rax, 0x78(%rbx)
cmpq $0x0, 0x20(%rsp)
je 0x58e5
cmpq $0x0, 0x18(%rsp)
je 0x58e5
cmpq $0x0, 0x10(%rsp)
je 0x58e5
cmpq $0x0, 0x8(%rsp)
je 0x58e5
cmpq $0x0, (%rsp)
je 0x58e5
testq %r12, %r12
je 0x58e5
testq %r13, %r13
je 0x58e5
testq %rbp, %rbp
je 0x58e5
testq %r15, %r15
je 0x58e5
testq %rax, %rax
je 0x58e5
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2d49
callq 0x2d6e
// File: /workspace/github_c_makefile_star2_O1/esheldon[P]xshear/src/lensum.c
// Function: lensum_add
void lensum_add(Lensum* self, Lensum* src) {

    self->weight   += src->weight;
    self->totpairs += src->totpairs;

    for (size_t i=0; i<src->nbin; i++) {
        self->npair[i] += src->npair[i];
        self->rsum[i] += src->rsum[i];
        self->wsum[i] += src->wsum[i];
        self->ssum[i] += src->ssum[i];
        self->dsum[i] += src->dsum[i];
        self->osum[i] += src->osum[i];
        self->dsensum_w[i] += src->dsensum_w[i];
        self->osensum_w[i] += src->osensum_w[i];
        self->dsensum_s[i] += src->dsensum_s[i];
        self->osensum_s[i] += src->osensum_s[i];
    }

}

// Assembly:
movsd 0x18(%rsi), %xmm0
addsd 0x18(%rdi), %xmm0
movsd %xmm0, 0x18(%rdi)
movq 0x20(%rsi), %rax
addq %rax, 0x20(%rdi)
cmpq $0x0, 0x28(%rsi)
je 0x5a7d
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x30(%rsi), %rax
movq %rax, -0x8(%rsp)
movq 0x38(%rsi), %rax
movq %rax, -0x10(%rsp)
movq 0x30(%rdi), %rax
movq %rax, -0x18(%rsp)
movq 0x38(%rdi), %r8
movq 0x40(%rsi), %rax
movq %rax, -0x20(%rsp)
movq 0x40(%rdi), %r10
movq 0x48(%rsi), %rax
movq %rax, -0x28(%rsp)
movq 0x48(%rdi), %rbx
movq 0x50(%rsi), %rax
movq %rax, -0x30(%rsp)
movq 0x50(%rdi), %r15
movq 0x58(%rdi), %r12
movq 0x60(%rdi), %r13
movq 0x68(%rdi), %rbp
movq 0x70(%rdi), %rax
movq 0x78(%rdi), %rdi
movq 0x58(%rsi), %rcx
movq %rcx, -0x38(%rsp)
movq 0x60(%rsi), %rcx
movq %rcx, -0x40(%rsp)
movq 0x68(%rsi), %rcx
movq %rcx, -0x48(%rsp)
movq 0x70(%rsi), %r11
movq 0x78(%rsi), %r14
xorl %ecx, %ecx
movq -0x18(%rsp), %r9
movq -0x8(%rsp), %rdx
movq (%rdx,%rcx,8), %rdx
addq %rdx, (%r9,%rcx,8)
movq -0x10(%rsp), %rdx
movsd (%rdx,%rcx,8), %xmm0
addsd (%r8,%rcx,8), %xmm0
movsd %xmm0, (%r8,%rcx,8)
movq -0x20(%rsp), %rdx
movsd (%rdx,%rcx,8), %xmm0
addsd (%r10,%rcx,8), %xmm0
movsd %xmm0, (%r10,%rcx,8)
movq -0x28(%rsp), %rdx
movsd (%rdx,%rcx,8), %xmm0
addsd (%rbx,%rcx,8), %xmm0
movsd %xmm0, (%rbx,%rcx,8)
movq -0x30(%rsp), %rdx
movsd (%rdx,%rcx,8), %xmm0
addsd (%r15,%rcx,8), %xmm0
movsd %xmm0, (%r15,%rcx,8)
movq -0x38(%rsp), %rdx
movsd (%rdx,%rcx,8), %xmm0
addsd (%r12,%rcx,8), %xmm0
movsd %xmm0, (%r12,%rcx,8)
movq -0x40(%rsp), %rdx
movsd (%rdx,%rcx,8), %xmm0
addsd (%r13,%rcx,8), %xmm0
movsd %xmm0, (%r13,%rcx,8)
movq -0x48(%rsp), %rdx
movsd (%rdx,%rcx,8), %xmm0
addsd (%rbp,%rcx,8), %xmm0
movsd %xmm0, (%rbp,%rcx,8)
movsd (%r11,%rcx,8), %xmm0
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movsd (%r14,%rcx,8), %xmm0
addsd (%rdi,%rcx,8), %xmm0
movsd %xmm0, (%rdi,%rcx,8)
incq %rcx
cmpq 0x28(%rsi), %rcx
jb 0x599f
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/esheldon[P]xshear/src/lensum.c
// Function: lensum_free
Lensum* lensum_free(Lensum* self) {
    if (self != NULL) {
        free(self->npair);
        free(self->rsum);
        free(self->wsum);
        free(self->ssum);
        free(self->dsum);
        free(self->osum);
        free(self->dsensum_w);
        free(self->osensum_w);
        free(self->dsensum_s);
        free(self->osensum_s);
    }
    free(self);
    return NULL;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x5afb
movq 0x30(%rbx), %rdi
callq 0x2030
movq 0x38(%rbx), %rdi
callq 0x2030
movq 0x40(%rbx), %rdi
callq 0x2030
movq 0x48(%rbx), %rdi
callq 0x2030
movq 0x50(%rbx), %rdi
callq 0x2030
movq 0x58(%rbx), %rdi
callq 0x2030
movq 0x60(%rbx), %rdi
callq 0x2030
movq 0x68(%rbx), %rdi
callq 0x2030
movq 0x70(%rbx), %rdi
callq 0x2030
movq 0x78(%rbx), %rdi
callq 0x2030
movq %rbx, %rdi
callq 0x2030
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/esheldon[P]xshear/src/lensum.c
// Function: lensums_free
Lensums* lensums_free(Lensums* self) {
    if (self != NULL) {
        if (self->data != NULL) {

            for (size_t i=0; i<self->size; i++) {
                Lensum* lensum = &self->data[i];
                free(lensum->npair);
                free(lensum->rsum);
                free(lensum->wsum);
                free(lensum->ssum);
                free(lensum->dsum);
                free(lensum->osum);
                free(lensum->dsensum_w);
                free(lensum->osensum_w);
                free(lensum->dsensum_s);
                free(lensum->osensum_s);
            }
            free(self->data);
        }
        free(self);
    }
    return NULL;
}

// Assembly:
testq %rdi, %rdi
je 0x5bc4
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x5bb1
cmpq $0x0, (%rbx)
je 0x5ba8
movl $0x78, %r14d
xorl %r15d, %r15d
movq 0x8(%rbx), %r12
movq -0x48(%r12,%r14), %rdi
callq 0x2030
movq -0x40(%r12,%r14), %rdi
callq 0x2030
movq -0x38(%r12,%r14), %rdi
callq 0x2030
movq -0x30(%r12,%r14), %rdi
callq 0x2030
movq -0x28(%r12,%r14), %rdi
callq 0x2030
movq -0x20(%r12,%r14), %rdi
callq 0x2030
movq -0x18(%r12,%r14), %rdi
callq 0x2030
movq -0x10(%r12,%r14), %rdi
callq 0x2030
movq -0x8(%r12,%r14), %rdi
callq 0x2030
movq (%r12,%r14), %rdi
callq 0x2030
incq %r15
subq $-0x80, %r14
cmpq (%rbx), %r15
jb 0x5b35
movq 0x8(%rbx), %rdi
callq 0x2030
movq %rbx, %rdi
callq 0x2030
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/esheldon[P]xshear/src/lensum.c
// Function: lensum_copy
Lensum* lensum_copy(Lensum* lensum) {
    int i=0;

    Lensum* copy=lensum_new(lensum->nbin, lensum->shear_style, lensum->scstyle, lensum->shear_units);
    copy->index = lensum->index;
    copy->weight = lensum->weight;
    copy->totpairs = lensum->totpairs;

    copy->nbin = lensum->nbin;

    for (i=0; i<copy->nbin; i++) {
        copy->npair[i] = lensum->npair[i];
        copy->rsum[i] = lensum->rsum[i];
        copy->wsum[i] = lensum->wsum[i];
        copy->ssum[i] = lensum->ssum[i];
        copy->dsum[i] = lensum->dsum[i];
        copy->osum[i] = lensum->osum[i];
        copy->dsensum_s[i] = lensum->dsensum_s[i];
        copy->osensum_s[i] = lensum->osensum_s[i];
        copy->dsensum_w[i] = lensum->dsensum_w[i];
        copy->osensum_w[i] = lensum->osensum_w[i];
    }

    return copy;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %r14
movq 0x28(%rdi), %rdi
movl 0x8(%r14), %edx
movl (%r14), %esi
movl 0x4(%r14), %ecx
callq 0x5783
movq 0x10(%r14), %rcx
movq %rcx, 0x10(%rax)
movsd 0x18(%r14), %xmm0
movsd %xmm0, 0x18(%rax)
movq 0x20(%r14), %rcx
movq %rcx, 0x20(%rax)
movq 0x28(%r14), %r11
movq %rax, 0x8(%rsp)
movq %r11, 0x28(%rax)
testq %r11, %r11
jle 0x606b
movq 0x30(%r14), %rax
movq %rax, 0x50(%rsp)
movq 0x38(%r14), %rax
movq %rax, 0x48(%rsp)
movq 0x8(%rsp), %r9
movq 0x30(%r9), %rax
movq %rax, 0x40(%rsp)
movq 0x38(%r9), %rax
movq %rax, 0x38(%rsp)
movq 0x40(%r14), %rax
movq %rax, 0x30(%rsp)
movq 0x40(%r9), %rax
movq %rax, 0x28(%rsp)
movq 0x48(%r14), %rax
movq %rax, 0x20(%rsp)
movq 0x48(%r9), %rax
movq %rax, 0x18(%rsp)
movq 0x50(%r14), %rax
movq %rax, 0x10(%rsp)
movq 0x50(%r9), %r12
movq 0x58(%r14), %r13
movq 0x70(%r14), %rbp
movq 0x78(%r14), %rbx
movq 0x60(%r14), %rdx
movq 0x68(%r14), %rax
movq 0x58(%r9), %rsi
movq 0x70(%r9), %rdi
movq 0x78(%r9), %rcx
movq 0x60(%r9), %r8
movq 0x68(%r9), %r9
xorl %r10d, %r10d
movq 0x40(%rsp), %r15
movq %r11, %r14
movq 0x50(%rsp), %r11
movq (%r11,%r10,8), %r11
movq %r11, (%r15,%r10,8)
movq %r14, %r11
movq 0x48(%rsp), %r14
movsd (%r14,%r10,8), %xmm0
movq 0x38(%rsp), %r14
movsd %xmm0, (%r14,%r10,8)
movq 0x30(%rsp), %r14
movsd (%r14,%r10,8), %xmm0
movq 0x28(%rsp), %r14
movsd %xmm0, (%r14,%r10,8)
movq 0x20(%rsp), %r14
movsd (%r14,%r10,8), %xmm0
movq 0x18(%rsp), %r14
movsd %xmm0, (%r14,%r10,8)
movq 0x10(%rsp), %r14
movsd (%r14,%r10,8), %xmm0
movsd %xmm0, (%r12,%r10,8)
movsd (%r13,%r10,8), %xmm0
movsd %xmm0, (%rsi,%r10,8)
movsd (%rbp,%r10,8), %xmm0
movsd %xmm0, (%rdi,%r10,8)
movsd (%rbx,%r10,8), %xmm0
movsd %xmm0, (%rcx,%r10,8)
movsd (%rdx,%r10,8), %xmm0
movsd %xmm0, (%r8,%r10,8)
movsd (%rax,%r10,8), %xmm0
movsd %xmm0, (%r9,%r10,8)
incq %r10
cmpq %r10, %r11
jne 0x5fbb
movq 0x8(%rsp), %rax
addq $0x58, %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/lensum.c
// Function: lensum_clear
void lensum_clear(Lensum* self) {

    self->index=-1;
    self->weight=0;
    self->totpairs=0;

    for (size_t i=0; i<self->nbin; i++) {
        self->npair[i] = 0;
        self->wsum[i] = 0;
        self->ssum[i] = 0;
        self->dsum[i] = 0;
        self->osum[i] = 0;
        self->rsum[i] = 0;
        self->dsensum_s[i] = 0;
        self->osensum_s[i] = 0;
        self->dsensum_w[i] = 0;
        self->osensum_w[i] = 0;
    }
}

// Assembly:
movq $-0x1, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
cmpq $0x0, 0x28(%rdi)
je 0x6102
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x30(%rdi), %rax
movq 0x38(%rdi), %rcx
movq 0x40(%rdi), %rdx
movq 0x48(%rdi), %rsi
movq 0x50(%rdi), %r8
movq 0x58(%rdi), %r9
movq 0x70(%rdi), %r10
movq 0x78(%rdi), %r11
movq 0x60(%rdi), %rbx
movq 0x68(%rdi), %r14
xorl %r15d, %r15d
xorl %r12d, %r12d
movq %r15, (%rax,%r12,8)
movq %r15, (%rdx,%r12,8)
movq %r15, (%rsi,%r12,8)
movq %r15, (%r8,%r12,8)
movq %r15, (%r9,%r12,8)
movq %r15, (%rcx,%r12,8)
movq %r15, (%r10,%r12,8)
movq %r15, (%r11,%r12,8)
movq %r15, (%rbx,%r12,8)
movq %r15, (%r14,%r12,8)
incq %r12
cmpq 0x28(%rdi), %r12
jb 0x60ca
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/esheldon[P]xshear/src/sconfig.c
// Function: get_mask_style
static int get_mask_style(struct cfg *cfg) {
    enum cfg_status status=0;
    int mask_style=0;

    char *mstr = cfg_get_string(cfg,"mask_style", &status);
    if (status) {
        fprintf(stderr,
                "Config Error for key mask_style %s\n",
                cfg_status_string(status));
        exit(1);
    }

    if (0 == do_strncmp(mstr,MASK_STYLE_NONE_STR)) {
        mask_style=MASK_STYLE_NONE;
    } else if (0 == do_strncmp(mstr,MASK_STYLE_SDSS_STR)) {
        mask_style=MASK_STYLE_SDSS;
    } else if (0 == do_strncmp(mstr,MASK_STYLE_EQ_STR)) {
        mask_style=MASK_STYLE_EQ;
    } else {
        fprintf(stderr, "Config Error: bad mask_style '%s'\n", mstr);
        exit(1);
    }

    free(mstr);

    return mask_style;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0xc(%rsp), %r14
movl $0x0, (%r14)
leaq 0x37f7(%rip), %rsi      # 0x9916
movq %r14, %rdx
callq 0x7158
movl (%r14), %edi
testl %edi, %edi
jne 0x6196
movq %rax, %rbx
leaq 0x380d(%rip), %rsi      # 0x9945
movq %rax, %rdi
callq 0x6551
testl %eax, %eax
je 0x6177
leaq 0x37ff(%rip), %rsi      # 0x994a
movq %rbx, %rdi
callq 0x6551
testl %eax, %eax
je 0x617e
leaq 0x37f1(%rip), %rsi      # 0x994f
movq %rbx, %rdi
callq 0x6551
movl $0x3, %ebp
testl %eax, %eax
je 0x6183
movq %rbx, %rdi
callq 0x3427
movl $0x1, %ebp
jmp 0x6183
movl $0x2, %ebp
movq %rbx, %rdi
callq 0x2030
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x33fb
// File: /workspace/github_c_makefile_star2_O1/esheldon[P]xshear/src/sconfig.c
// Function: get_shear_style
static int get_shear_style(struct cfg *cfg) {
    enum cfg_status status=0;
    int shear_style=0;

    char *mstr = cfg_get_string(cfg,"shear_style", &status);
    if (status) {
        fprintf(stderr,
                "Config Error for key shear_style %s\n",
                cfg_status_string(status));
        exit(1);
    }

    if (0 == do_strncmp(mstr,SHEAR_STYLE_REDUCED_STR)) {
        shear_style=SHEAR_STYLE_REDUCED;
    } else if (0 == do_strncmp(mstr,SHEAR_STYLE_LENSFIT_STR)) {
        shear_style=SHEAR_STYLE_LENSFIT;
    } else {
        fprintf(stderr, "Config Error: bad shear_style '%s'\n", mstr);
        exit(1);
    }

    free(mstr);

    return shear_style;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0xc(%rsp), %r14
movl $0x0, (%r14)
leaq 0x37c7(%rip), %rsi      # 0x997d
movq %r14, %rdx
callq 0x7158
movl (%r14), %edi
testl %edi, %edi
jne 0x6213
movq %rax, %rbx
leaq 0x37df(%rip), %rsi      # 0x99ae
movq %rax, %rdi
callq 0x6551
testl %eax, %eax
je 0x61fb
leaq 0x37d4(%rip), %rsi      # 0x99b6
movq %rbx, %rdi
callq 0x6551
movl $0x2, %ebp
testl %eax, %eax
je 0x6200
movq %rbx, %rdi
callq 0x3477
movl $0x1, %ebp
movq %rbx, %rdi
callq 0x2030
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x344b
// File: /workspace/github_c_makefile_star2_O1/esheldon[P]xshear/src/sconfig.c
// Function: get_scstyle
static int get_scstyle(struct cfg *cfg) {
    enum cfg_status status=0;
    int scstyle=0;

    char *mstr = cfg_get_string(cfg,"sigmacrit_style", &status);
    if (status) {
        fprintf(stderr,
                "Config Error for key sigmacrit_style %s\n",
                cfg_status_string(status));
        exit(1);
    }

    if (0 == do_strncmp(mstr,SIGMACRIT_STYLE_POINT_STR)) {
        scstyle=SIGMACRIT_STYLE_POINT;
    } else if (0 == do_strncmp(mstr,SIGMACRIT_STYLE_INTERP_STR)) {
        scstyle=SIGMACRIT_STYLE_INTERP;
    } else if (0 == do_strncmp(mstr,SIGMACRIT_STYLE_SAMPLE_STR)) {
        scstyle=SIGMACRIT_STYLE_SAMPLE;
    } else {
        fprintf(stderr, "Config Error: bad sigmacrit_style '%s'\n", mstr);
        exit(1);
    }

    free(mstr);

    return scstyle;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0xc(%rsp), %r14
movl $0x0, (%r14)
leaq 0x37af(%rip), %rsi      # 0x99e2
movq %r14, %rdx
callq 0x7158
movl (%r14), %edi
testl %edi, %edi
jne 0x62aa
movq %rax, %rbx
leaq 0x37cf(%rip), %rsi      # 0x9a1b
movq %rax, %rdi
callq 0x6551
testl %eax, %eax
je 0x628b
leaq 0x3478(%rip), %rsi      # 0x96d7
movq %rbx, %rdi
callq 0x6551
testl %eax, %eax
je 0x6292
leaq 0x37af(%rip), %rsi      # 0x9a21
movq %rbx, %rdi
callq 0x6551
movl $0x3, %ebp
testl %eax, %eax
je 0x6297
movq %rbx, %rdi
callq 0x34c7
movl $0x1, %ebp
jmp 0x6297
movl $0x2, %ebp
movq %rbx, %rdi
callq 0x2030
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x349b
// File: /workspace/github_c_makefile_star2_O1/esheldon[P]xshear/src/sconfig.c
// Function: get_Dlens_input
static int get_Dlens_input(struct cfg *cfg) {
    enum cfg_status status=0;
    long Dlens_input=0;

    Dlens_input = cfg_get_long(cfg,"Dlens_input", &status);
    if (status) {
        wlog("    Dlens_input not sent, defaulting to false\n");
        // not sent, default to Mpc
        Dlens_input = 0;
    }

    return Dlens_input;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0xc(%rsp), %rbx
movl $0x0, (%rbx)
leaq 0x378a(%rip), %rsi      # 0x9a50
movq %rbx, %rdx
callq 0x6ffb
cmpl $0x0, (%rbx)
jne 0x62d9
addq $0x10, %rsp
popq %rbx
retq
callq 0x34eb
xorl %eax, %eax
jmp 0x62d3
// File: /workspace/github_c_makefile_star2_O1/esheldon[P]xshear/src/sconfig.c
// Function: get_sourceid_style
static int get_sourceid_style(struct cfg *cfg) {
    enum cfg_status status=0;
    int sourceid_style=0;

    char *mstr = cfg_get_string(cfg,"sourceid_style", &status);
    if (status) {
        // tacitly assume the user wants the default SOURCEID_STYLE_NONE
        sourceid_style=SOURCEID_STYLE_NONE;
        return sourceid_style;
    }

    if (0 == do_strncmp(mstr,SOURCEID_STYLE_NONE_STR)) {
        sourceid_style=SOURCEID_STYLE_NONE;
    } else if (0 == do_strncmp(mstr,SOURCEID_STYLE_INDEX_STR)) {
        sourceid_style=SOURCEID_STYLE_INDEX;
    } else {
        fprintf(stderr, "Config Error: bad sourceid_style '%s'\n", mstr);
        exit(1);
    }

    free(mstr);

    return sourceid_style;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0xc(%rsp), %r14
movl $0x0, (%r14)
leaq 0x378e(%rip), %rsi      # 0x9a8b
movq %r14, %rdx
callq 0x7158
movl $0x1, %ebp
cmpl $0x0, (%r14)
jne 0x6353
movq %rax, %rbx
leaq 0x362b(%rip), %rsi      # 0x9945
movq %rax, %rdi
callq 0x6551
testl %eax, %eax
je 0x6346
leaq 0x376d(%rip), %rsi      # 0x9a9a
movq %rbx, %rdi
callq 0x6551
movl $0x2, %ebp
testl %eax, %eax
je 0x634b
movq %rbx, %rdi
callq 0x350d
movl $0x1, %ebp
movq %rbx, %rdi
callq 0x2030
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/esheldon[P]xshear/src/sconfig.c
// Function: get_r_units
static int get_r_units(struct cfg *cfg) {
    enum cfg_status status=0;
    int r_units=0;

    char *mstr = cfg_get_string(cfg,"r_units", &status);
    if (status) {
        wlog("    radius units not sent, defaulting to Mpc\n");
        // not sent, default to Mpc
        return UNITS_MPC;
    }

    if (0 == do_strncmp(mstr,UNITS_MPC_STR)) {
        r_units=UNITS_MPC;
    } else if (0 == do_strncmp(mstr,UNITS_ARCMIN_STR)) {
        r_units=UNITS_ARCMIN;
    } else {
        fprintf(stderr, "Config Error: bad r_units: '%s'\n", mstr);
        exit(1);
    }

    free(mstr);

    return r_units;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0xc(%rsp), %r14
movl $0x0, (%r14)
leaq 0x37ac(%rip), %rsi      # 0x9b25
movq %r14, %rdx
callq 0x7158
cmpl $0x0, (%r14)
jne 0x63d5
movq %rax, %rbx
leaq 0x3764(%rip), %rsi      # 0x9af5
movq %rax, %rdi
callq 0x6551
testl %eax, %eax
je 0x63bd
leaq 0x3755(%rip), %rsi      # 0x9af9
movq %rbx, %rdi
callq 0x6551
movl $0x2, %ebp
testl %eax, %eax
je 0x63c2
movq %rbx, %rdi
callq 0x3553
movl $0x1, %ebp
movq %rbx, %rdi
callq 0x2030
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x3531
movl $0x1, %ebp
jmp 0x63ca
// File: /workspace/github_c_makefile_star2_O1/esheldon[P]xshear/src/sconfig.c
// Function: get_shear_units
static int get_shear_units(struct cfg *cfg) {
    enum cfg_status status=0;
    int shear_units=0;

    char *mstr = cfg_get_string(cfg,"shear_units", &status);
    if (status) {
        wlog("    shear units not sent, defaulting to deltasig\n");
        // not sent, default to Mpc
        return UNITS_DELTASIG;
    }

    if (0 == do_strncmp(mstr,UNITS_DELTASIG_STR)) {
        shear_units=UNITS_DELTASIG;
    } else if (0 == do_strncmp(mstr,UNITS_SHEAR_STR)) {
        shear_units=UNITS_SHEAR;
    } else if (0 == do_strncmp(mstr,UNITS_BOTH_STR)) {
        shear_units=UNITS_BOTH;
    } else {
        fprintf(stderr, "Config Error: bad shear_units: '%s'\n", mstr);
        exit(1);
    }

    free(mstr);

    return shear_units;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0xc(%rsp), %r14
movl $0x0, (%r14)
leaq 0x3725(%rip), %rsi      # 0x9b21
movq %r14, %rdx
callq 0x7158
cmpl $0x0, (%r14)
jne 0x6472
movq %rax, %rbx
leaq 0x374b(%rip), %rsi      # 0x9b5f
movq %rax, %rdi
callq 0x6551
testl %eax, %eax
je 0x6453
leaq 0x3741(%rip), %rsi      # 0x9b68
movq %rbx, %rdi
callq 0x6551
testl %eax, %eax
je 0x645a
leaq 0x3734(%rip), %rsi      # 0x9b6e
movq %rbx, %rdi
callq 0x6551
movl $0x3, %ebp
testl %eax, %eax
je 0x645f
movq %rbx, %rdi
callq 0x3599
movl $0x1, %ebp
jmp 0x645f
movl $0x2, %ebp
movq %rbx, %rdi
callq 0x2030
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x3577
movl $0x1, %ebp
jmp 0x6467
// File: /workspace/github_c_makefile_star2_O1/esheldon[P]xshear/src/sconfig.c
// Function: get_weight_style
static int get_weight_style(struct cfg *cfg) {
    enum cfg_status status=0;
    int weight_style=0;

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

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

    free(mstr);

    return weight_style;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0xc(%rsp), %r14
movl $0x0, (%r14)
leaq 0x36ff(%rip), %rsi      # 0x9b98
movq %r14, %rdx
callq 0x7158
cmpl $0x0, (%r14)
jne 0x64f5
movq %rax, %rbx
leaq 0x3726(%rip), %rsi      # 0x9bd7
movq %rax, %rdi
callq 0x6551
testl %eax, %eax
je 0x64dd
leaq 0x371b(%rip), %rsi      # 0x9bdf
movq %rbx, %rdi
callq 0x6551
movl $0x2, %ebp
testl %eax, %eax
je 0x64e2
movq %rbx, %rdi
callq 0x35df
movl $0x1, %ebp
movq %rbx, %rdi
callq 0x2030
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x35bd
movl $0x1, %ebp
jmp 0x64ea
// File: /workspace/github_c_makefile_star2_O1/esheldon[P]xshear/src/sconfig.c
// Function: sconfig_free
ShearConfig* sconfig_free(ShearConfig* self) {
    if (self != NULL) {
        free(self->zl);
    }
    free(self);
    return NULL;
}

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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x33c3(%rip), %rsi      # 0x98f3
movq %rbx, %rdi
callq 0x2240
movq %rax, 0x60(%r14)
testq %rax, %rax
je 0x6549
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x3603
// File: /workspace/github_c_makefile_star2_O1/esheldon[P]xshear/src/sconfig.c
// Function: do_strncmp
static int do_strncmp(char *s1, char *s2)
{
    int l1=strlen(s1);
    int l2=strlen(s2);
    int ncmp=min(l1,l2);

    return strncmp(s1, s2, ncmp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x20e0
movq %rax, %r15
movq %rbx, %rdi
callq 0x20e0
cmpl %eax, %r15d
cmovll %r15d, %eax
movslq %eax, %rdx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x2050
nop
// File: /workspace/github_c_makefile_star2_O1/esheldon[P]xshear/src/config.c
// Function: cfg_strarr_free
char **cfg_strarr_free(char **arr, size_t size)
{
    size_t i=0;
    if (arr) {
        for (i=0; i<size; i++) {
            free(arr[i]);
            arr[i]=NULL;
        }
        free(arr); arr=NULL;
    }
    return NULL;
}

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

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

// Assembly:
testq %rdi, %rdi
je 0x66a4
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x2030
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0x6681
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x6679
movq 0x8(%r14), %rsi
callq 0x6588
movq $0x0, 0x10(%r14)
movq %r14, %rdi
callq 0x2030
xorl %r14d, %r14d
movq %r14, 0x10(%rbx)
movq 0x18(%rbx), %rdi
callq 0x65e2
movq %r14, 0x18(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2030
retq
// File: /workspace/github_c_makefile_star2_O1/esheldon[P]xshear/src/config.c
// Function: cfg_print
void cfg_print(struct cfg *self, FILE* stream)
{
    size_t el=0;
    int n_indent=0;

    if (!self)
        return;

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

}

// Assembly:
testq %rdi, %rdi
je 0x66dd
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
cmpq $0x0, (%rdi)
je 0x66d8
movq %rsi, %rbx
xorl %r15d, %r15d
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x66de
incq %r15
cmpq (%r14), %r15
jb 0x66be
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/esheldon[P]xshear/src/config.c
// Function: cfg_field_print
static void cfg_field_print(struct cfg_field *self, int n_indent, FILE* stream)
{
    size_t el=0;
    if (!self)
        return;

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

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

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x67af
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
cmpl $0x0, 0x8(%rdi)
jne 0x670c
movq 0x10(%r14), %rax
cmpq $0x0, (%rax)
je 0x67af
testl %r15d, %r15d
jle 0x6725
movl %r15d, %ebp
movl $0x20, %edi
movq %rbx, %rsi
callq 0x2150
decl %ebp
jne 0x6714
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x2110
leaq 0x3569(%rip), %rsi      # 0x9ca0
movq %rbx, %rdi
movl $0x3d, %edx
xorl %eax, %eax
callq 0x21a0
movl 0x8(%r14), %eax
cmpl $0x2, %eax
je 0x67b8
cmpl $0x1, %eax
jne 0x6824
movl $0x5b, %edi
movq %rbx, %rsi
callq 0x2150
movq 0x10(%r14), %rax
cmpq $0x0, (%rax)
je 0x67a8
xorl %r15d, %r15d
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x727c
movq 0x10(%r14), %rax
movq (%rax), %rax
decq %rax
cmpq %rax, %r15
jae 0x679c
movl $0x20, %edi
movq %rbx, %rsi
callq 0x2150
incq %r15
movq 0x10(%r14), %rax
cmpq (%rax), %r15
jb 0x6772
movl $0x5d, %edi
jmp 0x681a
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x34e6(%rip), %rsi      # 0x9ca5
movq %rbx, %rdi
movl $0x7b, %edx
xorl %eax, %eax
callq 0x21a0
movq 0x18(%r14), %r14
testq %r14, %r14
je 0x67fe
cmpq $0x0, (%r14)
je 0x67fe
leal 0x4(%r15), %ebp
xorl %r12d, %r12d
movq 0x10(%r14), %rax
movq (%rax,%r12,8), %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x66de
incq %r12
cmpq (%r14), %r12
jb 0x67e4
testl %r15d, %r15d
jle 0x6815
movl $0x20, %edi
movq %rbx, %rsi
callq 0x2150
decl %r15d
jne 0x6803
movl $0x7d, %edi
movq %rbx, %rsi
callq 0x2150
jmp 0x6831
movq %r14, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x727c
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2150