// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl 0x8(%rdi), %ecx
movl %ecx, %eax
cltd
idivl 0x14(%rdi)
testl %edx, %edx
jne 0x2644
movq %rdi, %rbx
movslq 0x28(%rdi), %rax
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
cmpq $-0x1, %rax
jl 0x1560
movslq %ecx, %rdx
movq 0x20(%rbx), %rsi
leal 0x2(%rax), %edi
xorl %r12d, %r12d
cmpl $0x1, (%rsi,%r12,4)
je 0x1571
incq %r12
cmpq %rdi, %r12
jne 0x153a
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
jmp 0x1616
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
jmp 0x1619
movq %r12, %rdi
cmpq %rax, %rdi
jg 0x159e
leaq 0x1(%rdi), %r13
cmpl $0x1, 0x4(%rsi,%rdi,4)
movq %r13, %rdi
jne 0x1574
movq %r13, %rcx
cmpl %ecx, %eax
jl 0x15b7
leaq 0x1(%rcx), %r14
cmpl $0x1, 0x4(%rsi,%rcx,4)
movq %r14, %rcx
jne 0x158a
jmp 0x15bd
movl %r12d, %eax
shlq $0x3, %rax
addq 0x18(%rbx), %rax
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
jmp 0x1605
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movq 0x18(%rbx), %rax
movl %r12d, %ecx
movq (%rax,%rcx,8), %rdi
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x1050
movq 0x18(%rbx), %rax
movl %r13d, %ecx
movq (%rax,%rcx,8), %rdi
movslq 0x8(%rbx), %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x1050
cmpl $-0x1, %r14d
je 0x19e9
movslq %r14d, %rax
shlq $0x3, %rax
addq 0x18(%rbx), %rax
movl 0x8(%rbx), %ecx
movq (%rax), %rdi
movslq %ecx, %rdx
shlq $0x2, %rdx
xorl %esi, %esi
callq 0x1050
movl 0x28(%rbx), %eax
cmpl $-0x2, %eax
jl 0x1681
leal 0x2(%rax), %ecx
movq 0x20(%rbx), %rsi
xorl %edi, %edi
testl %ecx, %ecx
cmovlel %edi, %ecx
incl %ecx
xorl %edx, %edx
addl (%rsi,%rdi,4), %edx
incq %rdi
cmpq %rdi, %rcx
jne 0x1630
cmpl $0x3, %edx
jg 0x264d
testl %eax, %eax
jle 0x1681
movq 0x20(%rbx), %rdi
movl %eax, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
addl (%rdi,%r8,4), %r9d
incq %r8
cmpq %r8, %rcx
jne 0x1654
cmpl $0x3, %r9d
ja 0x2635
movl %r9d, %edi
leaq 0x2990(%rip), %r8       # 0x4004
movslq (%r8,%rdi,4), %rdi
addq %r8, %rdi
movq %r12, -0x58(%rbp)
jmpq *%rdi
movq 0x20(%rbx), %rcx
cltq
cmpl $0x1, (%rcx,%rax,4)
jne 0x169d
movq %rbx, %rdi
callq 0x280c
movq 0x20(%rbx), %rcx
movslq 0x28(%rbx), %rax
cmpl $0x1, 0x4(%rcx,%rax,4)
jne 0x16b4
movq %rbx, %rdi
callq 0x2856
movq 0x20(%rbx), %rcx
movslq 0x28(%rbx), %rax
cmpl $0x1, 0x8(%rcx,%rax,4)
jne 0x2635
movq %rbx, %rdi
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x29e2
movq 0x20(%rbx), %rsi
cmpl %r9d, %edx
je 0x25ec
movl 0x28(%rbx), %r15d
movslq %r15d, %r14
cmpl $0x1, (%rsi,%r14,4)
jne 0x25f4
movq %rsi, -0x88(%rbp)
movslq 0xc(%rbx), %rax
movq %rax, -0x30(%rbp)
leaq (,%rax,4), %rsi
movl $0x1, %edi
callq 0x1060
movslq 0x14(%rbx), %rcx
movq %rcx, -0x38(%rbp)
testq %rcx, %rcx
jle 0x1772
movq 0x18(%rbx), %r12
movl -0x30(%rbp), %ecx
leaq (,%rcx,4), %rdx
xorl %esi, %esi
xorl %edi, %edi
cmpl $0x0, -0x30(%rbp)
jle 0x1766
movq 0x10(%r12,%r14,8), %r8
addq %rsi, %r8
movq 0x8(%r12,%r14,8), %r9
addq %rsi, %r9
xorl %r10d, %r10d
movl (%rax,%r10,4), %r11d
xorl (%r9,%r10,4), %r11d
xorl (%r8,%r10,4), %r11d
movl %r11d, (%rax,%r10,4)
incq %r10
cmpq %r10, %rcx
jne 0x174e
incq %rdi
addq %rdx, %rsi
cmpq -0x38(%rbp), %rdi
jne 0x1735
movq %rax, -0x40(%rbp)
movq %r13, -0x48(%rbp)
movl $0x18, %edi
callq 0x10e0
movq %rax, %r13
movslq 0x10(%rbx), %r14
imulq -0x30(%rbp), %r14
shlq $0x2, %r14
xorl %r12d, %r12d
movl $0x1, %edi
movq %r14, %rsi
callq 0x1060
movq %rax, (%r13,%r12,8)
incq %r12
cmpq $0x3, %r12
jne 0x1797
movl 0x8(%rbx), %eax
testl %eax, %eax
jle 0x225e
movq 0x18(%rbx), %rcx
xorl %edx, %edx
testl %r15d, %r15d
js 0x17f1
movq (%r13), %rax
movl (%rax,%rdx,4), %esi
movq $-0x1, %rdi
movq 0x8(%rcx,%rdi,8), %r8
xorl (%r8,%rdx,4), %esi
movl %esi, (%rax,%rdx,4)
movslq 0x28(%rbx), %r15
incq %rdi
cmpq %r15, %rdi
jl 0x17d6
movl 0x8(%rbx), %eax
incq %rdx
movslq %eax, %rsi
cmpq %rsi, %rdx
jl 0x17c3
movl 0x14(%rbx), %edi
jmp 0x2262
movq %r14, -0x68(%rbp)
movq %r13, -0x48(%rbp)
movl $0x18, %edi
callq 0x10e0
movq %rax, %r12
movslq 0x10(%rbx), %r14
movslq 0xc(%rbx), %rcx
movl %ecx, %r15d
movq %r14, -0x38(%rbp)
movq %rcx, -0x30(%rbp)
imulq %rcx, %r14
shlq $0x2, %r14
xorl %r13d, %r13d
movl $0x1, %edi
movq %r14, %rsi
callq 0x1060
movq %rax, (%r12,%r13,8)
incq %r13
cmpq $0x3, %r13
jne 0x1837
movq -0x30(%rbp), %rax
leaq (,%rax,4), %r14
movl $0x1, %edi
movq %r14, %rsi
callq 0x1060
movq %rax, -0x70(%rbp)
movl $0x1, %edi
movq %r14, -0x40(%rbp)
movq %r14, %rsi
callq 0x1060
movq %rax, -0x88(%rbp)
movq -0x38(%rbp), %r13
leaq (,%r13,8), %rdi
callq 0x10e0
movq %rax, %r14
testl %r13d, %r13d
jle 0x18bd
xorl %r13d, %r13d
movl $0x1, %edi
movq -0x40(%rbp), %rsi
callq 0x1060
movq %rax, (%r14,%r13,8)
incq %r13
cmpq %r13, -0x38(%rbp)
jne 0x18a2
movq %r14, -0x50(%rbp)
movslq 0x14(%rbx), %rcx
testq %rcx, %rcx
jle 0x195e
movq 0x18(%rbx), %rax
movq %rax, -0x40(%rbp)
movslq 0x28(%rbx), %rax
movq %rax, -0x60(%rbp)
leaq (,%r15,4), %rax
movq %rax, -0x38(%rbp)
xorl %edi, %edi
xorl %r8d, %r8d
movq -0x88(%rbp), %rax
movq %rcx, %rdx
cmpl $0x0, -0x30(%rbp)
movq -0x70(%rbp), %rcx
jle 0x194f
movq -0x40(%rbp), %rsi
movq -0x60(%rbp), %r11
movq 0x10(%rsi,%r11,8), %r9
addq %rdi, %r9
movq 0x8(%rsi,%r11,8), %r10
addq %rdi, %r10
movq (%rsi,%r11,8), %r11
addq %rdi, %r11
xorl %r14d, %r14d
movl (%r11,%r14,4), %r13d
movl (%rcx,%r14,4), %esi
xorl (%r10,%r14,4), %esi
xorl %r13d, %esi
movl %esi, (%rcx,%r14,4)
movl (%rax,%r14,4), %esi
xorl (%r9,%r14,4), %esi
xorl %r13d, %esi
movl %esi, (%rax,%r14,4)
incq %r14
cmpq %r14, %r15
jne 0x1925
incq %r8
addq -0x38(%rbp), %rdi
movq %rdx, %rcx
cmpq %rdx, %r8
jne 0x18f6
movl 0x8(%rbx), %esi
testl %esi, %esi
jle 0x1ad1
movq 0x18(%rbx), %rax
movl 0x28(%rbx), %edx
xorl %ecx, %ecx
movq -0x58(%rbp), %r13
movq -0x70(%rbp), %r14
movq -0x50(%rbp), %r15
testl %edx, %edx
js 0x19aa
movq (%r12), %rsi
movl (%rsi,%rcx,4), %edi
movq $-0x1, %r8
movq 0x8(%rax,%r8,8), %rdx
xorl (%rdx,%rcx,4), %edi
movl %edi, (%rsi,%rcx,4)
movslq 0x28(%rbx), %rdx
incq %r8
cmpq %rdx, %r8
jl 0x1990
movl 0x8(%rbx), %esi
incq %rcx
movslq %esi, %rdi
cmpq %rdi, %rcx
jl 0x197e
movl 0x14(%rbx), %ecx
jmp 0x1add
subl %r9d, %edx
cmpl $0x1, %edx
jg 0x19f4
movq 0x20(%rbx), %rsi
movq %rbx, %rdi
callq 0x2b20
movq 0x20(%rbx), %rax
movslq 0x28(%rbx), %rcx
cmpl $0x1, 0x8(%rax,%rcx,4)
je 0x16bf
jmp 0x2635
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
jmp 0x1616
cmpl $0x2, %edx
jne 0x2635
movq 0x20(%rbx), %rsi
movl (%rsi,%rcx,4), %edx
testl %edx, %edx
jne 0x1a7a
movl 0x8(%rbx), %edi
testl %edi, %edi
jle 0x1a5f
movslq %r12d, %rcx
movl %r12d, %edx
negq %rdx
xorl %esi, %esi
testl %eax, %eax
js 0x1a54
movq 0x18(%rbx), %rdi
movq $-0x1, %r8
leaq (%rdx,%r8), %r9
cmpq $-0x1, %r9
je 0x1a46
movq 0x8(%rdi,%r8,8), %rax
movl (%rax,%rsi,4), %eax
movq (%rdi,%rcx,8), %r9
xorl %eax, (%r9,%rsi,4)
movl 0x28(%rbx), %eax
movslq %eax, %r9
incq %r8
cmpq %r9, %r8
jl 0x1a29
movl 0x8(%rbx), %edi
incq %rsi
movslq %edi, %r8
cmpq %r8, %rsi
jl 0x1a1a
movq %rbx, %rdi
callq 0x2856
movq %rbx, %rdi
callq 0x29e2
movq 0x20(%rbx), %rsi
movslq 0x28(%rbx), %rcx
movl (%rsi,%rcx,4), %edx
cmpl $0x1, %edx
jne 0x2635
cmpl $0x1, 0x8(%rsi,%rcx,4)
jne 0x1aa2
movq %rbx, %rdi
callq 0x2b20
movq %rbx, %rdi
callq 0x29e2
movq 0x20(%rbx), %rsi
movslq 0x28(%rbx), %rcx
cmpl $0x1, 0x4(%rsi,%rcx,4)
jne 0x2635
movq %rbx, %rdi
movl %r12d, %esi
movl %r13d, %edx
callq 0x328c
movq %rbx, %rdi
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2856
movq -0x58(%rbp), %r13
movq -0x70(%rbp), %r14
movq -0x50(%rbp), %r15
testl %ecx, %ecx
js 0x1cc0
movl 0x28(%rbx), %eax
xorl %esi, %esi
testl %eax, %eax
jle 0x1b52
movl 0xc(%rbx), %ecx
xorl %edi, %edi
testl %ecx, %ecx
jle 0x1b44
movl %esi, %r8d
subl %edi, %r8d
movq 0x18(%rbx), %r9
xorl %r10d, %r10d
movl 0x10(%rbx), %r11d
leal (%r11,%r8), %eax
cltd
idivl %r11d
cmpl 0x14(%rbx), %edx
jge 0x1b39
movq (%r9,%rdi,8), %rax
imull %ecx, %edx
addl %r10d, %edx
movslq %edx, %rdx
movl (%rax,%rdx,4), %eax
movq 0x8(%r12), %rdx
imull %esi, %ecx
addl %r10d, %ecx
movslq %ecx, %rcx
xorl %eax, (%rdx,%rcx,4)
movl 0xc(%rbx), %ecx
incl %r10d
cmpl %ecx, %r10d
jl 0x1b04
movl 0x28(%rbx), %eax
incq %rdi
movslq %eax, %rdx
cmpq %rdx, %rdi
jl 0x1af3
movl 0x14(%rbx), %ecx
leaq 0x1(%rsi), %rdx
movslq %ecx, %rdi
cmpq %rdi, %rsi
movq %rdx, %rsi
jl 0x1aea
testl %ecx, %ecx
js 0x1cc0
movl 0xc(%rbx), %edx
xorl %eax, %eax
testl %edx, %edx
jle 0x1bc5
movq 0x18(%rbx), %rcx
xorl %esi, %esi
cmpl 0x14(%rbx), %eax
jge 0x1ba1
movslq 0x28(%rbx), %rdi
movq 0x8(%rcx,%rdi,8), %rdi
imull %eax, %edx
addl %esi, %edx
movslq %edx, %rdx
movl (%r14,%rsi,4), %r8d
xorl (%rdi,%rdx,4), %r8d
movq 0x8(%r12), %rdi
xorl %r8d, (%rdi,%rdx,4)
jmp 0x1bb6
movl (%r14,%rsi,4), %edi
movq 0x8(%r12), %r8
imull %eax, %edx
addl %esi, %edx
movslq %edx, %rdx
xorl %edi, (%r8,%rdx,4)
incq %rsi
movslq 0xc(%rbx), %rdx
cmpq %rdx, %rsi
jl 0x1b78
movl 0x14(%rbx), %ecx
leal 0x1(%rax), %esi
cmpl %ecx, %eax
movl %esi, %eax
jl 0x1b6e
testl %ecx, %ecx
movq -0x88(%rbp), %r14
js 0x1cc0
movl 0x28(%rbx), %eax
xorl %esi, %esi
testl %eax, %eax
jle 0x1c48
movl 0xc(%rbx), %ecx
xorl %edi, %edi
testl %ecx, %ecx
jle 0x1c3a
leal (%rdi,%rsi), %r8d
movq 0x18(%rbx), %r9
xorl %r10d, %r10d
movl 0x10(%rbx), %r11d
leal (%r11,%r8), %eax
cltd
idivl %r11d
cmpl 0x14(%rbx), %edx
jge 0x1c2f
movq (%r9,%rdi,8), %rax
imull %ecx, %edx
addl %r10d, %edx
movslq %edx, %rdx
movl (%rax,%rdx,4), %eax
movq 0x10(%r12), %rdx
imull %esi, %ecx
addl %r10d, %ecx
movslq %ecx, %rcx
xorl %eax, (%rdx,%rcx,4)
movl 0xc(%rbx), %ecx
incl %r10d
cmpl %ecx, %r10d
jl 0x1bfa
movl 0x28(%rbx), %eax
incq %rdi
movslq %eax, %rdx
cmpq %rdx, %rdi
jl 0x1beb
movl 0x14(%rbx), %ecx
leaq 0x1(%rsi), %rdx
movslq %ecx, %rdi
cmpq %rdi, %rsi
movq %rdx, %rsi
jl 0x1be2
testl %ecx, %ecx
js 0x1cc0
movl 0xc(%rbx), %edx
xorl %eax, %eax
testl %edx, %edx
jle 0x1cb7
movq 0x18(%rbx), %rcx
xorl %esi, %esi
cmpl 0x14(%rbx), %eax
jge 0x1c93
movslq 0x28(%rbx), %rdi
movq 0x10(%rcx,%rdi,8), %rdi
imull %eax, %edx
addl %esi, %edx
movslq %edx, %rdx
movl (%r14,%rsi,4), %r8d
xorl (%rdi,%rdx,4), %r8d
movq 0x10(%r12), %rdi
xorl %r8d, (%rdi,%rdx,4)
jmp 0x1ca8
movl (%r14,%rsi,4), %edi
movq 0x10(%r12), %r8
imull %eax, %edx
addl %esi, %edx
movslq %edx, %rdx
xorl %edi, (%r8,%rdx,4)
incq %rsi
movslq 0xc(%rbx), %rdx
cmpq %rdx, %rsi
jl 0x1c6a
movl 0x14(%rbx), %ecx
leal 0x1(%rax), %esi
cmpl %ecx, %eax
movl %esi, %eax
jl 0x1c60
movq %rcx, %rdi
movq -0x48(%rbp), %rax
movl %eax, %edx
subl %r13d, %edx
movq -0x68(%rbp), %rcx
subl %eax, %ecx
cltq
movq %rax, -0x80(%rbp)
movq %rdx, -0x78(%rbp)
cmpl %ecx, %edx
jne 0x1e81
movl 0xc(%rbx), %esi
movq %rdi, %rcx
testl %ecx, %ecx
js 0x1dcb
movq -0x68(%rbp), %rax
subl %r13d, %eax
movq %rax, -0x60(%rbp)
xorl %r14d, %r14d
testl %esi, %esi
jle 0x1db8
movq (%r12), %r9
movq 0x8(%r12), %rax
movq %rax, -0x30(%rbp)
movq -0x68(%rbp), %rax
addl %r14d, %eax
movq %rax, -0x38(%rbp)
movq 0x10(%r12), %rax
movq %rax, -0x40(%rbp)
movq %r15, %rax
movl %r14d, %r15d
subl %r13d, %r15d
movq (%rax,%r14,8), %rdi
movq -0x60(%rbp), %rax
leal (%rax,%r14), %ecx
xorl %r13d, %r13d
movl %r14d, %eax
imull %esi, %eax
movslq %eax, %r11
addq %r13, %r11
movl 0x10(%rbx), %r10d
movl %ecx, %eax
cltd
idivl %r10d
imull %esi, %edx
movslq %edx, %rax
addq %r13, %rax
movl (%r9,%rax,4), %r8d
xorl (%r9,%r11,4), %r8d
movq -0x38(%rbp), %rax
addl %r10d, %eax
cltd
idivl %r10d
imull %esi, %edx
movslq %edx, %rax
addq %r13, %rax
movq -0x30(%rbp), %rdx
xorl (%rdx,%rax,4), %r8d
leal (%r15,%r10), %eax
cltd
idivl %r10d
imull %esi, %edx
movslq %edx, %rax
addq %r13, %rax
movq -0x40(%rbp), %rdx
xorl (%rdx,%rax,4), %r8d
movl %r8d, (%rdi,%r13,4)
incq %r13
movslq 0xc(%rbx), %rsi
cmpq %rsi, %r13
jl 0x1d41
movl 0x14(%rbx), %ecx
movq -0x58(%rbp), %r13
movq -0x50(%rbp), %r15
leaq 0x1(%r14), %rax
movslq %ecx, %rdx
cmpq %rdx, %r14
movq %rax, %r14
jl 0x1d00
movl 0x10(%rbx), %eax
subl -0x68(%rbp), %r13d
leal (%rax,%r13), %edi
decl %edi
testl %esi, %esi
jle 0x1e11
movslq %edi, %rax
movq (%r15,%rax,8), %rax
movq 0x18(%rbx), %rcx
movq -0x80(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
xorl %edx, %edx
movl (%rax,%rdx,4), %r8d
imull %edi, %esi
movslq %esi, %rsi
addq %rdx, %rsi
movl %r8d, (%rcx,%rsi,4)
incq %rdx
movslq 0xc(%rbx), %rsi
cmpq %rsi, %rdx
jl 0x1df1
movl 0x14(%rbx), %ecx
decl %ecx
je 0x2210
movq 0x18(%rbx), %r8
leal (%rdi,%r13), %eax
movl 0x10(%rbx), %r9d
addl %r9d, %eax
cltd
idivl %r9d
testl %esi, %esi
jle 0x1e76
movslq %edx, %rax
movq (%r15,%rax,8), %rax
movq %rcx, %r10
movq -0x80(%rbp), %rcx
movq (%r8,%rcx,8), %r9
movq %r10, %rcx
xorl %r10d, %r10d
movl %esi, %r11d
imull %edi, %r11d
movslq %r11d, %r11
addq %r10, %r11
movl (%r9,%r11,4), %r11d
xorl (%rax,%r10,4), %r11d
imull %edx, %esi
movslq %esi, %rsi
addq %r10, %rsi
movl %r11d, (%r9,%rsi,4)
incq %r10
movslq 0xc(%rbx), %rsi
cmpq %rsi, %r10
jl 0x1e48
movl %edx, %edi
decl %ecx
jne 0x1e1d
jmp 0x2210
movl %ecx, -0x48(%rbp)
movl $0x18, %edi
callq 0x10e0
movq %rax, %r14
movslq 0x10(%rbx), %rax
movq %rax, -0x30(%rbp)
movq %rax, %rsi
shlq $0x2, %rsi
xorl %r15d, %r15d
movl $0x1, %edi
movq %rsi, %r13
callq 0x1060
movq %r13, %rsi
movq %rax, (%r14,%r15,8)
incq %r15
cmpq $0x3, %r15
jne 0x1ea3
movb $0x1, %al
movl %eax, -0x8c(%rbp)
movq -0x30(%rbp), %r8
testl %r8d, %r8d
js 0x1fa8
leal 0x1(%r8), %r9d
xorl %r11d, %r11d
movq -0x78(%rbp), %rax
movl %eax, %ecx
movq -0x68(%rbp), %r10
movl -0x48(%rbp), %edi
movq -0x58(%rbp), %r15
movl %ecx, %eax
cltd
idivl %r8d
testl %edx, %edx
je 0x1f06
incl %r11d
addl %edi, %ecx
cmpl %r11d, %r9d
jne 0x1eed
movl %r9d, %r11d
jmp 0x1f0f
testl %r11d, %r11d
je 0x1fa8
movq (%r14), %rdi
movq 0x8(%r14), %r8
movq 0x10(%r14), %r9
subl %r15d, %r10d
movq %r10, -0x30(%rbp)
xorl %ecx, %ecx
movl %r11d, -0x38(%rbp)
movq -0x50(%rbp), %r15
movq -0x78(%rbp), %r13
movl -0x48(%rbp), %r10d
movl %ecx, %eax
cltd
idivl 0x10(%rbx)
movslq %edx, %rax
incl (%rdi,%rax,4)
leal (%rcx,%r13), %eax
cltd
idivl 0x10(%rbx)
movslq %edx, %rax
incl (%r8,%rax,4)
movq -0x30(%rbp), %rax
leal (%rax,%rcx), %esi
movl %esi, %eax
cltd
idivl 0x10(%rbx)
movslq %edx, %rax
incl (%r9,%rax,4)
movl %ecx, %eax
cltd
idivl 0x10(%rbx)
movslq %edx, %rax
incl (%r9,%rax,4)
addl %r10d, %ecx
movl %ecx, %eax
cltd
idivl 0x10(%rbx)
movslq %edx, %rax
incl (%r8,%rax,4)
movl %esi, %eax
cltd
idivl 0x10(%rbx)
movslq %edx, %rax
incl (%rdi,%rax,4)
decl %r11d
jne 0x1f33
movslq 0x10(%rbx), %rsi
movq %rsi, -0x30(%rbp)
shlq $0x2, %rsi
movl $0x0, -0x8c(%rbp)
jmp 0x1fb7
movl $0x0, -0x38(%rbp)
movq -0x50(%rbp), %r15
movq -0x78(%rbp), %r13
movl $0x1, %edi
callq 0x1060
movq %rax, %rcx
movq -0x30(%rbp), %r9
testl %r9d, %r9d
jle 0x1ff2
movl %r9d, %eax
xorl %edx, %edx
xorl %esi, %esi
movq (%r14,%rsi,8), %rdi
cmpl $0x1, (%rdi,%rdx,4)
jne 0x1fe1
incl (%rcx,%rdx,4)
incq %rsi
cmpq $0x3, %rsi
jne 0x1fd4
incq %rdx
cmpq %rax, %rdx
jne 0x1fd2
movl 0x14(%rbx), %r8d
testl %r8d, %r8d
js 0x2147
movq $0x0, -0x30(%rbp)
movl 0x10(%rbx), %eax
testl %eax, %eax
jle 0x206b
xorl %r8d, %r8d
movl (%rcx,%r8,4), %edx
andl $-0x2, %edx
cmpl $0x2, %edx
jne 0x2060
movl 0xc(%rbx), %r10d
testl %r10d, %r10d
jle 0x2060
movq (%r12), %r9
movq -0x30(%rbp), %rax
leal (%r8,%rax), %esi
movq (%r15,%rax,8), %r11
xorl %r14d, %r14d
movl %esi, %eax
cltd
idivl 0x10(%rbx)
imull %r10d, %edx
movslq %edx, %rax
addq %r14, %rax
movl (%r9,%rax,4), %eax
xorl %eax, (%r11,%r14,4)
incq %r14
movslq 0xc(%rbx), %r10
cmpq %r10, %r14
jl 0x2039
movl 0x10(%rbx), %eax
incq %r8
movslq %eax, %rdx
cmpq %rdx, %r8
jl 0x2011
cmpb $0x0, -0x8c(%rbp)
jne 0x2122
movq -0x68(%rbp), %rax
movq -0x30(%rbp), %rdx
addl %edx, %eax
movq %rax, -0x40(%rbp)
movl %edx, %eax
subl -0x58(%rbp), %eax
movl %eax, -0x60(%rbp)
movl 0xc(%rbx), %r15d
xorl %r9d, %r9d
testl %r15d, %r15d
jle 0x2115
movq 0x8(%r12), %r10
movq 0x10(%r12), %r11
movl %r9d, %r14d
imull -0x48(%rbp), %r14d
movq -0x40(%rbp), %rax
leal (%rax,%r14), %r13d
movq -0x50(%rbp), %rax
movq -0x30(%rbp), %rdx
movq (%rax,%rdx,8), %rsi
addl -0x60(%rbp), %r14d
xorl %r8d, %r8d
movl 0x10(%rbx), %edi
leal (%rdi,%r13), %eax
cltd
idivl %edi
imull %r15d, %edx
movslq %edx, %rax
addq %r8, %rax
movl (%rsi,%r8,4), %edi
xorl (%r10,%rax,4), %edi
movl %edi, (%rsi,%r8,4)
movl 0x10(%rbx), %r15d
leal (%r14,%r15), %eax
cltd
idivl %r15d
movslq 0xc(%rbx), %rax
movslq %edx, %rdx
imulq %rax, %rdx
addq %r8, %rdx
xorl (%r11,%rdx,4), %edi
movl %edi, (%rsi,%r8,4)
incq %r8
movslq 0xc(%rbx), %r15
cmpq %r15, %r8
jl 0x20c7
incl %r9d
cmpl -0x38(%rbp), %r9d
jne 0x2095
movq -0x30(%rbp), %rdx
leaq 0x1(%rdx), %rax
movslq 0x14(%rbx), %r8
cmpq %r8, %rdx
movq %rax, -0x30(%rbp)
movq -0x50(%rbp), %r15
movq -0x78(%rbp), %r13
jl 0x2007
movl 0x10(%rbx), %r9d
leal -0x1(,%r13,2), %eax
cltd
idivl %r9d
movl %edx, %ecx
movl 0xc(%rbx), %edi
testl %edi, %edi
jle 0x2195
leal -0x1(%r13), %eax
cltq
movq (%r15,%rax,8), %rax
movq 0x18(%rbx), %rdx
movq -0x80(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
xorl %esi, %esi
movl (%rax,%rsi,4), %r8d
imull %ecx, %edi
movslq %edi, %rdi
addq %rsi, %rdi
movl %r8d, (%rdx,%rdi,4)
incq %rsi
movslq 0xc(%rbx), %rdi
cmpq %rdi, %rsi
jl 0x2174
movl 0x14(%rbx), %r8d
decl %r8d
je 0x2210
movq 0x18(%rbx), %r9
movl 0x10(%rbx), %r10d
leal (%rcx,%r13), %eax
cltd
idivl %r10d
movl %edx, %esi
testl %edi, %edi
jle 0x2200
movslq %esi, %rax
movq (%r15,%rax,8), %r10
movq -0x80(%rbp), %rax
movq (%r9,%rax,8), %r11
addl %r13d, %esi
xorl %r14d, %r14d
movl %edi, %eax
imull %ecx, %eax
cltq
addq %r14, %rax
movl (%r11,%rax,4), %r15d
xorl (%r10,%r14,4), %r15d
movl %esi, %eax
cltd
idivl 0x10(%rbx)
imull %edi, %edx
movslq %edx, %rax
addq %r14, %rax
movl %r15d, (%r11,%rax,4)
incq %r14
movslq 0xc(%rbx), %rdi
cmpq %rdi, %r14
jl 0x21c5
movl 0x10(%rbx), %r10d
movq -0x50(%rbp), %r15
jmp 0x2203
addl %r13d, %esi
movl %esi, %eax
cltd
idivl %r10d
movl %edx, %ecx
decl %r8d
jne 0x21a2
movq 0x20(%rbx), %r14
movq -0x80(%rbp), %rax
movl $0x0, (%r14,%rax,4)
movq %r12, %rdi
callq 0x10c0
movq -0x70(%rbp), %rdi
callq 0x10c0
movq -0x88(%rbp), %rdi
callq 0x10c0
movq %r15, %rdi
callq 0x10c0
movq %rbx, %rdi
movq %r14, %rsi
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2b20
movq -0x38(%rbp), %rdi
testl %edi, %edi
js 0x22e3
xorl %ecx, %ecx
testl %r15d, %r15d
jle 0x22d1
movl 0xc(%rbx), %esi
xorl %edi, %edi
testl %esi, %esi
jle 0x22c3
movl %ecx, %r8d
subl %edi, %r8d
movq 0x18(%rbx), %r9
xorl %r10d, %r10d
movl 0x10(%rbx), %r11d
leal (%r11,%r8), %eax
cltd
idivl %r11d
cmpl 0x14(%rbx), %edx
jge 0x22b7
movq (%r9,%rdi,8), %rax
imull %esi, %edx
addl %r10d, %edx
movslq %edx, %rdx
movl (%rax,%rdx,4), %eax
movq 0x8(%r13), %rdx
imull %ecx, %esi
addl %r10d, %esi
movslq %esi, %rsi
xorl %eax, (%rdx,%rsi,4)
movl 0xc(%rbx), %esi
incl %r10d
cmpl %esi, %r10d
jl 0x2283
movl 0x28(%rbx), %r15d
incq %rdi
movslq %r15d, %rax
cmpq %rax, %rdi
jl 0x2272
movl 0x14(%rbx), %edi
leaq 0x1(%rcx), %rax
movslq %edi, %rdx
cmpq %rdx, %rcx
movq %rax, %rcx
jl 0x2268
movl 0x8(%rbx), %eax
testl %eax, %eax
jle 0x230f
movq 0x18(%rbx), %rcx
movq 0x8(%r13), %rdx
xorl %esi, %esi
movslq 0x28(%rbx), %rax
movq 0x8(%rcx,%rax,8), %rax
movl (%rax,%rsi,4), %eax
xorl %eax, (%rdx,%rsi,4)
incq %rsi
movslq 0x8(%rbx), %rax
cmpq %rax, %rsi
jl 0x22f1
movl 0x14(%rbx), %edi
testl %edi, %edi
js 0x238f
movl 0x28(%rbx), %eax
xorl %ecx, %ecx
testl %eax, %eax
jle 0x237d
movl 0xc(%rbx), %esi
xorl %edi, %edi
testl %esi, %esi
jle 0x236f
leal (%rdi,%rcx), %r8d
movq 0x18(%rbx), %r9
xorl %r10d, %r10d
movl 0x10(%rbx), %r11d
leal (%r11,%r8), %eax
cltd
idivl %r11d
cmpl 0x14(%rbx), %edx
jge 0x2364
movq (%r9,%rdi,8), %rax
imull %esi, %edx
addl %r10d, %edx
movslq %edx, %rdx
movl (%rax,%rdx,4), %eax
movq 0x10(%r13), %rdx
imull %ecx, %esi
addl %r10d, %esi
movslq %esi, %rsi
xorl %eax, (%rdx,%rsi,4)
movl 0xc(%rbx), %esi
incl %r10d
cmpl %esi, %r10d
jl 0x2330
movl 0x28(%rbx), %eax
incq %rdi
movslq %eax, %rdx
cmpq %rdx, %rdi
jl 0x2321
movl 0x14(%rbx), %edi
leaq 0x1(%rcx), %rdx
movslq %edi, %rsi
cmpq %rsi, %rcx
movq %rdx, %rcx
jl 0x2318
movl 0x8(%rbx), %eax
testl %eax, %eax
jle 0x23b8
movq 0x18(%rbx), %rax
movq 0x10(%r13), %rcx
xorl %edx, %edx
movslq 0x28(%rbx), %rsi
movq 0x10(%rax,%rsi,8), %rsi
movl (%rsi,%rdx,4), %esi
xorl %esi, (%rcx,%rdx,4)
incq %rdx
movslq 0x8(%rbx), %rsi
cmpq %rsi, %rdx
jl 0x239d
movslq 0x10(%rbx), %r14
leaq (,%r14,8), %rdi
callq 0x10e0
movq %rax, %rdi
movl 0xc(%rbx), %r15d
testq %r14, %r14
movq %rax, -0x60(%rbp)
jle 0x2405
movslq %r15d, %rcx
shlq $0x2, %rcx
movq %rcx, -0x30(%rbp)
xorl %r12d, %r12d
movl $0x1, %edi
movq -0x30(%rbp), %rsi
callq 0x1060
movq -0x60(%rbp), %rdi
movq %rax, (%rdi,%r12,8)
incq %r12
cmpq %r12, %r14
jne 0x23e7
movl 0x14(%rbx), %ecx
testl %ecx, %ecx
js 0x24fe
movq -0x48(%rbp), %rax
subl -0x58(%rbp), %eax
movq %rax, -0x70(%rbp)
xorl %esi, %esi
movq -0x40(%rbp), %r12
testl %r15d, %r15d
jle 0x24e5
movq (%r13), %r8
movq 0x8(%r13), %rax
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rax
addl %esi, %eax
movq %rax, -0x38(%rbp)
movq 0x10(%r13), %rax
movq %rax, -0x40(%rbp)
movl %esi, %r14d
subl -0x58(%rbp), %r14d
movq (%rdi,%rsi,8), %rax
movq %rax, -0x50(%rbp)
movq -0x70(%rbp), %rax
leal (%rax,%rsi), %ecx
movq %r12, %r11
xorl %r12d, %r12d
movl %esi, %eax
imull %r15d, %eax
movslq %eax, %rdi
addq %r12, %rdi
movl 0x10(%rbx), %r10d
movl %ecx, %eax
cltd
idivl %r10d
imull %r15d, %edx
movslq %edx, %rax
addq %r12, %rax
movl (%r8,%rax,4), %r9d
xorl (%r8,%rdi,4), %r9d
movq -0x38(%rbp), %rax
addl %r10d, %eax
cltd
idivl %r10d
imull %r15d, %edx
movslq %edx, %rax
addq %r12, %rax
movq -0x30(%rbp), %rdx
xorl (%rdx,%rax,4), %r9d
leal (%r14,%r10), %eax
cltd
idivl %r10d
imull %r15d, %edx
movslq %edx, %rax
addq %r12, %rax
movq -0x40(%rbp), %rdx
xorl (%rdx,%rax,4), %r9d
xorl (%r11,%r12,4), %r9d
movq -0x50(%rbp), %rax
movl %r9d, (%rax,%r12,4)
incq %r12
movslq 0xc(%rbx), %r15
cmpq %r15, %r12
jl 0x2464
movl 0x14(%rbx), %ecx
movq %r11, %r12
movq -0x60(%rbp), %rdi
leaq 0x1(%rsi), %rax
movslq %ecx, %rdx
cmpq %rdx, %rsi
movq %rax, %rsi
jl 0x2421
movl 0x10(%rbx), %r14d
jmp 0x2502
movq -0x40(%rbp), %r12
movq -0x48(%rbp), %rsi
notl %esi
addl -0x58(%rbp), %esi
addl %r14d, %esi
testl %r15d, %r15d
jle 0x2548
movslq %esi, %rax
movq (%rdi,%rax,8), %rax
movq 0x18(%rbx), %rcx
xorl %edx, %edx
movl (%rax,%rdx,4), %edi
movslq 0x28(%rbx), %r8
movq (%rcx,%r8,8), %r8
imull %esi, %r15d
movslq %r15d, %r9
addq %rdx, %r9
movl %edi, (%r8,%r9,4)
incq %rdx
movslq 0xc(%rbx), %r15
cmpq %r15, %rdx
jl 0x2520
movl 0x14(%rbx), %ecx
decl %ecx
je 0x25b5
movq -0x58(%rbp), %rdi
subl -0x48(%rbp), %edi
movq 0x18(%rbx), %r8
movl 0x10(%rbx), %r9d
leal (%rdi,%rsi), %eax
addl %r9d, %eax
cltd
idivl %r9d
testl %r15d, %r15d
jle 0x25af
movslq %edx, %rax
movq -0x60(%rbp), %r9
movq (%r9,%rax,8), %rax
xorl %r9d, %r9d
movslq 0x28(%rbx), %r10
movq (%r8,%r10,8), %r10
movl %r15d, %r11d
imull %esi, %r11d
movslq %r11d, %r11
addq %r9, %r11
movl (%r10,%r11,4), %r11d
xorl (%rax,%r9,4), %r11d
imull %edx, %r15d
movslq %r15d, %r14
addq %r9, %r14
movl %r11d, (%r10,%r14,4)
incq %r9
movslq 0xc(%rbx), %r15
cmpq %r15, %r9
jl 0x2578
movl %edx, %esi
decl %ecx
jne 0x2557
movslq 0x28(%rbx), %rax
movq -0x88(%rbp), %r14
movl $0x0, (%r14,%rax,4)
movq %r13, %rdi
callq 0x10c0
movq %r12, %rdi
callq 0x10c0
movq -0x60(%rbp), %rdi
callq 0x10c0
movq %r14, %rsi
movq -0x58(%rbp), %r12
movq -0x48(%rbp), %r13
movq %rbx, %rdi
callq 0x2b20
movq 0x20(%rbx), %rsi
movslq 0x28(%rbx), %rax
cmpl $0x1, 0x4(%rsi,%rax,4)
jne 0x2621
movq %rbx, %rdi
movl %r12d, %esi
movl %r13d, %edx
callq 0x328c
movq %rbx, %rdi
callq 0x2856
movq 0x20(%rbx), %rsi
movslq 0x28(%rbx), %rax
cmpl $0x1, 0x8(%rsi,%rax,4)
jne 0x2635
movq %rbx, %rdi
callq 0x2b20
jmp 0x16bf
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1a3f(%rip), %rdi      # 0x408a
jmp 0x2654
leaq 0x1a20(%rip), %rdi      # 0x4074
callq 0x1110
movl $0x1, %edi
callq 0x10d0
nop