brute Andrey1800 (cuda) with solution

#include <stdio.h>

#define THREADX 16
#define THREADY 16

#define BLOCKSX 16
#define BLOCKSY 16

__global__
void kern(char *skey, char *solution, int *ans)
{
    char key[ 8 ];
    key[ 0 ] = skey[ 0 ];
    key[ 1 ] = skey[ 1 ];
    key[ 2 ] = skey[ 2 ];
    key[ 3 ] = skey[ 3 ];
    key[ 4 ] = blockIdx.x;
    key[ 5 ] = blockIdx.y;

    key[ 6 ] = threadIdx.x;
    key[ 7 ] = threadIdx.y;

    long long a = 0x86289CFB;
    long long b = 0x48AEEFD4;
    int i;
    for (i = 0; i < 8; i++) {
        char code = key[i];
        int xor1 = a >> 31;
        int xor2 = 0;
        int j = 0;
        while (j < 64) {
            if ((((b & 0x40BD223D) << 32) + (a & 0x61AC9F6E)) & (1 << j)) xor2++;
            j++;
        }
        xor2 = xor2 & 1;
        switch (code)
        {
            case 0:
                a = a * 2 ^ 0x4;
                b = b * 2;
                //printf( "a = %lld   b = %lld\n", a, b );
                break;
            case 1:
                a = a * 2;
                b = (b * 2) ^ 0x2;
                //printf( "[1] a = %d   b = %d\n", a, b );
                break;
            case 2:
                a = a * 2;
                b = b * 2;
                //printf( "a = %lld   b = %lld\n", a, b );
                break;
            case 3:
                b = b * 2;
                a = a * 2 ^ 0x80000000;
                //printf( "a = %lld   b = %lld\n", a, b );
                break;
            case 4:
                b = b * 2 ^ 0x40000000;
                a = a * 2;
                //printf( "a = %lld   b = %lld\n", a, b );
                break;
            case 5:
                b = b * 2;
                a = a * 2 ^ 0x20000000;
                //printf( "a = %lld   b = %lld\n", a, b );
                break;
            case 6:
                b = b * 2 ^ 0x10000000;
                a = a * 2;
                //printf( "a = %lld   b = %lld\n", a, b );
                break;
            case 7:
                b = b * 2;
                a = a * 2 ^ 0x8000000;
                //printf( "a = %lld   b = %lld\n", a, b );
                break;
            case 8:
                b = b * 2 ^ 0x4000000;
                a = a * 2;
                //printf( "a = %lld   b = %lld\n", a, b );
                break;
            case 9:
                b = b * 2;
                a = a * 2 ^ 0x2000000;
                //printf( "a = %lld   b = %lld\n", a, b );
                break;
            case 10:
                b = b * 2 ^ 0x1000000;
                a = a * 2 ^ 1;
                //printf( "a = %lld   b = %lld\n", a, b );
                break;
            case 11:
                b = b * 2;
                a = a * 2 ^ 0x800000;
                //printf( "a = %lld   b = %lld\n", a, b );
                break;
            case 12:
                b = b * 2 ^ 0x400000;
                a = a * 2;
                //printf( "a = %lld   b = %lld\n", a, b );
                break;
            case 13:
                b = b * 2;
                a = a * 2 ^ 0x200000;
                //printf( "a = %lld   b = %lld\n", a, b );
                break;
            case 14:
                b = b * 2 ^ 0x100000;
                a = a * 2;
                //printf( "a = %lld   b = %lld\n", a, b );
                break;
            case 15:
                b = b * 2;
                a = a * 2 ^ 0x80000;
                //printf( "a = %lld   b = %lld\n", a, b );
                break;
            default:
                break;
        }
        //printf( "-a- %lld\n", a );
        //printf( "-b- %lld\n", b );
        //printf( "-x- %d\n", xor1 );
        //printf( "-x- %d\n", xor2 );
        a = a ^ xor2;
        b = b ^ xor1;
        a = a & 0xffffffff;
        b = b & 0xffffffff;
    }
    int n,m;
    n = (b << 15) + (a >> 17);
    m = b ^ n & 0x40BD223D;
    if( m == 0xF0E6D69A )  // <<< real
    {
        for( int k = 0; k < 8; k++ )
            solution[ k ] = key[ k ];
    //if( m == 0x51182aa2 )
    //if( m == 0xff46d75e )
        //*ans = threadIdx.x * 100 + threadIdx.y;
        *ans = 1;
    }
}

int main()
{
    /////////// allocate
    int *d_ans, ans, zero = 0;
    cudaMalloc( (void**)&d_ans, 1 * sizeof( int ) );

    char key[ 8 ] = { 1, 2, 3, 10, 11, 12, 13, 14 };
    char *d_key, *d_sol;
    cudaMalloc( (void**)&d_key, 8 * sizeof( char ) );
    cudaMalloc( (void**)&d_sol, 8 * sizeof( char ) );

    for( key[ 0 ] = 0; key[ 0 ] < 16; key[ 0 ]++ )
        for( key[ 1 ] = 0; key[ 1 ] < 16; key[ 1 ]++ )
            for( key[ 2 ] = 0; key[ 2 ] < 16; key[ 2 ]++ )
                for( key[ 3 ] = 0; key[ 3 ] < 16; key[ 3 ]++ )
                {
                    /////////// copy
                    cudaMemcpy( d_key, key , 8 * sizeof( char ), cudaMemcpyHostToDevice );
                    cudaMemcpy( d_ans, &zero, 1 * sizeof( int ) , cudaMemcpyHostToDevice );

                    /////////// execute
                    dim3 dimBlock( THREADX, THREADY );
                    dim3 dimGrid( BLOCKSX, BLOCKSY );
                    kern<<<dimGrid, dimBlock>>>(d_key, d_sol, d_ans);

                    /////////// take back
                    cudaMemcpy( &ans, d_ans, 1 * sizeof( int ), cudaMemcpyDeviceToHost );
                    if( ans )
                    {
                        printf("FOUND - %d\n", ans);
                        cudaMemcpy( &key, d_sol, 8 * sizeof( char ), cudaMemcpyDeviceToHost );
                        for( int k = 0; k < 8; k++ )
                            printf( "%d ", key[ k ] );
                        printf( "\n" );
                        for( int k = 0; k < 8; k++ )
                        {
                            if( key[ k ] < 10 )
                                printf( "%c", key[ k ] + 0x30 );
                            else
                                printf( "%c", key[ k ] + 0x61 - 10 );
                        }
                        printf( "\n" );

                        cudaFree( d_key );
                        cudaFree( d_sol );
                        cudaFree( d_ans );
                        return EXIT_SUCCESS;
                    }
                }

        cudaFree( d_sol );
    cudaFree( d_key );
    cudaFree( d_ans );

    return EXIT_SUCCESS;
}