// File: /workspace/github_c_makefile_star2_O0/debbiemarkslab[P]plmc/src/plm.c
// Function: MSARead
alignment_t *MSARead(char *alignFile, options_t *options) {
    /* Read FASTA-formatted alignment */
    FILE *fpAli = NULL;
    if (alignFile != NULL) {
        fpAli = fopen(alignFile, "r");
    } else {
        fprintf(stderr, "Must specify alignment file: -a ALIGN_FILE\n");
        exit(1);
    }
    if (fpAli == NULL) {
        fprintf(stderr, "Error opening alignment file\n");
        exit(1);
    }

    /* Allocate alignment */
    alignment_t *ali = (alignment_t *) malloc(sizeof(alignment_t));
    ali->nSeqs = ali->nSites = ali->nCodes = 0;
    ali->alphabet = options->alphabet;
    ali->names = NULL;
    ali->sequences = NULL;
    ali->target = -1;
    ali->offsets = NULL;
    ali->nEff = 0;
    ali->weights = ali->fi = ali->fij = NULL;
    ali->nParams = 0;

    /* Verify alignment dimensions and structure (first pass through file) */
    char name[BUFFER_SIZE];
    char seq[BUFFER_SIZE];
    /* Read first line as name */
    fgetstr(name, fpAli);
    if (*name == '>') {
        MSAReadSeq(seq, fpAli);
    } else {
        fprintf(stderr, "Error reading alignment:"
                        " First line should start with >\n");
        exit(1);
    }
    ali->nCodes = strlen(ali->alphabet);
    ali->nSites = strlen(seq);
    ali->nSeqs = 1;
    while (!feof(fpAli)) {
        char c = fgetc(fpAli);
        if (c == '>') {
            /* Read name and sequence pair */
            fgetstr(name, fpAli);
            MSAReadSeq(seq, fpAli);
        } else {
            fprintf(stderr, "Error reading alignment:"
                            " sequence records should start with >\n");
            exit(1);
        }

        /* Validate sequence length */
        if (strlen(seq) != ali->nSites) {
            fprintf(stderr,
                "Incompatible sequence length (%lu should be %d) for %s:\n%s\n",
                strlen(seq), ali->nSites, name, seq);
            exit(1);
        }
        ali->nSeqs++;
    }

    /* Encode full alignment block (second pass through file) */
    ali->sequences = (letter_t *)
        malloc(ali->nSites * ali->nSeqs * sizeof(letter_t));
    ali->names = (char **) malloc(ali->nSeqs * sizeof(char *));
    for (int s = 0; s < ali->nSeqs; s++)
        for (int i = 0; i < ali->nSites; i++) seq(s, i) = 0;
    for (int s = 0; s < ali->nSeqs; s++) ali->names[s] = NULL;
    rewind(fpAli);
    for (int s = 0; s < ali->nSeqs; s++) {
        /* >Name */
        getc(fpAli);
        fgetstr(name, fpAli);
        ali->names[s] = (char *) malloc((strlen(name) + 1) * sizeof(char));
        strcpy(ali->names[s], name);

        /* Sequence */
        MSAReadSeq(seq, fpAli);
        for (int i = 0; i < ali->nSites; i++)
            seq(s, i) = MSAReadCode(seq[i], ali->alphabet, ali->nCodes);
    }

    /* --------------------------------_DEBUG_--------------------------------*/
    /* Alignment to stderr */
    // for (int s = 0; s < 10; s++) {
    // for (int s = 0; s < ali->nSeqs; s++) {
    //     for (int i = 0; i < ali->nSites; i++)
    //         if (seq(s, i) >= 0 && seq(s, i) < ali->nCodes) {
    //             fprintf(stderr, "%c", ali->alphabet[seq(s, i)]);
    //         } else if (seq(s, i) >= -ali->nCodes && seq(s, i) < 0) {
    //             fprintf(stderr, "%c",
    //                 tolower(ali->alphabet[seq(s, i) + ali->nCodes]));
    //         } else {
    //             fprintf(stderr, "*%d*", seq(s, i));
    //         }
    //     fprintf(stderr, "\n");
    // }
    // exit(0);
    /* --------------------------------^DEBUG^--------------------------------*/

    /* Focus mode: If a focus sequence (target) is provided, locate it */
    if (options->target != NULL) {
        for (int s = 0; s < ali->nSeqs; s++)
            if (strncmp(options->target, ali->names[s],
                strlen(options->target)) == 0) {
                if (ali->target >= 0) {
                    fprintf(stderr,
                        "Multiple sequences start with %s, picking sequence %d\n",
                        options->target, s + 1);
                } else {
                    ali->target = s;
                }
            }
        if (ali->target >= 0) {
            fprintf(stderr, "Found focus %s as sequence %d\n", options->target,
                ali->target + 1);
        } else {
            fprintf(stderr,
                "Could not find %s, proceeding without focus sequence\n",
                options->target);
        }
    }

    /* Always discard any sequences (rows) with out-of-alphabet characters */
    int* seqValid = (int *) malloc(ali->nSeqs * sizeof(int));
    for (int s = 0; s < ali->nSeqs; s++) seqValid[s] = 0;
    for (int s = 0; s < ali->nSeqs; s++)
        for (int i = 0; i < ali->nSites; i++)
            if ((seq(s, i) >= -ali->nCodes) && (seq(s, i) < ali->nCodes))
                seqValid[s]++;
    int nValidSeqs = 0;
    for (int s = 0; s < ali->nSeqs; s++)
        if (seqValid[s] == ali->nSites) nValidSeqs++;
    fprintf(stderr, "%d valid sequences out of %d \n", nValidSeqs, ali->nSeqs);
    
    /* Record indices of skipped sequences */
    ali->nSkippedSeqs = ali->nSeqs - nValidSeqs;
    ali->skippedSeqs = (int *) malloc(ali->nSkippedSeqs * sizeof(int));
    for (int s = 0, skipIndex = 0; s < ali->nSeqs; s++)
        if (seqValid[s] != ali->nSites) ali->skippedSeqs[skipIndex++] = s;

    /* Focus mode: select only focus columns (criteria below) */
    int nValidSites = ali->nSites;
    int* siteValid = (int *) malloc(ali->nSites * sizeof(int));
    for (int i = 0; i < ali->nSites; i++) siteValid[i] = 1;
    if (ali->target >= 0) {
        for (int i = 0; i < ali->nSites; i++) {
            /* For proteins, remove lower case and gap columns */
            if ((ali->alphabet == codesAA) 
                && (seq(ali->target, i) < 0))
                siteValid[i] = 0;
            /* Discard gaps */
            if ((ali->alphabet == codesAA)
                || (options->estimatorMAP == INFER_MAP_PLM_GAPREDUCE))
                if (seq(ali->target, i) == 0) siteValid[i] = 0;
        }
        nValidSites = 0;
        for (int i = 0; i < ali->nSites; i++)
            if (siteValid[i] == 1) nValidSites++;
        fprintf(stderr,
            "%d sites out of %d\n", nValidSites, ali->nSites);
    } else {
        fprintf(stderr,
            "%d sites\n", ali->nSites);
    }

    /* Focus mode: parse region (NAME/START_IX-END_IX) and map offsets */
    int leftOffset = 0;
    if (ali->target >= 0) {
        char *focusName = ali->names[ali->target];
        /* Name should be immediately followed by '/' */
        if (strlen(focusName) > strlen(options->target) + 1
            && focusName[strlen(options->target)] == '/') {
            /* Attempt to read integer region start */
            int regLeft = strlen(options->target) + 1;
            int ix = 0;
            if (isdigit(focusName[regLeft])) {
                while (regLeft + ix < strlen(focusName)
                       && isdigit(focusName[regLeft + ix + 1])) ix++;
                int tens = 1;
                leftOffset = -1;
                for (int i = ix; i >= 0; i--) {
                    leftOffset += tens * (focusName[regLeft + i] - '0');
                    tens *= 10;
                }
                fprintf(stderr, "Region starts at %d\n", leftOffset + 1);
            } else {
                fprintf(stderr, "Error parsing region, assuming start at 1");
            }
        }

        /* Map the offsets */
        ali->offsets = (int *) malloc(nValidSites * sizeof(int));
        for (int i = 0; i < nValidSites; i++) ali->offsets[i] = i + 1;
        int ix = 0;
        for (int i = 0; i < ali->nSites; i++)
            if (siteValid[i] == 1) {
                ali->offsets[ix] = i + 1 + leftOffset;
                ix++;
            }

        /* Reposition the target for reduced alignment */
        int targetShift = -1;
        for (int i = 0; i <= ali->target; i++)
            if (seqValid[i] == ali->nSites) targetShift++;
        ali->target = targetShift;
    }

    /* Copy only selected rows and columns */
    if (nValidSeqs < ali->nSeqs || nValidSites < ali->nSites) {
        letter_t *seqsReduced = (letter_t *)
            malloc(nValidSites * nValidSeqs * sizeof(letter_t));
        for (int i = 0; i < nValidSites * nValidSeqs; i++) seqsReduced[i] = 0;
        int sx = 0;
        for (int s = 0; s < ali->nSeqs; s++)
            if (seqValid[s] == ali->nSites) {
                int ix = 0;
                for (int i = 0; i < ali->nSites; i++) {
                    if (siteValid[i] == 1) {
                        seqsReduced[ix + sx * nValidSites] = seq(s, i);
                        ix++;
                    }
                }
                sx++;
            }

        /* Reallocate alignment with reduced dimensions */
        free(ali->sequences);
        ali->nSeqs = nValidSeqs;
        ali->nSites = nValidSites;
        ali->sequences = (letter_t *)
            malloc(nValidSites * nValidSeqs * sizeof(letter_t));
        for (int i = 0; i < nValidSites * nValidSeqs; i++)
            ali->sequences[i] = 0;
        for (int s = 0; s < nValidSeqs; s++)
            for (int i = 0; i < nValidSites; i++)
                seq(s, i) = seqsReduced[i + s * nValidSites];
        free(seqsReduced);
    }

    /* Shift any lowercase codes back to uppercase */
    for (int s = 0; s < ali->nSeqs; s++)
        for (int i = 0; i < ali->nSites; i++)
            if (seq(s, i) < 0) seq(s, i) += ali->nCodes;

    /* Intialize weights to 1.0 */
    ali->weights = (numeric_t *) malloc(ali->nSeqs * sizeof(numeric_t));
    for (int s = 0; s < ali->nSeqs; s++) ali->weights[s] = 1.0;
    ali->nEff = (numeric_t) ali->nSeqs;

    /* --------------------------------_DEBUG_--------------------------------*/
    /* Display offset map */
    // for (int i = 0; i < ali->nSites; i++) {
    //     fprintf(stderr, "%d : %d : %c\n", i + 1, ali->offsets[i],
    //             ali->alphabet[seq(ali->target, i)]);
    // }
    // exit(0);
    /* Display target */
    // for (int i = 0; i < ali->nSites; i++) {
    //     fprintf(stderr, "%c", ali->alphabet[seq(ali->target, i)]);
    // }
    // fprintf(stderr, "\n");
    // exit(0);
    /* --------------------------------^DEBUG^--------------------------------*/

    /* --------------------------------_DEBUG_--------------------------------*/
    // for (int s = 0; s < ali->nSeqs; s++) {
    //     fprintf(stderr, ">%s\n", ali->names[s]);
    //     for (int i = 0; i < ali->nSites; i++)
    //         fprintf(stderr, "%c", ali->alphabet[seq(s, i)]);
    //     fprintf(stderr, "\n");
    // }
    /* --------------------------------^DEBUG^--------------------------------*/
    return ali;
}

