LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: myudelson[P]hmm-scalable/FitBit.cpp
// Function: FitBit::init(FIT_BIT_SLOT)
void FitBit::init(enum FIT_BIT_SLOT fbs){
    switch (fbs) {
        case FBS_PAR:
            init(this->pi, this->A, this->B);
            break;
        case FBS_PARm1:
            init(this->PIm1, this->Am1, this->Bm1);
            break;
        case FBS_PARm2:
            init(this->PIm2, this->Am2, this->Bm2);
            break;
        case FBS_GRAD:
            init(this->gradPI, this->gradA, this->gradB);
            break;
        case FBS_GRADm1:
            init(this->gradPIm1, this->gradAm1, this->gradBm1);
            break;
        case FBS_GRADcopy:
            init(this->gradPIcopy, this->gradAcopy, this->gradBcopy);
            break;
        case FBS_PARcopy:
            init(this->PIcopy, this->Acopy, this->Bcopy);
            break;
        case FBS_DIR:
            init(this->dirPI, this->dirA, this->dirB);
            break;
        case FBS_DIRm1:
            init(this->dirPIm1, this->dirAm1, this->dirBm1);
            break;
        default:
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x8, %eax
ja 0xde45
movq -0x18(%rbp), %rax
leaq 0x42096(%rip), %rcx     # 0x4fd7c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0x10, %rsi
movq %rdi, %rdx
addq $0x18, %rdx
movq %rdi, %rcx
addq $0x20, %rcx
callq 0xd6d0
jmp 0xde47
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0x28, %rsi
movq %rdi, %rdx
addq $0x30, %rdx
movq %rdi, %rcx
addq $0x38, %rcx
callq 0xd6d0
jmp 0xde47
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0x40, %rsi
movq %rdi, %rdx
addq $0x48, %rdx
movq %rdi, %rcx
addq $0x50, %rcx
callq 0xd6d0
jmp 0xde47
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0x58, %rsi
movq %rdi, %rdx
addq $0x60, %rdx
movq %rdi, %rcx
addq $0x68, %rcx
callq 0xd6d0
jmp 0xde47
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0x70, %rsi
movq %rdi, %rdx
addq $0x78, %rdx
movq %rdi, %rcx
addq $0x80, %rcx
callq 0xd6d0
jmp 0xde47
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0x88, %rsi
movq %rdi, %rdx
addq $0x90, %rdx
movq %rdi, %rcx
addq $0x98, %rcx
callq 0xd6d0
jmp 0xde47
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0xa0, %rsi
movq %rdi, %rdx
addq $0xa8, %rdx
movq %rdi, %rcx
addq $0xb0, %rcx
callq 0xd6d0
jmp 0xde47
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0xb8, %rsi
movq %rdi, %rdx
addq $0xc0, %rdx
movq %rdi, %rcx
addq $0xc8, %rcx
callq 0xd6d0
jmp 0xde47
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0xd0, %rsi
movq %rdi, %rdx
addq $0xd8, %rdx
movq %rdi, %rcx
addq $0xe0, %rcx
callq 0xd6d0
jmp 0xde47
jmp 0xde47
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: myudelson[P]hmm-scalable/FitBit.cpp
// Function: FitBit::negate(FIT_BIT_SLOT)
void FitBit::negate(enum FIT_BIT_SLOT fbs){
    switch (fbs) {
        case FBS_PAR:
            negate(this->pi, this->A, this->B);
            break;
        case FBS_PARm1:
            negate(this->PIm1, this->Am1, this->Bm1);
            break;
        case FBS_PARm2:
            negate(this->PIm2, this->Am2, this->Bm2);
            break;
        case FBS_GRAD:
            negate(this->gradPI, this->gradA, this->gradB);
            break;
        case FBS_GRADm1:
            negate(this->gradPIm1, this->gradAm1, this->gradBm1);
            break;
        case FBS_GRADcopy:
            negate(this->gradPIcopy, this->gradAcopy, this->gradBcopy);
            break;
        case FBS_PARcopy:
            negate(this->PIcopy, this->Acopy, this->Bcopy);
            break;
        case FBS_DIR:
            negate(this->dirPI, this->dirA, this->dirB);
            break;
        case FBS_DIRm1:
            negate(this->dirPIm1, this->dirAm1, this->dirBm1);
            break;
        default:
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x8, %eax
ja 0xdfe5
movq -0x18(%rbp), %rax
leaq 0x41f1a(%rip), %rcx     # 0x4fda0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0x10, %rsi
movq %rdi, %rdx
addq $0x18, %rdx
movq %rdi, %rcx
addq $0x20, %rcx
callq 0xd7d0
jmp 0xdfe7
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0x28, %rsi
movq %rdi, %rdx
addq $0x30, %rdx
movq %rdi, %rcx
addq $0x38, %rcx
callq 0xd7d0
jmp 0xdfe7
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0x40, %rsi
movq %rdi, %rdx
addq $0x48, %rdx
movq %rdi, %rcx
addq $0x50, %rcx
callq 0xd7d0
jmp 0xdfe7
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0x58, %rsi
movq %rdi, %rdx
addq $0x60, %rdx
movq %rdi, %rcx
addq $0x68, %rcx
callq 0xd7d0
jmp 0xdfe7
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0x70, %rsi
movq %rdi, %rdx
addq $0x78, %rdx
movq %rdi, %rcx
addq $0x80, %rcx
callq 0xd7d0
jmp 0xdfe7
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0x88, %rsi
movq %rdi, %rdx
addq $0x90, %rdx
movq %rdi, %rcx
addq $0x98, %rcx
callq 0xd7d0
jmp 0xdfe7
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0xa0, %rsi
movq %rdi, %rdx
addq $0xa8, %rdx
movq %rdi, %rcx
addq $0xb0, %rcx
callq 0xd7d0
jmp 0xdfe7
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0xb8, %rsi
movq %rdi, %rdx
addq $0xc0, %rdx
movq %rdi, %rcx
addq $0xc8, %rcx
callq 0xd7d0
jmp 0xdfe7
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0xd0, %rsi
movq %rdi, %rdx
addq $0xd8, %rdx
movq %rdi, %rcx
addq $0xe0, %rcx
callq 0xd7d0
jmp 0xdfe7
jmp 0xdfe7
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: myudelson[P]hmm-scalable/FitBit.cpp
// Function: FitBit::toZero(FIT_BIT_SLOT)
void FitBit::toZero(enum FIT_BIT_SLOT fbs){
    switch (fbs) {
        case FBS_PAR:
            toZero(this->pi, this->A, this->B);
            break;
        case FBS_PARm1:
            toZero(this->PIm1, this->Am1, this->Bm1);
            break;
        case FBS_PARm2:
            toZero(this->PIm2, this->Am2, this->Bm2);
            break;
        case FBS_GRAD:
            toZero(this->gradPI, this->gradA, this->gradB);
            break;
        case FBS_GRADm1:
            toZero(this->gradPIm1, this->gradAm1, this->gradBm1);
            break;
        case FBS_GRADcopy:
            toZero(this->gradPIcopy, this->gradAcopy, this->gradBcopy);
            break;
        case FBS_PARcopy:
            toZero(this->PIcopy, this->Acopy, this->Bcopy);
            break;
        case FBS_DIR:
            toZero(this->dirPI, this->dirA, this->dirB);
            break;
        case FBS_DIRm1:
            toZero(this->dirPIm1, this->dirAm1, this->dirBm1);
            break;
        default:
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x8, %eax
ja 0xe134
movq -0x18(%rbp), %rax
leaq 0x41d9e(%rip), %rcx     # 0x4fdc4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rdi
movq 0x10(%rdi), %rsi
movq 0x18(%rdi), %rdx
movq 0x20(%rdi), %rcx
callq 0xd9e0
jmp 0xe136
movq -0x20(%rbp), %rdi
movq 0x28(%rdi), %rsi
movq 0x30(%rdi), %rdx
movq 0x38(%rdi), %rcx
callq 0xd9e0
jmp 0xe136
movq -0x20(%rbp), %rdi
movq 0x40(%rdi), %rsi
movq 0x48(%rdi), %rdx
movq 0x50(%rdi), %rcx
callq 0xd9e0
jmp 0xe136
movq -0x20(%rbp), %rdi
movq 0x58(%rdi), %rsi
movq 0x60(%rdi), %rdx
movq 0x68(%rdi), %rcx
callq 0xd9e0
jmp 0xe136
movq -0x20(%rbp), %rdi
movq 0x70(%rdi), %rsi
movq 0x78(%rdi), %rdx
movq 0x80(%rdi), %rcx
callq 0xd9e0
jmp 0xe136
movq -0x20(%rbp), %rdi
movq 0x88(%rdi), %rsi
movq 0x90(%rdi), %rdx
movq 0x98(%rdi), %rcx
callq 0xd9e0
jmp 0xe136
movq -0x20(%rbp), %rdi
movq 0xa0(%rdi), %rsi
movq 0xa8(%rdi), %rdx
movq 0xb0(%rdi), %rcx
callq 0xd9e0
jmp 0xe136
movq -0x20(%rbp), %rdi
movq 0xb8(%rdi), %rsi
movq 0xc0(%rdi), %rdx
movq 0xc8(%rdi), %rcx
callq 0xd9e0
jmp 0xe136
movq -0x20(%rbp), %rdi
movq 0xd0(%rdi), %rsi
movq 0xd8(%rdi), %rdx
movq 0xe0(%rdi), %rcx
callq 0xd9e0
jmp 0xe136
jmp 0xe136
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: myudelson[P]hmm-scalable/FitBit.cpp
// Function: FitBit::destroy(FIT_BIT_SLOT)
void FitBit::destroy(enum FIT_BIT_SLOT fbs){
    switch (fbs) {
        case FBS_PAR:
            destroy(this->pi, this->A, this->B);
            break;
        case FBS_PARm1:
            destroy(this->PIm1, this->Am1, this->Bm1);
            break;
        case FBS_PARm2:
            destroy(this->PIm2, this->Am2, this->Bm2);
            break;
        case FBS_GRAD:
            destroy(this->gradPI, this->gradA, this->gradB);
            break;
        case FBS_GRADm1:
            destroy(this->gradPIm1, this->gradAm1, this->gradBm1);
            break;
        case FBS_GRADcopy:
            destroy(this->gradPIcopy, this->gradAcopy, this->gradBcopy);
            break;
        case FBS_PARcopy:
            destroy(this->PIcopy, this->Acopy, this->Bcopy);
            break;
        case FBS_DIR:
            destroy(this->dirPI, this->dirA, this->dirB);
            break;
        case FBS_DIRm1:
            destroy(this->dirPIm1, this->dirAm1, this->dirBm1);
            break;
        default:
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x8, %eax
ja 0xe2d5
movq -0x18(%rbp), %rax
leaq 0x41c72(%rip), %rcx     # 0x4fde8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0x10, %rsi
movq %rdi, %rdx
addq $0x18, %rdx
movq %rdi, %rcx
addq $0x20, %rcx
callq 0xdbf0
jmp 0xe2d7
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0x28, %rsi
movq %rdi, %rdx
addq $0x30, %rdx
movq %rdi, %rcx
addq $0x38, %rcx
callq 0xdbf0
jmp 0xe2d7
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0x40, %rsi
movq %rdi, %rdx
addq $0x48, %rdx
movq %rdi, %rcx
addq $0x50, %rcx
callq 0xdbf0
jmp 0xe2d7
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0x58, %rsi
movq %rdi, %rdx
addq $0x60, %rdx
movq %rdi, %rcx
addq $0x68, %rcx
callq 0xdbf0
jmp 0xe2d7
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0x70, %rsi
movq %rdi, %rdx
addq $0x78, %rdx
movq %rdi, %rcx
addq $0x80, %rcx
callq 0xdbf0
jmp 0xe2d7
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0x88, %rsi
movq %rdi, %rdx
addq $0x90, %rdx
movq %rdi, %rcx
addq $0x98, %rcx
callq 0xdbf0
jmp 0xe2d7
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0xa0, %rsi
movq %rdi, %rdx
addq $0xa8, %rdx
movq %rdi, %rcx
addq $0xb0, %rcx
callq 0xdbf0
jmp 0xe2d7
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0xb8, %rsi
movq %rdi, %rdx
addq $0xc0, %rdx
movq %rdi, %rcx
addq $0xc8, %rcx
callq 0xdbf0
jmp 0xe2d7
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0xd0, %rsi
movq %rdi, %rdx
addq $0xd8, %rdx
movq %rdi, %rcx
addq $0xe0, %rcx
callq 0xdbf0
jmp 0xe2d7
jmp 0xe2d7
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: myudelson[P]hmm-scalable/FitBit.cpp
// Function: FitBit::copy(FIT_BIT_SLOT, FIT_BIT_SLOT)
void FitBit::copy(enum FIT_BIT_SLOT sourse_fbs, enum FIT_BIT_SLOT target_fbs) {
    NUMBER *soursePI = NULL;
    NUMBER **sourseA = NULL;
    NUMBER **sourseB = NULL;
    get(sourse_fbs, soursePI, sourseA, sourseB);
    NUMBER *targetPI = NULL;
    NUMBER **targetA = NULL;
    NUMBER **targetB = NULL;
    get(target_fbs, targetPI, targetA, targetB);
    
    copy(soursePI, sourseA, sourseB, targetPI, targetA, targetB);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl -0xc(%rbp), %esi
leaq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rcx
leaq -0x28(%rbp), %r8
callq 0xe2e0
movq -0x48(%rbp), %rdi
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movl -0x10(%rbp), %esi
leaq -0x30(%rbp), %rdx
leaq -0x38(%rbp), %rcx
leaq -0x40(%rbp), %r8
callq 0xe2e0
movq -0x48(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
leaq -0x28(%rbp), %rcx
leaq -0x30(%rbp), %r8
leaq -0x38(%rbp), %r9
leaq -0x40(%rbp), %rax
movq %rax, (%rsp)
callq 0xda80
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/FitBit.cpp
// Function: FitBit::add(FIT_BIT_SLOT, FIT_BIT_SLOT)
void FitBit::add(enum FIT_BIT_SLOT sourse_fbs, enum FIT_BIT_SLOT target_fbs) {
    NUMBER *soursePI = NULL;
    NUMBER **sourseA = NULL;
    NUMBER **sourseB = NULL;
    get(sourse_fbs, soursePI, sourseA, sourseB);
    NUMBER *targetPI = NULL;
    NUMBER **targetA = NULL;
    NUMBER **targetB = NULL;
    get(target_fbs, targetPI, targetA, targetB);
    
    add(soursePI, sourseA, sourseB, targetPI, targetA, targetB);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl -0xc(%rbp), %esi
leaq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rcx
leaq -0x28(%rbp), %r8
callq 0xe2e0
movq -0x48(%rbp), %rdi
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movl -0x10(%rbp), %esi
leaq -0x30(%rbp), %rdx
leaq -0x38(%rbp), %rcx
leaq -0x40(%rbp), %r8
callq 0xe2e0
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
movq -0x40(%rbp), %rax
movq %rax, (%rsp)
callq 0xdb30
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/./utils.h
// Function: double** init2D<double>(int, int)
T** init2D(NDAT size1, NDAT size2) {
	T** ar = (T **)Calloc(T *, (size_t)size1);
	for(NDAT i=0; i<size1; i++)
		ar[i] = (T *)Calloc(T, (size_t)size2);
	return ar;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movslq -0x4(%rbp), %rdi
movl $0x8, %esi
callq 0x5180
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0xf5d7
movslq -0x8(%rbp), %rdi
movl $0x8, %esi
callq 0x5180
movq %rax, %rdx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xf5a7
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: myudelson[P]hmm-scalable/FitBitSlicedA.cpp
// Function: FitBitSlicedA::init(double*&, double***&, double**&)
void FitBitSlicedA::init(NUMBER* &a_PI, NUMBER*** &a_A, NUMBER** &a_B) {
    if(this->pi != NULL) {
        if(a_PI == NULL)
            a_PI = init1D<NUMBER>((NDAT)this->nS); // init1DNumber(this->nS);
        else
            toZero1D<NUMBER>(a_PI, (NDAT)this->nS);
    }
    if(this->A  != NULL) {
        if(a_A == NULL)
            a_A  = init3D<NUMBER>((NDAT)this->nZ, (NDAT)this->nS, (NDAT)this->nS);
        else
            toZero3D<NUMBER>(a_A, (NDAT)this->nZ, (NDAT)this->nS, (NDAT)this->nS);
    }
    if(this->B  != NULL) {
        if(a_B == NULL)
            a_B  = init2D<NUMBER>( (NDAT)this->nS, (NDAT)this->nO);
        else
            toZero2D<NUMBER>(a_B, (NDAT)this->nS, (NDAT)this->nO);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x10(%rax)
je 0xfcf0
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xfcda
movq -0x28(%rbp), %rax
movsbl 0x1(%rax), %edi
callq 0xc410
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0xfcee
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdi
movsbl 0x1(%rax), %esi
callq 0xf540
jmp 0xfcf0
movq -0x28(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xfd44
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xfd26
movq -0x28(%rbp), %rax
movsbl 0x2(%rax), %edi
movsbl 0x1(%rax), %esi
movsbl 0x1(%rax), %edx
callq 0x11310
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0xfd42
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdi
movsbl 0x2(%rax), %esi
movsbl 0x1(%rax), %edx
movsbl 0x1(%rax), %ecx
callq 0x113c0
jmp 0xfd44
movq -0x28(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xfd8e
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xfd75
movq -0x28(%rbp), %rax
movsbl 0x1(%rax), %edi
movsbl (%rax), %esi
callq 0xf580
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0xfd8c
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rdi
movsbl 0x1(%rax), %esi
movsbl (%rax), %edx
callq 0xf5f0
jmp 0xfd8e
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/FitBitSlicedA.cpp
// Function: FitBitSlicedA::destroy(double*&, double***&, double**&)
void FitBitSlicedA::destroy(NUMBER* &a_PI, NUMBER*** &a_A, NUMBER** &a_B) {
    if(this->pi != NULL && a_PI != NULL) free(a_PI);
    if(this->A  != NULL && a_A  != NULL) free3D<NUMBER>(a_A, (NDAT)this->nZ, (NDAT)this->nS);
    if(this->B  != NULL && a_B  != NULL) free2D<NUMBER>(a_B, (NDAT)this->nS);
    a_PI = NULL;
    a_A  = NULL;
    a_B  = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x1023d
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1023d
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x5380
movq -0x28(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1026a
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1026a
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdi
movsbl 0x2(%rax), %esi
movsbl 0x1(%rax), %edx
callq 0x11290
movq -0x28(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x10293
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x10293
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rdi
movsbl 0x1(%rax), %esi
callq 0xc7f0
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: myudelson[P]hmm-scalable/FitBitSlicedA.cpp
// Function: FitBitSlicedA::toZero(FIT_BIT_SLOT)
void FitBitSlicedA::toZero(enum FIT_BIT_SLOT fbs){
    switch (fbs) {
        case FBS_PAR:
            toZero(this->pi, this->A, this->B);
            break;
        case FBS_PARm1:
            toZero(this->PIm1, this->Am1, this->Bm1);
            break;
        case FBS_PARm2:
            toZero(this->PIm2, this->Am2, this->Bm2);
            break;
        case FBS_GRAD:
            toZero(this->gradPI, this->gradA, this->gradB);
            break;
        case FBS_GRADm1:
            toZero(this->gradPIm1, this->gradAm1, this->gradBm1);
            break;
        case FBS_PARcopy:
            toZero(this->PIcopy, this->Acopy, this->Bcopy);
            break;
        case FBS_DIR:
            toZero(this->dirPI, this->dirA, this->dirB);
            break;
        case FBS_DIRm1:
            toZero(this->dirPIm1, this->dirAm1, this->dirBm1);
            break;
        default:
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x7, %eax
ja 0x106de
movq -0x18(%rbp), %rax
leaq 0x3f8a6(%rip), %rcx     # 0x4fe9c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rdi
movq 0x10(%rdi), %rsi
movq 0x18(%rdi), %rdx
movq 0x20(%rdi), %rcx
callq 0xfff0
jmp 0x106e0
movq -0x20(%rbp), %rdi
movq 0x28(%rdi), %rsi
movq 0x30(%rdi), %rdx
movq 0x38(%rdi), %rcx
callq 0xfff0
jmp 0x106e0
movq -0x20(%rbp), %rdi
movq 0x40(%rdi), %rsi
movq 0x48(%rdi), %rdx
movq 0x50(%rdi), %rcx
callq 0xfff0
jmp 0x106e0
movq -0x20(%rbp), %rdi
movq 0x58(%rdi), %rsi
movq 0x60(%rdi), %rdx
movq 0x68(%rdi), %rcx
callq 0xfff0
jmp 0x106e0
movq -0x20(%rbp), %rdi
movq 0x70(%rdi), %rsi
movq 0x78(%rdi), %rdx
movq 0x80(%rdi), %rcx
callq 0xfff0
jmp 0x106e0
movq -0x20(%rbp), %rdi
movq 0x88(%rdi), %rsi
movq 0x90(%rdi), %rdx
movq 0x98(%rdi), %rcx
callq 0xfff0
jmp 0x106e0
movq -0x20(%rbp), %rdi
movq 0xa0(%rdi), %rsi
movq 0xa8(%rdi), %rdx
movq 0xb0(%rdi), %rcx
callq 0xfff0
jmp 0x106e0
movq -0x20(%rbp), %rdi
movq 0xb8(%rdi), %rsi
movq 0xc0(%rdi), %rdx
movq 0xc8(%rdi), %rcx
callq 0xfff0
jmp 0x106e0
jmp 0x106e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/FitBitSlicedA.cpp
// Function: FitBitSlicedA::destroy(FIT_BIT_SLOT)
void FitBitSlicedA::destroy(enum FIT_BIT_SLOT fbs){
    switch (fbs) {
        case FBS_PAR:
            destroy(this->pi, this->A, this->B);
            break;
        case FBS_PARm1:
            destroy(this->PIm1, this->Am1, this->Bm1);
            break;
        case FBS_PARm2:
            destroy(this->PIm2, this->Am2, this->Bm2);
            break;
        case FBS_GRAD:
            destroy(this->gradPI, this->gradA, this->gradB);
            break;
        case FBS_GRADm1:
            destroy(this->gradPIm1, this->gradAm1, this->gradBm1);
            break;
        case FBS_PARcopy:
            destroy(this->PIcopy, this->Acopy, this->Bcopy);
            break;
        case FBS_DIR:
            destroy(this->dirPI, this->dirA, this->dirB);
            break;
        case FBS_DIRm1:
            destroy(this->dirPIm1, this->dirAm1, this->dirBm1);
            break;
        default:
            break;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x7, %eax
ja 0x10859
movq -0x18(%rbp), %rax
leaq 0x3f796(%rip), %rcx     # 0x4febc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0x10, %rsi
movq %rdi, %rdx
addq $0x18, %rdx
movq %rdi, %rcx
addq $0x20, %rcx
callq 0x10200
jmp 0x1085b
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0x28, %rsi
movq %rdi, %rdx
addq $0x30, %rdx
movq %rdi, %rcx
addq $0x38, %rcx
callq 0x10200
jmp 0x1085b
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0x40, %rsi
movq %rdi, %rdx
addq $0x48, %rdx
movq %rdi, %rcx
addq $0x50, %rcx
callq 0x10200
jmp 0x1085b
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0x58, %rsi
movq %rdi, %rdx
addq $0x60, %rdx
movq %rdi, %rcx
addq $0x68, %rcx
callq 0x10200
jmp 0x1085b
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0x70, %rsi
movq %rdi, %rdx
addq $0x78, %rdx
movq %rdi, %rcx
addq $0x80, %rcx
callq 0x10200
jmp 0x1085b
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0x88, %rsi
movq %rdi, %rdx
addq $0x90, %rdx
movq %rdi, %rcx
addq $0x98, %rcx
callq 0x10200
jmp 0x1085b
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0xa0, %rsi
movq %rdi, %rdx
addq $0xa8, %rdx
movq %rdi, %rcx
addq $0xb0, %rcx
callq 0x10200
jmp 0x1085b
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0xb8, %rsi
movq %rdi, %rdx
addq $0xc0, %rdx
movq %rdi, %rcx
addq $0xc8, %rcx
callq 0x10200
jmp 0x1085b
jmp 0x1085b
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/FitBitSlicedA.cpp
// Function: FitBitSlicedA::copy(FIT_BIT_SLOT, FIT_BIT_SLOT)
void FitBitSlicedA::copy(enum FIT_BIT_SLOT sourse_fbs, enum FIT_BIT_SLOT target_fbs) {
    NUMBER *soursePI = NULL;
    NUMBER ***sourseA = NULL;
    NUMBER **sourseB = NULL;
    get(sourse_fbs, soursePI, sourseA, sourseB);
    NUMBER *targetPI = NULL;
    NUMBER ***targetA = NULL;
    NUMBER **targetB = NULL;
    get(target_fbs, targetPI, targetA, targetB);
    
    copy(soursePI, sourseA, sourseB, targetPI, targetA, targetB);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl -0xc(%rbp), %esi
leaq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rcx
leaq -0x28(%rbp), %r8
callq 0x10870
movq -0x48(%rbp), %rdi
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movl -0x10(%rbp), %esi
leaq -0x30(%rbp), %rdx
leaq -0x38(%rbp), %rcx
leaq -0x40(%rbp), %r8
callq 0x10870
movq -0x48(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
leaq -0x28(%rbp), %rcx
leaq -0x30(%rbp), %r8
leaq -0x38(%rbp), %r9
leaq -0x40(%rbp), %rax
movq %rax, (%rsp)
callq 0x10090
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/FitBitSlicedA.cpp
// Function: FitBitSlicedA::doLog10ScaleGentle(FIT_BIT_SLOT)
void FitBitSlicedA::doLog10ScaleGentle(enum FIT_BIT_SLOT fbs) {
    // fbs - gradient or direction
    NUMBER *a_PI = NULL;
    NUMBER ***a_A = NULL;
    NUMBER **a_B = NULL;
    get(fbs, a_PI, a_A, a_B);
	if(this->pi != NULL) doLog10Scale1DGentle(a_PI, this->pi, this->nS);
    if(this->A  != NULL) {
        for(NPAR z=0; z<this->nZ; z++) {
            doLog10Scale2DGentle(a_A[z],  this->A[z], this->nS, this->nS);
        }
    }
    if(this->B  != NULL) {
        doLog10Scale2DGentle(a_B,  this->B, this->nS, this->nO);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl -0xc(%rbp), %esi
leaq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rcx
leaq -0x28(%rbp), %r8
callq 0x10870
movq -0x38(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x10e93
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rdi
movq 0x10(%rax), %rsi
movsbl 0x1(%rax), %edx
callq 0xa590
movq -0x38(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x10eeb
movb $0x0, -0x29(%rbp)
movq -0x38(%rbp), %rcx
movsbl -0x29(%rbp), %eax
movsbl 0x2(%rcx), %ecx
cmpl %ecx, %eax
jge 0x10ee9
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbq -0x29(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movq 0x18(%rax), %rcx
movsbq -0x29(%rbp), %rdx
movq (%rcx,%rdx,8), %rsi
movb 0x1(%rax), %cl
movsbl %cl, %edx
movsbl 0x1(%rax), %ecx
callq 0xa9a0
movb -0x29(%rbp), %al
addb $0x1, %al
movb %al, -0x29(%rbp)
jmp 0x10ea2
jmp 0x10eeb
movq -0x38(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x10f10
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rdi
movq 0x20(%rax), %rsi
movb 0x1(%rax), %cl
movsbl %cl, %edx
movsbl (%rax), %ecx
callq 0xa9a0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/./utils.h
// Function: void free3D<double>(double***, int, int)
void free3D(T*** ar, NDAT size1, NDAT size2) {
    for(NDAT i=0; i<size1; i++) {
        for(NDAT j=0; j<size2; j++)
            free(ar[i][j]);
        free(ar[i]);
    }
    free(ar);
    //    &ar = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x11300
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x112e4
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x5380
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x112b8
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x5380
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x112a9
movq -0x8(%rbp), %rdi
callq 0x5380
addq $0x20, %rsp
popq %rbp
retq
nop
// File: myudelson[P]hmm-scalable/./utils.h
// Function: double*** init3D<double>(int, int, int)
T*** init3D(NDAT size1, NDAT size2, NDAT size3) {
	NDAT i,j;
	T*** ar = Calloc(T **, (size_t)size1);
	for(i=0; i<size1; i++) {
		ar[i] = Calloc(T*, (size_t)size2);
		for(j=0; j<size2; j++)
			ar[i][j] = Calloc(T, (size_t)size3);
	}
	return ar;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movslq -0x4(%rbp), %rdi
movl $0x8, %esi
callq 0x5180
movq %rax, -0x20(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x113ab
movslq -0x8(%rbp), %rdi
movl $0x8, %esi
callq 0x5180
movq %rax, %rdx
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x1139e
movslq -0xc(%rbp), %rdi
movl $0x8, %esi
callq 0x5180
movq %rax, %rdx
movq -0x20(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x11366
jmp 0x113a0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1133a
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: myudelson[P]hmm-scalable/./utils.h
// Function: void toZero3D<double>(double***, int, int, int)
void toZero3D(T*** ar, NDAT size1, NDAT size2, NDAT size3) {
    for(NDAT i=0; i<size1; i++)
        for(NDAT j=0; j<size2; j++)
            for(NDAT l=0; l<size3; l++)
                ar[i][j][l] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x11443
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x11436
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x11429
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x113f6
jmp 0x1142b
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x113e7
jmp 0x11438
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x113d8
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: myudelson[P]hmm-scalable/FitBitSlicedAB.cpp
// Function: FitBitSlicedAB::init(double*&, double***&, double***&)
void FitBitSlicedAB::init(NUMBER* &a_PI, NUMBER*** &a_A, NUMBER*** &a_B) {
    if(this->pi != NULL) {
        if(a_PI == NULL)
            a_PI = init1D<NUMBER>((NDAT)this->nS); // init1DNumber(this->nS);
        else
            toZero1D<NUMBER>(a_PI, (NDAT)this->nS);
    }
    if(this->A  != NULL) {
        if(a_A == NULL)
            a_A  = init3D<NUMBER>((NDAT)this->nZ, (NDAT)this->nS, (NDAT)this->nS);
        else
            toZero3D<NUMBER>(a_A, (NDAT)this->nZ, (NDAT)this->nS, (NDAT)this->nS);
    }
    if(this->B  != NULL) {
        if(a_B == NULL)
            a_B  = init3D<NUMBER>((NDAT)this->nZ, (NDAT)this->nS, (NDAT)this->nO);
        else
            toZero3D<NUMBER>(a_B, (NDAT)this->nZ, (NDAT)this->nS, (NDAT)this->nO);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x11b10
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x11afa
movq -0x28(%rbp), %rax
movsbl 0x1(%rax), %edi
callq 0xc410
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x11b0e
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdi
movsbl 0x1(%rax), %esi
callq 0xf540
jmp 0x11b10
movq -0x28(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x11b64
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x11b46
movq -0x28(%rbp), %rax
movsbl 0x2(%rax), %edi
movsbl 0x1(%rax), %esi
movsbl 0x1(%rax), %edx
callq 0x11310
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
jmp 0x11b62
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdi
movsbl 0x2(%rax), %esi
movsbl 0x1(%rax), %edx
movsbl 0x1(%rax), %ecx
callq 0x113c0
jmp 0x11b64
movq -0x28(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x11bb6
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x11b99
movq -0x28(%rbp), %rax
movsbl 0x2(%rax), %edi
movsbl 0x1(%rax), %esi
movsbl (%rax), %edx
callq 0x11310
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x11bb4
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rdi
movsbl 0x2(%rax), %esi
movsbl 0x1(%rax), %edx
movsbl (%rax), %ecx
callq 0x113c0
jmp 0x11bb6
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: myudelson[P]hmm-scalable/FitBitSlicedAB.cpp
// Function: FitBitSlicedAB::destroy(double*&, double***&, double***&)
void FitBitSlicedAB::destroy(NUMBER* &a_PI, NUMBER*** &a_A, NUMBER*** &a_B) {
    if(this->pi != NULL && a_PI != NULL) free(a_PI);
    if(this->A  != NULL && a_A  != NULL) free3D<NUMBER>(a_A, (NDAT)this->nZ, (NDAT)this->nS);
    if(this->B  != NULL && a_B  != NULL) free3D<NUMBER>(a_B, (NDAT)this->nZ, (NDAT)this->nS);
    a_PI = NULL;
    a_A  = NULL;
    a_B  = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x120ad
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x120ad
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x5380
movq -0x28(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x120da
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x120da
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rdi
movsbl 0x2(%rax), %esi
movsbl 0x1(%rax), %edx
callq 0x11290
movq -0x28(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x12107
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x12107
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rdi
movsbl 0x2(%rax), %esi
movsbl 0x1(%rax), %edx
callq 0x11290
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: myudelson[P]hmm-scalable/FitBitSlicedAB.cpp
// Function: FitBitSlicedAB::copy(FIT_BIT_SLOT, FIT_BIT_SLOT)
void FitBitSlicedAB::copy(enum FIT_BIT_SLOT sourse_fbs, enum FIT_BIT_SLOT target_fbs) {
    NUMBER *soursePI = NULL;
    NUMBER ***sourseA = NULL;
    NUMBER ***sourseB = NULL;
    get(sourse_fbs, soursePI, sourseA, sourseB);
    NUMBER *targetPI = NULL;
    NUMBER ***targetA = NULL;
    NUMBER ***targetB = NULL;
    get(target_fbs, targetPI, targetA, targetB);
    
    copy(soursePI, sourseA, sourseB, targetPI, targetA, targetB);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl -0xc(%rbp), %esi
leaq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rcx
leaq -0x28(%rbp), %r8
callq 0x126e0
movq -0x48(%rbp), %rdi
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movl -0x10(%rbp), %esi
leaq -0x30(%rbp), %rdx
leaq -0x38(%rbp), %rcx
leaq -0x40(%rbp), %r8
callq 0x126e0
movq -0x48(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
leaq -0x28(%rbp), %rcx
leaq -0x30(%rbp), %r8
leaq -0x38(%rbp), %r9
leaq -0x40(%rbp), %rax
movq %rax, (%rsp)
callq 0x11ef0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/FitBitSlicedAB.cpp
// Function: FitBitSlicedAB::add(FIT_BIT_SLOT, FIT_BIT_SLOT)
void FitBitSlicedAB::add(enum FIT_BIT_SLOT sourse_fbs, enum FIT_BIT_SLOT target_fbs) {
    NUMBER *soursePI = NULL;
    NUMBER ***sourseA = NULL;
    NUMBER ***sourseB = NULL;
    get(sourse_fbs, soursePI, sourseA, sourseB);
    NUMBER *targetPI = NULL;
    NUMBER ***targetA = NULL;
    NUMBER ***targetB = NULL;
    get(target_fbs, targetPI, targetA, targetB);
    
    add(soursePI, sourseA, sourseB, targetPI, targetA, targetB);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl -0xc(%rbp), %esi
leaq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rcx
leaq -0x28(%rbp), %r8
callq 0x126e0
movq -0x48(%rbp), %rdi
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movl -0x10(%rbp), %esi
leaq -0x30(%rbp), %rdx
leaq -0x38(%rbp), %rcx
leaq -0x40(%rbp), %r8
callq 0x126e0
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
movq -0x40(%rbp), %rax
movq %rax, (%rsp)
callq 0x11fb0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: myudelson[P]hmm-scalable/FitBitSlicedAB.cpp
// Function: FitBitSlicedAB::doLog10ScaleGentle(FIT_BIT_SLOT)
void FitBitSlicedAB::doLog10ScaleGentle(enum FIT_BIT_SLOT fbs) {
    // fbs - gradient or direction
    NUMBER *a_PI = NULL;
    NUMBER ***a_A = NULL;
    NUMBER ***a_B = NULL;
    get(fbs, a_PI, a_A, a_B);
	if(this->pi != NULL) doLog10Scale1DGentle(a_PI, this->pi, this->nS);
    if(this->A  != NULL)
        for(NPAR z=0; z<this->nZ; z++)
            doLog10Scale2DGentle(a_A[z],  this->A[z], this->nS, this->nS);
//        doLog10Scale3DGentle(a_A,  this->A,  this->nZ, this->nS, this->nS);
	if(this->B  != NULL)
        for(NPAR z=0; z<this->nZ; z++)
            doLog10Scale2DGentle(a_B[z],  this->B[z], this->nS, this->nO);
//        doLog10Scale3DGentle(a_B,  this->B,  this->nZ, this->nS, this->nO);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl -0xc(%rbp), %esi
leaq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rcx
leaq -0x28(%rbp), %r8
callq 0x126e0
movq -0x38(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x12cf3
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rdi
movq 0x10(%rax), %rsi
movsbl 0x1(%rax), %edx
callq 0xa590
movq -0x38(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x12d4b
movb $0x0, -0x29(%rbp)
movq -0x38(%rbp), %rcx
movsbl -0x29(%rbp), %eax
movsbl 0x2(%rcx), %ecx
cmpl %ecx, %eax
jge 0x12d49
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbq -0x29(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movq 0x18(%rax), %rcx
movsbq -0x29(%rbp), %rdx
movq (%rcx,%rdx,8), %rsi
movb 0x1(%rax), %cl
movsbl %cl, %edx
movsbl 0x1(%rax), %ecx
callq 0xa9a0
movb -0x29(%rbp), %al
addb $0x1, %al
movb %al, -0x29(%rbp)
jmp 0x12d02
jmp 0x12d4b
movq -0x38(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x12da2
movb $0x0, -0x2a(%rbp)
movq -0x38(%rbp), %rcx
movsbl -0x2a(%rbp), %eax
movsbl 0x2(%rcx), %ecx
cmpl %ecx, %eax
jge 0x12da0
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movsbq -0x2a(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movq 0x20(%rax), %rcx
movsbq -0x2a(%rbp), %rdx
movq (%rcx,%rdx,8), %rsi
movb 0x1(%rax), %cl
movsbl %cl, %edx
movsbl (%rax), %ecx
callq 0xa9a0
movb -0x2a(%rbp), %al
addb $0x1, %al
movb %al, -0x2a(%rbp)
jmp 0x12d5a
jmp 0x12da2
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: myudelson[P]hmm-scalable/InputUtil.cpp
// Function: InputUtil::writeString(_IO_FILE*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void InputUtil::writeString(FILE *f, string str) {
    // Create char pointer from string.
    char* text = const_cast<char*>(str.c_str());
    // Find the length of the string.
    NDAT size = (NDAT)str.size();
    // Write the string's size to the file.
    fwrite(&size, sizeof(NDAT), 1, f);
    // Followed by the string itself.
    fwrite(text, 1, (size_t)size, f);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %rax
movq -0x30(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x5110
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x51c0
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rcx
leaq -0x1c(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x55a0
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rdx
movq -0x8(%rbp), %rcx
movl $0x1, %esi
callq 0x55a0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: myudelson[P]hmm-scalable/InputUtil.cpp
// Function: InputUtil::readString[abi:cxx11](_IO_FILE*)
string InputUtil::readString(FILE *f) {
    // Create new string object to store the retrieved text and to return to the calling function.
    string str;
    // UInt for storing the string's size.
    NDAT size;
    // Read the size of the string from the file and store it in size.
    fread(&size, sizeof(NDAT), 1, f);
    // Create a char pointer for temporary storage.
    char* text = new char[size];
    // Read [size] number of characters from the string and store them in text.
    fread(text, 1, (size_t)size, f);
    // Store the contents of text in str.
    str = text;
    // Resize str to match the size else we get extra cruft (line endings methinks).
    str.resize((size_t)size);
    // Finally, return the string to the calling function.
    delete[] text;
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x5420
movq -0x10(%rbp), %rcx
leaq -0x18(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x5470
jmp 0x1320d
movslq -0x18(%rbp), %rdi
callq 0x5030
movq %rax, -0x48(%rbp)
jmp 0x1321c
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movslq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rcx
movl $0x1, %esi
callq 0x5470
jmp 0x1323c
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x5400
jmp 0x1324b
movq -0x40(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x5410
jmp 0x1325a
movq -0x30(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x13271
movq -0x50(%rbp), %rdi
callq 0x53d0
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x1329d
jmp 0x13294
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x5170
jmp 0x132a7
movq -0x40(%rbp), %rdi
callq 0x5170
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x5540
// File: myudelson[P]hmm-scalable/InputUtil.cpp
// Function: readline(_IO_FILE*)
static char* readline(FILE *fid) {
	int length = 0;
	
	if(fgets(line,max_line_length,fid) == NULL)
		return NULL;
	
	while(strrchr(line,'\n') == NULL && strrchr(line,'\r') == NULL) // do take both line endings
	{
		max_line_length *= 2;
		line = (char *) realloc(line, (size_t)max_line_length);
		length = (int) strlen(line);
		if(fgets(line+length,max_line_length-length,fid) == NULL)
			break;
	}
	return line;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq 0x470ae(%rip), %rdi     # 0x5bde8
movl 0x470a4(%rip), %esi     # 0x5bde4
movq -0x10(%rbp), %rdx
callq 0x54b0
cmpq $0x0, %rax
jne 0x14d5c
movq $0x0, -0x8(%rbp)
jmp 0x14e10
jmp 0x14d5e
movq 0x47083(%rip), %rdi     # 0x5bde8
movl $0xa, %esi
callq 0x5350
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x15(%rbp)
jne 0x14d98
movq 0x47064(%rip), %rdi     # 0x5bde8
movl $0xd, %esi
callq 0x5350
cmpq $0x0, %rax
sete %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x14da1
jmp 0x14e05
movl 0x4703d(%rip), %eax     # 0x5bde4
shll %eax
movl %eax, 0x47035(%rip)     # 0x5bde4
movq 0x47032(%rip), %rdi     # 0x5bde8
movslq 0x47027(%rip), %rsi     # 0x5bde4
callq 0x54e0
movq %rax, 0x4701f(%rip)     # 0x5bde8
movq 0x47018(%rip), %rdi     # 0x5bde8
callq 0x5130
movl %eax, -0x14(%rbp)
movq 0x47009(%rip), %rdi     # 0x5bde8
movslq -0x14(%rbp), %rax
addq %rax, %rdi
movl 0x46ff8(%rip), %esi     # 0x5bde4
subl -0x14(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0x54b0
cmpq $0x0, %rax
jne 0x14e00
jmp 0x14e05
jmp 0x14d5e
movq 0x46fdc(%rip), %rax     # 0x5bde8
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: myudelson[P]hmm-scalable/./StripedArray.h
// Function: StripedArray<signed char>::StripedArray()
StripedArray<T>::StripedArray() {
	this->size = 0;
	this->stripe_size = 20000;
	this->nstripes = 0;
	this->size_last_stripe = 0;
	this->stripes = NULL;
//    this->complex = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movl $0x4e20, 0x4(%rax)      # imm = 0x4E20
movl $0x0, 0x8(%rax)
movl $0x0, 0xc(%rax)
movq $0x0, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: myudelson[P]hmm-scalable/./StripedArray.h
// Function: StripedArray<signed char>::add(signed char)
void StripedArray<T>::add(T value) {
	if(this->size == (NDAT_MAX-1)) {
		fprintf(stderr, "Error! Maximum array size reached.\n");
		return;
	}
	
	// add stripe if necessary
	if( this->nstripes==0 || this->size_last_stripe==this->stripe_size)
		this->addStripe();
	// place data
	this->stripes[this->nstripes-1][this->size_last_stripe++] = value;
	this->size++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x7ffffffe, (%rax)     # imm = 0x7FFFFFFE
jne 0x166ac
movq 0x4493f(%rip), %rax     # 0x5afd8
movq (%rax), %rdi
leaq 0x39ca2(%rip), %rsi     # 0x50345
movb $0x0, %al
callq 0x5440
jmp 0x166fd
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x166c2
movq -0x18(%rbp), %rcx
movl 0xc(%rcx), %eax
cmpl 0x4(%rcx), %eax
jne 0x166cb
movq -0x18(%rbp), %rdi
callq 0x174c0
movq -0x18(%rbp), %rax
movb -0x9(%rbp), %sil
movq 0x10(%rax), %rcx
movl 0x8(%rax), %edx
subl $0x1, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rcx
movl 0xc(%rax), %edx
movl %edx, %edi
addl $0x1, %edi
movl %edi, 0xc(%rax)
movslq %edx, %rdx
movb %sil, (%rcx,%rdx)
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: myudelson[P]hmm-scalable/./StripedArray.h
// Function: StripedArray<signed char>::toArray()
T* StripedArray<T>::toArray() {
    T *result = (T*)malloc( (size_t)this->size*sizeof(T));
    for(NDAT i=0; i<this->nstripes; i++) {
        T* dest = &result[ i*this->stripe_size ];
        size_t sz = sizeof(T)*( (i<(this->nstripes-1))?this->stripe_size:this->size_last_stripe );
        memcpy( dest, this->stripes[i], sz );  
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movslq (%rax), %rdi
shlq $0x0, %rdi
callq 0x53e0
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x30(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x16c39
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %edx
imull 0x4(%rcx), %edx
movslq %edx, %rdx
addq %rdx, %rax
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x16bf9
movq -0x30(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x34(%rbp)
jmp 0x16c03
movq -0x30(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rax
movl -0x34(%rbp), %ecx
movslq %ecx, %rcx
shlq $0x0, %rcx
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq -0x28(%rbp), %rdx
callq 0x5250
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x16bbb
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: myudelson[P]hmm-scalable/./StripedArray.h
// Function: StripedArray<signed char>::~StripedArray()
StripedArray<T>::~StripedArray() {
	for(NDAT i=0; i<this->nstripes;i++) {
//        if(this->complex)
//            for(NDAT j=0; j<( (i<(this->nstripes-1))?this->stripe_size:this->size_last_stripe );j++)
//                free(  (void *)(this->stripes[i][j]) );
		free(this->stripes[i]);
    }
	free(this->stripes);
//	for(NDAT i=0; i<this->nstripes;i++)
//		delete [] this->stripes[i];
//	delete [] this->stripes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x16c97
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x5380
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x16c6b
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x5380
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)