LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: BhanuPrakashN[P]sparse_chol/smatrix.cpp
// Function: TripletToCC(smatrix*)
sm *TripletToCC(sm *T){
    int m,n,nz,*Ti,*Tj,*Cp,*Ci,*temp,p;
    double *Cx,*Tx;
    sm *C;
    if(!TRIPLET(T))return NULL;
    m=T->m;
    n=T->n;
    Ti=T->i;
    Tj=T->p;
    Tx=T->x;
    nz=T->nz;
    C=smalloc(m,n,nz,Tx!=NULL,0);
    temp=(int*)calloc(n,sizeof(int));
    Cp=C->p;
    Ci=C->i;
    Cx=C->x;
    //printf("n=%d\n",C->n);
    for(int k=0;k<nz;k++)temp[Tj[k]]++;
    Cp[n]=cumsum(Cp,temp,n);
    for(int k=0;k<nz;k++){
        p=temp[Tj[k]]++;
        Ci[p]=Ti[k];
        Cx[p]=Tx[k];
    }
    return C;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x20cd
movq -0x10(%rbp), %rax
cmpl $0x0, 0x28(%rax)
jge 0x20da
movq $0x0, -0x8(%rbp)
jmp 0x2234
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
movl -0x1c(%rbp), %edx
cmpq $0x0, -0x60(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %ecx
xorl %r8d, %r8d
callq 0x1de0
movq %rax, -0x68(%rbp)
movslq -0x18(%rbp), %rdi
movl $0x4, %esi
callq 0x10a0
movq %rax, -0x48(%rbp)
movq -0x68(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x68(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x68(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x58(%rbp)
movl $0x0, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x21a7
movq -0x48(%rbp), %rax
movq -0x30(%rbp), %rcx
movslq -0x6c(%rbp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movl -0x6c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x6c(%rbp)
jmp 0x217b
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rsi
movl -0x18(%rbp), %edx
callq 0x2240
movl %eax, %edx
movq -0x38(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl $0x0, -0x70(%rbp)
movl -0x70(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x222c
movq -0x48(%rbp), %rcx
movq -0x30(%rbp), %rax
movslq -0x70(%rbp), %rdx
movslq (%rax,%rdx,4), %rdx
movl (%rcx,%rdx,4), %eax
movl %eax, %esi
addl $0x1, %esi
movl %esi, (%rcx,%rdx,4)
movl %eax, -0x4c(%rbp)
movq -0x28(%rbp), %rax
movslq -0x70(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x40(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x60(%rbp), %rax
movslq -0x70(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x58(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x70(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x70(%rbp)
jmp 0x21cb
movq -0x68(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nop
// File: BhanuPrakashN[P]sparse_chol/smatrix.cpp
// Function: cumsum(int*, int*, int)
int cumsum(int *a,int *b,int n){
    int nz=0;
    for(int i=0;i<n;i++){
        a[i]=nz;
        nz+=b[i];
        b[i]=a[i];
    }
    return nz;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x22a5
movl -0x18(%rbp), %edx
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x225d
movl -0x18(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: BhanuPrakashN[P]sparse_chol/smatrix.cpp
// Function: fmalloc(int, std::vector<int, std::allocator<int>>*)
Fm *fmalloc(int n,vector<int> *indices){
    Fm *F=(Fm*)malloc(sizeof(Fm));
    F->n=n;
    //if(indices!=NULL)sort(indices->begin(),indices->end());
    F->indices=indices;
    F->x=(double **)calloc(n,sizeof(double *));
    for(int i=0;i<n;i++)
        F->x[i]=(double*)calloc(n,sizeof(double));
    return F;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x18, %edi
callq 0x1150
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movslq -0x4(%rbp), %rdi
movl $0x8, %esi
callq 0x10a0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x27d6
movslq -0x4(%rbp), %rdi
movl $0x8, %esi
callq 0x10a0
movq %rax, %rdx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x27a2
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: BhanuPrakashN[P]sparse_chol/smatrix.cpp
// Function: fconstruct(Fmatrix*, smatrix*, int)
void fconstruct(Fm *F,sm *A,int j){
    int n=F->n,i;
    vector<int> *ind=F->indices;
    double **Fx=F->x;
    Fx[0][0]=sm_access(A,j,j);
    for(int p=1;p<n;p++){
        i=ind->at(p);
        Fx[0][p]=sm_access(A,i,j);
        Fx[p][0]=sm_access(A,i,j);
    }


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x26c0
movq -0x30(%rbp), %rax
movq (%rax), %rax
movsd %xmm0, (%rax)
movl $0x1, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x2898
movq -0x28(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0x16a0
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x26c0
movq -0x30(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x14(%rbp), %edx
callq 0x26c0
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsd %xmm0, (%rax)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x2835
addq $0x40, %rsp
popq %rbp
retq
nop
// File: BhanuPrakashN[P]sparse_chol/smatrix.cpp
// Function: printFm(Fmatrix*)
void printFm(Fm *F){
    for(int  i=0;i<F->n;i++){
        for(int j=0;j<F->n;j++){
            printf("%6.4g ",F->x[i][j]);
        }
        printf("\n");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x291b
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x2902
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
leaq 0x4825(%rip), %rdi      # 0x7115
movb $0x1, %al
callq 0x1030
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x28c5
leaq 0x47fd(%rip), %rdi      # 0x7106
movb $0x0, %al
callq 0x1030
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x28b3
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: BhanuPrakashN[P]sparse_chol/smatrix.cpp
// Function: Fupdate(Fmatrix*, Fmatrix*)
void Fupdate(Fm *F,Fm *U){
    vector<int> *ind=U->indices;
    int i,j;
    for(int k=0;k<U->n;k++){
        i=ind->at(k);
        for(int p=0;p<U->n;p++){
            j=ind->at(p);
            F->x[i][j]+=U->x[k][p];
        }
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x29ea
movq -0x18(%rbp), %rdi
movslq -0x24(%rbp), %rsi
callq 0x16a0
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x29da
movq -0x18(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x16a0
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x20(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x297b
jmp 0x29dc
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2953
addq $0x30, %rsp
popq %rbp
retq
// File: ef-gy[P]libefgy/include/ef.gy/tracer.h
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> efgy::math::tracer::formatter<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::format<int, (char)0>(efgy::math::tracer::tracer<int, void, (char)0, efgy::math::tracer::formatter<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
static result format(const tracer<T, void, op, formatter> &t) {
    std::stringstream s("");
    if (op) {
      s << "(" << op << t.value1 << ")";
    } else {
      s << t.value1;
    }
    return s.str();
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x1e8(%rbp)
movq %rdi, %rax
movq %rax, -0x1e0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x1b9(%rbp), %rdi
movq %rdi, -0x1d8(%rbp)
callq 0x6610
movq -0x1d8(%rbp), %rdx
leaq 0xd914(%rip), %rsi      # 0x38219
leaq -0x1b8(%rbp), %rdi
callq 0x7e70
jmp 0x2a913
movl $0x10, %edi
movl $0x8, %esi
callq 0x8480
movl %eax, -0x1ec(%rbp)
jmp 0x2a92a
movl -0x1ec(%rbp), %edx
leaq -0x198(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x6550
jmp 0x2a945
leaq -0x1b8(%rbp), %rdi
callq 0x6230
leaq -0x1b9(%rbp), %rdi
callq 0x63e0
leaq -0x188(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x65e0
jmp 0x2a972
movq -0x1e8(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x6370
jmp 0x2a987
leaq -0x198(%rbp), %rdi
callq 0x62d0
movq -0x1e0(%rbp), %rax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c8(%rbp)
movl %eax, -0x1cc(%rbp)
jmp 0x2a9d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c8(%rbp)
movl %eax, -0x1cc(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x6230
leaq -0x1b9(%rbp), %rdi
callq 0x63e0
jmp 0x2aa01
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c8(%rbp)
movl %eax, -0x1cc(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x62d0
movq -0x1c8(%rbp), %rdi
callq 0x6600
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH17_SpecializedLibraryFacilities/examples/getc.cc
// Function: main
int main()
{
	int ch;    // use an int, not a char to hold the return from get()

	// loop to read and write all the data in the input
	while ((ch = cin.get()) != EOF)
         	cout.put(ch);
	cout << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movq 0x2e0a(%rip), %rdi      # 0x3fe0
callq 0x1060
movl %eax, -0x8(%rbp)
cmpl $-0x1, %eax
je 0x11f7
movl -0x8(%rbp), %eax
movq 0x2de3(%rip), %rdi      # 0x3fd0
movsbl %al, %esi
callq 0x1030
jmp 0x11cf
movq 0x2dd2(%rip), %rdi      # 0x3fd0
movq 0x2dbb(%rip), %rsi      # 0x3fc0
callq 0x1050
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: nachogoro[P]wordcrack-herminia/src/Board.cpp
// Function: Word::addLetter(Letter*)
void Word::addLetter(Letter* letter)
{
    letter->markAsUsed(true);
    mLetters.push(letter);
    mCoords.push_front(letter->coord());
    mWord += letter->letter();
    mScore = mScore + letter->value();
    mMultiplier *= letter->wordMultiplier();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rsi, -0x30(%rbp)
callq 0x31c0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x3bb0
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
leaq -0x10(%rbp), %rsi
callq 0x4dd0
movq -0x18(%rbp), %rax
addq $0x78, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3b50
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x4e10
movq -0x10(%rbp), %rdi
callq 0x3ac0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
addq $0x8, %rdi
callq 0x32c0
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3af0
movl -0x1c(%rbp), %ecx
movl %eax, %edx
movq -0x18(%rbp), %rax
addl %edx, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x3b20
movl %eax, %ecx
movq -0x18(%rbp), %rax
imull 0xc8(%rax), %ecx
movl %ecx, 0xc8(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: nachogoro[P]wordcrack-herminia/src/Board.cpp
// Function: Word::removeLastLetter()
void Word::removeLastLetter()
{
    Letter* toRemove = mLetters.top();
    mLetters.pop();
    mCoords.pop_front();
    mWord = mWord.substr(0, mWord.length() - toRemove->letter().length());
    mScore = mScore - toRemove->value();
    mMultiplier /= toRemove->wordMultiplier();
    toRemove->markAsUsed(false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
callq 0x31c0
movq -0x58(%rbp), %rdi
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x28, %rdi
callq 0x4e90
movq -0x38(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x10(%rbp)
addq $0x28, %rdi
callq 0x4ec0
movq -0x38(%rbp), %rdi
addq $0x78, %rdi
callq 0x4ef0
movq -0x38(%rbp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
addq $0x8, %rdi
callq 0x3340
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3ac0
movq %rax, %rdi
callq 0x3340
movq -0x50(%rbp), %rcx
movq -0x48(%rbp), %rsi
subq %rax, %rcx
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x3240
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
leaq -0x30(%rbp), %rsi
callq 0x32a0
leaq -0x30(%rbp), %rdi
callq 0x3150
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3af0
movl -0x3c(%rbp), %ecx
movl %eax, %edx
movq -0x38(%rbp), %rax
subl %edx, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x3b20
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl 0xc8(%rax), %eax
cltd
idivl %ecx
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0xc8(%rax)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x3bb0
addq $0x60, %rsp
popq %rbp
retq
nop
// File: nachogoro[P]wordcrack-herminia/src/Board.cpp
// Function: Word::score() const
int Word::score() const
{ 
    const int base = mScore * mMultiplier;

    int lengthExtra = 0;

    switch (mLetters.size()) {
        case 4:
            lengthExtra = 2;
            break;
        case 5:
            lengthExtra = 4;
            break;
        case 6:
            lengthExtra = 8;
            break;
        case 7:
            lengthExtra = 12;
            break;
        case 8:
            lengthExtra = 18;
            break;
        default:
            break;
    }

    return base + lengthExtra;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
callq 0x31c0
movq -0x20(%rbp), %rdi
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl (%rdi), %eax
movl 0xc8(%rdi), %ecx
imull %ecx, %eax
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
addq $0x28, %rdi
callq 0x4f70
addq $-0x4, %rax
movq %rax, -0x18(%rbp)
subq $0x4, %rax
ja 0x3f2a
movq -0x18(%rbp), %rax
leaq 0x13110(%rip), %rcx     # 0x17004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x2, -0x10(%rbp)
jmp 0x3f2c
movl $0x4, -0x10(%rbp)
jmp 0x3f2c
movl $0x8, -0x10(%rbp)
jmp 0x3f2c
movl $0xc, -0x10(%rbp)
jmp 0x3f2c
movl $0x12, -0x10(%rbp)
jmp 0x3f2c
jmp 0x3f2c
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: nachogoro[P]wordcrack-herminia/src/Board.cpp
// Function: Letter::toString[abi:cxx11]() const
std::string Letter::toString() const
{
    std::string s = letter();
    s += std::to_string(value());
    s += "-";
    s += std::to_string(wordMultiplier());
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x80(%rbp)
movq %rdi, -0x78(%rbp)
movq %rdi, -0x88(%rbp)
callq 0x31c0
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdi
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x3ac0
movq -0x78(%rbp), %rdi
movq %rax, %rsi
callq 0x30e0
movq -0x70(%rbp), %rdi
callq 0x3af0
movl %eax, %esi
leaq -0x38(%rbp), %rdi
callq 0x5230
jmp 0x49f2
movq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x32c0
jmp 0x4a01
leaq -0x38(%rbp), %rdi
callq 0x3150
movq -0x78(%rbp), %rdi
leaq 0x12648(%rip), %rsi     # 0x1705d
callq 0x3210
jmp 0x4a1c
movq -0x70(%rbp), %rdi
callq 0x3b20
movl %eax, %esi
leaq -0x68(%rbp), %rdi
callq 0x5230
jmp 0x4a32
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x32c0
jmp 0x4a41
leaq -0x68(%rbp), %rdi
callq 0x3150
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x4a9b
jmp 0x4a92
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x4aab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3150
jmp 0x4aab
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3150
jmp 0x4aab
movq -0x78(%rbp), %rdi
callq 0x3150
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x3150
movq -0x40(%rbp), %rdi
callq 0x33f0
nopl (%rax)
// File: nachogoro[P]wordcrack-herminia/src/Board.cpp
// Function: Board::print()
void Board::print()
{
    for (int i = 0; i < VERTICAL_SIZE; ++i) {
        for (int j = 0; j < HORIZONTAL_SIZE; ++j) {
            std::cout << mLetters[i][j].toString() << " ";
        }
        std::cout << std::endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
callq 0x31c0
movq -0x50(%rbp), %rdi
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x4, -0xc(%rbp)
jge 0x4b9d
movl $0x0, -0x10(%rbp)
cmpl $0x4, -0x10(%rbp)
jge 0x4b7c
movq -0x48(%rbp), %rsi
movslq -0xc(%rbp), %rax
imulq $0xe0, %rax, %rax
addq %rax, %rsi
movslq -0x10(%rbp), %rax
imulq $0x38, %rax, %rax
addq %rax, %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x4990
movq -0x60(%rbp), %rsi
movq 0x1b494(%rip), %rdi     # 0x1ffc8
callq 0x31f0
movq %rax, -0x58(%rbp)
jmp 0x4b3f
movq -0x58(%rbp), %rdi
leaq 0x126a1(%rip), %rsi     # 0x171eb
callq 0x3220
jmp 0x4b51
leaq -0x30(%rbp), %rdi
callq 0x3150
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4af9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3150
jmp 0x4ba3
movq 0x1b445(%rip), %rdi     # 0x1ffc8
movq 0x1b426(%rip), %rsi     # 0x1ffb0
callq 0x3260
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4ae8
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x33f0
nopl (%rax)
// File: nachogoro[P]wordcrack-herminia/src/Dictionary.cpp
// Function: Dictionary::Dictionary(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Dictionary::Dictionary(const std::string& fileName)
{
    std::ifstream infile(fileName);

    std::string line;
    while (std::getline(infile, line))
    {
        mDict.insert(line);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq %rdi, -0x268(%rbp)
movq %rsi, -0x260(%rbp)
callq 0x31c0
movq -0x268(%rbp), %rdi
movq -0x260(%rbp), %rsi
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x258(%rbp)
movq %rdi, %rax
movq %rax, -0x250(%rbp)
callq 0xadd0
movq -0x10(%rbp), %rsi
leaq -0x218(%rbp), %rdi
movl $0x8, %edx
callq 0x3370
jmp 0xa545
leaq -0x248(%rbp), %rdi
callq 0x3300
leaq -0x218(%rbp), %rdi
leaq -0x248(%rbp), %rsi
callq 0x3060
movq %rax, -0x270(%rbp)
jmp 0xa56d
movq -0x270(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x32b0
movb %al, -0x271(%rbp)
jmp 0xa58b
movb -0x271(%rbp), %al
testb $0x1, %al
jne 0xa597
jmp 0xa5ee
movq -0x250(%rbp), %rdi
leaq -0x248(%rbp), %rsi
callq 0xaef0
jmp 0xa5ac
jmp 0xa551
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0xa60f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x248(%rbp), %rdi
callq 0x3150
leaq -0x218(%rbp), %rdi
callq 0x3070
jmp 0xa60f
leaq -0x248(%rbp), %rdi
callq 0x3150
leaq -0x218(%rbp), %rdi
callq 0x3070
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
movq -0x258(%rbp), %rdi
callq 0xa6b0
movq -0x220(%rbp), %rdi
callq 0x33f0
nopw (%rax,%rax)
// File: nachogoro[P]wordcrack-herminia/src/Trie.cpp
// Function: Trie::recursiveFindNode(TrieNode*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
TrieNode* Trie::recursiveFindNode(TrieNode* parent, const std::string& word) const
{
    if (parent->word == word)
    {
        return parent;
    }

    size_t parentLength = parent->word.size();
    std::string prefix = word.substr(0, parentLength+1);

    auto nextNode = findNodeInSetStartingWith(parent->childrenWords, prefix);

    if (nextNode != parent->childrenWords.end())
    {
        return recursiveFindNode(nextNode->get(), word);
    }
    else
    {
        return NULL;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x90(%rbp)
movq %rsi, -0x88(%rbp)
movq %rdx, -0x80(%rbp)
callq 0x31c0
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xbd50
testb $0x1, %al
jne 0xb39b
jmp 0xb3a8
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xb48d
movq -0x18(%rbp), %rdi
callq 0x3180
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rcx
incq %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x48(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x3240
movq -0xa0(%rbp), %rsi
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0xb290
movq %rax, -0x98(%rbp)
jmp 0xb3f1
movq -0x98(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0xbe60
movq %rax, -0x68(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xc0d0
testb $0x1, %al
jne 0xb420
jmp 0xb475
leaq -0x50(%rbp), %rdi
callq 0xc0a0
movq %rax, %rdi
callq 0xbd10
movq -0x78(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0xb340
movq %rax, -0xa8(%rbp)
jmp 0xb44a
movq -0xa8(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x6c(%rbp)
jmp 0xb484
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3150
jmp 0xb49a
movq $0x0, -0x8(%rbp)
movl $0x1, -0x6c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3150
movq -0x8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x33f0
nopw %cs:(%rax,%rax)
// File: nachogoro[P]wordcrack-herminia/src/main.cpp
// Function: findAllWords(Board, Dictionary const&, std::map<Word, int, std::less<Word>, std::allocator<std::pair<Word const, int>>>&)
void findAllWords(
        Board board, const Dictionary& dict,
        std::map<Word, int>& results)
{
    for (int row = 0; row < VERTICAL_SIZE; ++row)
    {
        for (int col = 0; col < HORIZONTAL_SIZE; ++col)
        {
            Coordinate coord(col, row);
            Word word;
            word.addLetter(board.letterAt(coord));
            processNewWord(board, dict, results, coord, word);
            word.removeLastLetter();
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rdi, -0x1f0(%rbp)
movq %rsi, -0x1e8(%rbp)
movq %rdx, -0x1e0(%rbp)
callq 0x31c0
movq -0x1f0(%rbp), %rdi
movq -0x1e8(%rbp), %rsi
movq -0x1e0(%rbp), %rdx
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
jge 0xea01
movl $0x0, -0x20(%rbp)
cmpl $0x4, -0x20(%rbp)
jge 0xe9f1
movl -0x20(%rbp), %esi
movl -0x1c(%rbp), %edx
leaq -0x28(%rbp), %rdi
movq %rdi, -0x200(%rbp)
callq 0x4cf0
leaq -0xf8(%rbp), %rdi
callq 0x3bf0
movq -0x1f0(%rbp), %rdi
movq -0x200(%rbp), %rsi
callq 0x48b0
movq %rax, -0x1f8(%rbp)
jmp 0xe916
movq -0x1f8(%rbp), %rsi
leaq -0xf8(%rbp), %rdi
callq 0x3cd0
jmp 0xe92b
movq -0x10(%rbp), %rax
movq %rax, -0x210(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x208(%rbp)
leaq -0x1d8(%rbp), %rdi
leaq -0xf8(%rbp), %rsi
callq 0x11100
jmp 0xe956
movq -0x208(%rbp), %rdx
movq -0x210(%rbp), %rsi
movq -0x1f0(%rbp), %rdi
leaq -0x28(%rbp), %rcx
leaq -0x1d8(%rbp), %r8
callq 0xed90
jmp 0xe97d
leaq -0x1d8(%rbp), %rdi
callq 0x111d0
leaq -0xf8(%rbp), %rdi
callq 0x3da0
jmp 0xe997
leaq -0xf8(%rbp), %rdi
callq 0x111d0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xe8ce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x100(%rbp)
movl %eax, -0x104(%rbp)
jmp 0xe9e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x100(%rbp)
movl %eax, -0x104(%rbp)
leaq -0x1d8(%rbp), %rdi
callq 0x111d0
leaq -0xf8(%rbp), %rdi
callq 0x111d0
jmp 0xea0a
jmp 0xe9f3
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xe8bd
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
movq -0x100(%rbp), %rdi
callq 0x33f0
nopw %cs:(%rax,%rax)
// File: nachogoro[P]wordcrack-herminia/src/main.cpp
// Function: verifyWord(Board&, Dictionary const&, std::map<Word, int, std::less<Word>, std::allocator<std::pair<Word const, int>>>&, Coordinate const&, Word)
void verifyWord(Board& board, const Dictionary& dict, std::map<Word, int>& results, const Coordinate& coord, Word word)
{
    if (coord.isValid() && board.isAvailable(coord)) {
        word.addLetter(board.letterAt(coord));
        if (dict.wordExists(word.currentWord())) {
            resultFound(results, word);
        }

        if (dict.moreWordsBeginningWith(word.currentWord())) {
            processNewWord(board, dict, results, coord, word);
        }
        word.removeLastLetter();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x170(%rbp)
movq %rsi, -0x168(%rbp)
movq %rdx, -0x160(%rbp)
movq %rcx, -0x158(%rbp)
movq %r8, -0x150(%rbp)
callq 0x31c0
movq -0x170(%rbp), %rdi
movq -0x168(%rbp), %rsi
movq -0x160(%rbp), %rdx
movq -0x158(%rbp), %rcx
movq -0x150(%rbp), %r8
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x116a0
testb $0x1, %al
jne 0xf63c
jmp 0xf7fc
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4920
testb $0x1, %al
jne 0xf652
jmp 0xf7fc
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x48b0
movq -0x150(%rbp), %rdi
movq %rax, %rsi
callq 0x3cd0
movq -0x150(%rbp), %rsi
movq -0x10(%rbp), %rax
movq %rax, -0x188(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x180(%rbp)
callq 0x5490
movq -0x188(%rbp), %rdi
movq -0x180(%rbp), %rsi
callq 0xa630
movb %al, -0x171(%rbp)
jmp 0xf6ab
leaq -0x48(%rbp), %rdi
callq 0x3150
movb -0x171(%rbp), %al
testb $0x1, %al
jne 0xf6c0
jmp 0xf6ec
movq -0x150(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0xf350
jmp 0xf6ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3150
jmp 0xf805
movq -0x150(%rbp), %rsi
movq -0x10(%rbp), %rax
movq %rax, -0x1a0(%rbp)
leaq -0x78(%rbp), %rdi
movq %rdi, -0x198(%rbp)
callq 0x5490
movq -0x1a0(%rbp), %rdi
movq -0x198(%rbp), %rsi
callq 0xa670
movb %al, -0x189(%rbp)
jmp 0xf729
leaq -0x78(%rbp), %rdi
callq 0x3150
movb -0x189(%rbp), %al
testb $0x1, %al
jne 0xf741
jmp 0xf7f0
movq -0x150(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x1c8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1c0(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x1b8(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x1b0(%rbp)
leaq -0x148(%rbp), %rdi
movq %rdi, -0x1a8(%rbp)
callq 0x11100
movq -0x1c8(%rbp), %rdi
movq -0x1c0(%rbp), %rsi
movq -0x1b8(%rbp), %rdx
movq -0x1b0(%rbp), %rcx
movq -0x1a8(%rbp), %r8
callq 0xed90
jmp 0xf7b1
leaq -0x148(%rbp), %rdi
callq 0x111d0
jmp 0xf7f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x3150
jmp 0xf805
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x148(%rbp), %rdi
callq 0x111d0
jmp 0xf805
movq -0x150(%rbp), %rdi
callq 0x3da0
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x33f0
nop
// File: nachogoro[P]wordcrack-herminia/src/Board.h
// Function: Coordinate::isValid() const
bool isValid() const
        {
            return x() >= 0 &&
                x() < HORIZONTAL_SIZE &&
                y() >= 0 && 
                y() < VERTICAL_SIZE;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x20(%rbp)
callq 0x31c0
movq -0x20(%rbp), %rdi
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x5360
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x9(%rbp)
jl 0x1170e
movq -0x18(%rbp), %rdi
callq 0x5360
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x4, %ecx
movb %al, -0x9(%rbp)
jge 0x1170e
movq -0x18(%rbp), %rdi
callq 0x5390
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x9(%rbp)
jl 0x1170e
movq -0x18(%rbp), %rdi
callq 0x5390
cmpl $0x4, %eax
setl %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: lemire[P]backward_multiplication/unit/basictests.cpp
// Function: print(std::vector<unsigned long, std::allocator<unsigned long>> const&)
void print(const std::vector<uint64_t> &b) {
  if (b.size() == 0)
    return;
  for (size_t i = b.size() - 1; i != SIZE_MAX; i--) {
    std::cout << std::hex << std::setfill('0') << std::setw(8) << b[i];
    std::cout << " ";
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x2bd0
cmpq $0x0, %rax
jne 0x1b9e
jmp 0x1c5a
movq 0x30(%rsp), %rdi
callq 0x2bd0
subq $0x1, %rax
movq %rax, 0x28(%rsp)
cmpq $-0x1, 0x28(%rsp)
je 0x1c5a
movq 0x640c(%rip), %rdi      # 0x7fd0
leaq 0x1025(%rip), %rsi      # 0x2bf0
callq 0x1060
movq %rax, 0x8(%rsp)
movl $0x30, %edi
callq 0x2c10
movq 0x8(%rsp), %rdi
movb %al, 0x27(%rsp)
movzbl 0x27(%rsp), %esi
callq 0x1160
movq %rax, 0x10(%rsp)
movl $0x8, %edi
callq 0x2c30
movq 0x10(%rsp), %rdi
movl %eax, 0x20(%rsp)
movl 0x20(%rsp), %esi
callq 0x1130
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x2c50
movq 0x18(%rsp), %rdi
movq (%rax), %rsi
callq 0x1040
movq 0x6395(%rip), %rdi      # 0x7fd0
leaq 0x343e(%rip), %rsi      # 0x5080
callq 0x10f0
movq 0x28(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x1bb1
addq $0x38, %rsp
retq
nop
// File: lemire[P]backward_multiplication/unit/basictests.cpp
// Function: main
int main() {
  if (unittest(false) && unittest(true)) {
    printf("Code looks good.\n");
    return EXIT_SUCCESS;
  }
  printf("Error detected.\n");
  return EXIT_FAILURE;
}

// Assembly:
pushq %rax
movl $0x0, 0x4(%rsp)
xorl %edi, %edi
callq 0x1c60
testb $0x1, %al
jne 0x2b16
jmp 0x2b3e
movl $0x1, %edi
callq 0x1c60
testb $0x1, %al
jne 0x2b26
jmp 0x2b3e
leaq 0x258b(%rip), %rdi      # 0x50b8
movb $0x0, %al
callq 0x1030
movl $0x0, 0x4(%rsp)
jmp 0x2b54
leaq 0x2585(%rip), %rdi      # 0x50ca
movb $0x0, %al
callq 0x1030
movl $0x1, 0x4(%rsp)
movl 0x4(%rsp), %eax
popq %rcx
retq
nopw (%rax,%rax)
// File: kdungs[P]codecon/src/matching.cc
// Function: distance(std::vector<double, std::allocator<double>> const&, std::vector<double, std::allocator<double>> const&)
double distance(const Row& lhs, const Row& rhs) {
  assert(lhs.size() == rhs.size());

  auto sqdists = Row{};
  sqdists.reserve(lhs.size());
  std::transform(
      std::begin(lhs), std::end(lhs), std::begin(rhs),
      std::back_inserter(sqdists),
      [](const double l, const double r) { return std::pow(l - r, 2); });
  return std::accumulate(std::begin(sqdists), std::end(sqdists), 0.0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4210
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4210
movq %rax, %rcx
movq -0x88(%rbp), %rax
cmpq %rcx, %rax
jne 0x23cd
jmp 0x23ec
leaq 0x6c30(%rip), %rdi      # 0x9004
leaq 0x6c42(%rip), %rsi      # 0x901d
movl $0xf, %edx
leaq 0x6c46(%rip), %rcx      # 0x902d
callq 0x2110
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x4230
movq -0x8(%rbp), %rdi
callq 0x4210
movq -0x90(%rbp), %rdi
movq %rax, %rsi
callq 0x4250
jmp 0x2425
movq -0x8(%rbp), %rdi
callq 0x4350
movq %rax, -0x98(%rbp)
jmp 0x2437
movq -0x98(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4380
movq %rax, -0xa0(%rbp)
jmp 0x2454
movq -0xa0(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4350
movq %rax, -0xa8(%rbp)
jmp 0x2471
movq -0xa8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x43b0
movq %rax, -0xb0(%rbp)
jmp 0x248e
movq -0xb0(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq -0x60(%rbp), %rcx
callq 0x2550
movq %rax, -0xb8(%rbp)
jmp 0x24b7
movq -0xb8(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4440
movq %rax, -0xc0(%rbp)
jmp 0x24d4
movq -0xc0(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4470
movq %rax, -0xc8(%rbp)
jmp 0x24f1
movq -0xc8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x78(%rbp), %rdi
movq -0x80(%rbp), %rsi
xorps %xmm0, %xmm0
callq 0x43e0
movsd %xmm0, -0xd0(%rbp)
jmp 0x2516
leaq -0x30(%rbp), %rdi
callq 0x44a0
movsd -0xd0(%rbp), %xmm0
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x44a0
movq -0x38(%rbp), %rdi
callq 0x2230
nop
// File: kdungs[P]codecon/src/matching.cc
// Function: parseRow(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Row parseRow(const std::string& str) {
  auto row = Row{};
  std::stringstream ss{str};
  std::string tmp;
  while (getline(ss, tmp, ',')) {
    row.push_back(std::stod(tmp));
  }
  return row;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rdi, -0x1f8(%rbp)
movq %rdi, %rax
movq %rax, -0x1f0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x4230
movq -0x10(%rbp), %rax
movq %rax, -0x1e8(%rbp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x4500
movl %eax, -0x1dc(%rbp)
jmp 0x265d
movl -0x1dc(%rbp), %edx
movq -0x1e8(%rbp), %rsi
leaq -0x1a0(%rbp), %rdi
callq 0x21f0
jmp 0x2678
leaq -0x1d0(%rbp), %rdi
callq 0x21b0
leaq -0x1a0(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
movl $0x2c, %edx
callq 0x2240
movq %rax, -0x200(%rbp)
jmp 0x26a5
movq -0x200(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2180
movb %al, -0x201(%rbp)
jmp 0x26c3
movb -0x201(%rbp), %al
testb $0x1, %al
jne 0x26d2
jmp 0x2756
xorl %eax, %eax
movl %eax, %esi
leaq -0x1d0(%rbp), %rdi
callq 0x4550
movsd %xmm0, -0x210(%rbp)
jmp 0x26ec
movq -0x1f8(%rbp), %rdi
movsd -0x210(%rbp), %xmm0
movsd %xmm0, -0x1d8(%rbp)
leaq -0x1d8(%rbp), %rsi
callq 0x4520
jmp 0x2711
jmp 0x2684
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x2794
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x2100
leaq -0x1a0(%rbp), %rdi
callq 0x2120
jmp 0x2794
movb $0x1, -0x11(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x2100
leaq -0x1a0(%rbp), %rdi
callq 0x2120
testb $0x1, -0x11(%rbp)
jne 0x2784
movq -0x1f8(%rbp), %rdi
callq 0x44a0
movq -0x1f0(%rbp), %rax
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
movq -0x1f8(%rbp), %rdi
callq 0x44a0
movq -0x1a8(%rbp), %rdi
callq 0x2230
nopl (%rax)
// File: dadocolussi[P]gdc-circular_queue/src/gdc_circular_queue.hpp
// Function: gdc::circular_queue<char>::available() const
size_type available() const noexcept
		{
			auto rp = _q.rpos.load(std::memory_order_relaxed);
			auto wp = _q.wpos.load(std::memory_order_relaxed);
			size_t n;
			
			if (wp >= rp)
			{
				// _____xxxxx_____
				//      ^    ^
				//     rp    wp
				//
				// Scenario 2 (empty):
				// _______________
				//      ^
				//    wp==rp
				n = wp - rp;
			}
			else
			{
				// xxxxx_____xxxxx
				//      ^    ^
				//     wp    rp
				n = capacity() + wp - rp;
			}
			
			assert(n < capacity());
			
			return n;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x68(%rbp)
movq %rax, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movl -0xc(%rbp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x68c40
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x54(%rbp)
decl %eax
subl $0x2, %eax
jb 0x77520
jmp 0x77509
movl -0x54(%rbp), %eax
subl $0x5, %eax
je 0x7752d
jmp 0x77513
movq -0x60(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x77538
movq -0x60(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x77538
movq -0x60(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x68(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0x40(%rbp)
addq $0x40, %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x78(%rbp)
movl -0x24(%rbp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x68c40
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x6c(%rbp)
decl %eax
subl $0x2, %eax
jb 0x77591
jmp 0x7757a
movl -0x6c(%rbp), %eax
subl $0x5, %eax
je 0x7759e
jmp 0x77584
movq -0x78(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x775a9
movq -0x78(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x775a9
movq -0x78(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x40(%rbp), %rax
jb 0x775c9
movq -0x48(%rbp), %rax
subq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
jmp 0x775de
movq -0x68(%rbp), %rdi
callq 0x68c60
addq -0x48(%rbp), %rax
subq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x68(%rbp), %rdi
movq -0x50(%rbp), %rax
movq %rax, -0x80(%rbp)
callq 0x68c60
movq %rax, %rcx
movq -0x80(%rbp), %rax
cmpq %rcx, %rax
jae 0x775fd
jmp 0x7761c
leaq 0xb8fc(%rip), %rdi      # 0x82f00
leaq 0xaa9c(%rip), %rsi      # 0x820a7
movl $0xae, %edx
leaq 0xb8f8(%rip), %rcx      # 0x82f0f
callq 0xe440
movq -0x50(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/examples/variadic3.cc
// Function: main
int main()
{
	// no braces, so calls variadic version of min_elem
	cout << min_elem(1.0,2,3,4.5,0.0,5,6,7,8,9) << endl;
	// calls min_element that takes a single argument
	// of type initializer_list<int>
	cout << min_elem({1,2,3,4,0,5,6,7,8,9}) << endl;

	int i = 5;
	cout << bigger(i, {1,2,3,4,0,5,6,7,8,9}) << endl;

	string s = "how now brown cow";
	print(cout, i, s, 42);  // two parameters in the pack
	print(cout, i, s);      // one parameter in the pack
	print(cout, i);         // no parameters in the pack
	cout << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movl $0x0, -0x4(%rbp)
movq %rsp, %rax
movl $0x9, (%rax)
movsd 0x1c65(%rip), %xmm0     # 0x4008
movl $0x2, %edi
movl $0x3, %esi
movsd 0x1c5b(%rip), %xmm1     # 0x4010
xorps %xmm2, %xmm2
movl $0x5, %edx
movl $0x6, %ecx
movl $0x7, %r8d
movl $0x8, %r9d
callq 0x25e0
movq 0x3bfe(%rip), %rdi      # 0x5fd8
movq %rdi, -0xd0(%rbp)
callq 0x21f0
movq %rax, %rdi
movq 0x3bd0(%rip), %rsi      # 0x5fc0
movq %rsi, -0xc8(%rbp)
callq 0x20f0
movabsq $0x900000008, %rax      # imm = 0x900000008
movq %rax, -0xd8(%rbp)
movq %rax, -0x20(%rbp)
movups 0x1c10(%rip), %xmm0     # 0x4028
movaps %xmm0, -0x30(%rbp)
movups 0x1bf5(%rip), %xmm0     # 0x4018
movaps %xmm0, -0x40(%rbp)
leaq -0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
movq $0xa, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2680
movq -0xd0(%rbp), %rdi
movl %eax, %esi
callq 0x21b0
movq -0xc8(%rbp), %rsi
movq %rax, %rdi
callq 0x20f0
movq -0xd8(%rbp), %rax
movl $0x5, -0x44(%rbp)
movq %rax, -0x60(%rbp)
movups 0x1bd6(%rip), %xmm0     # 0x4050
movaps %xmm0, -0x70(%rbp)
movups 0x1bbb(%rip), %xmm0     # 0x4040
movaps %xmm0, -0x80(%rbp)
leaq -0x80(%rbp), %rax
movq %rax, -0x58(%rbp)
movq $0xa, -0x50(%rbp)
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
leaq -0x44(%rbp), %rdi
callq 0x2730
movq -0xd0(%rbp), %rdi
movzbl %al, %esi
callq 0x21e0
movq -0xc8(%rbp), %rsi
movq %rax, %rdi
callq 0x20f0
leaq -0xa1(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x21d0
movq -0xc0(%rbp), %rdx
leaq 0x1b7f(%rip), %rsi      # 0x4068
leaq -0xa0(%rbp), %rdi
callq 0x2160
jmp 0x24f7
leaq -0xa1(%rbp), %rdi
callq 0x2100
movl $0x2a, -0xb8(%rbp)
movq 0x3ac4(%rip), %rdi      # 0x5fd8
leaq -0x44(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
leaq -0xb8(%rbp), %rcx
callq 0x27c0
jmp 0x252d
movq 0x3aa4(%rip), %rdi      # 0x5fd8
leaq -0x44(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
callq 0x2810
jmp 0x2546
movq 0x3a8b(%rip), %rdi      # 0x5fd8
leaq -0x44(%rbp), %rsi
callq 0x2860
jmp 0x2558
movq 0x3a79(%rip), %rdi      # 0x5fd8
movq 0x3a5a(%rip), %rsi      # 0x5fc0
callq 0x20f0
jmp 0x256d
movl $0x0, -0x4(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x20a0
movl -0x4(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xa1(%rbp), %rdi
callq 0x2100
jmp 0x25ca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb0(%rbp)
movl %eax, -0xb4(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x20a0
movq -0xb0(%rbp), %rdi
callq 0x21c0
nopw %cs:(%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/examples/variadic3.cc
// Function: int min_elem<int>(std::initializer_list<int>)
T min_elem(initializer_list<T> il)
{
	if (il.size() == 0)
		throw "empty";
	auto b = il.begin();      // we know there's at least one element in the list
	T ret(*b++);              // start off with the first element as the ``smallest''
	while (b != il.end())     // till we run out of elements
		ret = min(ret, *b++); // update ret if we find a smaller value
	return ret;               // return the value we found
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x2b90
cmpq $0x0, %rax
jne 0x26c6
movl $0x8, %edi
callq 0x2080
movq %rax, %rdi
leaq 0x19c7(%rip), %rax      # 0x407a
movq %rax, (%rdi)
movq 0x390b(%rip), %rsi      # 0x5fc8
xorl %eax, %eax
movl %eax, %edx
callq 0x21a0
leaq -0x10(%rbp), %rdi
callq 0x2bb0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x18(%rbp)
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x2bd0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
je 0x2723
movq -0x18(%rbp), %rsi
movq %rsi, %rax
addq $0x4, %rax
movq %rax, -0x18(%rbp)
leaq -0x1c(%rbp), %rdi
callq 0x2c10
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
jmp 0x26e7
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/examples/variadic3.cc
// Function: bool bigger<int>(int const&, std::initializer_list<int>)
bool bigger(const T& t, initializer_list<T> il)
{
	if (il.size() == 0)
		return false;
	auto b = il.begin();
	while (b != il.end())
		if (t < *b)
			return true;
		else
			++b;
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x2b90
cmpq $0x0, %rax
jne 0x2759
movb $0x0, -0x1(%rbp)
jmp 0x27a9
leaq -0x18(%rbp), %rdi
callq 0x2bb0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x2bd0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
je 0x27a5
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x2797
movb $0x1, -0x1(%rbp)
jmp 0x27a9
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
jmp 0x2766
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/exprtk_simple_example_14.cpp
// Function: void stddev_example<double>()
void stddev_example()
{
   typedef exprtk::expression<T> expression_t;
   typedef exprtk::parser<T>     parser_t;

   const std::string stddev_program =
      " var x[25] := {                     "
      "                 1,  2,  3,  4,  5, "
      "                 6,  7,  8,  9, 10, "
      "                11, 12, 13, 14, 15, "
      "                16, 17, 18, 19, 20, "
      "                21, 22, 23, 24, 25  "
      "              };                    "
      "                                    "
      " sqrt(sum([x - avg(x)]^2) / x[])    ";

   expression_t expression;

   parser_t parser;
   parser.compile(stddev_program,expression);

   const T stddev = expression.value();

   printf("stddev(1..25) = %10.6f\n",stddev);
}

// Assembly:
subq $0xae8, %rsp            # imm = 0xAE8
leaq 0xac7(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x111640
movq 0x8(%rsp), %rdx
leaq 0x32dd10(%rip), %rsi    # 0x446535
leaq 0xac8(%rsp), %rdi
callq 0x118740
jmp 0x118834
leaq 0xac7(%rsp), %rdi
callq 0x111760
leaq 0xa90(%rsp), %rdi
callq 0x118c60
jmp 0x118850
leaq 0x18(%rsp), %rdi
movl $0x7f, %esi
callq 0x118d10
jmp 0x118861
leaq 0x168(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x118e40
jmp 0x118875
leaq 0x18(%rsp), %rdi
callq 0x119670
leaq 0x168(%rsp), %rdi
leaq 0xac8(%rsp), %rsi
leaq 0xa90(%rsp), %rdx
callq 0x1196e0
jmp 0x11889e
leaq 0xa90(%rsp), %rdi
callq 0x119f70
movsd %xmm0, (%rsp)
jmp 0x1188b2
movsd (%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
leaq 0x32ddb0(%rip), %rdi    # 0x44667a
movb $0x1, %al
callq 0x111080
jmp 0x1188d3
leaq 0x168(%rsp), %rdi
callq 0x119f90
leaq 0xa90(%rsp), %rdi
callq 0x11a190
leaq 0xac8(%rsp), %rdi
callq 0x111778
addq $0xae8, %rsp            # imm = 0xAE8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xab8(%rsp)
movl %eax, 0xab4(%rsp)
leaq 0xac7(%rsp), %rdi
callq 0x111760
jmp 0x1189af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xab8(%rsp)
movl %eax, 0xab4(%rsp)
jmp 0x1189a2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xab8(%rsp)
movl %eax, 0xab4(%rsp)
jmp 0x118995
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xab8(%rsp)
movl %eax, 0xab4(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x119670
jmp 0x118995
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xab8(%rsp)
movl %eax, 0xab4(%rsp)
leaq 0x168(%rsp), %rdi
callq 0x119f90
leaq 0xa90(%rsp), %rdi
callq 0x11a190
leaq 0xac8(%rsp), %rdi
callq 0x111778
movq 0xab8(%rsp), %rdi
callq 0x111440
nopl (%rax)