// Assembly:
subq $0x14148, %rsp          # imm = 0x14148
movq %rdi, 0x14140(%rsp)
movq %rsi, 0x14138(%rsp)
movq $0x0, 0x14130(%rsp)
cmpq $0x0, 0x14140(%rsp)
je 0x5b0c
movq 0x14140(%rsp), %rdi
leaq 0x1462c(%rip), %rsi     # 0x1a129
callq 0x1190
movq %rax, 0x14130(%rsp)
jmp 0x5b2e
movq 0x164e5(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
leaq 0x13611(%rip), %rsi     # 0x1912e
movb $0x0, %al
callq 0x1140
movl $0x1, %edi
callq 0x11c0
cmpq $0x0, 0x14130(%rsp)
jne 0x5b5b
movq 0x164b8(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
leaq 0x13610(%rip), %rsi     # 0x1915a
movb $0x0, %al
callq 0x1140
movl $0x1, %edi
callq 0x11c0
movl $0x88, %edi
callq 0x1170
movq %rax, 0x14128(%rsp)
movq 0x14128(%rsp), %rax
movl $0x0, 0x8(%rax)
movq 0x14128(%rsp), %rax
movl $0x0, 0x4(%rax)
movq 0x14128(%rsp), %rax
movl $0x0, (%rax)
movq 0x14138(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x14128(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x14128(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x14128(%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x14128(%rsp), %rax
movl $0xffffffff, 0x38(%rax) # imm = 0xFFFFFFFF
movq 0x14128(%rsp), %rax
movq $0x0, 0x40(%rax)
movq 0x14128(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x48(%rax)
movq 0x14128(%rsp), %rax
movq $0x0, 0x60(%rax)
movq 0x14128(%rsp), %rax
movq $0x0, 0x58(%rax)
movq 0x14128(%rsp), %rax
movq $0x0, 0x50(%rax)
movq 0x14128(%rsp), %rax
movl $0x0, 0x68(%rax)
leaq 0xa120(%rsp), %rdi
movq 0x14130(%rsp), %rdx
movl $0xa000, %esi           # imm = 0xA000
callq 0x1120
cmpq $0x0, %rax
je 0x5cc7
leaq 0xa120(%rsp), %rdi
movl $0xa, %esi
callq 0x10c0
movq %rax, 0x118(%rsp)
cmpq $0x0, %rax
je 0x5c8a
movq 0x118(%rsp), %rax
movb $0x0, (%rax)
jmp 0x5c8c
leaq 0xa120(%rsp), %rdi
callq 0x10b0
subq $0x1, %rax
movsbl 0xa120(%rsp,%rax), %eax
cmpl $0xd, %eax
jne 0x5cc5
leaq 0xa120(%rsp), %rdi
callq 0x10b0
subq $0x1, %rax
movb $0x0, 0xa120(%rsp,%rax)
jmp 0x5c8c
jmp 0x5cc7
movsbl 0xa120(%rsp), %eax
cmpl $0x3e, %eax
jne 0x5ceb
leaq 0x120(%rsp), %rdi
movq 0x14130(%rsp), %rsi
callq 0x9b80
jmp 0x5d0d
movq 0x16306(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
leaq 0x1347c(%rip), %rsi     # 0x19178
movb $0x0, %al
callq 0x1140
movl $0x1, %edi
callq 0x11c0
movq 0x14128(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x10b0
movl %eax, %ecx
movq 0x14128(%rsp), %rax
movl %ecx, 0x8(%rax)
leaq 0x120(%rsp), %rdi
callq 0x10b0
movl %eax, %ecx
movq 0x14128(%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x14128(%rsp), %rax
movl $0x1, (%rax)
movq 0x14130(%rsp), %rdi
callq 0x1150
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x5d71
jmp 0x5ee0
movq 0x14130(%rsp), %rdi
callq 0x1100
movb %al, 0x117(%rsp)
movsbl 0x117(%rsp), %eax
cmpl $0x3e, %eax
jne 0x5e35
leaq 0xa120(%rsp), %rdi
movq 0x14130(%rsp), %rdx
movl $0xa000, %esi           # imm = 0xA000
callq 0x1120
cmpq $0x0, %rax
je 0x5e1e
leaq 0xa120(%rsp), %rdi
movl $0xa, %esi
callq 0x10c0
movq %rax, 0x108(%rsp)
cmpq $0x0, %rax
je 0x5de1
movq 0x108(%rsp), %rax
movb $0x0, (%rax)
jmp 0x5de3
leaq 0xa120(%rsp), %rdi
callq 0x10b0
subq $0x1, %rax
movsbl 0xa120(%rsp,%rax), %eax
cmpl $0xd, %eax
jne 0x5e1c
leaq 0xa120(%rsp), %rdi
callq 0x10b0
subq $0x1, %rax
movb $0x0, 0xa120(%rsp,%rax)
jmp 0x5de3
jmp 0x5e1e
leaq 0x120(%rsp), %rdi
movq 0x14130(%rsp), %rsi
callq 0x9b80
jmp 0x5e57
movq 0x161bc(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
leaq 0x1336b(%rip), %rsi     # 0x191b1
movb $0x0, %al
callq 0x1140
movl $0x1, %edi
callq 0x11c0
leaq 0x120(%rsp), %rdi
callq 0x10b0
movq 0x14128(%rsp), %rcx
movslq 0x4(%rcx), %rcx
cmpq %rcx, %rax
je 0x5ecc
movq 0x1617c(%rip), %rax     # 0x1bff8
movq (%rax), %rax
movq %rax, 0x38(%rsp)
leaq 0x120(%rsp), %rdi
callq 0x10b0
movq 0x38(%rsp), %rdi
movq %rax, %rdx
movq 0x14128(%rsp), %rax
movl 0x4(%rax), %ecx
leaq 0xa120(%rsp), %r8
leaq 0x120(%rsp), %r9
leaq 0x13335(%rip), %rsi     # 0x191f0
movb $0x0, %al
callq 0x1140
movl $0x1, %edi
callq 0x11c0
movq 0x14128(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x5d53
movq 0x14128(%rsp), %rax
movl 0x4(%rax), %eax
movq 0x14128(%rsp), %rcx
imull (%rcx), %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x1170
movq %rax, %rcx
movq 0x14128(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x14128(%rsp), %rax
movslq (%rax), %rdi
shlq $0x3, %rdi
callq 0x1170
movq %rax, %rcx
movq 0x14128(%rsp), %rax
movq %rcx, 0x18(%rax)
movl $0x0, 0x104(%rsp)
movl 0x104(%rsp), %eax
movq 0x14128(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x5fce
movl $0x0, 0x100(%rsp)
movl 0x100(%rsp), %eax
movq 0x14128(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x5fb6
movq 0x14128(%rsp), %rax
movq 0x20(%rax), %rax
movl 0x100(%rsp), %ecx
movl 0x104(%rsp), %edx
movq 0x14128(%rsp), %rsi
imull 0x4(%rsi), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movl $0x0, (%rax,%rcx,4)
movl 0x100(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x100(%rsp)
jmp 0x5f5d
jmp 0x5fb8
movl 0x104(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x104(%rsp)
jmp 0x5f3f
movl $0x0, 0xfc(%rsp)
movl 0xfc(%rsp), %eax
movq 0x14128(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x601b
movq 0x14128(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0xfc(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
movl 0xfc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xfc(%rsp)
jmp 0x5fd9
movq 0x14130(%rsp), %rdi
callq 0x10d0
movl $0x0, 0xf8(%rsp)
movl 0xf8(%rsp), %eax
movq 0x14128(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x61fc
movq 0x14130(%rsp), %rdi
callq 0x11f0
leaq 0xa120(%rsp), %rdi
movq 0x14130(%rsp), %rdx
movl $0xa000, %esi           # imm = 0xA000
callq 0x1120
cmpq $0x0, %rax
je 0x60df
leaq 0xa120(%rsp), %rdi
movl $0xa, %esi
callq 0x10c0
movq %rax, 0xf0(%rsp)
cmpq $0x0, %rax
je 0x60a2
movq 0xf0(%rsp), %rax
movb $0x0, (%rax)
jmp 0x60a4
leaq 0xa120(%rsp), %rdi
callq 0x10b0
subq $0x1, %rax
movsbl 0xa120(%rsp,%rax), %eax
cmpl $0xd, %eax
jne 0x60dd
leaq 0xa120(%rsp), %rdi
callq 0x10b0
subq $0x1, %rax
movb $0x0, 0xa120(%rsp,%rax)
jmp 0x60a4
jmp 0x60df
leaq 0xa120(%rsp), %rdi
callq 0x10b0
movq %rax, %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x1170
movq %rax, %rdx
movq 0x14128(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0xf8(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x14128(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0xf8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0xa120(%rsp), %rsi
callq 0x1050
leaq 0x120(%rsp), %rdi
movq 0x14130(%rsp), %rsi
callq 0x9b80
movl $0x0, 0xec(%rsp)
movl 0xec(%rsp), %eax
movq 0x14128(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x61e4
movslq 0xec(%rsp), %rax
movb 0x120(%rsp,%rax), %al
movq 0x14128(%rsp), %rcx
movq 0x10(%rcx), %rsi
movq 0x14128(%rsp), %rcx
movl 0x8(%rcx), %edx
movsbl %al, %edi
callq 0x9cb0
movl %eax, %edx
movq 0x14128(%rsp), %rax
movq 0x20(%rax), %rax
movl 0xec(%rsp), %ecx
movl 0xf8(%rsp), %esi
movq 0x14128(%rsp), %rdi
imull 0x4(%rdi), %esi
addl %esi, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl 0xec(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xec(%rsp)
jmp 0x615c
jmp 0x61e6
movl 0xf8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xf8(%rsp)
jmp 0x6033
movq 0x14138(%rsp), %rax
cmpq $0x0, (%rax)
je 0x6353
movl $0x0, 0xe8(%rsp)
movl 0xe8(%rsp), %eax
movq 0x14128(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x62ed
movq 0x14138(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x14128(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0xe8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x30(%rsp)
movq 0x14138(%rsp), %rax
movq (%rax), %rdi
callq 0x10b0
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq %rax, %rdx
callq 0x1040
cmpl $0x0, %eax
jne 0x62d5
movq 0x14128(%rsp), %rax
cmpl $0x0, 0x38(%rax)
jl 0x62c1
movq 0x15d5f(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
movq 0x14138(%rsp), %rax
movq (%rax), %rdx
movl 0xe8(%rsp), %ecx
addl $0x1, %ecx
leaq 0x12f74(%rip), %rsi     # 0x1922c
movb $0x0, %al
callq 0x1140
jmp 0x62d3
movl 0xe8(%rsp), %ecx
movq 0x14128(%rsp), %rax
movl %ecx, 0x38(%rax)
jmp 0x62d5
jmp 0x62d7
movl 0xe8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xe8(%rsp)
jmp 0x6219
movq 0x14128(%rsp), %rax
cmpl $0x0, 0x38(%rax)
jl 0x632e
movq 0x15cf6(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
movq 0x14138(%rsp), %rax
movq (%rax), %rdx
movq 0x14128(%rsp), %rax
movl 0x38(%rax), %ecx
addl $0x1, %ecx
leaq 0x12f3e(%rip), %rsi     # 0x19263
movb $0x0, %al
callq 0x1140
jmp 0x6351
movq 0x15cc3(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
movq 0x14138(%rsp), %rax
movq (%rax), %rdx
leaq 0x12f38(%rip), %rsi     # 0x19282
movb $0x0, %al
callq 0x1140
jmp 0x6353
movq 0x14128(%rsp), %rax
movslq (%rax), %rdi
shlq $0x2, %rdi
callq 0x1170
movq %rax, 0xe0(%rsp)
movl $0x0, 0xdc(%rsp)
movl 0xdc(%rsp), %eax
movq 0x14128(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x63b7
movq 0xe0(%rsp), %rax
movslq 0xdc(%rsp), %rcx
movl $0x0, (%rax,%rcx,4)
movl 0xdc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xdc(%rsp)
jmp 0x637a
movl $0x0, 0xd8(%rsp)
movl 0xd8(%rsp), %eax
movq 0x14128(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x64bf
movl $0x0, 0xd4(%rsp)
movl 0xd4(%rsp), %eax
movq 0x14128(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x64a7
movq 0x14128(%rsp), %rax
movq 0x20(%rax), %rax
movl 0xd4(%rsp), %ecx
movl 0xd8(%rsp), %edx
movq 0x14128(%rsp), %rsi
imull 0x4(%rsi), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movq 0x14128(%rsp), %rdx
xorl %ecx, %ecx
subl 0x8(%rdx), %ecx
cmpl %ecx, %eax
jl 0x648f
movq 0x14128(%rsp), %rax
movq 0x20(%rax), %rax
movl 0xd4(%rsp), %ecx
movl 0xd8(%rsp), %edx
movq 0x14128(%rsp), %rsi
imull 0x4(%rsi), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movq 0x14128(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0x648f
movq 0xe0(%rsp), %rax
movslq 0xd8(%rsp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
jmp 0x6491
movl 0xd4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xd4(%rsp)
jmp 0x63e4
jmp 0x64a9
movl 0xd8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xd8(%rsp)
jmp 0x63c2
movl $0x0, 0xd0(%rsp)
movl $0x0, 0xcc(%rsp)
movl 0xcc(%rsp), %eax
movq 0x14128(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x652e
movq 0xe0(%rsp), %rax
movslq 0xcc(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq 0x14128(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jne 0x6519
movl 0xd0(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xd0(%rsp)
jmp 0x651b
movl 0xcc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xcc(%rsp)
jmp 0x64d5
movq 0x15ac3(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
movl 0xd0(%rsp), %edx
movq 0x14128(%rsp), %rax
movl (%rax), %ecx
leaq 0x12d68(%rip), %rsi     # 0x192b8
movb $0x0, %al
callq 0x1140
movq 0x14128(%rsp), %rax
movl (%rax), %ecx
subl 0xd0(%rsp), %ecx
movq 0x14128(%rsp), %rax
movl %ecx, 0x28(%rax)
movq 0x14128(%rsp), %rax
movslq 0x28(%rax), %rdi
shlq $0x2, %rdi
callq 0x1170
movq %rax, %rcx
movq 0x14128(%rsp), %rax
movq %rcx, 0x30(%rax)
movl $0x0, 0xc8(%rsp)
movl $0x0, 0xc4(%rsp)
movl 0xc8(%rsp), %eax
movq 0x14128(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x6621
movq 0xe0(%rsp), %rax
movslq 0xc8(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq 0x14128(%rsp), %rcx
cmpl 0x4(%rcx), %eax
je 0x660c
movl 0xc8(%rsp), %edx
movq 0x14128(%rsp), %rax
movq 0x30(%rax), %rax
movl 0xc4(%rsp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0xc4(%rsp)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x660e
movl 0xc8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc8(%rsp)
jmp 0x65ad
movq 0x14128(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0xc0(%rsp)
movq 0x14128(%rsp), %rax
movslq 0x4(%rax), %rdi
shlq $0x2, %rdi
callq 0x1170
movq %rax, 0xb8(%rsp)
movl $0x0, 0xb4(%rsp)
movl 0xb4(%rsp), %eax
movq 0x14128(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x6699
movq 0xb8(%rsp), %rax
movslq 0xb4(%rsp), %rcx
movl $0x1, (%rax,%rcx,4)
movl 0xb4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xb4(%rsp)
jmp 0x665b
movq 0x14128(%rsp), %rax
cmpl $0x0, 0x38(%rax)
jl 0x684a
movl $0x0, 0xb0(%rsp)
movl 0xb0(%rsp), %eax
movq 0x14128(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x67b8
movq 0x14128(%rsp), %rax
movq 0x10(%rax), %rax
cmpq 0x15a77(%rip), %rax     # 0x1c158
jne 0x672f
movq 0x14128(%rsp), %rax
movq 0x20(%rax), %rax
movl 0xb0(%rsp), %ecx
movq 0x14128(%rsp), %rdx
movl 0x38(%rdx), %edx
movq 0x14128(%rsp), %rsi
imull 0x4(%rsi), %edx
addl %edx, %ecx
movslq %ecx, %rcx
cmpl $0x0, (%rax,%rcx,4)
jge 0x672f
movq 0xb8(%rsp), %rax
movslq 0xb0(%rsp), %rcx
movl $0x0, (%rax,%rcx,4)
movq 0x14128(%rsp), %rax
movq 0x10(%rax), %rax
cmpq 0x15a16(%rip), %rax     # 0x1c158
je 0x6752
movq 0x14138(%rsp), %rax
cmpl $0x1, 0x18(%rax)
jne 0x67a0
movq 0x14128(%rsp), %rax
movq 0x20(%rax), %rax
movl 0xb0(%rsp), %ecx
movq 0x14128(%rsp), %rdx
movl 0x38(%rdx), %edx
movq 0x14128(%rsp), %rsi
imull 0x4(%rsi), %edx
addl %edx, %ecx
movslq %ecx, %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x679e
movq 0xb8(%rsp), %rax
movslq 0xb0(%rsp), %rcx
movl $0x0, (%rax,%rcx,4)
jmp 0x67a0
jmp 0x67a2
movl 0xb0(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xb0(%rsp)
jmp 0x66b6
movl $0x0, 0xc0(%rsp)
movl $0x0, 0xac(%rsp)
movl 0xac(%rsp), %eax
movq 0x14128(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x681e
movq 0xb8(%rsp), %rax
movslq 0xac(%rsp), %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0x6809
movl 0xc0(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc0(%rsp)
jmp 0x680b
movl 0xac(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xac(%rsp)
jmp 0x67ce
movq 0x157d3(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
movl 0xc0(%rsp), %edx
movq 0x14128(%rsp), %rax
movl 0x4(%rax), %ecx
leaq 0x12a96(%rip), %rsi     # 0x192d7
movb $0x0, %al
callq 0x1140
jmp 0x686d
movq 0x157a7(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
movq 0x14128(%rsp), %rax
movl 0x4(%rax), %edx
leaq 0x12a85(%rip), %rsi     # 0x192eb
movb $0x0, %al
callq 0x1140
movl $0x0, 0xa8(%rsp)
movq 0x14128(%rsp), %rax
cmpl $0x0, 0x38(%rax)
jl 0x6c39
movq 0x14128(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x14128(%rsp), %rcx
movslq 0x38(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0xa0(%rsp)
movq 0xa0(%rsp), %rdi
callq 0x10b0
movq %rax, 0x20(%rsp)
movq 0x14138(%rsp), %rax
movq (%rax), %rdi
callq 0x10b0
movq %rax, %rcx
movq 0x20(%rsp), %rax
addq $0x1, %rcx
cmpq %rcx, %rax
jbe 0x6ac9
movq 0xa0(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x14138(%rsp), %rax
movq (%rax), %rdi
callq 0x10b0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
jne 0x6ac9
movq 0x14138(%rsp), %rax
movq (%rax), %rdi
callq 0x10b0
addq $0x1, %rax
movl %eax, 0x9c(%rsp)
movl $0x0, 0x98(%rsp)
callq 0x1220
movq (%rax), %rax
movq 0xa0(%rsp), %rcx
movslq 0x9c(%rsp), %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x6aaf
jmp 0x6970
movl 0x9c(%rsp), %eax
addl 0x98(%rsp), %eax
cltq
movq %rax, 0x8(%rsp)
movq 0xa0(%rsp), %rdi
callq 0x10b0
movq 0x8(%rsp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, 0x17(%rsp)
jae 0x69e3
callq 0x1220
movq (%rax), %rax
movq 0xa0(%rsp), %rcx
movl 0x9c(%rsp), %edx
addl 0x98(%rsp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
setne %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x69ed
jmp 0x6a03
movl 0x98(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x98(%rsp)
jmp 0x6970
movl $0x1, 0x94(%rsp)
movl $0xffffffff, 0xa8(%rsp) # imm = 0xFFFFFFFF
movl 0x98(%rsp), %eax
movl %eax, 0x90(%rsp)
cmpl $0x0, 0x90(%rsp)
jl 0x6a8b
movl 0x94(%rsp), %eax
movq 0xa0(%rsp), %rcx
movl 0x9c(%rsp), %edx
addl 0x90(%rsp), %edx
movslq %edx, %rdx
movsbl (%rcx,%rdx), %ecx
subl $0x30, %ecx
imull %ecx, %eax
addl 0xa8(%rsp), %eax
movl %eax, 0xa8(%rsp)
imull $0xa, 0x94(%rsp), %eax
movl %eax, 0x94(%rsp)
movl 0x90(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x90(%rsp)
jmp 0x6a27
movq 0x15566(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
movl 0xa8(%rsp), %edx
addl $0x1, %edx
leaq 0x1284f(%rip), %rsi     # 0x192f5
movb $0x0, %al
callq 0x1140
jmp 0x6ac7
movq 0x15542(%rip), %rax     # 0x1bff8
movq (%rax), %rdi
leaq 0x1284a(%rip), %rsi     # 0x1930a
movb $0x0, %al
callq 0x1140
jmp 0x6ac9
movslq 0xc0(%rsp), %rdi
shlq $0x2, %rdi
callq 0x1170
movq %rax, %rcx
movq 0x14128(%rsp), %rax
movq %rcx, 0x40(%rax)
movl $0x0, 0x8c(%rsp)
movl 0x8c(%rsp), %eax
cmpl 0xc0(%rsp), %eax
jge 0x6b38
movl 0x8c(%rsp), %edx
addl $0x1, %edx
movq 0x14128(%rsp), %rax
movq 0x40(%rax), %rax
movslq 0x8c(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x8c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8c(%rsp)
jmp 0x6af4
movl $0x0, 0x88(%rsp)
movl $0x0, 0x84(%rsp)
movl 0x84(%rsp), %eax
movq 0x14128(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x6bc6
movq 0xb8(%rsp), %rax
movslq 0x84(%rsp), %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0x6bb1
movl 0x84(%rsp), %edx
addl $0x1, %edx
addl 0xa8(%rsp), %edx
movq 0x14128(%rsp), %rax
movq 0x40(%rax), %rax
movslq 0x88(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x88(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x88(%rsp)
jmp 0x6bb3
movl 0x84(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x84(%rsp)
jmp 0x6b4e
movl $0xffffffff, 0x80(%rsp) # imm = 0xFFFFFFFF
movl $0x0, 0x7c(%rsp)
movl 0x7c(%rsp), %eax
movq 0x14128(%rsp), %rcx
cmpl 0x38(%rcx), %eax
jg 0x6c27
movq 0xe0(%rsp), %rax
movslq 0x7c(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq 0x14128(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jne 0x6c18
movl 0x80(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x80(%rsp)
jmp 0x6c1a
movl 0x7c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x7c(%rsp)
jmp 0x6bd9
movl 0x80(%rsp), %ecx
movq 0x14128(%rsp), %rax
movl %ecx, 0x38(%rax)
movl 0xd0(%rsp), %eax
movq 0x14128(%rsp), %rcx
cmpl (%rcx), %eax
jl 0x6c64
movl 0xc0(%rsp), %eax
movq 0x14128(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x6ef3
movl 0xc0(%rsp), %eax
imull 0xd0(%rsp), %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x1170
movq %rax, 0x70(%rsp)
movl $0x0, 0x6c(%rsp)
movl 0x6c(%rsp), %eax
movl 0xc0(%rsp), %ecx
imull 0xd0(%rsp), %ecx
cmpl %ecx, %eax
jge 0x6cc1
movq 0x70(%rsp), %rax
movslq 0x6c(%rsp), %rcx
movl $0x0, (%rax,%rcx,4)
movl 0x6c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x6c(%rsp)
jmp 0x6c8c
movl $0x0, 0x68(%rsp)
movl $0x0, 0x64(%rsp)
movl 0x64(%rsp), %eax
movq 0x14128(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x6db9
movq 0xe0(%rsp), %rax
movslq 0x64(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq 0x14128(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jne 0x6da7
movl $0x0, 0x60(%rsp)
movl $0x0, 0x5c(%rsp)
movl 0x5c(%rsp), %eax
movq 0x14128(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x6d9c
movq 0xb8(%rsp), %rax
movslq 0x5c(%rsp), %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0x6d8a
movq 0x14128(%rsp), %rax
movq 0x20(%rax), %rax
movl 0x5c(%rsp), %ecx
movl 0x64(%rsp), %edx
movq 0x14128(%rsp), %rsi
imull 0x4(%rsi), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
movq 0x70(%rsp), %rax
movl 0x60(%rsp), %ecx
movl 0x68(%rsp), %esi
imull 0xc0(%rsp), %esi
addl %esi, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl 0x60(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x60(%rsp)
jmp 0x6d8c
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
jmp 0x6d16
movl 0x68(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x68(%rsp)
jmp 0x6da9
movl 0x64(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x64(%rsp)
jmp 0x6cd1
movq 0x14128(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x1030
movl 0xd0(%rsp), %ecx
movq 0x14128(%rsp), %rax
movl %ecx, (%rax)
movl 0xc0(%rsp), %ecx
movq 0x14128(%rsp), %rax
movl %ecx, 0x4(%rax)
movl 0xc0(%rsp), %eax
imull 0xd0(%rsp), %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x1170
movq %rax, %rcx
movq 0x14128(%rsp), %rax
movq %rcx, 0x20(%rax)
movl $0x0, 0x58(%rsp)
movl 0x58(%rsp), %eax
movl 0xc0(%rsp), %ecx
imull 0xd0(%rsp), %ecx
cmpl %ecx, %eax
jge 0x6e5b
movq 0x14128(%rsp), %rax
movq 0x20(%rax), %rax
movslq 0x58(%rsp), %rcx
movl $0x0, (%rax,%rcx,4)
movl 0x58(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x6e1f
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
cmpl 0xd0(%rsp), %eax
jge 0x6ee9
movl $0x0, 0x50(%rsp)
movl 0x50(%rsp), %eax
cmpl 0xc0(%rsp), %eax
jge 0x6ed7
movq 0x70(%rsp), %rax
movl 0x50(%rsp), %ecx
movl 0x54(%rsp), %edx
imull 0xc0(%rsp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
movq 0x14128(%rsp), %rax
movq 0x20(%rax), %rax
movl 0x50(%rsp), %ecx
movl 0x54(%rsp), %esi
movq 0x14128(%rsp), %rdi
imull 0x4(%rdi), %esi
addl %esi, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl 0x50(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x50(%rsp)
jmp 0x6e78
jmp 0x6ed9
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x6e63
movq 0x70(%rsp), %rdi
callq 0x1030
movl $0x0, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
movq 0x14128(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x6fad
movl $0x0, 0x48(%rsp)
movl 0x48(%rsp), %eax
movq 0x14128(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x6f9b
movq 0x14128(%rsp), %rax
movq 0x20(%rax), %rax
movl 0x48(%rsp), %ecx
movl 0x4c(%rsp), %edx
movq 0x14128(%rsp), %rsi
imull 0x4(%rsi), %edx
addl %edx, %ecx
movslq %ecx, %rcx
cmpl $0x0, (%rax,%rcx,4)
jge 0x6f89
movq 0x14128(%rsp), %rax
movl 0x8(%rax), %edx
movq 0x14128(%rsp), %rax
movq 0x20(%rax), %rax
movl 0x48(%rsp), %ecx
movl 0x4c(%rsp), %esi
movq 0x14128(%rsp), %rdi
imull 0x4(%rdi), %esi
addl %esi, %ecx
movslq %ecx, %rcx
addl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
jmp 0x6f8b
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x6f17
jmp 0x6f9d
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x6efb
movq 0x14128(%rsp), %rax
movslq (%rax), %rdi
shlq $0x3, %rdi
callq 0x1170
movq %rax, %rcx
movq 0x14128(%rsp), %rax
movq %rcx, 0x50(%rax)
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
movq 0x14128(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x7013
movq 0x14128(%rsp), %rax
movq 0x50(%rax), %rax
movslq 0x44(%rsp), %rcx
movsd 0x1204f(%rip), %xmm0    # 0x19050
movsd %xmm0, (%rax,%rcx,8)
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x6fd8
movq 0x14128(%rsp), %rax
cvtsi2sdl (%rax), %xmm0
movq 0x14128(%rsp), %rax
movsd %xmm0, 0x48(%rax)
movq 0x14128(%rsp), %rax
addq $0x14148, %rsp          # imm = 0x14148
retq
nopl (%rax)