// File: syzcch[P]FEC_C_version/./fec_star.h
// Function: star::decoding()
void decoding()
    {
        int i,j,k,m,stripe;
        int rs_nbr = 0;      /*rs_nbr means error data number*/
        int rs_data_nbr = 0; /*rs_data_nbr means how many error data in original data*/
        int rs_check_nbr = 0;/*rs_check_nbr means how many error data in redundancy data*/
        int rs_disk1 = -1;
        int rs_disk2 = -1;
        int rs_disk3 = -1;

        if( check_data_size % block_nbr != 0)
        {
            printf(" Cannot  striping. wrong DATA_LENGTH!\n");
            exit(1);
        }

        for(i = 0; i < data_disk_nbr+ 2; i++)
        {
            if(restarts[i] == 1)
            {
                rs_disk1 = i;
                break;
            }
        }
        if( rs_disk1 != -1)
        {
            for( i = rs_disk1 + 1; i < data_disk_nbr + 2; i++)
            {
                if(restarts[i] == 1)
                {
                    rs_disk2 = i;
                    break;
                }
            }
        }
        if(rs_disk2 != -1)
        {
            for( i = rs_disk2 + 1; i < data_disk_nbr + 2; i++)
            {
                if(restarts[i] == 1)
                {
                    rs_disk3 = i;
                    break;
                }
            }
        }

        if(rs_disk1 != -1)memset(check_data[rs_disk1], 0,check_data_size*sizeof(int));
        if(rs_disk2 != -1)memset(check_data[rs_disk2], 0,check_data_size*sizeof(int));
        if(rs_disk3 != -1)memset(check_data[rs_disk3], 0,check_data_size*sizeof(int));


//      printf("rs_disks : %d %d %d\n", rs_disk1,rs_disk2,rs_disk3);

        for( i = 0; i <= data_disk_nbr + 2; i++)
            rs_nbr += restarts[i];

        if( TOLERENCE < rs_nbr)
        {
            printf(" Too many error data!\n");
            exit(1);
        }

        //printf("rs_nbr = %d\n",rs_nbr);
        for( i = 0; i < data_disk_nbr; i++)
            rs_data_nbr += restarts[i];

        rs_check_nbr = rs_nbr - rs_data_nbr;

        if(rs_data_nbr == 0)
        {
            if(restarts[data_disk_nbr] == 1)
                STAR_encoding_row();
            if(restarts[data_disk_nbr + 1] == 1)
                STAR_encoding_diag1();
            if(restarts[data_disk_nbr + 2] == 1)
                STAR_encoding_diag2();
        }

        if(rs_data_nbr == 1)
        {
            if( rs_check_nbr <= 1)
            {
                Evenodd_decoding(restarts);
                if(restarts[data_disk_nbr + 2] == 1)
                    STAR_encoding_diag2();
            }
            if(rs_check_nbr == 2)
            {
                if( restarts[data_disk_nbr] == 0)/*no error in row checksum*/
                {
                    for( i = 0; i < check_data_size; i++)
                    {
                        for( j = 0; j <= data_disk_nbr; j++)
                        {
                            if( j != rs_disk1)
                                check_data[rs_disk1][i] ^= check_data[j][i];
                        }
                    }
                    STAR_encoding_diag1();
                    STAR_encoding_diag2();
                }
                if(restarts[data_disk_nbr] == 1)/*row checksum is broken*/
                {
                    if(restarts[data_disk_nbr + 2] == 1)
                    {
                        Evenodd_decoding(restarts);
                        STAR_encoding_diag2();
                    }
                    if(restarts[data_disk_nbr + 1] == 1)
                    {
                        Evenodd_decoding_1(rs_disk1, rs_disk2);
                        STAR_encoding_diag1();
                    }
                }
            }
        }

        if(rs_data_nbr == 2)
        {
            if(rs_check_nbr == 0)
            {
                Evenodd_decoding(restarts);
            }
            else /*rs_check_nbr == 1*/
                if(restarts[data_disk_nbr] == 1)
                {
                    int *tmp_for_s1s2;
                    tmp_for_s1s2 = (int *)malloc(sizeof(int) * block_size);
                    memset( tmp_for_s1s2, 0, sizeof(int)  * block_size);
                    for( i = 0; i < block_nbr; i++)/*s1 xor s2*/
                    {
                        for( j = 0; j < block_size; j++)
                        {
                            tmp_for_s1s2[j] ^= check_data[data_disk_nbr + 1][i * block_size + j];
                            tmp_for_s1s2[j] ^= check_data[data_disk_nbr + 2][i * block_size + j];
                        }
                    }

                    int **tmp;// storing s
                    tmp = (int **)malloc( sizeof(int *) * 3);
                    for( i = 0; i < 3; i++)
                    {
                        tmp[i] = (int *)malloc(sizeof(int) * p * block_size);
                        memset( tmp[i], 0, sizeof(int) * p * block_size);
                    }

                    for( i = 0; i < check_data_size; i++)
                    {
                        for ( j = 0; j <= data_disk_nbr; j++)
                        {
                            tmp[0][i] ^= check_data[j][i] ;
                        }
                    }
                    for( stripe = 0; stripe < block_nbr + 1; stripe++)
                    {
                        for( i = 0; i < data_disk_nbr; i++)
                        {
                            for( j = 0; j < block_size; j++)
                            {
                                k = (stripe - i + p) % p;
                                if( k < block_nbr)
                                {
                                    tmp[1][stripe * block_size + j] ^= check_data[i][k * block_size + j];
                                }
                            }
                        }
                    }
                    for(  i = 0; i < check_data_size; i++)
                    {
                        tmp[1][i] ^= check_data[data_disk_nbr + 1][i];
                    }


                    for( stripe = 0; stripe < block_nbr + 1; stripe++)
                    {
                        for( i = 0; i < data_disk_nbr; i++)
                        {
                            for( j = 0; j < block_size ; j++)
                            {
                                k = (stripe + i + p) % p;
                                if( k < block_nbr)
                                {
                                    tmp[2][stripe * block_size + j] ^= check_data[i][k * block_size + j];
                                }
                            }
                        }
                    }
                    for( i = 0 ; i < check_data_size; i++)
                    {
                        tmp[2][i] ^= check_data[data_disk_nbr + 2][i];
                    }

                    /*finish computing all s~~ ,storing them in **tmp */
                    int **tmp_for_xor;
                    tmp_for_xor = (int **)malloc( sizeof(int *) * p);
                    for( i = 0; i < p; i++)
                    {
                        tmp_for_xor[i] = (int *)malloc(sizeof(int) * block_size);
                        memset( tmp_for_xor[i], 0, sizeof(int) * block_size);
                    }

                    for( i = 0; i < block_nbr + 1; i++)
                    {
                        for( j = 0; j < block_size; j ++)
                        {
                            tmp_for_xor[i][j] = tmp[0][i * block_size + j] ^ tmp[0][((rs_disk2 - rs_disk1 + i) % p) * block_size + j]
                                                ^ tmp[1][((rs_disk2 + p + i) % p) * block_size + j] ^ tmp[2][((p - rs_disk1 + i) % p) * block_size + j]
                                                ^ tmp_for_s1s2[j];
                        }
                    }

                    /*    *tmp[0] = c[p][0] xor c[s][rs_disk2 - rs_disk1]
                          *tmp[i] = c[p][i] xor c[s][(rs_disk2 - rs_disk1 + i)%p]
                      ...................................
                    */
                    /*c[p][k] xor c[p][p-1] = tmp_for_xor[k], and [rs_disk2][p-1] is zero*/
                    k = p - 1 - ( rs_disk2 - rs_disk1);
                    for( i = 0; i< block_size; i++)
                    {
                        check_data[data_disk_nbr][k * block_size + i] = tmp_for_xor[k][i];
                    }

                    m = block_nbr - 1;
                    while(m)
                    {
                        i = (k + rs_disk1 - rs_disk2 + p) % p;

                        for( j = 0; j < block_size; j++)
                        {
                            check_data[data_disk_nbr][i * block_size + j] = tmp_for_xor[i][j] ^ check_data[data_disk_nbr][k * block_size + j];
                        }
                        k = i;
                        m--;
                    }
                    restarts[data_disk_nbr] = 0;/*restore p*/
                    free(tmp);
                    free(tmp_for_s1s2);
                    free(tmp_for_xor);

                    Evenodd_decoding( restarts);
                }

            if(restarts[data_disk_nbr + 1] == 1)
            {
                Evenodd_decoding_1(rs_disk1, rs_disk2);
                STAR_encoding_diag1();
            }
            if(restarts[data_disk_nbr + 2] == 1)
            {
                Evenodd_decoding(restarts);
                STAR_encoding_diag2();
            }
        }

        /*3 error data*/
        if(rs_data_nbr == 3)
        {
            int r,s,t,u,v;

            int **tmp;/*store s~~*/
            tmp = (int **)malloc( sizeof(int *) * 3);
            for( i = 0; i < 3; i++)
            {
                tmp[i] = (int *)malloc(sizeof(int) * p * block_size);
                memset( tmp[i], 0, sizeof(int) * p * block_size);
            }
            int *tmp_for_s1;
            tmp_for_s1 = (int *)malloc(sizeof(int) * block_size);
            memset( tmp_for_s1, 0, sizeof(int) * block_size);

            int *tmp_for_s2;
            tmp_for_s2 = (int *)malloc(sizeof(int) * block_size);
            memset( tmp_for_s2, 0, sizeof(int) * block_size);

            int **tmp_for_xor;
            tmp_for_xor = (int **)malloc( sizeof(int *) * p);
            for( i = 0; i < p; i++)
            {
                tmp_for_xor[i] = (int *)malloc(sizeof(int) * block_size);
                memset( tmp_for_xor[i], 0, sizeof(int) * block_size);
            }


            /*computing s~~*/
            for( i = 0; i < block_nbr; i++)
            {
                for( j = 0; j < block_size; j++)
                {
                    tmp_for_s1[j] ^= check_data[data_disk_nbr][i * block_size + j];
                    tmp_for_s1[j] ^= check_data[data_disk_nbr + 1][i * block_size + j];

                    tmp_for_s2[j] ^= check_data[data_disk_nbr][i * block_size + j];
                    tmp_for_s2[j] ^= check_data[data_disk_nbr + 2][i * block_size + j];
                }
            }


            for( i = 0; i < check_data_size; i++)
            {
                for ( j = 0; j <= data_disk_nbr; j++)
                {
                    tmp[0][i] ^= check_data[j][i] ;
                }
            }

            for( stripe = 0; stripe < block_nbr + 1; stripe++)
            {
                for( i = 0; i < data_disk_nbr; i++)
                {
                    for( j = 0; j < block_size; j++)
                    {
                        k = (stripe - i + p) % p;
                        if( k < block_nbr)
                        {
                            tmp[1][stripe * block_size + j] ^= check_data[i][k * block_size + j];
                        }
                    }
                }
            }
            for(  i = 0; i < block_nbr + 1; i++)
            {
                for(j = 0; j < block_size; j++)
                {
                    if( i < block_nbr)
                        tmp[1][i * block_size + j] ^= (check_data[data_disk_nbr + 1][i * block_size + j] ^ tmp_for_s1[j]);
                    else tmp[1][i * block_size + j] ^= tmp_for_s1[j];
                }
            }


            for( stripe = 0; stripe < block_nbr + 1; stripe++)
            {
                for( i = 0; i < data_disk_nbr; i++)
                {
                    for( j = 0; j < block_size ; j++)
                    {
                        k = (stripe + i + p) % p;
                        if( k < block_nbr)
                        {
                            tmp[2][stripe * block_size + j] ^= check_data[i][k * block_size + j];
                        }
                    }
                }
            }

            for( i = 0 ; i < block_nbr + 1; i++)
            {
                for(j = 0; j < block_size; j++)
                {
                    if( i < block_nbr)
                        tmp[2][i * block_size + j] ^= (check_data[data_disk_nbr + 2][i * block_size + j] ^ tmp_for_s2[j]);
                    else tmp[2][i * block_size + j] ^= tmp_for_s2[j];
                }
            }

            /*finish computing all s~~ ,storing them in **tmp */

            r = rs_disk1;
            s = rs_disk2;
            t = rs_disk3;
            u = s - r;
            v = t - s;

            /*deal with 3 error data with symmetry*/
            if( u == v)
            {
                for( i = 0; i < block_nbr + 1; i++)
                {
                    for( j = 0; j < block_size; j ++)
                    {
                        tmp_for_xor[i][j] = tmp[0][i * block_size + j] ^ tmp[0][((t - r + i) % p) * block_size + j]
                                            ^ tmp[1][((t + p + i) % p) * block_size + j] ^ tmp[2][((p - r + i) % p) * block_size + j];
                    }
                }
                /*    *tmp_for_xor[0] = c[s][0] xor c[s][t-r]
                      *tmp_for_xor[1] = c[s][1] xor c[s][(t-r+1)%p]
                      *tmp_for_xor[i] = c[s][i] xor c[s][(t-r+i)%p]
                      ...................................*/
                /*c[s][k] xor c[s][p-1] = tmp_for_xor[k],and c[s][p-1] is zero*/
                k = p - 1 -( t - r );
                for( i = 0; i< block_size; i++)
                {
                    check_data[s][k * block_size + i] = tmp_for_xor[k][i];
                }

                m = block_nbr - 1;
                while(m)
                {
                    i = (r - t + k + p) % p;

                    for( j = 0; j < block_size; j++)
                    {
                        check_data[s][i * block_size + j] = tmp_for_xor[i][j] ^ check_data[s][k * block_size + j];
                    }
                    k = i;
                    m--;
                }
            }

            /*asymmetry*/
            else if( u != v)
            {
                int d;/*d means cross*/
                int **flag;

                flag = (int**)malloc(3*sizeof(int*));
                for(i=0; i<3; i++)
                {
                    flag[i] = (int*)malloc(sizeof(int) * p);
                    memset(flag[i],0, p*sizeof(int));
                }

                for(d = 0; d <= p; d++)
                {
                    if( (u + v * d) % p == 0)
                        break;
                }

                for(i = 0; i< d ; i++ )
                {
                    /*slope -1*/
                    flag[0][(0 + i * v) % p] ++;
                    flag[1][(s - r + i * v) % p]++;
                    flag[2][(t - r + i * v) % p]++;

                    /*slope 1*/
                    flag[2][(0 + i * v) % p]++;
                    flag[1][(t-s+i * v) % p]++;
                    flag[0][(t-r+i * v) % p]++;

                }

                int *count;
                count = (int*)malloc(sizeof(int) * p);
                memset(count, 0, sizeof(int)*p);

                for(i = 0; i < p; i++) /*find how many 1 in line i*/
                {
                    for(j = 0; j<3; j++)
                    {
                        if(flag[j][i] == 1)
                            count[i]++;
                    }
                }

                for( m = 0; m < block_nbr + 1; m++)/*a xor a */
                {
                    for( i = 0; i < p ; i++)
                    {
                        if(count[i] == 2 || count[i] == 3)
                        {
                            for( j = 0; j < block_size; j++)
                                tmp_for_xor[m /** v*/][j] ^= tmp[0][((i + m /** v*/) % p) * block_size + j];
                        }
                    }
                    for( i = 0; i < d; i++)
                    {
                        for( j = 0; j < block_size; j++)
                        {
                            tmp_for_xor[m][j] ^= tmp[1][ ((t + p + 0 + i * v + m) % p) * block_size + j];
                            tmp_for_xor[m][j] ^= tmp[2][ ((p - r + 0 + i * v + m) % p) * block_size + j];
                        }
                    }
                }
                /*now,*tmp_for_xor[0] = c[s][u] xor c[s][p-u]
                       *tmp_for_xor[i] = c[s][(u + i)%p] xor c[s][ ( p-u+i)%p ]
                       ...............................................*/
                i = u - 1;
                k = (u + i) % p;/*c[s][k] xor c[s][p-1] = tmp_for_xor[k],and c[s][p-1] is zero*/
                for( j = 0; j< block_size; j++)
                {
                    check_data[s][k * block_size + j] = tmp_for_xor[i][j];
                }

                m = block_nbr - 1;
                while(m)
                {
                    i = (k + u) % p;

                    for( j = 0; j < block_size; j++)
                    {
                        check_data[s][((u + i) % p) * block_size + j] = tmp_for_xor[i][j] ^ check_data[s][k * block_size + j];
                    }
                    k = (u + i) % p;
                    m--;
                }

                /* is count[i]==3,then s = s XOR s[0][i]*/
                /*next, the value of count[u] & count[p-u] is equal 1 or 2*/
                /*
                if((count[u] == 1) && (count[p-u]==1))
                {
                    then a[s][u] XOR a[s][p-u] = s XOR s[1][t] XOR s[2][(p-r)%p] XOR s[1][(t+v)%p] XOR ......
                }
                else if(count[u] ==2)
                {
                  then using s[0][u]and s[0][p-u]
                }
                */
            }

            restarts[s] = 0;/*data s have been restore*/
            free(tmp);
            free(tmp_for_s1);
            free(tmp_for_s2);
            free(tmp_for_xor);

            Evenodd_decoding(restarts);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0xa8(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x30(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x34(%rbp) # imm = 0xFFFFFFFF
movl 0x8(%rcx), %eax
cltd
idivl 0x14(%rcx)
cmpl $0x0, %edx
je 0x27d8
leaq 0x3875(%rip), %rdi      # 0x603c
movb $0x0, %al
callq 0x2040
movl $0x1, %edi
callq 0x2160
movl $0x0, -0xc(%rbp)
movq -0xa8(%rbp), %rcx
movl -0xc(%rbp), %eax
movl 0x28(%rcx), %ecx
addl $0x2, %ecx
cmpl %ecx, %eax
jge 0x281d
movq -0xa8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0x2810
movl -0xc(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x281d
jmp 0x2812
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x27df
cmpl $-0x1, -0x2c(%rbp)
je 0x286c
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0xa8(%rbp), %rcx
movl -0xc(%rbp), %eax
movl 0x28(%rcx), %ecx
addl $0x2, %ecx
cmpl %ecx, %eax
jge 0x286a
movq -0xa8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0x285d
movl -0xc(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0x286a
jmp 0x285f
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x282c
jmp 0x286c
cmpl $-0x1, -0x30(%rbp)
je 0x28bb
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0xa8(%rbp), %rcx
movl -0xc(%rbp), %eax
movl 0x28(%rcx), %ecx
addl $0x2, %ecx
cmpl %ecx, %eax
jge 0x28b9
movq -0xa8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0x28ac
movl -0xc(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0x28b9
jmp 0x28ae
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x287b
jmp 0x28bb
cmpl $-0x1, -0x2c(%rbp)
je 0x28e3
movq -0xa8(%rbp), %rax
movq 0x18(%rax), %rcx
movslq -0x2c(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movslq 0x8(%rax), %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x2090
cmpl $-0x1, -0x30(%rbp)
je 0x290b
movq -0xa8(%rbp), %rax
movq 0x18(%rax), %rcx
movslq -0x30(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movslq 0x8(%rax), %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x2090
cmpl $-0x1, -0x34(%rbp)
je 0x2933
movq -0xa8(%rbp), %rax
movq 0x18(%rax), %rcx
movslq -0x34(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movslq 0x8(%rax), %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x2090
movl $0x0, -0xc(%rbp)
movq -0xa8(%rbp), %rcx
movl -0xc(%rbp), %eax
movl 0x28(%rcx), %ecx
addl $0x2, %ecx
cmpl %ecx, %eax
jg 0x2971
movq -0xa8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x293a
movl $0x3, %eax
cmpl -0x20(%rbp), %eax
jge 0x2993
leaq 0x36e1(%rip), %rdi      # 0x6063
movb $0x0, %al
callq 0x2040
movl $0x1, %edi
callq 0x2160
movl $0x0, -0xc(%rbp)
movq -0xa8(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x28(%rcx), %eax
jge 0x29cc
movq -0xa8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x299a
movl -0x20(%rbp), %eax
subl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x2a4a
movq -0xa8(%rbp), %rcx
movq 0x20(%rcx), %rax
movslq 0x28(%rcx), %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0x29fc
movq -0xa8(%rbp), %rdi
callq 0x4800
movq -0xa8(%rbp), %rcx
movq 0x20(%rcx), %rax
movl 0x28(%rcx), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0x2a22
movq -0xa8(%rbp), %rdi
callq 0x4880
movq -0xa8(%rbp), %rcx
movq 0x20(%rcx), %rax
movl 0x28(%rcx), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0x2a48
movq -0xa8(%rbp), %rdi
callq 0x4b10
jmp 0x2a4a
cmpl $0x1, -0x24(%rbp)
jne 0x2bd4
cmpl $0x1, -0x28(%rbp)
jg 0x2a92
movq -0xa8(%rbp), %rdi
movq 0x20(%rdi), %rsi
callq 0x4cc0
movq -0xa8(%rbp), %rcx
movq 0x20(%rcx), %rax
movl 0x28(%rcx), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0x2a90
movq -0xa8(%rbp), %rdi
callq 0x4b10
jmp 0x2a92
cmpl $0x2, -0x28(%rbp)
jne 0x2bd2
movq -0xa8(%rbp), %rcx
movq 0x20(%rcx), %rax
movslq 0x28(%rcx), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x2b4b
movl $0x0, -0xc(%rbp)
movq -0xa8(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x2b33
movl $0x0, -0x10(%rbp)
movq -0xa8(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x28(%rcx), %eax
jg 0x2b26
movl -0x10(%rbp), %eax
cmpl -0x2c(%rbp), %eax
je 0x2b19
movq -0xa8(%rbp), %rax
movq 0x18(%rax), %rcx
movslq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0xc(%rbp), %rdx
movl (%rcx,%rdx,4), %edx
movq 0x18(%rax), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0xc(%rbp), %rcx
xorl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
jmp 0x2b1b
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2ad2
jmp 0x2b28
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2abc
movq -0xa8(%rbp), %rdi
callq 0x4880
movq -0xa8(%rbp), %rdi
callq 0x4b10
movq -0xa8(%rbp), %rcx
movq 0x20(%rcx), %rax
movslq 0x28(%rcx), %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0x2bd0
movq -0xa8(%rbp), %rcx
movq 0x20(%rcx), %rax
movl 0x28(%rcx), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0x2b96
movq -0xa8(%rbp), %rdi
movq 0x20(%rdi), %rsi
callq 0x4cc0
movq -0xa8(%rbp), %rdi
callq 0x4b10
movq -0xa8(%rbp), %rcx
movq 0x20(%rcx), %rax
movl 0x28(%rcx), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0x2bce
movq -0xa8(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl -0x30(%rbp), %edx
callq 0x5720
movq -0xa8(%rbp), %rdi
callq 0x4880
jmp 0x2bd0
jmp 0x2bd2
jmp 0x2bd4
cmpl $0x2, -0x24(%rbp)
jne 0x33be
cmpl $0x0, -0x28(%rbp)
jne 0x2bf9
movq -0xa8(%rbp), %rdi
movq 0x20(%rdi), %rsi
callq 0x4cc0
jmp 0x334e
movq -0xa8(%rbp), %rcx
movq 0x20(%rcx), %rax
movslq 0x28(%rcx), %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0x334c
movq -0xa8(%rbp), %rax
movslq 0xc(%rax), %rdi
shlq $0x2, %rdi
callq 0x2180
movq %rax, %rcx
movq -0xa8(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movslq 0xc(%rax), %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x2090
movl $0x0, -0xc(%rbp)
movq -0xa8(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x14(%rcx), %eax
jge 0x2cf7
movl $0x0, -0x10(%rbp)
movq -0xa8(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x2ce7
movq -0xa8(%rbp), %rdx
movq 0x18(%rdx), %rax
movl 0x28(%rdx), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl -0xc(%rbp), %ecx
imull 0xc(%rdx), %ecx
addl -0x10(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %esi
movq -0x40(%rbp), %rax
movslq -0x10(%rbp), %rcx
xorl (%rax,%rcx,4), %esi
movl %esi, (%rax,%rcx,4)
movq 0x18(%rdx), %rax
movl 0x28(%rdx), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl -0xc(%rbp), %ecx
imull 0xc(%rdx), %ecx
addl -0x10(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
movq -0x40(%rbp), %rax
movslq -0x10(%rbp), %rcx
xorl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2c68
jmp 0x2ce9
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2c4e
movl $0x18, %edi
callq 0x2180
movq %rax, -0x48(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
jge 0x2d72
movq -0xa8(%rbp), %rax
movslq 0x10(%rax), %rdi
shlq $0x2, %rdi
movslq 0xc(%rax), %rax
imulq %rax, %rdi
callq 0x2180
movq %rax, %rsi
movq -0xa8(%rbp), %rax
movq -0x48(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movq %rsi, (%rcx,%rdx,8)
movq -0x48(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movslq 0x10(%rax), %rdx
shlq $0x2, %rdx
movslq 0xc(%rax), %rax
imulq %rax, %rdx
xorl %esi, %esi
callq 0x2090
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2d0c
movl $0x0, -0xc(%rbp)
movq -0xa8(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x2de1
movl $0x0, -0x10(%rbp)
movq -0xa8(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x28(%rcx), %eax
jg 0x2dd4
movq -0xa8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x48(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
xorl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2d8f
jmp 0x2dd6
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2d79
movl $0x0, -0x1c(%rbp)
movq -0xa8(%rbp), %rcx
movl -0x1c(%rbp), %eax
movl 0x14(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x2eba
movl $0x0, -0xc(%rbp)
movq -0xa8(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x28(%rcx), %eax
jge 0x2eaa
movl $0x0, -0x10(%rbp)
movq -0xa8(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x2e9a
movq -0xa8(%rbp), %rcx
movl -0x1c(%rbp), %eax
subl -0xc(%rbp), %eax
addl 0x10(%rcx), %eax
cltd
idivl 0x10(%rcx)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x14(%rcx), %eax
jge 0x2e8d
movq -0xa8(%rbp), %rsi
movq 0x18(%rsi), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x14(%rbp), %ecx
imull 0xc(%rsi), %ecx
addl -0x10(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x1c(%rbp), %ecx
imull 0xc(%rsi), %ecx
addl -0x10(%rbp), %ecx
movslq %ecx, %rcx
xorl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
jmp 0x2e8f
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2e21
jmp 0x2e9c
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2e07
jmp 0x2eac
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2de8
movl $0x0, -0xc(%rbp)
movq -0xa8(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x2f0c
movq -0xa8(%rbp), %rcx
movq 0x18(%rcx), %rax
movl 0x28(%rcx), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
xorl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2ec1
movl $0x0, -0x1c(%rbp)
movq -0xa8(%rbp), %rcx
movl -0x1c(%rbp), %eax
movl 0x14(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x2fe5
movl $0x0, -0xc(%rbp)
movq -0xa8(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x28(%rcx), %eax
jge 0x2fd5
movl $0x0, -0x10(%rbp)
movq -0xa8(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x2fc5
movq -0xa8(%rbp), %rcx
movl -0x1c(%rbp), %eax
addl -0xc(%rbp), %eax
addl 0x10(%rcx), %eax
cltd
idivl 0x10(%rcx)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x14(%rcx), %eax
jge 0x2fb8
movq -0xa8(%rbp), %rsi
movq 0x18(%rsi), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x14(%rbp), %ecx
imull 0xc(%rsi), %ecx
addl -0x10(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x1c(%rbp), %ecx
imull 0xc(%rsi), %ecx
addl -0x10(%rbp), %ecx
movslq %ecx, %rcx
xorl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
jmp 0x2fba
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2f4c
jmp 0x2fc7
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2f32
jmp 0x2fd7
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2f13
movl $0x0, -0xc(%rbp)
movq -0xa8(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x3037
movq -0xa8(%rbp), %rcx
movq 0x18(%rcx), %rax
movl 0x28(%rcx), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
xorl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2fec
movq -0xa8(%rbp), %rax
movslq 0x10(%rax), %rdi
shlq $0x3, %rdi
callq 0x2180
movq %rax, -0x50(%rbp)
movl $0x0, -0xc(%rbp)
movq -0xa8(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x30b5
movq -0xa8(%rbp), %rax
movslq 0xc(%rax), %rdi
shlq $0x2, %rdi
callq 0x2180
movq %rax, %rsi
movq -0xa8(%rbp), %rax
movq -0x50(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movq %rsi, (%rcx,%rdx,8)
movq -0x50(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movslq 0xc(%rax), %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x2090
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3056
movl $0x0, -0xc(%rbp)
movq -0xa8(%rbp), %rcx
movl -0xc(%rbp), %eax
movl 0x14(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x31e1
movl $0x0, -0x10(%rbp)
movq -0xa8(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x31d1
movq -0xa8(%rbp), %rsi
movq -0x48(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
imull 0xc(%rsi), %ecx
addl -0x10(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xc0(%rbp)
movq -0x48(%rbp), %rax
movq (%rax), %rcx
movl -0x30(%rbp), %eax
subl -0x2c(%rbp), %eax
addl -0xc(%rbp), %eax
cltd
idivl 0x10(%rsi)
movl -0xc0(%rbp), %eax
imull 0xc(%rsi), %edx
addl -0x10(%rbp), %edx
movslq %edx, %rdx
xorl (%rcx,%rdx,4), %eax
movl %eax, -0xbc(%rbp)
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rcx
movl -0x30(%rbp), %eax
addl 0x10(%rsi), %eax
addl -0xc(%rbp), %eax
cltd
idivl 0x10(%rsi)
movl -0xbc(%rbp), %eax
imull 0xc(%rsi), %edx
addl -0x10(%rbp), %edx
movslq %edx, %rdx
xorl (%rcx,%rdx,4), %eax
movl %eax, -0xac(%rbp)
movq -0x48(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0xb8(%rbp)
movl 0x10(%rsi), %eax
subl -0x2c(%rbp), %eax
addl -0xc(%rbp), %eax
cltd
idivl 0x10(%rsi)
movq -0xb8(%rbp), %rax
movl %edx, %ecx
movl -0xac(%rbp), %edx
imull 0xc(%rsi), %ecx
addl -0x10(%rbp), %ecx
movslq %ecx, %rcx
xorl (%rax,%rcx,4), %edx
movq -0x40(%rbp), %rax
movslq -0x10(%rbp), %rcx
xorl (%rax,%rcx,4), %edx
movq -0x50(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x30db
jmp 0x31d3
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x30bc
movq -0xa8(%rbp), %rax
movl 0x10(%rax), %eax
subl $0x1, %eax
movl -0x30(%rbp), %ecx
subl -0x2c(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0xc(%rbp)
movq -0xa8(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x3250
movq -0xa8(%rbp), %rsi
movq -0x50(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq 0x18(%rsi), %rax
movslq 0x28(%rsi), %rcx
movq (%rax,%rcx,8), %rax
movl -0x14(%rbp), %ecx
imull 0xc(%rsi), %ecx
addl -0xc(%rbp), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3200
movq -0xa8(%rbp), %rax
movl 0x14(%rax), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x330b
movq -0xa8(%rbp), %rcx
movl -0x14(%rbp), %eax
addl -0x2c(%rbp), %eax
subl -0x30(%rbp), %eax
addl 0x10(%rcx), %eax
cltd
idivl 0x10(%rcx)
movl %edx, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0xa8(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x32f7
movq -0xa8(%rbp), %rsi
movq -0x50(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq 0x18(%rsi), %rax
movslq 0x28(%rsi), %rcx
movq (%rax,%rcx,8), %rax
movl -0x14(%rbp), %ecx
imull 0xc(%rsi), %ecx
addl -0x10(%rbp), %ecx
movslq %ecx, %rcx
xorl (%rax,%rcx,4), %edx
movq 0x18(%rsi), %rax
movslq 0x28(%rsi), %rcx
movq (%rax,%rcx,8), %rax
movl -0xc(%rbp), %ecx
imull 0xc(%rsi), %ecx
addl -0x10(%rbp), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x328b
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3260
movq -0xa8(%rbp), %rcx
movq 0x20(%rcx), %rax
movslq 0x28(%rcx), %rcx
movl $0x0, (%rax,%rcx,4)
movq -0x48(%rbp), %rdi
callq 0x2150
movq -0x40(%rbp), %rdi
callq 0x2150
movq -0x50(%rbp), %rdi
callq 0x2150
movq -0xa8(%rbp), %rdi
movq 0x20(%rdi), %rsi
callq 0x4cc0
jmp 0x334e
movq -0xa8(%rbp), %rcx
movq 0x20(%rcx), %rax
movl 0x28(%rcx), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0x3386
movq -0xa8(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl -0x30(%rbp), %edx
callq 0x5720
movq -0xa8(%rbp), %rdi
callq 0x4880
movq -0xa8(%rbp), %rcx
movq 0x20(%rcx), %rax
movl 0x28(%rcx), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0x33bc
movq -0xa8(%rbp), %rdi
movq 0x20(%rdi), %rsi
callq 0x4cc0
movq -0xa8(%rbp), %rdi
callq 0x4b10
jmp 0x33be
cmpl $0x3, -0x24(%rbp)
jne 0x434a
movl $0x18, %edi
callq 0x2180
movq %rax, -0x70(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
jge 0x3443
movq -0xa8(%rbp), %rax
movslq 0x10(%rax), %rdi
shlq $0x2, %rdi
movslq 0xc(%rax), %rax
imulq %rax, %rdi
callq 0x2180
movq %rax, %rsi
movq -0xa8(%rbp), %rax
movq -0x70(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movq %rsi, (%rcx,%rdx,8)
movq -0x70(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movslq 0x10(%rax), %rdx
shlq $0x2, %rdx
movslq 0xc(%rax), %rax
imulq %rax, %rdx
xorl %esi, %esi
callq 0x2090
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x33dd
movq -0xa8(%rbp), %rax
movslq 0xc(%rax), %rdi
shlq $0x2, %rdi
callq 0x2180
movq %rax, %rcx
movq -0xa8(%rbp), %rax
movq %rcx, -0x78(%rbp)
movq -0x78(%rbp), %rdi
movslq 0xc(%rax), %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x2090
movq -0xa8(%rbp), %rax
movslq 0xc(%rax), %rdi
shlq $0x2, %rdi
callq 0x2180
movq %rax, %rcx
movq -0xa8(%rbp), %rax
movq %rcx, -0x80(%rbp)
movq -0x80(%rbp), %rdi
movslq 0xc(%rax), %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x2090
movq -0xa8(%rbp), %rax
movslq 0x10(%rax), %rdi
shlq $0x3, %rdi
callq 0x2180
movq %rax, -0x88(%rbp)
movl $0x0, -0xc(%rbp)
movq -0xa8(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x3534
movq -0xa8(%rbp), %rax
movslq 0xc(%rax), %rdi
shlq $0x2, %rdi
callq 0x2180
movq %rax, %rsi
movq -0xa8(%rbp), %rax
movq -0x88(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movq %rsi, (%rcx,%rdx,8)
movq -0x88(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movslq 0xc(%rax), %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x2090
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x34cf
movl $0x0, -0xc(%rbp)
movq -0xa8(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x14(%rcx), %eax
jge 0x363f
movl $0x0, -0x10(%rbp)
movq -0xa8(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x362f
movq -0xa8(%rbp), %rdx
movq 0x18(%rdx), %rax
movslq 0x28(%rdx), %rcx
movq (%rax,%rcx,8), %rax
movl -0xc(%rbp), %ecx
imull 0xc(%rdx), %ecx
addl -0x10(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %esi
movq -0x78(%rbp), %rax
movslq -0x10(%rbp), %rcx
xorl (%rax,%rcx,4), %esi
movl %esi, (%rax,%rcx,4)
movq 0x18(%rdx), %rax
movl 0x28(%rdx), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl -0xc(%rbp), %ecx
imull 0xc(%rdx), %ecx
addl -0x10(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %esi
movq -0x78(%rbp), %rax
movslq -0x10(%rbp), %rcx
xorl (%rax,%rcx,4), %esi
movl %esi, (%rax,%rcx,4)
movq 0x18(%rdx), %rax
movslq 0x28(%rdx), %rcx
movq (%rax,%rcx,8), %rax
movl -0xc(%rbp), %ecx
imull 0xc(%rdx), %ecx
addl -0x10(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %esi
movq -0x80(%rbp), %rax
movslq -0x10(%rbp), %rcx
xorl (%rax,%rcx,4), %esi
movl %esi, (%rax,%rcx,4)
movq 0x18(%rdx), %rax
movl 0x28(%rdx), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl -0xc(%rbp), %ecx
imull 0xc(%rdx), %ecx
addl -0x10(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
movq -0x80(%rbp), %rax
movslq -0x10(%rbp), %rcx
xorl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3555
jmp 0x3631
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x353b
movl $0x0, -0xc(%rbp)
movq -0xa8(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x36ae
movl $0x0, -0x10(%rbp)
movq -0xa8(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x28(%rcx), %eax
jg 0x36a1
movq -0xa8(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x70(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
xorl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x365c
jmp 0x36a3
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3646
movl $0x0, -0x1c(%rbp)
movq -0xa8(%rbp), %rcx
movl -0x1c(%rbp), %eax
movl 0x14(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x3787
movl $0x0, -0xc(%rbp)
movq -0xa8(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x28(%rcx), %eax
jge 0x3777
movl $0x0, -0x10(%rbp)
movq -0xa8(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x3767
movq -0xa8(%rbp), %rcx
movl -0x1c(%rbp), %eax
subl -0xc(%rbp), %eax
addl 0x10(%rcx), %eax
cltd
idivl 0x10(%rcx)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x14(%rcx), %eax
jge 0x375a
movq -0xa8(%rbp), %rsi
movq 0x18(%rsi), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x14(%rbp), %ecx
imull 0xc(%rsi), %ecx
addl -0x10(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
movq -0x70(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x1c(%rbp), %ecx
imull 0xc(%rsi), %ecx
addl -0x10(%rbp), %ecx
movslq %ecx, %rcx
xorl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
jmp 0x375c
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x36ee
jmp 0x3769
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x36d4
jmp 0x3779
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x36b5
movl $0x0, -0xc(%rbp)
movq -0xa8(%rbp), %rcx
movl -0xc(%rbp), %eax
movl 0x14(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x386c
movl $0x0, -0x10(%rbp)
movq -0xa8(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x385c
movq -0xa8(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x14(%rcx), %eax
jge 0x381f
movq -0xa8(%rbp), %rsi
movq 0x18(%rsi), %rax
movl 0x28(%rsi), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl -0xc(%rbp), %ecx
imull 0xc(%rsi), %ecx
addl -0x10(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
movq -0x78(%rbp), %rax
movslq -0x10(%rbp), %rcx
xorl (%rax,%rcx,4), %edx
movq -0x70(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
imull 0xc(%rsi), %ecx
addl -0x10(%rbp), %ecx
movslq %ecx, %rcx
xorl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
jmp 0x384c
movq -0xa8(%rbp), %rsi
movq -0x78(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x70(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
imull 0xc(%rsi), %ecx
addl -0x10(%rbp), %ecx
movslq %ecx, %rcx
xorl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
jmp 0x384e
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x37ad
jmp 0x385e
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x378e
movl $0x0, -0x1c(%rbp)
movq -0xa8(%rbp), %rcx
movl -0x1c(%rbp), %eax
movl 0x14(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x3945
movl $0x0, -0xc(%rbp)
movq -0xa8(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x28(%rcx), %eax
jge 0x3935
movl $0x0, -0x10(%rbp)
movq -0xa8(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x3925
movq -0xa8(%rbp), %rcx
movl -0x1c(%rbp), %eax
addl -0xc(%rbp), %eax
addl 0x10(%rcx), %eax
cltd
idivl 0x10(%rcx)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x14(%rcx), %eax
jge 0x3918
movq -0xa8(%rbp), %rsi
movq 0x18(%rsi), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x14(%rbp), %ecx
imull 0xc(%rsi), %ecx
addl -0x10(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
movq -0x70(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x1c(%rbp), %ecx
imull 0xc(%rsi), %ecx
addl -0x10(%rbp), %ecx
movslq %ecx, %rcx
xorl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
jmp 0x391a
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x38ac
jmp 0x3927
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3892
jmp 0x3937
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3873
movl $0x0, -0xc(%rbp)
movq -0xa8(%rbp), %rcx
movl -0xc(%rbp), %eax
movl 0x14(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x3a2a
movl $0x0, -0x10(%rbp)
movq -0xa8(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x3a1a
movq -0xa8(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x14(%rcx), %eax
jge 0x39dd
movq -0xa8(%rbp), %rsi
movq 0x18(%rsi), %rax
movl 0x28(%rsi), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl -0xc(%rbp), %ecx
imull 0xc(%rsi), %ecx
addl -0x10(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
movq -0x80(%rbp), %rax
movslq -0x10(%rbp), %rcx
xorl (%rax,%rcx,4), %edx
movq -0x70(%rbp), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
imull 0xc(%rsi), %ecx
addl -0x10(%rbp), %ecx
movslq %ecx, %rcx
xorl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
jmp 0x3a0a
movq -0xa8(%rbp), %rsi
movq -0x80(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x70(%rbp), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
imull 0xc(%rsi), %ecx
addl -0x10(%rbp), %ecx
movslq %ecx, %rcx
xorl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
jmp 0x3a0c
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x396b
jmp 0x3a1c
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x394c
movl -0x2c(%rbp), %eax
movl %eax, -0x54(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x58(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x5c(%rbp)
movl -0x58(%rbp), %eax
subl -0x54(%rbp), %eax
movl %eax, -0x60(%rbp)
movl -0x5c(%rbp), %eax
subl -0x58(%rbp), %eax
movl %eax, -0x64(%rbp)
movl -0x60(%rbp), %eax
cmpl -0x64(%rbp), %eax
jne 0x3cb3
movl $0x0, -0xc(%rbp)
movq -0xa8(%rbp), %rcx
movl -0xc(%rbp), %eax
movl 0x14(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x3b7e
movl $0x0, -0x10(%rbp)
movq -0xa8(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x3b6e
movq -0xa8(%rbp), %rsi
movq -0x70(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
imull 0xc(%rsi), %ecx
addl -0x10(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0xd8(%rbp)
movq -0x70(%rbp), %rax
movq (%rax), %rcx
movl -0x5c(%rbp), %eax
subl -0x54(%rbp), %eax
addl -0xc(%rbp), %eax
cltd
idivl 0x10(%rsi)
movl -0xd8(%rbp), %eax
imull 0xc(%rsi), %edx
addl -0x10(%rbp), %edx
movslq %edx, %rdx
xorl (%rcx,%rdx,4), %eax
movl %eax, -0xd4(%rbp)
movq -0x70(%rbp), %rax
movq 0x8(%rax), %rcx
movl -0x5c(%rbp), %eax
addl 0x10(%rsi), %eax
addl -0xc(%rbp), %eax
cltd
idivl 0x10(%rsi)
movl -0xd4(%rbp), %eax
imull 0xc(%rsi), %edx
addl -0x10(%rbp), %edx
movslq %edx, %rdx
xorl (%rcx,%rdx,4), %eax
movl %eax, -0xc4(%rbp)
movq -0x70(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0xd0(%rbp)
movl 0x10(%rsi), %eax
subl -0x54(%rbp), %eax
addl -0xc(%rbp), %eax
cltd
idivl 0x10(%rsi)
movq -0xd0(%rbp), %rax
movl %edx, %ecx
movl -0xc4(%rbp), %edx
imull 0xc(%rsi), %ecx
addl -0x10(%rbp), %ecx
movslq %ecx, %rcx
xorl (%rax,%rcx,4), %edx
movq -0x88(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3a80
jmp 0x3b70
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3a61
movq -0xa8(%rbp), %rax
movl 0x10(%rax), %eax
subl $0x1, %eax
movl -0x5c(%rbp), %ecx
subl -0x54(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0xc(%rbp)
movq -0xa8(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x3bf0
movq -0xa8(%rbp), %rsi
movq -0x88(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq 0x18(%rsi), %rax
movslq -0x58(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x14(%rbp), %ecx
imull 0xc(%rsi), %ecx
addl -0xc(%rbp), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3b9d
movq -0xa8(%rbp), %rax
movl 0x14(%rax), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x3cae
movq -0xa8(%rbp), %rcx
movl -0x54(%rbp), %eax
subl -0x5c(%rbp), %eax
addl -0x14(%rbp), %eax
addl 0x10(%rcx), %eax
cltd
idivl 0x10(%rcx)
movl %edx, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0xa8(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x3c9a
movq -0xa8(%rbp), %rsi
movq -0x88(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq 0x18(%rsi), %rax
movslq -0x58(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x14(%rbp), %ecx
imull 0xc(%rsi), %ecx
addl -0x10(%rbp), %ecx
movslq %ecx, %rcx
xorl (%rax,%rcx,4), %edx
movq 0x18(%rsi), %rax
movslq -0x58(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0xc(%rbp), %ecx
imull 0xc(%rsi), %ecx
addl -0x10(%rbp), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3c2b
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3c00
jmp 0x42fd
movl -0x60(%rbp), %eax
cmpl -0x64(%rbp), %eax
je 0x42fb
movl $0x18, %edi
callq 0x2180
movq %rax, -0x98(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
jge 0x3d33
movq -0xa8(%rbp), %rax
movslq 0x10(%rax), %rdi
shlq $0x2, %rdi
callq 0x2180
movq %rax, %rsi
movq -0xa8(%rbp), %rax
movq -0x98(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movq %rsi, (%rcx,%rdx,8)
movq -0x98(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movslq 0x10(%rax), %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x2090
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3cd7
movl $0x0, -0x8c(%rbp)
movq -0xa8(%rbp), %rcx
movl -0x8c(%rbp), %eax
cmpl 0x10(%rcx), %eax
jg 0x3d83
movq -0xa8(%rbp), %rcx
movl -0x60(%rbp), %eax
movl -0x64(%rbp), %edx
imull -0x8c(%rbp), %edx
addl %edx, %eax
cltd
idivl 0x10(%rcx)
cmpl $0x0, %edx
jne 0x3d70
jmp 0x3d83
jmp 0x3d72
movl -0x8c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8c(%rbp)
jmp 0x3d3d
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x8c(%rbp), %eax
jge 0x3ef2
movq -0xa8(%rbp), %rcx
movq -0x98(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x108(%rbp)
movl -0xc(%rbp), %eax
imull -0x64(%rbp), %eax
addl $0x0, %eax
cltd
idivl 0x10(%rcx)
movq -0x108(%rbp), %rax
movslq %edx, %rdx
movl (%rax,%rdx,4), %esi
addl $0x1, %esi
movl %esi, (%rax,%rdx,4)
movq -0x98(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x100(%rbp)
movl -0x58(%rbp), %eax
subl -0x54(%rbp), %eax
movl -0xc(%rbp), %edx
imull -0x64(%rbp), %edx
addl %edx, %eax
cltd
idivl 0x10(%rcx)
movq -0x100(%rbp), %rax
movslq %edx, %rdx
movl (%rax,%rdx,4), %esi
addl $0x1, %esi
movl %esi, (%rax,%rdx,4)
movq -0x98(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0xf8(%rbp)
movl -0x5c(%rbp), %eax
subl -0x54(%rbp), %eax
movl -0xc(%rbp), %edx
imull -0x64(%rbp), %edx
addl %edx, %eax
cltd
idivl 0x10(%rcx)
movq -0xf8(%rbp), %rax
movslq %edx, %rdx
movl (%rax,%rdx,4), %esi
addl $0x1, %esi
movl %esi, (%rax,%rdx,4)
movq -0x98(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0xf0(%rbp)
movl -0xc(%rbp), %eax
imull -0x64(%rbp), %eax
addl $0x0, %eax
cltd
idivl 0x10(%rcx)
movq -0xf0(%rbp), %rax
movslq %edx, %rdx
movl (%rax,%rdx,4), %esi
addl $0x1, %esi
movl %esi, (%rax,%rdx,4)
movq -0x98(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xe8(%rbp)
movl -0x5c(%rbp), %eax
subl -0x58(%rbp), %eax
movl -0xc(%rbp), %edx
imull -0x64(%rbp), %edx
addl %edx, %eax
cltd
idivl 0x10(%rcx)
movq -0xe8(%rbp), %rax
movslq %edx, %rdx
movl (%rax,%rdx,4), %esi
addl $0x1, %esi
movl %esi, (%rax,%rdx,4)
movq -0x98(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xe0(%rbp)
movl -0x5c(%rbp), %eax
subl -0x54(%rbp), %eax
movl -0xc(%rbp), %edx
imull -0x64(%rbp), %edx
addl %edx, %eax
cltd
idivl 0x10(%rcx)
movq -0xe0(%rbp), %rax
movslq %edx, %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3d8a
movq -0xa8(%rbp), %rax
movslq 0x10(%rax), %rdi
shlq $0x2, %rdi
callq 0x2180
movq %rax, %rcx
movq -0xa8(%rbp), %rax
movq %rcx, -0xa0(%rbp)
movq -0xa0(%rbp), %rdi
movslq 0x10(%rax), %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x2090
movl $0x0, -0xc(%rbp)
movq -0xa8(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x3f97
movl $0x0, -0x10(%rbp)
cmpl $0x3, -0x10(%rbp)
jge 0x3f8a
movq -0x98(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0xc(%rbp), %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0x3f7d
movq -0xa0(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
jmp 0x3f7f
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3f4a
jmp 0x3f8c
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3f34
movl $0x0, -0x18(%rbp)
movq -0xa8(%rbp), %rcx
movl -0x18(%rbp), %eax
movl 0x14(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x4192
movl $0x0, -0xc(%rbp)
movq -0xa8(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x10(%rcx), %eax
jge 0x407a
movq -0xa0(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpl $0x2, (%rax,%rcx,4)
je 0x3ff2
movq -0xa0(%rbp), %rax
movslq -0xc(%rbp), %rcx
cmpl $0x3, (%rax,%rcx,4)
jne 0x406a
movl $0x0, -0x10(%rbp)
movq -0xa8(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x4068
movq -0xa8(%rbp), %rcx
movq -0x70(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x110(%rbp)
movl -0xc(%rbp), %eax
addl -0x18(%rbp), %eax
cltd
idivl 0x10(%rcx)
movq -0x110(%rbp), %rax
movl %edx, %ecx
movq -0xa8(%rbp), %rdx
imull 0xc(%rdx), %ecx
addl -0x10(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
movq -0x88(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
xorl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3ff9
jmp 0x406a
jmp 0x406c
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3fbd
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x8c(%rbp), %eax
jge 0x4182
movl $0x0, -0x10(%rbp)
movq -0xa8(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x4172
movq -0xa8(%rbp), %rcx
movq -0x70(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x120(%rbp)
movl -0x5c(%rbp), %eax
addl 0x10(%rcx), %eax
addl $0x0, %eax
movl -0xc(%rbp), %edx
imull -0x64(%rbp), %edx
addl %edx, %eax
addl -0x18(%rbp), %eax
cltd
idivl 0x10(%rcx)
movq -0x120(%rbp), %rax
imull 0xc(%rcx), %edx
addl -0x10(%rbp), %edx
movslq %edx, %rdx
movl (%rax,%rdx,4), %esi
movq -0x88(%rbp), %rax
movslq -0x18(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movslq -0x10(%rbp), %rdx
xorl (%rax,%rdx,4), %esi
movl %esi, (%rax,%rdx,4)
movq -0x70(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x118(%rbp)
movl 0x10(%rcx), %eax
subl -0x54(%rbp), %eax
addl $0x0, %eax
movl -0xc(%rbp), %edx
imull -0x64(%rbp), %edx
addl %edx, %eax
addl -0x18(%rbp), %eax
cltd
idivl 0x10(%rcx)
movq -0x118(%rbp), %rax
movl %edx, %ecx
movq -0xa8(%rbp), %rdx
imull 0xc(%rdx), %ecx
addl -0x10(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
movq -0x88(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
xorl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4097
jmp 0x4174
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4081
jmp 0x4184
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3f9e
movq -0xa8(%rbp), %rcx
movl -0x60(%rbp), %eax
subl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x60(%rbp), %eax
addl -0xc(%rbp), %eax
cltd
idivl 0x10(%rcx)
movl %edx, -0x14(%rbp)
movl $0x0, -0x10(%rbp)
movq -0xa8(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x4209
movq -0xa8(%rbp), %rsi
movq -0x88(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq 0x18(%rsi), %rax
movslq -0x58(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x14(%rbp), %ecx
imull 0xc(%rsi), %ecx
addl -0x10(%rbp), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x41b6
movq -0xa8(%rbp), %rax
movl 0x14(%rax), %eax
subl $0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x42f9
movq -0xa8(%rbp), %rcx
movl -0x14(%rbp), %eax
addl -0x60(%rbp), %eax
cltd
idivl 0x10(%rcx)
movl %edx, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0xa8(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x42d7
movq -0xa8(%rbp), %rsi
movq -0x88(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movq 0x18(%rsi), %rcx
movslq -0x58(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movl -0x14(%rbp), %edx
imull 0xc(%rsi), %edx
addl -0x10(%rbp), %edx
movslq %edx, %rdx
xorl (%rcx,%rdx,4), %eax
movl %eax, -0x124(%rbp)
movq 0x18(%rsi), %rax
movslq -0x58(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x130(%rbp)
movl -0x60(%rbp), %eax
addl -0xc(%rbp), %eax
cltd
idivl 0x10(%rsi)
movq -0x130(%rbp), %rax
movl %edx, %ecx
movl -0x124(%rbp), %edx
imull 0xc(%rsi), %ecx
addl -0x10(%rbp), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x423e
movq -0xa8(%rbp), %rcx
movl -0x60(%rbp), %eax
addl -0xc(%rbp), %eax
cltd
idivl 0x10(%rcx)
movl %edx, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4219
jmp 0x42fb
jmp 0x42fd
movq -0xa8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x58(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movq -0x70(%rbp), %rdi
callq 0x2150
movq -0x78(%rbp), %rdi
callq 0x2150
movq -0x80(%rbp), %rdi
callq 0x2150
movq -0x88(%rbp), %rdi
callq 0x2150
movq -0xa8(%rbp), %rdi
movq 0x20(%rdi), %rsi
callq 0x4cc0
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)