// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/htscodecs/htscodecs/tokenise_name3.c
// Function: encode_name
static int encode_name(name_context *ctx, char *name, int len, int mode) {
    int i, is_fixed, fixed_len;

    int exact;
    int cnum = ctx->counter++;
    int pnum = search_trie(ctx, name, len, cnum, &exact, &is_fixed, &fixed_len);
    if (pnum < 0) pnum = cnum ? cnum-1 : 0;
    //pnum = pnum & (MAX_NAMES-1);
    //cnum = cnum & (MAX_NAMES-1);
    //if (pnum == cnum) {pnum = cnum ? cnum-1 : 0;}
#ifdef ENC_DEBUG
    fprintf(stderr, "%d: pnum=%d (%d), exact=%d\n%s\n%s\n",
            ctx->counter, pnum, cnum-pnum, exact, ctx->lc[pnum].last_name, name);
#endif

    // Return DUP or DIFF switch, plus the distance.
    if (exact && len == strlen(ctx->lc[pnum].last_name)) {
        encode_token_dup(ctx, cnum-pnum);
        ctx->lc[cnum].last_name = name;
        ctx->lc[cnum].last_ntok = ctx->lc[pnum].last_ntok;
        int nc = ctx->lc[cnum].last_ntok ? ctx->lc[cnum].last_ntok : MAX_TOKENS;
        ctx->lc[cnum].last = malloc(nc * sizeof(*ctx->lc[cnum].last));
        if (!ctx->lc[cnum].last)
            return -1;
        memcpy(ctx->lc[cnum].last, ctx->lc[pnum].last,
               ctx->lc[cnum].last_ntok * sizeof(*ctx->lc[cnum].last));
        return 0;
    }

    ctx->lc[cnum].last = malloc(MAX_TOKENS * sizeof(*ctx->lc[cnum].last));
    if (!ctx->lc[cnum].last)
        return -1;
    encode_token_diff(ctx, cnum-pnum);
    int ntok = 1;

    if (fixed_len == 36) {
        // ONT uuid4 format data
        if (37 >= ctx->max_tok) {
            do {
                memset(&ctx->desc[ctx->max_tok << 4], 0, 16*sizeof(ctx->desc[0]));
                memset(&ctx->token_dcount[ctx->max_tok], 0, sizeof(int));
                memset(&ctx->token_icount[ctx->max_tok], 0, sizeof(int));
            } while (ctx->max_tok++ < 37);
        }
#ifdef ENC_DEBUG
        fprintf(stderr, "Tok %d (%d x uuid chr)", ntok, len);
#endif
        for (i = 0; i < 36; i++, ntok++) {
            encode_token_char(ctx, ntok, name[i]);
            ctx->lc[cnum].last[ntok].token_int = name[i];
            ctx->lc[cnum].last[ntok].token_type = N_CHAR;
        }
        is_fixed = 0;
        i = 36;
    } else if (is_fixed) {
        // Other fixed length data
        if (ntok >= ctx->max_tok) {
            memset(&ctx->desc[ctx->max_tok << 4], 0, 16*sizeof(ctx->desc[0]));
            memset(&ctx->token_dcount[ctx->max_tok], 0, sizeof(int));
            memset(&ctx->token_icount[ctx->max_tok], 0, sizeof(int));
            ctx->max_tok = ntok+1;
        }
        if (pnum < cnum && ntok < ctx->lc[pnum].last_ntok && ctx->lc[pnum].last[ntok].token_type == N_ALPHA) {
            if (ctx->lc[pnum].last[ntok].token_int == fixed_len && memcmp(name, ctx->lc[pnum].last_name, fixed_len) == 0) {
                encode_token_match(ctx, ntok);
            } else {
                encode_token_alpha(ctx, ntok, name, fixed_len);
            }
        } else {
            encode_token_alpha(ctx, ntok, name, fixed_len);
        }
        ctx->lc[cnum].last[ntok].token_int = fixed_len;
        ctx->lc[cnum].last[ntok].token_str = 0;
        ctx->lc[cnum].last[ntok++].token_type = N_ALPHA;
        i = fixed_len;
    } else {
        i = 0;
    }

    for (; i < len; i++) {
        if (ntok >= ctx->max_tok) {
            if (ctx->max_tok >= MAX_TOKENS)
                return -1;
            memset(&ctx->desc[ctx->max_tok << 4], 0, 16*sizeof(ctx->desc[0]));
            memset(&ctx->token_dcount[ctx->max_tok], 0, sizeof(int));
            memset(&ctx->token_icount[ctx->max_tok], 0, sizeof(int));
            ctx->max_tok = ntok+1;
        }

        /* Determine data type of this segment */
        if (isalpha((uint8_t)name[i])) {
            int s = i+1;
//          int S = i+1;

//          // FIXME: try which of these is best.  alnum is good sometimes.
//          while (s < len && isalpha((uint8_t)name[s]))
            while (s < len && (isalpha((uint8_t)name[s]) ||
                               ispunct((uint8_t)name[s])))
//          while (s < len && name[s] != ':')
//          while (s < len && !isdigit((uint8_t)name[s]) && name[s] != ':')
                s++;

//          if (!is_fixed) {
//              while (S < len && isalnum((uint8_t)name[S]))
//                  S++;
//              if (s < S)
//                  s = S;
//          }

            // Single byte strings are better encoded as chars.
            if (s-i == 1) goto n_char;

            if (pnum < cnum && ntok < ctx->lc[pnum].last_ntok && ctx->lc[pnum].last[ntok].token_type == N_ALPHA) {
                if (s-i == ctx->lc[pnum].last[ntok].token_int &&
                    memcmp(&name[i], 
                           &ctx->lc[pnum].last_name[ctx->lc[pnum].last[ntok].token_str],
                           s-i) == 0) {
#ifdef ENC_DEBUG
                    fprintf(stderr, "Tok %d (alpha-mat, %.*s)\n", N_MATCH, s-i, &name[i]);
#endif
                    if (encode_token_match(ctx, ntok) < 0) return -1;
                } else {
#ifdef ENC_DEBUG
                    fprintf(stderr, "Tok %d (alpha, %.*s / %.*s)\n", N_ALPHA,
                            s-i, &ctx->lc[pnum].last_name[ctx->lc[pnum].last[ntok].token_str], s-i, &name[i]);
#endif
                    // same token/length, but mismatches
                    if (encode_token_alpha(ctx, ntok, &name[i], s-i) < 0) return -1;
                }
            } else {
#ifdef ENC_DEBUG
                fprintf(stderr, "Tok %d (new alpha, %.*s)\n", N_ALPHA, s-i, &name[i]);
#endif
                if (encode_token_alpha(ctx, ntok, &name[i], s-i) < 0) return -1;
            }

            ctx->lc[cnum].last[ntok].token_int = s-i;
            ctx->lc[cnum].last[ntok].token_str = i;
            ctx->lc[cnum].last[ntok].token_type = N_ALPHA;

            i = s-1;
        } else if (name[i] == '0') digits0: {
            // Digits starting with zero; encode length + value
            uint32_t s = i;
            uint32_t v = 0;
            int d = 0;

            while (s < len && isdigit((uint8_t)name[s]) && s-i < 9) {
                v = v*10 + name[s] - '0';
                //putchar(name[s]);
                s++;
            }

            // TODO: optimise choice over whether to switch from DIGITS to DELTA
            // regularly vs all DIGITS, also MATCH vs DELTA 0.
            if (pnum < cnum && ntok < ctx->lc[pnum].last_ntok && ctx->lc[pnum].last[ntok].token_type == N_DIGITS0) {
                d = v - ctx->lc[pnum].last[ntok].token_int;
                if (d == 0 && ctx->lc[pnum].last[ntok].token_str == s-i) {
#ifdef ENC_DEBUG
                    fprintf(stderr, "Tok %d (dig-mat, %d)\n", N_MATCH, v);
#endif
                    if (encode_token_match(ctx, ntok) < 0) return -1;
                    //ctx->lc[pnum].last[ntok].token_delta=0;
                } else if (mode == 1 && d < 256 && d >= 0 && ctx->lc[pnum].last[ntok].token_str == s-i) {
#ifdef ENC_DEBUG
                    fprintf(stderr, "Tok %d (dig0-delta, %d / %d)\n", N_DDELTA0, ctx->lc[pnum].last[ntok].token_int, v);
#endif
                    //if (encode_token_int1_(ctx, ntok, N_DZLEN, s-i) < 0) return -1;
                    if (encode_token_int1(ctx, ntok, N_DDELTA0, d) < 0) return -1;
                    //ctx->lc[pnum].last[ntok].token_delta=1;
                } else {
#ifdef ENC_DEBUG
                    fprintf(stderr, "Tok %d (dig0, %d / %d len %d)\n", N_DIGITS0, ctx->lc[pnum].last[ntok].token_int, v, s-i);
#endif
                    if (encode_token_int1_(ctx, ntok, N_DZLEN, s-i) < 0) return -1;
                    if (encode_token_int(ctx, ntok, N_DIGITS0, v) < 0) return -1;
                    //ctx->lc[pnum].last[ntok].token_delta=0;
                }
            } else {
#ifdef ENC_DEBUG
                fprintf(stderr, "Tok %d (new dig0, %d len %d)\n", N_DIGITS0, v, s-i);
#endif
                if (encode_token_int1_(ctx, ntok, N_DZLEN, s-i) < 0) return -1;
                if (encode_token_int(ctx, ntok, N_DIGITS0, v) < 0) return -1;
                //ctx->lc[pnum].last[ntok].token_delta=0;
            }

            ctx->lc[cnum].last[ntok].token_str = s-i; // length
            ctx->lc[cnum].last[ntok].token_int = v;
            ctx->lc[cnum].last[ntok].token_type = N_DIGITS0;

            i = s-1;
        } else if (isdigit((uint8_t)name[i])) {
            // digits starting 1-9; encode value
            uint32_t s = i;
            uint32_t v = 0;
            int d = 0;

            while (s < len && isdigit((uint8_t)name[s]) && s-i < 9) {
                v = v*10 + name[s] - '0';
                //putchar(name[s]);
                s++;
            }

            // dataset/10/K562_cytosol_LID8465_TopHat_v2.names
            // col 4 is Illumina lane - we don't want match & delta in there
            // as it has multiple lanes (so not ALL match) and delta is just
            // random chance, increasing entropy instead.
//          if (ntok == 4  || ntok == 8 || ntok == 10) {
//              encode_token_int(ctx, ntok, N_DIGITS, v);
//          } else {

            // If the last token was DIGITS0 and we are the same length, then encode
            // using that method instead as it seems likely the entire column is fixed
            // width, sometimes with leading zeros.
            if (pnum < cnum && ntok < ctx->lc[pnum].last_ntok &&
                ctx->lc[pnum].last[ntok].token_type == N_DIGITS0 &&
                ctx->lc[pnum].last[ntok].token_str == s-i)
                goto digits0;
            
            // TODO: optimise choice over whether to switch from DIGITS to DELTA
            // regularly vs all DIGITS, also MATCH vs DELTA 0.
            if (pnum < cnum && ntok < ctx->lc[pnum].last_ntok && ctx->lc[pnum].last[ntok].token_type == N_DIGITS) {
                d = v - ctx->lc[pnum].last[ntok].token_int;
                if (d == 0) {
#ifdef ENC_DEBUG
                    fprintf(stderr, "Tok %d (dig-mat, %d)\n", N_MATCH, v);
#endif
                    if (encode_token_match(ctx, ntok) < 0) return -1;
                    //ctx->lc[pnum].last[ntok].token_delta=0;
                    //ctx->token_zcount[ntok]++;
                } else if (mode == 1 && d < 256 && d >= 0
                           //&& (10+ctx->token_dcount[ntok]) > (ctx->token_icount[ntok]+ctx->token_zcount[ntok])
                           && (5+ctx->token_dcount[ntok]) > ctx->token_icount[ntok]
                           ) {
#ifdef ENC_DEBUG
                    fprintf(stderr, "Tok %d (dig-delta, %d / %d)\n", N_DDELTA, ctx->lc[pnum].last[ntok].token_int, v);
#endif
                    if (encode_token_int1(ctx, ntok, N_DDELTA, d) < 0) return -1;
                    //ctx->lc[pnum].last[ntok].token_delta=1;
                    ctx->token_dcount[ntok]++;
                } else {
#ifdef ENC_DEBUG
                    fprintf(stderr, "Tok %d (dig, %d / %d)\n", N_DIGITS, ctx->lc[pnum].last[ntok].token_int, v);
#endif
                    if (encode_token_int(ctx, ntok, N_DIGITS, v) < 0) return -1;
                    //ctx->lc[pnum].last[ntok].token_delta=0;
                    ctx->token_icount[ntok]++;
                }
            } else {
#ifdef ENC_DEBUG
                fprintf(stderr, "Tok %d (new dig, %d)\n", N_DIGITS, v);
#endif
                if (encode_token_int(ctx, ntok, N_DIGITS, v) < 0) return -1;
                //ctx->lc[pnum].last[ntok].token_delta=0;
            }
//          }

            ctx->lc[cnum].last[ntok].token_int = v;
            ctx->lc[cnum].last[ntok].token_type = N_DIGITS;

            i = s-1;
        } else {
        n_char:
            //if (!isalpha((uint8_t)name[i])) putchar(name[i]);
            if (pnum < cnum && ntok < ctx->lc[pnum].last_ntok && ctx->lc[pnum].last[ntok].token_type == N_CHAR) {
                if (name[i] == ctx->lc[pnum].last[ntok].token_int) {
#ifdef ENC_DEBUG
                    fprintf(stderr, "Tok %d (chr-mat, %c)\n", N_MATCH, name[i]);
#endif
                    if (encode_token_match(ctx, ntok) < 0) return -1;
                } else {
#ifdef ENC_DEBUG
                    fprintf(stderr, "Tok %d (chr, %c / %c)\n", N_CHAR, ctx->lc[pnum].last[ntok].token_int, name[i]);
#endif
                    if (encode_token_char(ctx, ntok, name[i]) < 0) return -1;
                }
            } else {
#ifdef ENC_DEBUG
                fprintf(stderr, "Tok %d (new chr, %c)\n", N_CHAR, name[i]);
#endif
                if (encode_token_char(ctx, ntok, name[i]) < 0) return -1;
            }

            ctx->lc[cnum].last[ntok].token_int = name[i];
            ctx->lc[cnum].last[ntok].token_type = N_CHAR;
        }

        ntok++;
        //putchar(' ');
    }

#ifdef ENC_DEBUG
    fprintf(stderr, "Tok %d (end)\n", N_END);
#endif
    if (ntok >= ctx->max_tok) {
        if (ctx->max_tok >= MAX_TOKENS)
            return -1;
        memset(&ctx->desc[ctx->max_tok << 4], 0, 16*sizeof(ctx->desc[0]));
        memset(&ctx->token_dcount[ctx->max_tok], 0, sizeof(int));
        memset(&ctx->token_icount[ctx->max_tok], 0, sizeof(int));
        ctx->max_tok = ntok+1;
    }
    if (encode_token_end(ctx, ntok) < 0) return -1;
#ifdef ENC_DEBUG
    fprintf(stderr, "ntok=%d max_tok=%d\n", ntok, ctx->max_tok);
#endif

    //printf("Encoded %.*s with %d tokens\n", len, name, ntok);
    
    ctx->lc[cnum].last_name = name;
    ctx->lc[cnum].last_ntok = ntok;
    last_context_tok *shrunk = realloc(ctx->lc[cnum].last,
                                       (ntok+1) * sizeof(*ctx->lc[cnum].last));
    if (shrunk)
        ctx->lc[cnum].last = shrunk;

    if (!ctx->lc[cnum].last)
        return -1;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x8(%rcx)
movl %eax, -0x34(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movslq -0x1c(%rbp), %rdx
movl -0x34(%rbp), %ecx
leaq -0x30(%rbp), %r8
leaq -0x28(%rbp), %r9
leaq -0x2c(%rbp), %rax
movq %rax, (%rsp)
callq 0xcc710
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x38(%rbp)
jge 0xc96e6
cmpl $0x0, -0x34(%rbp)
je 0xc96d9
movl -0x34(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x6c(%rbp)
jmp 0xc96e0
xorl %eax, %eax
movl %eax, -0x6c(%rbp)
jmp 0xc96e0
movl -0x6c(%rbp), %eax
movl %eax, -0x38(%rbp)
cmpl $0x0, -0x30(%rbp)
je 0xc9858
movslq -0x1c(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x38(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x41b0
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jne 0xc9858
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %esi
subl -0x38(%rbp), %esi
callq 0xcce70
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x38(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpl $0x0, 0x8(%rax)
je 0xc97a6
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, -0x7c(%rbp)
jmp 0xc97b0
movl $0x80, %eax
movl %eax, -0x7c(%rbp)
jmp 0xc97b0
movl -0x7c(%rbp), %eax
movl %eax, -0x3c(%rbp)
movslq -0x3c(%rbp), %rax
imulq $0xc, %rax, %rdi
callq 0x4650
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x10(%rax)
jne 0xc9801
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xca88c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x38(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq 0x8(%rax), %rax
imulq $0xc, %rax, %rdx
callq 0x43b0
movl $0x0, -0x4(%rbp)
jmp 0xca88c
movl $0x600, %edi            # imm = 0x600
callq 0x4650
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x10(%rax)
jne 0xc98a0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xca88c
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %esi
subl -0x38(%rbp), %esi
callq 0xccea0
movl $0x1, -0x40(%rbp)
cmpl $0x24, -0x2c(%rbp)
jne 0xc9a1d
movq -0x10(%rbp), %rcx
movl $0x25, %eax
cmpl 0x14420(%rcx), %eax
jl 0xc9973
jmp 0xc98d7
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rax
movl 0x14420(%rax), %eax
shll $0x4, %eax
cltq
imulq $0x28, %rax, %rax
addq %rax, %rdi
xorl %esi, %esi
movl $0x280, %edx            # imm = 0x280
callq 0x4250
movq -0x10(%rbp), %rdi
addq $0x14020, %rdi          # imm = 0x14020
movq -0x10(%rbp), %rax
movslq 0x14420(%rax), %rax
shlq $0x2, %rax
addq %rax, %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x4250
movq -0x10(%rbp), %rdi
addq $0x14220, %rdi          # imm = 0x14220
movq -0x10(%rbp), %rax
movslq 0x14420(%rax), %rax
shlq $0x2, %rax
addq %rax, %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x4250
movq -0x10(%rbp), %rcx
movl 0x14420(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x14420(%rcx)
cmpl $0x25, %eax
jl 0xc98d7
jmp 0xc9973
movl $0x0, -0x24(%rbp)
cmpl $0x24, -0x24(%rbp)
jge 0xc9a0a
movq -0x10(%rbp), %rdi
movl -0x40(%rbp), %esi
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %edx
callq 0xcced0
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq 0x10(%rax), %rax
movslq -0x40(%rbp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movslq -0x40(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl $0x2, (%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0xc997a
movl $0x0, -0x28(%rbp)
movl $0x24, -0x24(%rbp)
jmp 0xc9c2d
cmpl $0x0, -0x28(%rbp)
je 0xc9c24
movl -0x40(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x14420(%rcx), %eax
jl 0xc9ac6
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rax
movl 0x14420(%rax), %eax
shll $0x4, %eax
cltq
imulq $0x28, %rax, %rax
addq %rax, %rdi
xorl %esi, %esi
movl $0x280, %edx            # imm = 0x280
callq 0x4250
movq -0x10(%rbp), %rdi
addq $0x14020, %rdi          # imm = 0x14020
movq -0x10(%rbp), %rax
movslq 0x14420(%rax), %rax
shlq $0x2, %rax
addq %rax, %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x4250
movq -0x10(%rbp), %rdi
addq $0x14220, %rdi          # imm = 0x14220
movq -0x10(%rbp), %rax
movslq 0x14420(%rax), %rax
shlq $0x2, %rax
addq %rax, %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x4250
movl -0x40(%rbp), %ecx
addl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14420(%rax)
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0xc9b89
movl -0x40(%rbp), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x38(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x8(%rcx), %eax
jge 0xc9b89
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x38(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movslq -0x40(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
cmpl $0x1, (%rax)
jne 0xc9b89
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x38(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movslq -0x40(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
cmpl -0x2c(%rbp), %eax
jne 0xc9b74
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x38(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movslq -0x2c(%rbp), %rdx
callq 0x41c0
cmpl $0x0, %eax
jne 0xc9b74
movq -0x10(%rbp), %rdi
movl -0x40(%rbp), %esi
callq 0xccf90
jmp 0xc9b87
movq -0x10(%rbp), %rdi
movl -0x40(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x2c(%rbp), %ecx
callq 0xccfc0
jmp 0xc9b9c
movq -0x10(%rbp), %rdi
movl -0x40(%rbp), %esi
movq -0x18(%rbp), %rdx
movl -0x2c(%rbp), %ecx
callq 0xccfc0
movl -0x2c(%rbp), %ecx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq 0x10(%rax), %rax
movslq -0x40(%rbp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movslq -0x40(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movl -0x40(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x40(%rbp)
movslq %ecx, %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl $0x1, (%rax)
movl -0x2c(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0xc9c2b
movl $0x0, -0x24(%rbp)
jmp 0xc9c2d
jmp 0xc9c2f
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0xca70e
movl -0x40(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x14420(%rcx), %eax
jl 0xc9cf6
movq -0x10(%rbp), %rax
cmpl $0x80, 0x14420(%rax)
jl 0xc9c6a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xca88c
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rax
movl 0x14420(%rax), %eax
shll $0x4, %eax
cltq
imulq $0x28, %rax, %rax
addq %rax, %rdi
xorl %esi, %esi
movl $0x280, %edx            # imm = 0x280
callq 0x4250
movq -0x10(%rbp), %rdi
addq $0x14020, %rdi          # imm = 0x14020
movq -0x10(%rbp), %rax
movslq 0x14420(%rax), %rax
shlq $0x2, %rax
addq %rax, %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x4250
movq -0x10(%rbp), %rdi
addq $0x14220, %rdi          # imm = 0x14220
movq -0x10(%rbp), %rax
movslq 0x14420(%rax), %rax
shlq $0x2, %rax
addq %rax, %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x4250
movl -0x40(%rbp), %ecx
addl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14420(%rax)
callq 0x44f0
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movslq -0x24(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
je 0xc9f93
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %ecx
xorl %eax, %eax
cmpl -0x1c(%rbp), %ecx
movb %al, -0x7d(%rbp)
jge 0xc9d8d
callq 0x44f0
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movslq -0x44(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %ecx
andl $0x400, %ecx            # imm = 0x400
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x7e(%rbp)
jne 0xc9d87
callq 0x44f0
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movslq -0x44(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x4, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x7e(%rbp)
movb -0x7e(%rbp), %al
movb %al, -0x7d(%rbp)
movb -0x7d(%rbp), %al
testb $0x1, %al
jne 0xc9d96
jmp 0xc9da1
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0xc9d28
movl -0x44(%rbp), %eax
subl -0x24(%rbp), %eax
cmpl $0x1, %eax
jne 0xc9db1
jmp 0xca5a3
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0xc9edd
movl -0x40(%rbp), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x38(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x8(%rcx), %eax
jge 0xc9edd
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x38(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movslq -0x40(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
cmpl $0x1, (%rax)
jne 0xc9edd
movl -0x44(%rbp), %eax
subl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x38(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movq 0x10(%rcx), %rcx
movslq -0x40(%rbp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x4(%rcx), %eax
jne 0xc9eab
movq -0x18(%rbp), %rdi
movslq -0x24(%rbp), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x38(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x38(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movslq -0x40(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movslq 0x8(%rax), %rax
addq %rax, %rsi
movl -0x44(%rbp), %eax
subl -0x24(%rbp), %eax
movslq %eax, %rdx
callq 0x41c0
cmpl $0x0, %eax
jne 0xc9eab
movq -0x10(%rbp), %rdi
movl -0x40(%rbp), %esi
callq 0xccf90
cmpl $0x0, %eax
jge 0xc9ea9
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xca88c
jmp 0xc9edb
movq -0x10(%rbp), %rdi
movl -0x40(%rbp), %esi
movq -0x18(%rbp), %rdx
movslq -0x24(%rbp), %rax
addq %rax, %rdx
movl -0x44(%rbp), %ecx
subl -0x24(%rbp), %ecx
callq 0xccfc0
cmpl $0x0, %eax
jge 0xc9ed9
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xca88c
jmp 0xc9edb
jmp 0xc9f0d
movq -0x10(%rbp), %rdi
movl -0x40(%rbp), %esi
movq -0x18(%rbp), %rdx
movslq -0x24(%rbp), %rax
addq %rax, %rdx
movl -0x44(%rbp), %ecx
subl -0x24(%rbp), %ecx
callq 0xccfc0
cmpl $0x0, %eax
jge 0xc9f0b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xca88c
jmp 0xc9f0d
movl -0x44(%rbp), %ecx
subl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq 0x10(%rax), %rax
movslq -0x40(%rbp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x4(%rax)
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq 0x10(%rax), %rax
movslq -0x40(%rbp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movslq -0x40(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl $0x1, (%rax)
movl -0x44(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xca6f7
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jne 0xca295
jmp 0xc9faa
movl -0x24(%rbp), %eax
movl %eax, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movl $0x0, -0x50(%rbp)
movl -0x48(%rbp), %ecx
xorl %eax, %eax
cmpl -0x1c(%rbp), %ecx
movb %al, -0x7f(%rbp)
jae 0xca004
callq 0x44f0
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movl -0x48(%rbp), %edx
movzbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %ecx
andl $0x800, %ecx            # imm = 0x800
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x7f(%rbp)
je 0xca004
movl -0x48(%rbp), %eax
subl -0x24(%rbp), %eax
cmpl $0x9, %eax
setb %al
movb %al, -0x7f(%rbp)
movb -0x7f(%rbp), %al
testb $0x1, %al
jne 0xca00d
jmp 0xca02f
imull $0xa, -0x4c(%rbp), %eax
movq -0x18(%rbp), %rcx
movl -0x48(%rbp), %edx
movsbl (%rcx,%rdx), %ecx
addl %ecx, %eax
subl $0x30, %eax
movl %eax, -0x4c(%rbp)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0xc9fbe
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0xca1c0
movl -0x40(%rbp), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x38(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x8(%rcx), %eax
jge 0xca1c0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x38(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movslq -0x40(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
cmpl $0x3, (%rax)
jne 0xca1c0
movl -0x4c(%rbp), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x38(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movq 0x10(%rcx), %rcx
movslq -0x40(%rbp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rcx
subl 0x4(%rcx), %eax
movl %eax, -0x50(%rbp)
cmpl $0x0, -0x50(%rbp)
jne 0xca103
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x38(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movslq -0x40(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl -0x48(%rbp), %ecx
subl -0x24(%rbp), %ecx
cmpl %ecx, %eax
jne 0xca103
movq -0x10(%rbp), %rdi
movl -0x40(%rbp), %esi
callq 0xccf90
cmpl $0x0, %eax
jge 0xca0fe
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xca88c
jmp 0xca1be
cmpl $0x1, -0x20(%rbp)
jne 0xca16d
cmpl $0x100, -0x50(%rbp)     # imm = 0x100
jge 0xca16d
cmpl $0x0, -0x50(%rbp)
jl 0xca16d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x38(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movslq -0x40(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl -0x48(%rbp), %ecx
subl -0x24(%rbp), %ecx
cmpl %ecx, %eax
jne 0xca16d
movq -0x10(%rbp), %rdi
movl -0x40(%rbp), %esi
movl -0x50(%rbp), %ecx
movl $0x9, %edx
callq 0xcd0e0
cmpl $0x0, %eax
jge 0xca16b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xca88c
jmp 0xca1bc
movq -0x10(%rbp), %rdi
movl -0x40(%rbp), %esi
movl -0x48(%rbp), %ecx
subl -0x24(%rbp), %ecx
movl $0x4, %edx
callq 0xcd1a0
cmpl $0x0, %eax
jge 0xca195
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xca88c
movq -0x10(%rbp), %rdi
movl -0x40(%rbp), %esi
movl -0x4c(%rbp), %ecx
movl $0x3, %edx
callq 0xcd240
cmpl $0x0, %eax
jge 0xca1ba
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xca88c
jmp 0xca1bc
jmp 0xca1be
jmp 0xca20f
movq -0x10(%rbp), %rdi
movl -0x40(%rbp), %esi
movl -0x48(%rbp), %ecx
subl -0x24(%rbp), %ecx
movl $0x4, %edx
callq 0xcd1a0
cmpl $0x0, %eax
jge 0xca1e8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xca88c
movq -0x10(%rbp), %rdi
movl -0x40(%rbp), %esi
movl -0x4c(%rbp), %ecx
movl $0x3, %edx
callq 0xcd240
cmpl $0x0, %eax
jge 0xca20d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xca88c
jmp 0xca20f
movl -0x48(%rbp), %ecx
subl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq 0x10(%rax), %rax
movslq -0x40(%rbp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movl -0x4c(%rbp), %ecx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq 0x10(%rax), %rax
movslq -0x40(%rbp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movslq -0x40(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl $0x3, (%rax)
movl -0x48(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xca6f5
callq 0x44f0
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movslq -0x24(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0xca5a1
movl -0x24(%rbp), %eax
movl %eax, -0x54(%rbp)
movl $0x0, -0x58(%rbp)
movl $0x0, -0x5c(%rbp)
movl -0x54(%rbp), %ecx
xorl %eax, %eax
cmpl -0x1c(%rbp), %ecx
movb %al, -0x80(%rbp)
jae 0xca318
callq 0x44f0
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movl -0x54(%rbp), %edx
movzbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %ecx
andl $0x800, %ecx            # imm = 0x800
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x80(%rbp)
je 0xca318
movl -0x54(%rbp), %eax
subl -0x24(%rbp), %eax
cmpl $0x9, %eax
setb %al
movb %al, -0x80(%rbp)
movb -0x80(%rbp), %al
testb $0x1, %al
jne 0xca321
jmp 0xca343
imull $0xa, -0x58(%rbp), %eax
movq -0x18(%rbp), %rcx
movl -0x54(%rbp), %edx
movsbl (%rcx,%rdx), %ecx
addl %ecx, %eax
subl $0x30, %eax
movl %eax, -0x58(%rbp)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0xca2d2
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0xca3be
movl -0x40(%rbp), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x38(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x8(%rcx), %eax
jge 0xca3be
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x38(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movslq -0x40(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
cmpl $0x3, (%rax)
jne 0xca3be
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x38(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movslq -0x40(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl -0x54(%rbp), %ecx
subl -0x24(%rbp), %ecx
cmpl %ecx, %eax
jne 0xca3be
jmp 0xc9faa
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0xca51e
movl -0x40(%rbp), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x38(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x8(%rcx), %eax
jge 0xca51e
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x38(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movslq -0x40(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
cmpl $0x7, (%rax)
jne 0xca51e
movl -0x58(%rbp), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x38(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movq 0x10(%rcx), %rcx
movslq -0x40(%rbp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rcx
subl 0x4(%rcx), %eax
movl %eax, -0x5c(%rbp)
cmpl $0x0, -0x5c(%rbp)
jne 0xca464
movq -0x10(%rbp), %rdi
movl -0x40(%rbp), %esi
callq 0xccf90
cmpl $0x0, %eax
jge 0xca45f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xca88c
jmp 0xca51c
cmpl $0x1, -0x20(%rbp)
jne 0xca4dc
cmpl $0x100, -0x5c(%rbp)     # imm = 0x100
jge 0xca4dc
cmpl $0x0, -0x5c(%rbp)
jl 0xca4dc
movq -0x10(%rbp), %rax
movslq -0x40(%rbp), %rcx
movl 0x14020(%rax,%rcx,4), %eax
addl $0x5, %eax
movq -0x10(%rbp), %rcx
movslq -0x40(%rbp), %rdx
cmpl 0x14220(%rcx,%rdx,4), %eax
jle 0xca4dc
movq -0x10(%rbp), %rdi
movl -0x40(%rbp), %esi
movl -0x5c(%rbp), %ecx
movl $0x8, %edx
callq 0xcd0e0
cmpl $0x0, %eax
jge 0xca4c1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xca88c
movq -0x10(%rbp), %rax
movslq -0x40(%rbp), %rcx
movl 0x14020(%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, 0x14020(%rax,%rcx,4)
jmp 0xca51a
movq -0x10(%rbp), %rdi
movl -0x40(%rbp), %esi
movl -0x58(%rbp), %ecx
movl $0x7, %edx
callq 0xcd240
cmpl $0x0, %eax
jge 0xca501
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xca88c
movq -0x10(%rbp), %rax
movslq -0x40(%rbp), %rcx
movl 0x14220(%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, 0x14220(%rax,%rcx,4)
jmp 0xca51c
jmp 0xca545
movq -0x10(%rbp), %rdi
movl -0x40(%rbp), %esi
movl -0x58(%rbp), %ecx
movl $0x7, %edx
callq 0xcd240
cmpl $0x0, %eax
jge 0xca543
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xca88c
jmp 0xca545
movl -0x58(%rbp), %ecx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq 0x10(%rax), %rax
movslq -0x40(%rbp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movslq -0x40(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl $0x7, (%rax)
movl -0x54(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xca6f3
jmp 0xca5a3
movl -0x38(%rbp), %eax
cmpl -0x34(%rbp), %eax
jge 0xca671
movl -0x40(%rbp), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x38(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x8(%rcx), %eax
jge 0xca671
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x38(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movslq -0x40(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
cmpl $0x2, (%rax)
jne 0xca671
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x38(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rcx
movq 0x10(%rcx), %rcx
movslq -0x40(%rbp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rcx
cmpl 0x4(%rcx), %eax
jne 0xca644
movq -0x10(%rbp), %rdi
movl -0x40(%rbp), %esi
callq 0xccf90
cmpl $0x0, %eax
jge 0xca642
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xca88c
jmp 0xca66f
movq -0x10(%rbp), %rdi
movl -0x40(%rbp), %esi
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %edx
callq 0xcced0
cmpl $0x0, %eax
jge 0xca66d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xca88c
jmp 0xca66f
jmp 0xca69c
movq -0x10(%rbp), %rdi
movl -0x40(%rbp), %esi
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %edx
callq 0xcced0
cmpl $0x0, %eax
jge 0xca69a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xca88c
jmp 0xca69c
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq 0x10(%rax), %rax
movslq -0x40(%rbp), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movslq -0x40(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl $0x2, (%rax)
jmp 0xca6f5
jmp 0xca6f7
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xc9c2f
movl -0x40(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x14420(%rcx), %eax
jl 0xca7c9
movq -0x10(%rbp), %rax
cmpl $0x80, 0x14420(%rax)
jl 0xca73d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xca88c
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movq -0x10(%rbp), %rax
movl 0x14420(%rax), %eax
shll $0x4, %eax
cltq
imulq $0x28, %rax, %rax
addq %rax, %rdi
xorl %esi, %esi
movl $0x280, %edx            # imm = 0x280
callq 0x4250
movq -0x10(%rbp), %rdi
addq $0x14020, %rdi          # imm = 0x14020
movq -0x10(%rbp), %rax
movslq 0x14420(%rax), %rax
shlq $0x2, %rax
addq %rax, %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x4250
movq -0x10(%rbp), %rdi
addq $0x14220, %rdi          # imm = 0x14220
movq -0x10(%rbp), %rax
movslq 0x14420(%rax), %rax
shlq $0x2, %rax
addq %rax, %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x4250
movl -0x40(%rbp), %ecx
addl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14420(%rax)
movq -0x10(%rbp), %rdi
movl -0x40(%rbp), %esi
callq 0xcd360
cmpl $0x0, %eax
jge 0xca7e6
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xca88c
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movl -0x40(%rbp), %ecx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
movl -0x40(%rbp), %eax
addl $0x1, %eax
cltq
imulq $0xc, %rax, %rsi
callq 0x4820
movq %rax, -0x68(%rbp)
cmpq $0x0, -0x68(%rbp)
je 0xca863
movq -0x68(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x34(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x10(%rax)
jne 0xca885
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xca88c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax,%rax)