// File: /workspace/github_cpp_makefile_star2_O2/Luthaf[P]zeopp/networkstorage.cc
// Function: substituteAtoms(ATOM_NETWORK*, ATOM_NETWORK*, bool, int*, bool)
bool substituteAtoms(ATOM_NETWORK *origNet, ATOM_NETWORK *newNet,
                     bool substituteSeed, int *numSubstitutions, bool radial){
    int numAtoms = origNet->numAtoms;
    double max_bond_length = 1.95;
    
    vector< vector<int> > bonds = vector< vector<int> >(numAtoms, vector<int>());
    for(int i = 0; i < numAtoms; i++){
        ATOM atom_one = origNet->atoms[i];
        for(int j = i + 1; j < numAtoms; j++){
            ATOM atom_two = origNet->atoms[j];
            if(origNet->calcDistance(atom_one, atom_two) < max_bond_length){
                if(atom_one.type.compare(atom_two.type) == 0){
                    cerr << "Atomic network substitution aborted because atoms of same type "
                    "are bonded to one another" << "\n" << "Occurred for type "
                    << atom_one.type << " between atoms " << i << " and " << j << "\n";
                    return false;
                }
                bonds[i].push_back(j);
                bonds[j].push_back(i);
            }
        }
    }
    
    for(int i = 0; i < numAtoms; i++){
        if(origNet->atoms[i].type.compare("Si") == 0){
            if(bonds[i].size() != 4){
                cerr << "Atomic network substitution aborted because Si atom bonded to "
                << bonds[i].size() << " other atoms instead of 4" << "\n"
                << "Occurred for atom " << i << "\n";
                return false;
            }
        }
        else if(origNet->atoms[i].type.compare("O") == 0){
            if(bonds[i].size() != 2){
                cerr << "Atomic network substitution aborted because O atom bonded to "
                << bonds[i].size() << " other atoms instead of 2" << "\n"
                << "Occurred for atom " << i << "\n";
                return false;
            }
        }
        else{
            cerr << "Atomic network substitution aborted because atom type other than "
            "Si or O detected" << "\n" << "Occurred for atom " << i << "\n";
            return false;
        }
    }
    
    int firstSiID = -1;
    for(int i = 0; i < numAtoms; i++){
        if(origNet->atoms[i].type.compare("Si") == 0){
            firstSiID = i;
            break;
        }
    }
    
    if(firstSiID == -1){
        cerr << "Error: Atom substitution failed because structure does not "
        "contain any Si atoms \n";
        return false;
    }
    
    vector<bool> atomProc = vector<bool>(numAtoms, false); // Whether atom has been processed
    vector<bool> atomSubs = vector<bool>(numAtoms, false); // Whether atom has been substituted
    int numProc = 0; // Number of processed atoms
    
    vector< pair<int, bool> > atomsToProcess; // Stack of atom/substituion info
    vector<int> fromIDs; // Stack of where each atom/subst came from
    
    pair<int, bool> seed(firstSiID, substituteSeed);
    atomsToProcess.push_back(seed);  // Seed with the first Si atom and not substituting it
    fromIDs.push_back(-1); // Starting node
    
    while(atomsToProcess.size() != 0){
        pair<int, bool> atomInfo = atomsToProcess.back(); atomsToProcess.pop_back();
        int id = atomInfo.first; bool subst = atomInfo.second;
        int fromID = fromIDs.back(); fromIDs.pop_back();
        
        // Atom previously processed. Ensure that atom substitution agrees with previous results for Si atoms
        if(atomProc[id] ){
            if((origNet->atoms[id].type.compare("Si") == 0) && (atomSubs[id] != subst)){
                cerr << "Atomic network substitution aborted because every other Si atom "
                "substitution criteria failed" << "\n";
                return false;
            }
        }
        // First time atom is processed
        else {
            numProc++;
            // Mark atom as processed
            atomProc[id] = true;
            
            // If oxygen, should not be substituted but reverse substituion state for next set of Si atoms
            if(origNet->atoms[id].type.compare("O") == 0){
                atomSubs[id] = false;
                subst = !subst;
            }
            // If silicon, pass on substitution state to oxygen atoms, who will then reverse it
            // Record substitution status
            else if(origNet->atoms[id].type.compare("Si") == 0){
                atomSubs[id] = subst;
            }
            // Invalid type
            else {
                cerr << "Atomic network substitution aborted because atom type other than Si or O detected" << "\n"
                << "Occurred for atom " << id << "\n";
                return false;
            }
            
            // Added bonded atoms to stack with appropriate subsitution state
            for(unsigned int j = 0; j < bonds[id].size(); j++){
                if(bonds[id][j] != fromID){
                    atomsToProcess.push_back(pair<int, bool>(bonds[id][j], subst));
                    fromIDs.push_back(id);
                }
            }
        }
    }
    
    if(numProc != numAtoms){
        cerr << "Atom network substituion failed because not all atoms are interconnected" << "\n"
        << "Visited " << numProc << " out of " << numAtoms << " atoms " << "\n";
        return false;
    }
    
    // Perform final consistency check
    for(int i = 0; i < numAtoms; i++){
        // Just check pair of atoms bonded to each oxygen
        if(origNet->atoms[i].type.compare("O") == 0){
            if(atomSubs[bonds[i][0]] && atomSubs[bonds[i][1]]){
                cerr << "Atom network substitution failed final consistency check." << "\n"
                << "Oxygen atom #" << i << " is bound to atoms " <<  bonds[i][0] << " and " << bonds[i][1] << " which are of same type. " << "\n"
                << "Algorithmic issue likely." << "\n"
                << "Please contact the source code provider" << "\n";
                return false;
            }
        }
    }
    
    // Copy original information
    origNet->copy(newNet);
    
    // Change atoms that should be subsituted
    *numSubstitutions = 0;
    for(int i = 0; i < numAtoms; i++){
        if(atomSubs[i]){
            newNet->atoms[i].type   = "Al";
            newNet->atoms[i].radius = lookupRadius("Al", radial);
            (*numSubstitutions)++;
        }
    }
    
    // Successful substitution
    return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
movl %r8d, 0x74(%rsp)
movq %rcx, 0x78(%rsp)
movl %edx, 0xc(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdi, %r15
movslq 0x110(%rdi), %rsi
xorpd %xmm0, %xmm0
leaq 0x120(%rsp), %rdx
movapd %xmm0, (%rdx)
andq $0x0, 0x10(%rdx)
leaq 0x38(%rsp), %rdi
leaq 0x88(%rsp), %rcx
movq %rsi, %r13
callq 0x4b956
leaq 0x120(%rsp), %r14
movq %r14, %rdi
callq 0xb290
xorl %eax, %eax
leaq 0x20(%rsp), %rbp
leaq 0x88(%rsp), %rbx
leaq 0x50(%rsp), %r12
movl %eax, 0x20(%rsp)
cmpl %r13d, %eax
jge 0x41517
cltq
imulq $0x98, %rax, %rsi
addq 0x2f0(%r15), %rsi
movq %r14, %rdi
callq 0xa75c
movq %rbp, %rax
movslq (%rax), %rax
incq %rax
movl %eax, 0x50(%rsp)
cmpl %r13d, %eax
jge 0x41444
imulq $0x98, %rax, %rsi
addq 0x2f0(%r15), %rsi
movq %rbx, %rdi
callq 0xa75c
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3f612
movsd 0xc02f7(%rip), %xmm1    # 0x1016e0
ucomisd %xmm0, %xmm1
jbe 0x41434
leaq 0x160(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0x4040
testl %eax, %eax
je 0x41457
movslq 0x20(%rsp), %rax
imulq $0x18, %rax, %rdi
addq 0x38(%rsp), %rdi
movq %r12, %rsi
callq 0x9434
movslq 0x50(%rsp), %rax
imulq $0x18, %rax, %rdi
addq 0x38(%rsp), %rdi
movq %rbp, %rsi
callq 0x9434
movq %rbx, %rdi
callq 0xa808
movq %r12, %rax
jmp 0x413aa
movq %r14, %rdi
callq 0xa808
movl 0x20(%rsp), %eax
incl %eax
jmp 0x41382
movq 0x10eb92(%rip), %rdi    # 0x14fff0
leaq 0xc05c6(%rip), %rsi     # 0x101a2b
callq 0x4480
leaq 0xc110d(%rip), %rsi     # 0x10257e
movq %rax, %rdi
callq 0x4480
leaq 0xc0604(%rip), %rsi     # 0x101a84
movq %rax, %rdi
callq 0x4480
movq %rax, %rdi
leaq 0x160(%rsp), %rsi
callq 0x43f0
leaq 0xc05f8(%rip), %rsi     # 0x101a97
movq %rax, %rdi
callq 0x4480
movl 0x20(%rsp), %esi
movq %rax, %rdi
callq 0x4760
leaq 0xc227a(%rip), %rsi     # 0x103734
movq %rax, %rdi
callq 0x4480
movl 0x50(%rsp), %esi
movq %rax, %rdi
callq 0x4760
leaq 0xc10a9(%rip), %rsi     # 0x10257e
movq %rax, %rdi
callq 0x4480
leaq 0x88(%rsp), %rdi
callq 0xa808
leaq 0x120(%rsp), %rdi
callq 0xa808
xorl %ebx, %ebx
leaq 0x38(%rsp), %rdi
callq 0xad7e
movl %ebx, %eax
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ebx, %ebx
movq %r13, %rax
testl %eax, %eax
movl $0x0, %ecx
cmovgl %eax, %ecx
movq %rcx, 0x10(%rsp)
pushq $0x8
popq %r12
pushq $0x40
popq %r14
leaq 0xbb2b1(%rip), %rbp     # 0xfc7eb
cmpq %rbx, 0x10(%rsp)
je 0x415af
movq 0x2f0(%r15), %rdi
addq %r14, %rdi
movq %rbp, %rsi
callq 0x4190
testl %eax, %eax
je 0x41587
movq 0x2f0(%r15), %rdi
addq %r14, %rdi
leaq 0xbb278(%rip), %rsi     # 0xfc7e0
callq 0x4190
testl %eax, %eax
jne 0x415e9
movq 0x38(%rsp), %rax
movq (%rax,%r12), %rcx
subq -0x8(%rax,%r12), %rcx
cmpq $0x8, %rcx
je 0x4159f
jmp 0x415fc
movq 0x38(%rsp), %rax
movq (%rax,%r12), %rcx
subq -0x8(%rax,%r12), %rcx
cmpq $0x10, %rcx
jne 0x41892
incq %rbx
addq $0x18, %r12
addq $0x98, %r14
jmp 0x4153a
pushq $0x40
popq %r12
xorl %r14d, %r14d
leaq 0xbb22e(%rip), %rbx     # 0xfc7eb
movq %r13, %rbp
cmpq %r14, 0x10(%rsp)
je 0x41638
movq 0x2f0(%r15), %rdi
addq %r12, %rdi
movq %rbx, %rsi
callq 0x4190
testl %eax, %eax
je 0x41650
incq %r14
addq $0x98, %r12
jmp 0x415c0
movq 0x10ea00(%rip), %rdi    # 0x14fff0
leaq 0xc0574(%rip), %rsi     # 0x101b6b
jmp 0x418c9
movq 0x10e9ed(%rip), %rdi    # 0x14fff0
leaq 0xc0509(%rip), %rsi     # 0x101b13
callq 0x4480
movq 0x38(%rsp), %rcx
movq (%rcx,%r12), %rsi
subq -0x8(%rcx,%r12), %rsi
sarq $0x2, %rsi
movq %rax, %rdi
callq 0x42e0
movq %rax, %rdi
leaq 0xc051e(%rip), %rsi     # 0x101b51
jmp 0x418c9
movq 0x10e9b1(%rip), %rdi    # 0x14fff0
leaq 0xc0577(%rip), %rsi     # 0x101bbd
callq 0x4480
jmp 0x414f7
leaq 0x88(%rsp), %rdx
movb $0x0, (%rdx)
leaq 0x120(%rsp), %rdi
leaq 0x20(%rsp), %rcx
movq %rbp, %rsi
callq 0x2a0d6
leaq 0x20(%rsp), %rdx
movb $0x0, (%rdx)
leaq 0x88(%rsp), %rdi
leaq 0x50(%rsp), %rcx
movq %rbp, %rsi
callq 0x2a0d6
xorpd %xmm0, %xmm0
leaq 0x20(%rsp), %rdi
andq $0x0, 0x10(%rdi)
movapd %xmm0, (%rdi)
andq $0x0, 0x60(%rsp)
movapd %xmm0, 0x50(%rsp)
leaq 0x80(%rsp), %rsi
movl %r14d, (%rsi)
movl 0xc(%rsp), %eax
movb %al, 0x4(%rsi)
callq 0x4b9ac
leaq 0x18(%rsp), %rsi
orl $-0x1, (%rsi)
leaq 0x50(%rsp), %rdi
callq 0x10324
movl $0x0, 0xc(%rsp)
leaq 0x120(%rsp), %rbp
leaq 0x8(%rsp), %r14
movq 0x28(%rsp), %rax
cmpq 0x20(%rsp), %rax
je 0x4190a
leaq -0x8(%rax), %rcx
movslq -0x8(%rax), %rsi
movb -0x4(%rax), %bl
movq %rcx, 0x28(%rsp)
movl %esi, 0x8(%rsp)
movq 0x58(%rsp), %rax
movl -0x4(%rax), %r12d
addq $-0x4, %rax
movq %rax, 0x58(%rsp)
movq %rbp, %rdi
callq 0x1043e
testq %rdx, (%rax)
je 0x4177e
movslq 0x8(%rsp), %rax
movq 0x2f0(%r15), %rcx
imulq $0x98, %rax, %rax
leaq (%rcx,%rax), %rdi
addq $0x40, %rdi
leaq 0xbb09d(%rip), %rsi     # 0xfc7eb
callq 0x4190
testl %eax, %eax
jne 0x416e9
movslq 0x8(%rsp), %rsi
leaq 0x88(%rsp), %rdi
callq 0x1043e
testq %rdx, (%rax)
sete %al
xorb %bl, %al
testb $0x1, %al
jne 0x416e9
jmp 0x41ac5
movslq 0x8(%rsp), %rsi
movq %rbp, %rdi
callq 0x1043e
movl %ebx, %ebp
andb $0x1, %bpl
orq %rdx, (%rax)
movslq 0x8(%rsp), %rax
movq 0x2f0(%r15), %rcx
imulq $0x98, %rax, %rax
leaq (%rcx,%rax), %rdi
addq $0x40, %rdi
leaq 0xbb02a(%rip), %rsi     # 0xfc7e0
callq 0x4190
movslq 0x8(%rsp), %rsi
testl %eax, %eax
je 0x4180a
movq 0x2f0(%r15), %rax
imulq $0x98, %rsi, %rcx
leaq (%rax,%rcx), %rdi
addq $0x40, %rdi
leaq 0xbb00a(%rip), %rsi     # 0xfc7eb
callq 0x4190
testl %eax, %eax
jne 0x41ada
movslq 0x8(%rsp), %rsi
leaq 0x88(%rsp), %rdi
callq 0x1043e
testb $0x1, %bl
je 0x41823
orq %rdx, (%rax)
jmp 0x41829
leaq 0x88(%rsp), %rdi
callq 0x1043e
notq %rdx
andq %rdx, (%rax)
xorb $0x1, %bpl
jmp 0x41829
notq %rdx
andq %rdx, (%rax)
incl 0xc(%rsp)
xorl %ebx, %ebx
movl %ebx, %ebx
movslq 0x8(%rsp), %rax
movq 0x38(%rsp), %rcx
imulq $0x18, %rax, %rdx
movq (%rcx,%rdx), %rax
movq 0x8(%rcx,%rdx), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %rbx, %rcx
jbe 0x41885
movl (%rax,%rbx,4), %eax
cmpl %r12d, %eax
je 0x41881
movl %eax, 0x18(%rsp)
movb %bpl, 0x1c(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x4cfb6
leaq 0x50(%rsp), %rdi
movq %r14, %rsi
callq 0x9434
incl %ebx
jmp 0x4182f
leaq 0x120(%rsp), %rbp
jmp 0x416e9
movq 0x10e757(%rip), %rdi    # 0x14fff0
leaq 0xc0207(%rip), %rsi     # 0x101aa7
callq 0x4480
movq 0x38(%rsp), %rcx
movq (%rcx,%r12), %rsi
subq -0x8(%rcx,%r12), %rsi
sarq $0x2, %rsi
movq %rax, %rdi
callq 0x42e0
movq %rax, %rdi
leaq 0xc021d(%rip), %rsi     # 0x101ae6
callq 0x4480
leaq 0xc0ca9(%rip), %rsi     # 0x10257e
movq %rax, %rdi
callq 0x4480
leaq 0xc021c(%rip), %rsi     # 0x101b00
movq %rax, %rdi
callq 0x4480
movq %rax, %rdi
movl %ebx, %esi
callq 0x4760
leaq 0xc0c81(%rip), %rsi     # 0x10257e
movq %rax, %rdi
callq 0x4480
jmp 0x414f7
movl 0xc(%rsp), %ebp
cmpl %r13d, %ebp
jne 0x4199c
imulq $0x18, 0x10(%rsp), %rbp
xorl %ebx, %ebx
pushq $0x40
popq %r13
leaq 0xbaeb6(%rip), %r14     # 0xfc7e0
xorl %r12d, %r12d
cmpq %r12, %rbp
je 0x41a14
movq 0x2f0(%r15), %rdi
addq %r13, %rdi
movq %r14, %rsi
callq 0x4190
testl %eax, %eax
jne 0x4198d
movq 0x38(%rsp), %rax
movq (%rax,%r12), %rax
movslq (%rax), %rsi
leaq 0x88(%rsp), %rdi
callq 0x1043e
testq %rdx, (%rax)
je 0x4198d
movq 0x38(%rsp), %rax
movq (%rax,%r12), %rax
movslq 0x4(%rax), %rsi
leaq 0x88(%rsp), %rdi
callq 0x1043e
testq %rdx, (%rax)
jne 0x41b5b
addq $0x18, %r12
incl %ebx
addq $0x98, %r13
jmp 0x4192d
movq 0x10e64d(%rip), %rdi    # 0x14fff0
leaq 0xc02c2(%rip), %rsi     # 0x101c6c
callq 0x4480
leaq 0xc0bc8(%rip), %rsi     # 0x10257e
movq %rax, %rdi
callq 0x4480
leaq 0xc02f0(%rip), %rsi     # 0x101cb5
movq %rax, %rdi
callq 0x4480
movq %rax, %rdi
movl %ebp, %esi
callq 0x4760
leaq 0xbf196(%rip), %rsi     # 0x100b74
movq %rax, %rdi
callq 0x4480
movq %rax, %rdi
movl %r13d, %esi
callq 0x4760
leaq 0xc00a7(%rip), %rsi     # 0x101a9f
movq %rax, %rdi
callq 0x4480
leaq 0xc0b77(%rip), %rsi     # 0x10257e
movq %rax, %rdi
callq 0x4480
jmp 0x41b26
movq %r15, %rdi
movq 0x68(%rsp), %rsi
callq 0x3eada
movq 0x78(%rsp), %rax
andl $0x0, (%rax)
pushq $0x40
popq %r12
xorl %ebx, %ebx
leaq 0x88(%rsp), %r14
leaq 0xc06a0(%rip), %r15     # 0x1020de
leaq 0x1b8(%rsp), %r13
movzbl 0x74(%rsp), %ebp
cmpq %rbx, 0x10(%rsp)
je 0x41ac1
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1043e
testq %rdx, (%rax)
je 0x41ab5
movq 0x68(%rsp), %rax
movq 0x2f0(%rax), %rdi
addq %r12, %rdi
movq %r15, %rsi
callq 0x4810
movq %r13, %rdi
movq %r15, %rsi
leaq 0x18(%rsp), %rdx
callq 0x1b80e
movq %r13, %rdi
movl %ebp, %esi
callq 0x1b1bb
movq 0x68(%rsp), %rax
movq 0x2f0(%rax), %rax
movsd %xmm0, -0x10(%rax,%r12)
movq %r13, %rdi
callq 0x4210
movq 0x78(%rsp), %rax
incl (%rax)
incq %rbx
addq $0x98, %r12
jmp 0x41a4b
movb $0x1, %bl
jmp 0x41b28
movq 0x10e524(%rip), %rdi    # 0x14fff0
leaq 0xc013c(%rip), %rsi     # 0x101c0f
callq 0x4480
jmp 0x41b17
movq 0x10e50f(%rip), %rdi    # 0x14fff0
leaq 0xc0083(%rip), %rsi     # 0x101b6b
callq 0x4480
leaq 0xc0a8a(%rip), %rsi     # 0x10257e
movq %rax, %rdi
callq 0x4480
leaq 0xbfffd(%rip), %rsi     # 0x101b00
movq %rax, %rdi
callq 0x4480
movl 0x8(%rsp), %esi
movq %rax, %rdi
callq 0x4760
leaq 0xc0a60(%rip), %rsi     # 0x10257e
movq %rax, %rdi
callq 0x4480
xorl %ebx, %ebx
leaq 0x50(%rsp), %rdi
callq 0xb290
leaq 0x20(%rsp), %rdi
callq 0x4ce3c
leaq 0x88(%rsp), %rdi
callq 0xa976
leaq 0x120(%rsp), %rdi
callq 0xa976
jmp 0x414f9
movq 0x10e48e(%rip), %rdi    # 0x14fff0
leaq 0xc0155(%rip), %rsi     # 0x101cbe
callq 0x4480
leaq 0xc0a09(%rip), %rsi     # 0x10257e
movq %rax, %rdi
callq 0x4480
leaq 0xc0174(%rip), %rsi     # 0x101cf8
movq %rax, %rdi
callq 0x4480
movq %rax, %rdi
movl %ebx, %esi
callq 0x4760
leaq 0xc0169(%rip), %rsi     # 0x101d06
movq %rax, %rdi
callq 0x4480
movq 0x38(%rsp), %rcx
movq (%rcx,%r12), %rcx
movl (%rcx), %esi
movq %rax, %rdi
callq 0x4760
leaq 0xc1b75(%rip), %rsi     # 0x103734
movq %rax, %rdi
callq 0x4480
movq 0x38(%rsp), %rcx
movq (%rcx,%r12), %rcx
movl 0x4(%rcx), %esi
movq %rax, %rdi
callq 0x4760
leaq 0xc0138(%rip), %rsi     # 0x101d1a
movq %rax, %rdi
callq 0x4480
leaq 0xc098d(%rip), %rsi     # 0x10257e
movq %rax, %rdi
callq 0x4480
leaq 0xc0134(%rip), %rsi     # 0x101d34
movq %rax, %rdi
callq 0x4480
leaq 0xc096f(%rip), %rsi     # 0x10257e
movq %rax, %rdi
callq 0x4480
leaq 0xc0130(%rip), %rsi     # 0x101d4e
movq %rax, %rdi
callq 0x4480
leaq 0xc0951(%rip), %rsi     # 0x10257e
movq %rax, %rdi
callq 0x4480
jmp 0x41b26
jmp 0x41c87
jmp 0x41c87
movq %rax, %rbx
jmp 0x41cab
jmp 0x41cba
jmp 0x41cba
jmp 0x41c87
jmp 0x41c87
jmp 0x41c87
jmp 0x41c87
jmp 0x41c87
jmp 0x41c87
jmp 0x41c87
movq %rax, %rbx
leaq 0x1b8(%rsp), %rdi
callq 0x4210
jmp 0x41c8a
jmp 0x41c87
jmp 0x41c87
jmp 0x41c87
jmp 0x41c87
jmp 0x41cba
jmp 0x41c87
movq %rax, %rbx
leaq 0x120(%rsp), %rdi
callq 0xb290
jmp 0x41ced
jmp 0x41c87
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xb290
leaq 0x20(%rsp), %rdi
callq 0x4ce3c
leaq 0x88(%rsp), %rdi
callq 0xa976
leaq 0x120(%rsp), %rdi
callq 0xa976
jmp 0x41ce3
movq %rax, %rbx
jmp 0x41ce3
jmp 0x41cc6
movq %rax, %rbx
jmp 0x41cd6
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0xa808
leaq 0x120(%rsp), %rdi
callq 0xa808
leaq 0x38(%rsp), %rdi
callq 0xad7e
movq %rbx, %rdi
callq 0x4780