using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Chess
{
    class Program
    {
        static int N = 8;
        static int M = 100000;
        static double[,,] U = new double[N, N, N];
        static int[] x = new int[M];
        static int[] y = new int[M];
        static int[] z = new int[M];

        static void MakeOperator()
        {
            int q = 1;
            for (int layer = 0; layer <N; ++layer)
            {
                for (int j = 0; j < N; ++j)
                {
                    for (int k = 0; k < N; ++k)
                    {
                        q *= -1;
                        U[j, k, layer] = q;
                    }
                    q *= -1;
                }
            }
        }

        static void ShowLayer(int layer)
        {
            Console.WriteLine("Layer {0}", layer);
            for (int i = 0; i < N; ++i)
            {
                for (int j =0; j < N; ++j)
                {
                    Console.Write("{0} ", U[i, j, layer]);
                }
                Console.WriteLine();
            }
            Console.WriteLine();
        }

        static void GenerateInputs()
        {
            Random rnd = new Random();
            for (int i = 0; i < M; ++i)
            {
                x[i] = rnd.Next() % 8;
                y[i] = rnd.Next() % 8;              
            }
        }

        static void ComputeOutput()
        {
            for (int i = 0; i < N; ++i)
            {
                z[i] = 0;
            }
            for (int i = N; i < M; ++i)
            {
                double zet = 0.0;
                for (int j = 0; j < N; ++j)
                {
                    zet += U[x[i - j], y[i - j], j];
                }
                z[i] = (int)Math.Round(zet);
            }
        }

        static void Identification()
        {
            double[,,] Ut = new double[N, N, N];
            for (int layer = 0; layer < N; ++layer)
            {
                for (int j = 0; j < N; ++j)
                {
                    for (int k = 0; k < N; ++k)
                    {
                        Ut[j, k, layer] = 0.0;
                    }
                }
            }
            int last_error = N;
            for (int i = N; i < M; ++i)
            {
                double zet = 0.0;
                for (int j = 0; j < N; ++j)
                {
                    zet += Ut[x[i - j], y[i - j], j];
                }
                zet = (double)(z[i]) - zet;

                int indicator = (int)Math.Round(zet);
                if (0 != indicator)
                {
                    last_error = i;
                }

                zet /= N;
                for (int j = 0; j < N; ++j)
                {
                    Ut[x[i - j], y[i - j], j] += zet;
                }
            }
            Console.WriteLine("Last error position {0}", last_error);
        }

        static void Main(string[] args)
        {
            MakeOperator();
            //ShowLayer(0);
            //ShowLayer(1);
            GenerateInputs();
            ComputeOutput();
            Identification();
        }
    }
}