// File: Luthaf[P]zeopp/networkstorage.cc
// Function: fracSubstituteAtoms(ATOM_NETWORK*, ATOM_NETWORK*, bool, double, int, int*, double*, bool)
bool fracSubstituteAtoms(ATOM_NETWORK *origNet, ATOM_NETWORK *newNet,
                         bool substituteSeed, double frac, int randSeed,
                         int *numSubstitutions, double *fracSub, bool radial){
    int numAtoms = origNet->numAtoms;
    double max_bond_length = 1.95;
    
    if(frac > 0.5){
        cerr << "Fractional atomic network substitution failed because the fraction can not exceed 0.5" << "\n";
        return false;
    }
    if(frac < 0.0){
        cerr << "Fractional atomic network substitution failed because of invalid negative fraction " << frac << "\n";
        return false;
    }
    
    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 << "Fractional 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);
            }
        }
    }
    
    int numSi = 0;
    
    for(int i = 0; i < numAtoms; i++){
        if(origNet->atoms[i].type.compare("Si") == 0){
            if(bonds[i].size() != 4){
                cerr << "Fractional 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;
            }
            numSi++;
        }
        else if(origNet->atoms[i].type.compare("O") == 0){
            if(bonds[i].size() != 2){
                cerr << "Fractional 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 << "Fractional 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: Fractional atomic network 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 << "Fractional 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 << "Fractional 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 << "Fractional 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 << "Fractional 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);
    
    int totalSubs = nearestInt(frac*numSi); // How many substituions to actually perform
    *fracSub = (1.0*totalSubs)/numSi;        // Store the actual substitution fraction
    
    srand(randSeed); // Seed random number generator
    
    // Record all originally substituted atoms
    vector<pair<int, int> > subIDs;
    for(int i = 0; i < numAtoms; i++){
        if(atomSubs[i]){
            subIDs.push_back(pair<int,int> (rand(), i));
        }
    }
    
    sort(subIDs.begin(), subIDs.end(), comparePairs); // Sort the pairs by their random values
    
    // Change atoms that should be substituted
    for(*numSubstitutions = 0; *numSubstitutions < totalSubs; (*numSubstitutions)++){
        int id = subIDs[*numSubstitutions].second;
        newNet->atoms[id].type   = "Al";
        newNet->atoms[id].radius = lookupRadius("Al", radial);
    }
    
    
    // Change Oxygen type if O atom connected to Al
    for(int i=0; i < numAtoms; i++){
        if(origNet->atoms[i].type.compare("O") == 0)
        {
            if(newNet->atoms[(bonds[i].at(0))].type.compare("Al") == 0 || newNet->atoms[(
                                                                                         bonds[i].at(1))].type.compare("Al") == 0)
            {
                newNet->atoms[i].type   = "O_Al";
            };
        };
    };
    
    
    
    // Successful substitution
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x670, %rsp            # imm = 0x670
movb 0x10(%rbp), %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %dl
movb %dl, -0x19(%rbp)
movsd %xmm0, -0x28(%rbp)
movl %ecx, -0x2c(%rbp)
movq %r8, -0x38(%rbp)
movq %r9, -0x40(%rbp)
andb $0x1, %al
movb %al, -0x41(%rbp)
movq -0x10(%rbp), %rax
movl 0x110(%rax), %eax
movl %eax, -0x48(%rbp)
movsd 0x15b39a(%rip), %xmm0   # 0x1f7880
movsd %xmm0, -0x50(%rbp)
movsd -0x28(%rbp), %xmm0
movsd 0x155b80(%rip), %xmm1   # 0x1f2078
ucomisd %xmm1, %xmm0
jbe 0x9c529
movq 0x1d6aeb(%rip), %rdi    # 0x272ff0
leaq 0x15b9da(%rip), %rsi    # 0x1f7ee6
callq 0x5540
movq %rax, %rdi
leaq 0x15d10a(%rip), %rsi    # 0x1f9625
callq 0x5540
movb $0x0, -0x1(%rbp)
jmp 0x9dc35
xorps %xmm0, %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0x9c56b
movq 0x1d6ab6(%rip), %rdi    # 0x272ff0
leaq 0x15b9fb(%rip), %rsi    # 0x1f7f3c
callq 0x5540
movq %rax, %rdi
movsd -0x28(%rbp), %xmm0
callq 0x5980
movq %rax, %rdi
leaq 0x15d0c8(%rip), %rsi    # 0x1f9625
callq 0x5540
movb $0x0, -0x1(%rbp)
jmp 0x9dc35
movslq -0x48(%rbp), %rax
movq %rax, -0x3c0(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x80(%rbp)
movq $0x0, -0x70(%rbp)
leaq -0x80(%rbp), %rdi
movq %rdi, -0x3b8(%rbp)
callq 0xd0d0
leaq -0x81(%rbp), %rdi
movq %rdi, -0x3b0(%rbp)
callq 0x12b40
movq -0x3c0(%rbp), %rsi
movq -0x3b8(%rbp), %rdx
movq -0x3b0(%rbp), %rcx
leaq -0x68(%rbp), %rdi
callq 0xaedd0
jmp 0x9c5c8
leaq -0x81(%rbp), %rdi
callq 0x13770
leaq -0x80(%rbp), %rdi
callq 0xec80
movl $0x0, -0x98(%rbp)
movl -0x98(%rbp), %eax
cmpl -0x48(%rbp), %eax
jge 0x9c912
movq -0x10(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
movslq -0x98(%rbp), %rsi
callq 0xfcc0
movq %rax, %rsi
leaq -0x130(%rbp), %rdi
callq 0xf0d0
jmp 0x9c61e
movl -0x98(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x134(%rbp)
movl -0x134(%rbp), %eax
cmpl -0x48(%rbp), %eax
jge 0x9c8c5
movq -0x10(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
movslq -0x134(%rbp), %rsi
callq 0xfcc0
movq %rax, %rsi
leaq -0x1d0(%rbp), %rdi
callq 0xf0d0
jmp 0x9c664
movq -0x10(%rbp), %rdi
leaq -0x130(%rbp), %rsi
leaq -0x1d0(%rbp), %rdx
callq 0x979b0
movsd %xmm0, -0x3c8(%rbp)
jmp 0x9c685
movsd -0x3c8(%rbp), %xmm1
movsd -0x50(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x9c88d
leaq -0xf0(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x5050
movl %eax, -0x3cc(%rbp)
jmp 0x9c6b7
movl -0x3cc(%rbp), %eax
cmpl $0x0, %eax
jne 0x9c849
movq 0x1d6923(%rip), %rdi    # 0x272ff0
leaq 0x15b8bc(%rip), %rsi    # 0x1f7f90
callq 0x5540
movq %rax, -0x3d8(%rbp)
jmp 0x9c6e2
movq -0x3d8(%rbp), %rdi
leaq 0x15cf35(%rip), %rsi    # 0x1f9625
callq 0x5540
movq %rax, -0x3e0(%rbp)
jmp 0x9c6fe
movq -0x3e0(%rbp), %rdi
leaq 0x15b4e8(%rip), %rsi    # 0x1f7bf4
callq 0x5540
movq %rax, -0x3e8(%rbp)
jmp 0x9c71a
movq -0x3e8(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x5480
movq %rax, -0x3f0(%rbp)
jmp 0x9c736
movq -0x3f0(%rbp), %rdi
leaq 0x15b4c3(%rip), %rsi    # 0x1f7c07
callq 0x5540
movq %rax, -0x3f8(%rbp)
jmp 0x9c752
movq -0x3f8(%rbp), %rdi
movl -0x98(%rbp), %esi
callq 0x58d0
movq %rax, -0x400(%rbp)
jmp 0x9c76d
movq -0x400(%rbp), %rdi
leaq 0x15ecb1(%rip), %rsi    # 0x1fb42c
callq 0x5540
movq %rax, -0x408(%rbp)
jmp 0x9c789
movq -0x408(%rbp), %rdi
movl -0x134(%rbp), %esi
callq 0x58d0
movq %rax, -0x410(%rbp)
jmp 0x9c7a4
movq -0x410(%rbp), %rdi
leaq 0x15ce73(%rip), %rsi    # 0x1f9625
callq 0x5540
jmp 0x9c7b9
movb $0x0, -0x1(%rbp)
movl $0x1, -0x1d4(%rbp)
jmp 0x9c897
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x81(%rbp), %rdi
callq 0x13770
leaq -0x80(%rbp), %rdi
callq 0xec80
jmp 0x9dc43
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x9dc2a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x9c901
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0xf200
jmp 0x9c901
movslq -0x98(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x10890
movq %rax, %rdi
leaq -0x134(%rbp), %rsi
callq 0xd1b0
jmp 0x9c86a
movslq -0x134(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x10890
movq %rax, %rdi
leaq -0x98(%rbp), %rsi
callq 0xd1b0
jmp 0x9c88b
jmp 0x9c88d
movl $0x0, -0x1d4(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0xf200
movl -0x1d4(%rbp), %eax
testl %eax, %eax
jne 0x9c8cf
jmp 0x9c8af
jmp 0x9c8b1
movl -0x134(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x134(%rbp)
jmp 0x9c62d
movl $0x0, -0x1d4(%rbp)
leaq -0x130(%rbp), %rdi
callq 0xf200
movl -0x1d4(%rbp), %eax
testl %eax, %eax
jne 0x9dc1f
jmp 0x9c8eb
jmp 0x9c8ed
movl -0x98(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x98(%rbp)
jmp 0x9c5e7
leaq -0x130(%rbp), %rdi
callq 0xf200
jmp 0x9dc2a
movl $0x0, -0x1d8(%rbp)
movl $0x0, -0x1dc(%rbp)
movl -0x1dc(%rbp), %eax
cmpl -0x48(%rbp), %eax
jge 0x9cc6d
movq -0x10(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
movslq -0x1dc(%rbp), %rsi
callq 0xfcc0
movq %rax, %rdi
addq $0x40, %rdi
leaq 0x155e3c(%rip), %rsi    # 0x1f2796
callq 0x51b0
cmpl $0x0, %eax
jne 0x9ca81
movslq -0x1dc(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x10890
movq %rax, %rdi
callq 0x10090
cmpq $0x4, %rax
je 0x9ca6d
movq 0x1d665f(%rip), %rdi    # 0x272ff0
leaq 0x15b65c(%rip), %rsi    # 0x1f7ff4
callq 0x5540
movq %rax, -0x418(%rbp)
jmp 0x9c9a6
movslq -0x1dc(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x10890
movq %rax, %rdi
callq 0x10090
movq -0x418(%rbp), %rdi
movq %rax, %rsi
callq 0x5160
movq %rax, -0x420(%rbp)
jmp 0x9c9d6
movq -0x420(%rbp), %rdi
leaq 0x15b272(%rip), %rsi    # 0x1f7c56
callq 0x5540
movq %rax, -0x428(%rbp)
jmp 0x9c9f2
movq -0x428(%rbp), %rdi
leaq 0x15cc25(%rip), %rsi    # 0x1f9625
callq 0x5540
movq %rax, -0x430(%rbp)
jmp 0x9ca0e
movq -0x430(%rbp), %rdi
leaq 0x15b254(%rip), %rsi    # 0x1f7c70
callq 0x5540
movq %rax, -0x438(%rbp)
jmp 0x9ca2a
movq -0x438(%rbp), %rdi
movl -0x1dc(%rbp), %esi
callq 0x58d0
movq %rax, -0x440(%rbp)
jmp 0x9ca45
movq -0x440(%rbp), %rdi
leaq 0x15cbd2(%rip), %rsi    # 0x1f9625
callq 0x5540
jmp 0x9ca5a
movb $0x0, -0x1(%rbp)
movl $0x1, -0x1d4(%rbp)
jmp 0x9dc1f
movl -0x1d8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1d8(%rbp)
jmp 0x9cc57
movq -0x10(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
movslq -0x1dc(%rbp), %rsi
callq 0xfcc0
movq %rax, %rdi
addq $0x40, %rdi
leaq 0x155ce5(%rip), %rsi    # 0x1f278b
callq 0x51b0
cmpl $0x0, %eax
jne 0x9cbbe
movslq -0x1dc(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x10890
movq %rax, %rdi
callq 0x10090
cmpq $0x2, %rax
je 0x9cbb9
movq 0x1d6513(%rip), %rdi    # 0x272ff0
leaq 0x15b55a(%rip), %rsi    # 0x1f803e
callq 0x5540
movq %rax, -0x448(%rbp)
jmp 0x9caf2
movslq -0x1dc(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x10890
movq %rax, %rdi
callq 0x10090
movq -0x448(%rbp), %rdi
movq %rax, %rsi
callq 0x5160
movq %rax, -0x450(%rbp)
jmp 0x9cb22
movq -0x450(%rbp), %rdi
leaq 0x15b191(%rip), %rsi    # 0x1f7cc1
callq 0x5540
movq %rax, -0x458(%rbp)
jmp 0x9cb3e
movq -0x458(%rbp), %rdi
leaq 0x15cad9(%rip), %rsi    # 0x1f9625
callq 0x5540
movq %rax, -0x460(%rbp)
jmp 0x9cb5a
movq -0x460(%rbp), %rdi
leaq 0x15b108(%rip), %rsi    # 0x1f7c70
callq 0x5540
movq %rax, -0x468(%rbp)
jmp 0x9cb76
movq -0x468(%rbp), %rdi
movl -0x1dc(%rbp), %esi
callq 0x58d0
movq %rax, -0x470(%rbp)
jmp 0x9cb91
movq -0x470(%rbp), %rdi
leaq 0x15ca86(%rip), %rsi    # 0x1f9625
callq 0x5540
jmp 0x9cba6
movb $0x0, -0x1(%rbp)
movl $0x1, -0x1d4(%rbp)
jmp 0x9dc1f
jmp 0x9cc55
movq 0x1d642b(%rip), %rdi    # 0x272ff0
leaq 0x15b4bb(%rip), %rsi    # 0x1f8087
callq 0x5540
movq %rax, -0x478(%rbp)
jmp 0x9cbda
movq -0x478(%rbp), %rdi
leaq 0x15ca3d(%rip), %rsi    # 0x1f9625
callq 0x5540
movq %rax, -0x480(%rbp)
jmp 0x9cbf6
movq -0x480(%rbp), %rdi
leaq 0x15b06c(%rip), %rsi    # 0x1f7c70
callq 0x5540
movq %rax, -0x488(%rbp)
jmp 0x9cc12
movq -0x488(%rbp), %rdi
movl -0x1dc(%rbp), %esi
callq 0x58d0
movq %rax, -0x490(%rbp)
jmp 0x9cc2d
movq -0x490(%rbp), %rdi
leaq 0x15c9ea(%rip), %rsi    # 0x1f9625
callq 0x5540
jmp 0x9cc42
movb $0x0, -0x1(%rbp)
movl $0x1, -0x1d4(%rbp)
jmp 0x9dc1f
jmp 0x9cc57
jmp 0x9cc59
movl -0x1dc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1dc(%rbp)
jmp 0x9c926
movl $0xffffffff, -0x1e0(%rbp) # imm = 0xFFFFFFFF
movl $0x0, -0x1e4(%rbp)
movl -0x1e4(%rbp), %eax
cmpl -0x48(%rbp), %eax
jge 0x9ccdc
movq -0x10(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
movslq -0x1e4(%rbp), %rsi
callq 0xfcc0
movq %rax, %rdi
addq $0x40, %rdi
leaq 0x155ae5(%rip), %rsi    # 0x1f2796
callq 0x51b0
cmpl $0x0, %eax
jne 0x9ccc9
movl -0x1e4(%rbp), %eax
movl %eax, -0x1e0(%rbp)
jmp 0x9ccdc
jmp 0x9cccb
movl -0x1e4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1e4(%rbp)
jmp 0x9cc81
cmpl $-0x1, -0x1e0(%rbp)
jne 0x9cd0d
movq 0x1d6304(%rip), %rdi    # 0x272ff0
leaq 0x15b3f1(%rip), %rsi    # 0x1f80e4
callq 0x5540
jmp 0x9ccfa
movb $0x0, -0x1(%rbp)
movl $0x1, -0x1d4(%rbp)
jmp 0x9dc1f
movslq -0x48(%rbp), %rax
movq %rax, -0x4a0(%rbp)
movb $0x0, -0x211(%rbp)
leaq -0x212(%rbp), %rdi
movq %rdi, -0x498(%rbp)
callq 0x64b50
movq -0x4a0(%rbp), %rsi
movq -0x498(%rbp), %rcx
leaq -0x210(%rbp), %rdi
leaq -0x211(%rbp), %rdx
callq 0x64b70
jmp 0x9cd55
leaq -0x212(%rbp), %rdi
callq 0x64bf0
movslq -0x48(%rbp), %rax
movq %rax, -0x4b0(%rbp)
movb $0x0, -0x241(%rbp)
leaq -0x242(%rbp), %rdi
movq %rdi, -0x4a8(%rbp)
callq 0x64b50
movq -0x4b0(%rbp), %rsi
movq -0x4a8(%rbp), %rcx
leaq -0x240(%rbp), %rdi
leaq -0x241(%rbp), %rdx
callq 0x64b70
jmp 0x9cda9
leaq -0x242(%rbp), %rdi
callq 0x64bf0
movl $0x0, -0x248(%rbp)
leaq -0x260(%rbp), %rdi
callq 0xaee50
leaq -0x278(%rbp), %rdi
callq 0xd0d0
leaq -0x280(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
leaq -0x19(%rbp), %rdx
callq 0xaee70
jmp 0x9cdf0
leaq -0x260(%rbp), %rdi
leaq -0x280(%rbp), %rsi
callq 0xaeea0
jmp 0x9ce05
movl $0xffffffff, -0x284(%rbp) # imm = 0xFFFFFFFF
leaq -0x278(%rbp), %rdi
leaq -0x284(%rbp), %rsi
callq 0xffc0
jmp 0x9ce24
jmp 0x9ce26
leaq -0x260(%rbp), %rdi
callq 0xaef10
cmpq $0x0, %rax
je 0x9d35b
leaq -0x260(%rbp), %rdi
movq %rdi, -0x4d0(%rbp)
callq 0xaef30
movq -0x4d0(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x290(%rbp)
callq 0xaef70
movl -0x290(%rbp), %eax
movl %eax, -0x294(%rbp)
movb -0x28c(%rbp), %al
andb $0x1, %al
movb %al, -0x295(%rbp)
leaq -0x278(%rbp), %rdi
movq %rdi, -0x4c8(%rbp)
callq 0x29870
movq -0x4c8(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x29c(%rbp)
callq 0xaefa0
movslq -0x294(%rbp), %rsi
leaq -0x210(%rbp), %rdi
callq 0x29990
movq %rdx, -0x4c0(%rbp)
movq %rax, -0x4b8(%rbp)
jmp 0x9cec9
movq -0x4c0(%rbp), %rax
movq -0x4b8(%rbp), %rcx
movq %rcx, -0x2b0(%rbp)
movq %rax, -0x2a8(%rbp)
leaq -0x2b0(%rbp), %rdi
callq 0x101a0
testb $0x1, %al
jne 0x9cefa
jmp 0x9d04f
movq -0x10(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
movslq -0x294(%rbp), %rsi
callq 0xfcc0
movq %rax, %rdi
addq $0x40, %rdi
leaq 0x155877(%rip), %rsi    # 0x1f2796
callq 0x51b0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x4d1(%rbp)
jne 0x9cf9a
movslq -0x294(%rbp), %rsi
leaq -0x240(%rbp), %rdi
callq 0x29990
movq %rdx, -0x4e8(%rbp)
movq %rax, -0x4e0(%rbp)
jmp 0x9cf56
movq -0x4e8(%rbp), %rax
movq -0x4e0(%rbp), %rcx
movq %rcx, -0x2c0(%rbp)
movq %rax, -0x2b8(%rbp)
leaq -0x2c0(%rbp), %rdi
callq 0x101a0
andb $0x1, %al
movzbl %al, %eax
movb -0x295(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
setne %al
movb %al, -0x4d1(%rbp)
movb -0x4d1(%rbp), %al
testb $0x1, %al
jne 0x9cfa9
jmp 0x9d04a
movq 0x1d6040(%rip), %rdi    # 0x272ff0
leaq 0x15b194(%rip), %rsi    # 0x1f814b
callq 0x5540
movq %rax, -0x4f0(%rbp)
jmp 0x9cfc5
movq -0x4f0(%rbp), %rdi
leaq 0x15c652(%rip), %rsi    # 0x1f9625
callq 0x5540
jmp 0x9cfda
movb $0x0, -0x1(%rbp)
movl $0x1, -0x1d4(%rbp)
jmp 0x9dbbb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x212(%rbp), %rdi
callq 0x64bf0
jmp 0x9dc2a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x242(%rbp), %rdi
callq 0x64bf0
jmp 0x9dc11
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x9dbed
jmp 0x9d356
movl -0x248(%rbp), %eax
incl %eax
movl %eax, -0x248(%rbp)
movslq -0x294(%rbp), %rsi
leaq -0x210(%rbp), %rdi
callq 0x29990
movq %rdx, -0x500(%rbp)
movq %rax, -0x4f8(%rbp)
jmp 0x9d080
movq -0x500(%rbp), %rax
movq -0x4f8(%rbp), %rcx
movq %rcx, -0x2d0(%rbp)
movq %rax, -0x2c8(%rbp)
leaq -0x2d0(%rbp), %rdi
movl $0x1, %esi
callq 0x10040
movq -0x10(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
movslq -0x294(%rbp), %rsi
callq 0xfcc0
movq %rax, %rdi
addq $0x40, %rdi
leaq 0x1556b9(%rip), %rsi    # 0x1f278b
callq 0x51b0
cmpl $0x0, %eax
jne 0x9d13e
movslq -0x294(%rbp), %rsi
leaq -0x240(%rbp), %rdi
callq 0x29990
movq %rdx, -0x510(%rbp)
movq %rax, -0x508(%rbp)
jmp 0x9d0ff
movq -0x510(%rbp), %rax
movq -0x508(%rbp), %rcx
movq %rcx, -0x2e0(%rbp)
movq %rax, -0x2d8(%rbp)
leaq -0x2e0(%rbp), %rdi
xorl %esi, %esi
callq 0x10040
movb -0x295(%rbp), %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x295(%rbp)
jmp 0x9d26e
movq -0x10(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
movslq -0x294(%rbp), %rsi
callq 0xfcc0
movq %rax, %rdi
addq $0x40, %rdi
leaq 0x155633(%rip), %rsi    # 0x1f2796
callq 0x51b0
cmpl $0x0, %eax
jne 0x9d1d5
movb -0x295(%rbp), %al
movb %al, -0x521(%rbp)
movslq -0x294(%rbp), %rsi
leaq -0x240(%rbp), %rdi
callq 0x29990
movq %rdx, -0x520(%rbp)
movq %rax, -0x518(%rbp)
jmp 0x9d19c
movb -0x521(%rbp), %al
movq -0x520(%rbp), %rcx
movq -0x518(%rbp), %rdx
movq %rdx, -0x2f0(%rbp)
movq %rcx, -0x2e8(%rbp)
movzbl %al, %esi
andl $0x1, %esi
leaq -0x2f0(%rbp), %rdi
callq 0x10040
jmp 0x9d26c
movq 0x1d5e14(%rip), %rdi    # 0x272ff0
leaq 0x15aea4(%rip), %rsi    # 0x1f8087
callq 0x5540
movq %rax, -0x530(%rbp)
jmp 0x9d1f1
movq -0x530(%rbp), %rdi
leaq 0x15c426(%rip), %rsi    # 0x1f9625
callq 0x5540
movq %rax, -0x538(%rbp)
jmp 0x9d20d
movq -0x538(%rbp), %rdi
leaq 0x15aa55(%rip), %rsi    # 0x1f7c70
callq 0x5540
movq %rax, -0x540(%rbp)
jmp 0x9d229
movq -0x540(%rbp), %rdi
movl -0x294(%rbp), %esi
callq 0x58d0
movq %rax, -0x548(%rbp)
jmp 0x9d244
movq -0x548(%rbp), %rdi
leaq 0x15c3d3(%rip), %rsi    # 0x1f9625
callq 0x5540
jmp 0x9d259
movb $0x0, -0x1(%rbp)
movl $0x1, -0x1d4(%rbp)
jmp 0x9dbbb
jmp 0x9d26e
movl $0x0, -0x2f4(%rbp)
movl -0x2f4(%rbp), %eax
movq %rax, -0x550(%rbp)
movslq -0x294(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x10890
movq %rax, %rdi
callq 0x10090
movq %rax, %rcx
movq -0x550(%rbp), %rax
cmpq %rcx, %rax
jae 0x9d354
movslq -0x294(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x10890
movq %rax, %rdi
movl -0x2f4(%rbp), %eax
movl %eax, %esi
callq 0xed60
movl (%rax), %eax
cmpl -0x29c(%rbp), %eax
je 0x9d33e
movslq -0x294(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x10890
movq %rax, %rdi
movl -0x2f4(%rbp), %eax
movl %eax, %esi
callq 0xed60
movq %rax, %rsi
leaq -0x2fc(%rbp), %rdi
leaq -0x295(%rbp), %rdx
callq 0xaee70
jmp 0x9d312
leaq -0x260(%rbp), %rdi
leaq -0x2fc(%rbp), %rsi
callq 0xaefd0
jmp 0x9d327
leaq -0x278(%rbp), %rdi
leaq -0x294(%rbp), %rsi
callq 0xd1b0
jmp 0x9d33c
jmp 0x9d33e
jmp 0x9d340
movl -0x2f4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2f4(%rbp)
jmp 0x9d278
jmp 0x9d356
jmp 0x9ce26
movl -0x248(%rbp), %eax
cmpl -0x48(%rbp), %eax
je 0x9d451
movq 0x1d5c7f(%rip), %rdi    # 0x272ff0
leaq 0x15ae3b(%rip), %rsi    # 0x1f81b3
callq 0x5540
movq %rax, -0x558(%rbp)
jmp 0x9d386
movq -0x558(%rbp), %rdi
leaq 0x15c291(%rip), %rsi    # 0x1f9625
callq 0x5540
movq %rax, -0x560(%rbp)
jmp 0x9d3a2
movq -0x560(%rbp), %rdi
leaq 0x15aa75(%rip), %rsi    # 0x1f7e25
callq 0x5540
movq %rax, -0x568(%rbp)
jmp 0x9d3be
movq -0x568(%rbp), %rdi
movl -0x248(%rbp), %esi
callq 0x58d0
movq %rax, -0x570(%rbp)
jmp 0x9d3d9
movq -0x570(%rbp), %rdi
leaq 0x1597ed(%rip), %rsi    # 0x1f6bd4
callq 0x5540
movq %rax, -0x578(%rbp)
jmp 0x9d3f5
movq -0x578(%rbp), %rdi
movl -0x48(%rbp), %esi
callq 0x58d0
movq %rax, -0x580(%rbp)
jmp 0x9d40d
movq -0x580(%rbp), %rdi
leaq 0x15a7f4(%rip), %rsi    # 0x1f7c0f
callq 0x5540
movq %rax, -0x588(%rbp)
jmp 0x9d429
movq -0x588(%rbp), %rdi
leaq 0x15c1ee(%rip), %rsi    # 0x1f9625
callq 0x5540
jmp 0x9d43e
movb $0x0, -0x1(%rbp)
movl $0x1, -0x1d4(%rbp)
jmp 0x9dbbb
movl $0x0, -0x300(%rbp)
movl -0x300(%rbp), %eax
cmpl -0x48(%rbp), %eax
jge 0x9d764
movq -0x10(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
movslq -0x300(%rbp), %rsi
callq 0xfcc0
movq %rax, %rdi
addq $0x40, %rdi
leaq 0x1552fc(%rip), %rsi    # 0x1f278b
callq 0x51b0
cmpl $0x0, %eax
jne 0x9d74e
movslq -0x300(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x10890
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xed60
movslq (%rax), %rsi
leaq -0x240(%rbp), %rdi
callq 0x29990
movq %rdx, -0x598(%rbp)
movq %rax, -0x590(%rbp)
jmp 0x9d4d8
movq -0x598(%rbp), %rax
movq -0x590(%rbp), %rcx
movq %rcx, -0x310(%rbp)
movq %rax, -0x308(%rbp)
leaq -0x310(%rbp), %rdi
callq 0x101a0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x599(%rbp)
jne 0x9d511
jmp 0x9d57b
movslq -0x300(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x10890
movq %rax, %rdi
movl $0x1, %esi
callq 0xed60
movslq (%rax), %rsi
leaq -0x240(%rbp), %rdi
callq 0x29990
movq %rdx, -0x5b0(%rbp)
movq %rax, -0x5a8(%rbp)
jmp 0x9d54d
movq -0x5b0(%rbp), %rax
movq -0x5a8(%rbp), %rcx
movq %rcx, -0x320(%rbp)
movq %rax, -0x318(%rbp)
leaq -0x320(%rbp), %rdi
callq 0x101a0
movb %al, -0x599(%rbp)
movb -0x599(%rbp), %al
testb $0x1, %al
jne 0x9d58a
jmp 0x9d74c
movq 0x1d5a5f(%rip), %rdi    # 0x272ff0
leaq 0x15ac6f(%rip), %rsi    # 0x1f8207
callq 0x5540
movq %rax, -0x5b8(%rbp)
jmp 0x9d5a6
movq -0x5b8(%rbp), %rdi
leaq 0x15c071(%rip), %rsi    # 0x1f9625
callq 0x5540
movq %rax, -0x5c0(%rbp)
jmp 0x9d5c2
movq -0x5c0(%rbp), %rdi
leaq 0x15a898(%rip), %rsi    # 0x1f7e68
callq 0x5540
movq %rax, -0x5c8(%rbp)
jmp 0x9d5de
movq -0x5c8(%rbp), %rdi
movl -0x300(%rbp), %esi
callq 0x58d0
movq %rax, -0x5d0(%rbp)
jmp 0x9d5f9
movq -0x5d0(%rbp), %rdi
leaq 0x15a86f(%rip), %rsi    # 0x1f7e76
callq 0x5540
movq %rax, -0x5d8(%rbp)
jmp 0x9d615
movslq -0x300(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x10890
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xed60
movq -0x5d8(%rbp), %rdi
movl (%rax), %esi
callq 0x58d0
movq %rax, -0x5e0(%rbp)
jmp 0x9d648
movq -0x5e0(%rbp), %rdi
leaq 0x15ddd6(%rip), %rsi    # 0x1fb42c
callq 0x5540
movq %rax, -0x5e8(%rbp)
jmp 0x9d664
movslq -0x300(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x10890
movq %rax, %rdi
movl $0x1, %esi
callq 0xed60
movq -0x5e8(%rbp), %rdi
movl (%rax), %esi
callq 0x58d0
movq %rax, -0x5f0(%rbp)
jmp 0x9d698
movq -0x5f0(%rbp), %rdi
leaq 0x15a7e4(%rip), %rsi    # 0x1f7e8a
callq 0x5540
movq %rax, -0x5f8(%rbp)
jmp 0x9d6b4
movq -0x5f8(%rbp), %rdi
leaq 0x15bf63(%rip), %rsi    # 0x1f9625
callq 0x5540
movq %rax, -0x600(%rbp)
jmp 0x9d6d0
movq -0x600(%rbp), %rdi
leaq 0x15a7c6(%rip), %rsi    # 0x1f7ea4
callq 0x5540
movq %rax, -0x608(%rbp)
jmp 0x9d6ec
movq -0x608(%rbp), %rdi
leaq 0x15bf2b(%rip), %rsi    # 0x1f9625
callq 0x5540
movq %rax, -0x610(%rbp)
jmp 0x9d708
movq -0x610(%rbp), %rdi
leaq 0x15a7a8(%rip), %rsi    # 0x1f7ebe
callq 0x5540
movq %rax, -0x618(%rbp)
jmp 0x9d724
movq -0x618(%rbp), %rdi
leaq 0x15bef3(%rip), %rsi    # 0x1f9625
callq 0x5540
jmp 0x9d739
movb $0x0, -0x1(%rbp)
movl $0x1, -0x1d4(%rbp)
jmp 0x9dbbb
jmp 0x9d74e
jmp 0x9d750
movl -0x300(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x300(%rbp)
jmp 0x9d45b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x96980
jmp 0x9d773
movsd -0x28(%rbp), %xmm0
cvtsi2sdl -0x1d8(%rbp), %xmm1
mulsd %xmm1, %xmm0
callq 0x9dc50
movl %eax, -0x61c(%rbp)
jmp 0x9d791
movl -0x61c(%rbp), %eax
movl %eax, -0x324(%rbp)
cvtsi2sdl -0x324(%rbp), %xmm1
movsd 0x1548a3(%rip), %xmm0   # 0x1f2050
mulsd %xmm1, %xmm0
cvtsi2sdl -0x1d8(%rbp), %xmm1
divsd %xmm1, %xmm0
movq -0x40(%rbp), %rax
movsd %xmm0, (%rax)
movl -0x2c(%rbp), %edi
callq 0x5510
leaq -0x340(%rbp), %rdi
callq 0x10280
movl $0x0, -0x344(%rbp)
movl -0x344(%rbp), %eax
cmpl -0x48(%rbp), %eax
jge 0x9d8ae
movslq -0x344(%rbp), %rsi
leaq -0x240(%rbp), %rdi
callq 0x29990
movq %rdx, -0x630(%rbp)
movq %rax, -0x628(%rbp)
jmp 0x9d815
movq -0x630(%rbp), %rax
movq -0x628(%rbp), %rcx
movq %rcx, -0x358(%rbp)
movq %rax, -0x350(%rbp)
leaq -0x358(%rbp), %rdi
callq 0x101a0
testb $0x1, %al
jne 0x9d843
jmp 0x9d898
callq 0x5190
movl %eax, -0x364(%rbp)
leaq -0x360(%rbp), %rdi
leaq -0x364(%rbp), %rsi
leaq -0x344(%rbp), %rdx
callq 0xaf060
jmp 0x9d86a
leaq -0x340(%rbp), %rdi
leaq -0x360(%rbp), %rsi
callq 0x10370
jmp 0x9d87f
jmp 0x9d898
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x9dbad
jmp 0x9d89a
movl -0x344(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x344(%rbp)
jmp 0x9d7e3
leaq -0x340(%rbp), %rdi
movq %rdi, -0x638(%rbp)
callq 0x2b960
movq -0x638(%rbp), %rdi
movq %rax, -0x370(%rbp)
callq 0x2b7b0
movq %rax, -0x378(%rbp)
movq -0x370(%rbp), %rdi
movq -0x378(%rbp), %rsi
leaq -0x1470(%rip), %rdx     # 0x9c480
callq 0xaf090
jmp 0x9d8f7
movq -0x38(%rbp), %rax
movl $0x0, (%rax)
movq -0x38(%rbp), %rax
movl (%rax), %eax
cmpl -0x324(%rbp), %eax
jge 0x9da36
movq -0x38(%rbp), %rax
movslq (%rax), %rsi
leaq -0x340(%rbp), %rdi
callq 0x10440
movl 0x4(%rax), %eax
movl %eax, -0x37c(%rbp)
movq -0x18(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
movslq -0x37c(%rbp), %rsi
callq 0xfcc0
movq %rax, %rdi
addq $0x40, %rdi
leaq 0x15a8fa(%rip), %rsi    # 0x1f824e
callq 0x5710
jmp 0x9d95b
leaq -0x3a1(%rbp), %rdi
movq %rdi, -0x640(%rbp)
callq 0x5900
movq -0x640(%rbp), %rdx
leaq 0x15a8d2(%rip), %rsi    # 0x1f824e
leaq -0x3a0(%rbp), %rdi
callq 0x47530
jmp 0x9d98a
movzbl -0x41(%rbp), %esi
andl $0x1, %esi
leaq -0x3a0(%rbp), %rdi
callq 0x466e0
movsd %xmm0, -0x648(%rbp)
jmp 0x9d9a7
movq -0x18(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
movslq -0x37c(%rbp), %rsi
callq 0xfcc0
movsd -0x648(%rbp), %xmm0
movsd %xmm0, 0x30(%rax)
leaq -0x3a0(%rbp), %rdi
callq 0x5300
leaq -0x3a1(%rbp), %rdi
callq 0x55d0
movq -0x38(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x9d901
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x9da25
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x3a0(%rbp), %rdi
callq 0x5300
leaq -0x3a1(%rbp), %rdi
callq 0x55d0
jmp 0x9dbad
movl $0x0, -0x3a8(%rbp)
movl -0x3a8(%rbp), %eax
cmpl -0x48(%rbp), %eax
jge 0x9db91
movq -0x10(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
movslq -0x3a8(%rbp), %rsi
callq 0xfcc0
movq %rax, %rdi
addq $0x40, %rdi
leaq 0x154d17(%rip), %rsi    # 0x1f278b
callq 0x51b0
cmpl $0x0, %eax
jne 0x9db7b
movq -0x18(%rbp), %rax
addq $0x2f0, %rax            # imm = 0x2F0
movq %rax, -0x658(%rbp)
movslq -0x3a8(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x10890
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x101d0
movq %rax, -0x650(%rbp)
jmp 0x9dab8
movq -0x658(%rbp), %rdi
movq -0x650(%rbp), %rax
movslq (%rax), %rsi
callq 0xfcc0
movq %rax, %rdi
addq $0x40, %rdi
leaq 0x15a772(%rip), %rsi    # 0x1f824e
callq 0x51b0
cmpl $0x0, %eax
je 0x9db4b
movq -0x18(%rbp), %rax
addq $0x2f0, %rax            # imm = 0x2F0
movq %rax, -0x668(%rbp)
movslq -0x3a8(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x10890
movq %rax, %rdi
movl $0x1, %esi
callq 0x101d0
movq %rax, -0x660(%rbp)
jmp 0x9db1d
movq -0x668(%rbp), %rdi
movq -0x660(%rbp), %rax
movslq (%rax), %rsi
callq 0xfcc0
movq %rax, %rdi
addq $0x40, %rdi
leaq 0x15a70d(%rip), %rsi    # 0x1f824e
callq 0x51b0
cmpl $0x0, %eax
jne 0x9db79
movq -0x18(%rbp), %rdi
addq $0x2f0, %rdi            # imm = 0x2F0
movslq -0x3a8(%rbp), %rsi
callq 0xfcc0
movq %rax, %rdi
addq $0x40, %rdi
leaq 0x15a6dc(%rip), %rsi    # 0x1f824c
callq 0x5710
jmp 0x9db77
jmp 0x9db79
jmp 0x9db7b
jmp 0x9db7d
movl -0x3a8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3a8(%rbp)
jmp 0x9da40
movb $0x1, -0x1(%rbp)
movl $0x1, -0x1d4(%rbp)
leaq -0x340(%rbp), %rdi
callq 0x10460
jmp 0x9dbbb
leaq -0x340(%rbp), %rdi
callq 0x10460
jmp 0x9dbed
leaq -0x278(%rbp), %rdi
callq 0xec80
leaq -0x260(%rbp), %rdi
callq 0xaf000
leaq -0x240(%rbp), %rdi
callq 0xf9b0
leaq -0x210(%rbp), %rdi
callq 0xf9b0
jmp 0x9dc1f
leaq -0x278(%rbp), %rdi
callq 0xec80
leaq -0x260(%rbp), %rdi
callq 0xaf000
leaq -0x240(%rbp), %rdi
callq 0xf9b0
leaq -0x210(%rbp), %rdi
callq 0xf9b0
jmp 0x9dc2a
leaq -0x68(%rbp), %rdi
callq 0x108b0
jmp 0x9dc35
leaq -0x68(%rbp), %rdi
callq 0x108b0
jmp 0x9dc43
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x670, %rsp            # imm = 0x670
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x58f0
nop