LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
callq 0x3e40
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x400f
movq -0x8(%rbp), %rax
movsd 0x28(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x3fec
movsd -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
mulsd 0x30(%rax), %xmm0
callq 0x21c0
movq -0x8(%rbp), %rax
divsd 0x30(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x400d
movsd -0x20(%rbp), %xmm0
movq -0x8(%rbp), %rax
mulsd 0x30(%rax), %xmm0
callq 0x2220
movq -0x8(%rbp), %rax
divsd 0x30(%rax), %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x400f
movsd -0x20(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
callq 0x3f80
movsd %xmm0, -0x20(%rbp)
movsd 0x9fd2(%rip), %xmm1     # 0xe028
addsd -0x18(%rbp), %xmm1
movsd -0x20(%rbp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd 0x9f3f(%rip), %xmm0     # 0xe028
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movsd -0x10(%rbp), %xmm1
xorps %xmm0, %xmm0
callq 0x4020
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
callq 0x4150
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movsd 0x10(%rax), %xmm0
mulsd -0x18(%rbp), %xmm0
mulsd -0x18(%rbp), %xmm0
mulsd -0x20(%rbp), %xmm0
mulsd -0x28(%rbp), %xmm0
mulsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd 0x9ebf(%rip), %xmm0     # 0xe028
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
je 0x41ac
movq -0x8(%rbp), %rax
movsd 0x18(%rax), %xmm0
mulsd -0x18(%rbp), %xmm0
mulsd -0x18(%rbp), %xmm0
movsd -0x18(%rbp), %xmm2
movq -0x8(%rbp), %rax
movsd 0x20(%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0x41f2
movsd -0x18(%rbp), %xmm0
mulsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movsd 0x18(%rax), %xmm0
mulsd -0x20(%rbp), %xmm0
movsd -0x18(%rbp), %xmm2
movq -0x8(%rbp), %rax
movsd 0x28(%rax), %xmm1
mulsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
addsd 0x20(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0x9e2e(%rip), %xmm0     # 0xe028
divsd -0x28(%rbp), %xmm0
callq 0x2270
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x18(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
movsd 0x9dc8(%rip), %xmm1     # 0xe018
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x18(%rbp), %xmm0
addsd -0x10(%rbp), %xmm0
movsd 0x9dad(%rip), %xmm1     # 0xe018
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0xa, -0x1c(%rbp)
jge 0x42f4
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd 0x88(%rax,%rcx,8), %xmm0
movsd -0x28(%rbp), %xmm2
movsd -0x30(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movsd -0x38(%rbp), %xmm0
callq 0x40d0
movsd %xmm0, -0x40(%rbp)
movsd -0x28(%rbp), %xmm0
mulsd -0x40(%rbp), %xmm0
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd 0xd8(%rax,%rcx,8), %xmm2
movsd -0x48(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x427b
movsd -0x48(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movsd -0x20(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x4330
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x4394
movq -0x10(%rbp), %rdi
movsd -0x18(%rbp), %xmm1
xorps %xmm0, %xmm0
callq 0x4020
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movsd -0x20(%rbp), %xmm1
xorps %xmm0, %xmm0
callq 0x4020
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
callq 0x4020
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
mulsd -0x28(%rbp), %xmm0
divsd -0x30(%rbp), %xmm0
movsd 0x9ddd(%rip), %xmm1     # 0xe168
mulsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/cosmo.c
// Function: scinv_pre
double scinv_pre(double zl, double dcl, double dcs) {
    // flat universe, simple in dc
    double scinv;
    if (dcs <= dcl) {
        scinv=0.0;
        return scinv;
    }

    scinv = dcl/(1.+zl)*(dcs-dcl)/dcs * FOUR_PI_G_OVER_C_SQUARED;
    return scinv;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd -0x20(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x43d7
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x441b
movsd -0x18(%rbp), %xmm0
movsd 0x9c44(%rip), %xmm1     # 0xe028
addsd -0x10(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd -0x20(%rbp), %xmm1
subsd -0x18(%rbp), %xmm1
mulsd %xmm1, %xmm0
divsd -0x20(%rbp), %xmm0
movsd 0x9d60(%rip), %xmm1     # 0xe168
mulsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4915
jmp 0x48a5
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x48da
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0x48dc
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x4890
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x4890
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
callq 0x2030
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4941
movq $0x0, -0x8(%rbp)
jmp 0x4991
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jge 0x4965
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x4920
movq %rax, -0x8(%rbp)
jmp 0x4991
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jle 0x4989
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x4920
movq %rax, -0x8(%rbp)
jmp 0x4991
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x4a2d
movl -0xc(%rbp), %esi
movl $0x9, %edi
callq 0x49a0
movq 0xd5de(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x97ad(%rip), %rsi      # 0xe1d1
movb $0x0, %al
callq 0x2170
jmp 0x4a7f
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0x49f0
movl -0xc(%rbp), %esi
movl $0x9, %edi
callq 0x49a0
movq 0xd5a4(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
leaq 0x99a0(%rip), %rsi      # 0xe405
movb $0x0, %al
callq 0x2170
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0x49f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4b34
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x4a90
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x4a90
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x4b00
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x4b08
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
jbe 0x4b24
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x4b2c
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x4b75
movq 0xd49e(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x966f(%rip), %rsi      # 0xe1d3
movb $0x0, %al
callq 0x2170
movl $0x1, %edi
callq 0x2250
movl $0x1, %edi
movl $0x18, %esi
callq 0x2140
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4bb1
movq 0xd462(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x964f(%rip), %rsi      # 0xe1ef
movb $0x0, %al
callq 0x2170
movl $0x1, %edi
callq 0x2250
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movl $0x80, %esi
callq 0x2140
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x4c06
movq 0xd411(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x961a(%rip), %rsi      # 0xe20f
movb $0x0, %al
callq 0x2170
movl $0x1, %edi
callq 0x2250
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x5021
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movsd -0x10(%rbp), %xmm0
movq -0x20(%rbp), %rax
divsd 0x20(%rax), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
callq 0x2120
movq -0x20(%rbp), %rax
movsd %xmm0, 0x58(%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4fc9
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x50e0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movb $0x0, %al
callq 0xb370
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x50(%rax)
movsd -0x18(%rbp), %xmm0
movq -0x28(%rbp), %rax
divsd 0x20(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x28(%rbp), %rax
movsd 0x10(%rax), %xmm1
movsd -0x30(%rbp), %xmm2
movq -0x28(%rbp), %rax
movq 0x50(%rax), %rsi
callq 0x2500
movq -0x28(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0xbba0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x504d
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x51ad
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq 0x50(%rcx), %rcx
cmpq (%rcx), %rax
jae 0x519a
movq -0x28(%rbp), %rax
movq 0x50(%rax), %rax
movq 0x10(%rax), %rax
movq -0x30(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rax
subq 0x10(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x4430
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x5140
jmp 0x519c
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x5110
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x54ab
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x547d
jmp 0x542a
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x545f
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq 0x10(%rax), %rdi
callq 0x2030
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x2030
movq -0x10(%rbp), %rax
movq $0x0, 0x50(%rax)
jmp 0x5461
movq -0x10(%rbp), %rax
addq $0x80, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x541b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x4890
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rdi
callq 0x2030
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x580a
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5810
movq -0x18(%rbp), %rax
addq $0x80, %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x57d4
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %esi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rax), %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x4(%rax), %ecx
callq 0x5bb0
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x5b98
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5dc0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x5b59
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x63c9
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rdi
callq 0x2030
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x657f
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x6576
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x6569
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x7, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2030
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x2030
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x2030
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x2030
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x2030
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x2030
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rdi
callq 0x2030
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x2030
movq -0x18(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x2030
movq -0x18(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x2030
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x64ae
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rdi
callq 0x2030
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $-0x1, 0x10(%rax)
movq -0x8(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jae 0x6c5f
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x10(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x10(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x10(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x10(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq -0x10(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq -0x10(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq -0x10(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x6b74
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x76f1(%rip), %rsi      # 0xe916
leaq -0xc(%rbp), %rdx
callq 0x8c30
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x726d
movq 0xadb9(%rip), %rax      # 0x11ff8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %edi
callq 0x7dc0
movq -0x20(%rbp), %rdi
movq %rax, %rdx
leaq 0x76c5(%rip), %rsi      # 0xe921
movb $0x0, %al
callq 0x2170
movl $0x1, %edi
callq 0x2250
movq -0x18(%rbp), %rdi
leaq 0x76cd(%rip), %rsi      # 0xe945
callq 0x7ce0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x728e
movl $0x1, -0x10(%rbp)
jmp 0x72fa
movq -0x18(%rbp), %rdi
leaq 0x76b1(%rip), %rsi      # 0xe94a
callq 0x7ce0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x72af
movl $0x2, -0x10(%rbp)
jmp 0x72f8
movq -0x18(%rbp), %rdi
leaq 0x7695(%rip), %rsi      # 0xe94f
callq 0x7ce0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x72d0
movl $0x3, -0x10(%rbp)
jmp 0x72f6
movq 0xad21(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x7675(%rip), %rsi      # 0xe95a
movb $0x0, %al
callq 0x2170
movl $0x1, %edi
callq 0x2250
jmp 0x72f8
jmp 0x72fa
movq -0x18(%rbp), %rdi
callq 0x2030
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x7648(%rip), %rsi      # 0xe97d
leaq -0xc(%rbp), %rdx
callq 0x8c30
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x737d
movq 0xaca9(%rip), %rax      # 0x11ff8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %edi
callq 0x7dc0
movq -0x20(%rbp), %rdi
movq %rax, %rdx
leaq 0x761d(%rip), %rsi      # 0xe989
movb $0x0, %al
callq 0x2170
movl $0x1, %edi
callq 0x2250
movq -0x18(%rbp), %rdi
leaq 0x7626(%rip), %rsi      # 0xe9ae
callq 0x7ce0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x739e
movl $0x1, -0x10(%rbp)
jmp 0x73e7
movq -0x18(%rbp), %rdi
leaq 0x760d(%rip), %rsi      # 0xe9b6
callq 0x7ce0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x73bf
movl $0x2, -0x10(%rbp)
jmp 0x73e5
movq 0xac32(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x75ea(%rip), %rsi      # 0xe9be
movb $0x0, %al
callq 0x2170
movl $0x1, %edi
callq 0x2250
jmp 0x73e7
movq -0x18(%rbp), %rdi
callq 0x2030
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x75bd(%rip), %rsi      # 0xe9e2
leaq -0xc(%rbp), %rdx
callq 0x8c30
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x746d
movq 0xabb9(%rip), %rax      # 0x11ff8
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %edi
callq 0x7dc0
movq -0x20(%rbp), %rdi
movq %rax, %rdx
leaq 0x7596(%rip), %rsi      # 0xe9f2
movb $0x0, %al
callq 0x2170
movl $0x1, %edi
callq 0x2250
movq -0x18(%rbp), %rdi
leaq 0x75a3(%rip), %rsi      # 0xea1b
callq 0x7ce0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x748e
movl $0x1, -0x10(%rbp)
jmp 0x74fa
movq -0x18(%rbp), %rdi
leaq 0x723e(%rip), %rsi      # 0xe6d7
callq 0x7ce0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x74af
movl $0x2, -0x10(%rbp)
jmp 0x74f8
movq -0x18(%rbp), %rdi
leaq 0x7567(%rip), %rsi      # 0xea21
callq 0x7ce0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x74d0
movl $0x3, -0x10(%rbp)
jmp 0x74f6
movq 0xab21(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x7543(%rip), %rsi      # 0xea28
movb $0x0, %al
callq 0x2170
movl $0x1, %edi
callq 0x2250
jmp 0x74f8
jmp 0x74fa
movq -0x18(%rbp), %rdi
callq 0x2030
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x751a(%rip), %rsi      # 0xea50
leaq -0xc(%rbp), %rdx
callq 0x8910
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x7569
movq 0xaaa8(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x7502(%rip), %rsi      # 0xea5c
movb $0x0, %al
callq 0x2170
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x74e6(%rip), %rsi      # 0xea8b
leaq -0x14(%rbp), %rdx
callq 0x8c30
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x75c7
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x7640
movq -0x20(%rbp), %rdi
leaq 0x7373(%rip), %rsi      # 0xe945
callq 0x7ce0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x75e8
movl $0x1, -0x18(%rbp)
jmp 0x7631
movq -0x20(%rbp), %rdi
leaq 0x74a7(%rip), %rsi      # 0xea9a
callq 0x7ce0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x7609
movl $0x2, -0x18(%rbp)
jmp 0x762f
movq 0xa9e8(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
leaq 0x7482(%rip), %rsi      # 0xeaa0
movb $0x0, %al
callq 0x2170
movl $0x1, %edi
callq 0x2250
jmp 0x7631
movq -0x20(%rbp), %rdi
callq 0x2030
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x74b0(%rip), %rsi      # 0xeb25
leaq -0x14(%rbp), %rdx
callq 0x8c30
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x76a9
movq 0xa969(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x742e(%rip), %rsi      # 0xeac7
movb $0x0, %al
callq 0x2170
movl $0x1, -0x4(%rbp)
jmp 0x7722
movq -0x20(%rbp), %rdi
leaq 0x7441(%rip), %rsi      # 0xeaf5
callq 0x7ce0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x76ca
movl $0x1, -0x18(%rbp)
jmp 0x7713
movq -0x20(%rbp), %rdi
leaq 0x7424(%rip), %rsi      # 0xeaf9
callq 0x7ce0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x76eb
movl $0x2, -0x18(%rbp)
jmp 0x7711
movq 0xa906(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
leaq 0x7400(%rip), %rsi      # 0xeb00
movb $0x0, %al
callq 0x2170
movl $0x1, %edi
callq 0x2250
jmp 0x7713
movq -0x20(%rbp), %rdi
callq 0x2030
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x73cc(%rip), %rsi      # 0xeb21
leaq -0x14(%rbp), %rdx
callq 0x8c30
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x778c
movq 0xa889(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x73b4(%rip), %rsi      # 0xeb2d
movb $0x0, %al
callq 0x2170
movl $0x1, -0x4(%rbp)
jmp 0x7828
movq -0x20(%rbp), %rdi
leaq 0x73c8(%rip), %rsi      # 0xeb5f
callq 0x7ce0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x77ad
movl $0x1, -0x18(%rbp)
jmp 0x7819
movq -0x20(%rbp), %rdi
leaq 0x73b0(%rip), %rsi      # 0xeb68
callq 0x7ce0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x77ce
movl $0x2, -0x18(%rbp)
jmp 0x7817
movq -0x20(%rbp), %rdi
leaq 0x7395(%rip), %rsi      # 0xeb6e
callq 0x7ce0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x77ef
movl $0x3, -0x18(%rbp)
jmp 0x7815
movq 0xa802(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
leaq 0x736f(%rip), %rsi      # 0xeb73
movb $0x0, %al
callq 0x2170
movl $0x1, %edi
callq 0x2250
jmp 0x7817
jmp 0x7819
movq -0x20(%rbp), %rdi
callq 0x2030
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x7333(%rip), %rsi      # 0xeb98
leaq -0x14(%rbp), %rdx
callq 0x8c30
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x7899
movq 0xa779(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
leaq 0x731c(%rip), %rsi      # 0xeba5
movb $0x0, %al
callq 0x2170
movl $0x1, -0x4(%rbp)
jmp 0x7912
movq -0x20(%rbp), %rdi
leaq 0x7333(%rip), %rsi      # 0xebd7
callq 0x7ce0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x78ba
movl $0x1, -0x18(%rbp)
jmp 0x7903
movq -0x20(%rbp), %rdi
leaq 0x731a(%rip), %rsi      # 0xebdf
callq 0x7ce0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x78db
movl $0x2, -0x18(%rbp)
jmp 0x7901
movq 0xa716(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
leaq 0x72f7(%rip), %rsi      # 0xebe7
movb $0x0, %al
callq 0x2170
movl $0x1, %edi
callq 0x2250
jmp 0x7903
movq -0x20(%rbp), %rdi
callq 0x2030
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7940
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rdi
callq 0x2030
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x6c68(%rip), %rsi      # 0xe8f3
callq 0x2210
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x60(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x60(%rax)
jne 0x7ccc
movq 0xa34b(%rip), %rax      # 0x11ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x6c3a(%rip), %rsi      # 0xe8f5
movb $0x0, %al
callq 0x2170
movl $0x1, %edi
callq 0x2250
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20d0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20d0
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x7d18
movl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x7d1e
movl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
callq 0x2050
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7db1
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x7da0
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x7d67
movq -0x8(%rbp), %rdi
callq 0x2030
movq $0x0, -0x8(%rbp)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/config.c
// Function: cfg_status_string
const char* cfg_status_string(enum cfg_status status)
{
    int imax=sizeof(cfg_status_names)-1;

    if (status < 0 || status > imax) {
        return NULL;
    } else {
        return cfg_status_names[status];
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl $0x4f, -0x10(%rbp)
cmpl $0x0, -0xc(%rbp)
jb 0x7ddc
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jbe 0x7de6
movq $0x0, -0x8(%rbp)
jmp 0x7dfa
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0xa36e(%rip), %rax      # 0x12160
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7e99
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x7e77
movq $0x0, -0x10(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x7e75
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x7eb0
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x7e32
jmp 0x7e77
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rdi
callq 0x2030
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/esheldon[P]xshear/src/config.c
// Function: cfg_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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7f08
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2030
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x8f40
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x7e00
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
callq 0x2030
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq