using System;

using System.Collections;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

public class Program

{

    public static void Main()

    {

    }

}

 public class Key

    {

        public byte K { get; private set; }

        public byte[] KArray { get; private set; }

        public Key(byte k) : this(k, (byte)new Random().Next(1, 256)) { }

        public Key(byte k, byte k0)

        {

            if (k > 0)

                K = k;

            KArray = new byte[2 * K];

            GenerateKey(k0);

        }

        private void GenerateKey(byte k0)

        {

            KArray[0] = k0;

            string str = string.Empty;

            for (int i = 1; i < KArray.Length; i++)

            {

                str = (KArray[i - 1] * KArray[i - 1]).ToString().Substring(0, 3);

                if (int.Parse(str) > 255)

                    KArray[i] = Convert.ToByte(str.Substring(0, 2));

                else

                    KArray[i] = Convert.ToByte(str);

            }

        }

​

    }

    public class Kutter

    {

        private static double ToYUV_Y(Color c)

        {

            return 0.299 * c.R + 0.587 * c.G + 0.114 * c.B;

        }

        public static Bitmap Embed(Bitmap image, string message, Parameters p)

        {

            var msg = Encoding.GetEncoding(1251).GetBytes(message);

            int y = image.Height, x = image.Width;

            if (x % 8 != 0) x -= x % 8;

            if (y % 8 != 0) y -= y % 8;

            double[,] _Y = new double[x, y];

            //выбираем из картинки синюю компоненту RGB-модели

            Byte[,] B = new Byte[x, y];

​

            Color pixel;

            for (int i = 0; i < x; i++)

                for (int j = 0; j < y; j++)

                {

                    pixel = image.GetPixel(i, j);

                    _Y[i, j] = ToYUV_Y(pixel);

                    B[i, j] = pixel.B;

                }

            Key key = p.key;

​

            var xx = msg.Select(z => new Bits(z)).SelectMany(f => f.ToString().ToCharArray())

                .Select(g => Convert.ToInt32(g.ToString()))

                .ToArray();

​

            int X, Y, tay = p.tay;

            X = Y = 0;

            double[,] newB = new double[x, y];

            Array.Copy(B, newB, B.Length);

            double v = p.v;

            for (int i = 0; i < tay * xx.Length; i++)

            {

​

                X = (int)Math.Floor((double)i / y) + 1;

                Y = i % y + 1;

​

                for (int s = 0; s < key.K; s++)

                {

                    X = (X + Bits.xor(new Bits(key.KArray[2 * s]),

                        new Bits(Y)).Number) % x + 1;

                    Y = (Y + Bits.xor(new Bits(key.KArray[2 * s + 1]),

                          new Bits(X)).Number) % y + 1;

                }

                int j = (int)Math.Ceiling((double)(i + 1) / tay);

                X--;

                Y--;

                newB[X, Y] = B[X, Y] + (2 * xx[j - 1] - 1) * v * _Y[X, Y];

                if (newB[X, Y] > 255) newB[X, Y] = 255;

                if (newB[X, Y] < 0) newB[X, Y] = 0;

​

            }

            //сохранение нового изображения

            Bitmap image2 = image;

            for (int i = 0; i < x; i++)

                for (int j = 0; j < y; j++)

                {

                    Color r = image.GetPixel(i, j);

                    image2.SetPixel(i, j, Color.FromArgb(r.R, r.G, (byte)Math.Round(newB[i, j])));

                }

​

            return image2;

        }

        public static string Extract(Bitmap image, Parameters p)

        {

            var tay = p.tay;

            Key key = p.key;

​

            int y = image.Height, x = image.Width;

            Byte[,] B = new Byte[x, y];

            for (int i = 0; i < x; i++)

                for (int j = 0; j < y; j++)

                    B[i, j] = image.GetPixel(i, j).B;

​

            int t = 0;

            int X, Y;

            X = Y = 0;

            const int sigm = 3;

            int s1, s2, s3, s4;

            s1 = s2 = s3 = s4 = 0;

            List<double> B2 = new List<double>();

            List<double> B2o = new List<double>();

            List<int> message = new List<int>();

​

            for (int i = 0; i < x * y; i++)

            {

                if (t == 0)

                {

                    B2 = new List<double>(tay);

                    B2o = new List<double>(tay);

                }

                X = (int)Math.Floor((double)i / y) + 1;

                Y = i % y + 1;

​

                for (int s = 0; s < key.K; s++)

                {

                    X = (X + Bits.xor(new Bits(key.KArray[2 * s]),

                        new Bits(Y)).Number) % x + 1;

                    Y = (Y + Bits.xor(new Bits(key.KArray[2 * s + 1]),

                          new Bits(X)).Number) % y + 1;

                }

                X--;

                Y--;

                if (sigm < X && X < x - sigm)

                {

                    s1 = -sigm;

                    s2 = sigm;

                }

                if (X <= sigm)

                {

                    s1 = 1 - X;

                    s2 = sigm;

                }

                if (X >= x - sigm)

                {

                    s1 = -sigm;

                    s2 = x - X - 1;

                }

                if (sigm < Y && Y < y - sigm)

                {

                    s3 = -sigm;

                    s4 = sigm;

                }

                if (Y <= sigm)

                {

                    s3 = 1 - Y;

                    s4 = sigm;

                }

                if (Y >= y - sigm)

                {

                    s3 = -sigm;

                    s4 = y - Y - 1;

                }

                double sum = 0;

                for (int a = s1; a <= s2; a++)

                    sum += B[X + a, Y];

​

                for (int a = s3; a <= s4; a++)

                    sum += B[X, Y + a];

​

                sum -= 2 * B[X, Y];

                sum /= (s2 - s1 + s4 - s3);

​

                B2.Add(B[X, Y]);

                B2o.Add(sum);

​

                t++;

                if (t >= tay)

                {

                    double delta = B2.Select((f, ind) => f - B2o[ind]).Sum() / tay;

                    int j = (int)Math.Ceiling((double)(i + 1) / tay);

                    if (delta <= 0)

                        message.Add(0);

                    else

                        message.Add(1);

                    t = 0;

                }

            }

            string M1 = string.Join("", message);

            byte[] msg = new byte[M1.Length / 8];

            for (int i = 0; i < msg.Length; i++)

            {

                var temp = new Bits(M1.Substring(8 * (i + 1) - 8, 8));

                msg[i] = (byte)temp.Number;

            }

            return Encoding.GetEncoding(1251).GetString(msg);

​

        }

    }

    public class Parameters

    {

        public double v { get; set; }

        public int tay { get; set; }

        public Key key { get; set; }

​

    }

 class Bits

    {

        private ArrayList bits = new ArrayList();

​

        private int len = 0, num = 0;

​

        /// <summary>

        /// Конструктор. Переводит целое значение в двоичный вид.

        /// </summary>

        public Bits(int value)

        {

            num = value; ToBits();

        }

​

        /// <summary>

        /// Конструктор. Код символа преобразует в двоичный вид.

        /// </summary>

        public Bits(char value)

        {

            num = (int)value; ToBits();

        }

​

        /// <summary>

        /// Конструктор. Код символа преобразует в двоичный вид.

        /// </summary>

        public Bits(byte value)

        {

            num = (int)value; ToBits();

        }

​

        /// <summary>

        /// Конструктор. Преобразует строку в "битовый массив"

        /// Все ненулевые элементы строки интерпритируются как '1'.

        /// </summary>

        public Bits(string value)

        {

            len = value.Length;

​

            for (int i = 0; i < len; i++)

                if (value[i] == '0') bits.Add(0);

                else bits.Add(1);

        }

​

        /// <summary>

        /// Свойство. Возвращает текущее количество бит.

        /// </summary>

        public int Length

        {

            get

            {

                return len;

            }

        }

​

        /// <summary>

        /// Свойство. Возвращает десятичное представление "битового массива".

        /// </summary>

        public int Number

        {

            get

            {

                ToInt(); return num;

            }

        }

​

        /// <summary>

        /// Свойство. Возвращает символ, который представлен текущим десятичным числом.

        /// </summary>

        public char Char

        {

            get

            {

                ToInt(); return (char)num;

            }

        }

​

        /// <summary>

        /// Операция индексации []. Возвращает i-ый элемент "битового массива".

        /// </summary>

        public int this[int i]

        {

            get

            {

                if (i >= 0 && i < len) return (int)bits[i];

                else return -1;

            }

​

            set

            {

                if (i >= 0 && i < len)

                    if (value > 0) bits[i] = 1;

                    else bits[i] = 0;

            }

        }

​

        /// <summary>

        /// Функция добавляет в конец новый элемент.

        /// Все ненулевые элементы интерпритируются как '1'.

        /// </summary>

        public void Add(object value)

        {

            if ((int)value == 0) bits.Add(0);

            else bits.Add(1);

​

            len++;

        }

​

        /// <summary>

        /// Функция вставляет в позицию index значение value

        /// Все ненулевые элементы интерпритируются как '1'.

        /// </summary>

        public void Insert(int index, object value)

        {

            if (index < 0 || index > len) return;

​

            if (value.Equals(0)) bits.Insert(index, 0);

            else bits.Insert(index, 1);

​

            len++;

        }

​

        /// <summary>

        /// Функция удаляет значение из позиции index.

        /// </summary>

        public void Erase(int index)

        {

            if (index < 0 || index > len) return;

​

            bits.RemoveAt(index); len--;

        }

​

        /// <summary>

        /// Функция инвертирует все биты. '0' = '1'; '1' = '0'.

        /// </summary>

        public void InvertBits()

        {

            for (int i = 0; i < len; i++)

                if (bits[i].Equals(0)) bits[i] = 1;

                else bits[i] = 0;

        }

​

        /// <summary>

        /// Функция разворачивает "битовый массив" задом наперед.

        /// </summary>

        public void Reverse()

        {

            bits.Reverse();

        }

​

        /// <summary>

        /// Функция преобразует текущий "битовый массив" в строку.

        /// </summary>

        public override string ToString()

        {

            string str = "";

​

            for (int i = 0; i < len; i++)

                str += bits[i].ToString();

​

            return str;

        }

​

        /// <summary>

        /// Функция производит циклический сдвиг "битового массива" влево.

        /// </summary>

        public void ToLeft()

        {

            object tmp;

​

            for (int i = 1; i < len - 1; i++)

            {

                tmp = bits[i + 1]; bits[i + 1] = bits[i]; bits[i] = tmp;

            }

​

            tmp = bits[0]; bits[0] = bits[len - 1]; bits[len - 1] = tmp;

        }

​

        /// <summary>

        /// Функция производит циклический сдвиг "битового массива" вправо.

        /// </summary>

        public void ToRight()

        {

            object tmp;

​

            tmp = bits[0]; bits[0] = bits[len - 1]; bits[len - 1] = tmp;

​

            for (int i = len - 2; i != 0; i--)

            {

                tmp = bits[i]; bits[i] = bits[i + 1]; bits[i + 1] = tmp;

            }

        }

​

        /// <summary>

        /// Функция производит перевод десятичного числа в двоичное представление.

        /// </summary>

        private void ToBits()

        {

            int temp = num;

​

            for (int i = 0; i < 8; i++)

            {

                bits.Add(temp % 2); temp = (int)Math.Floor((double)temp / 2);

            }

​

            len = bits.Count; bits.Reverse();

        }

​

        /// <summary>

        /// Функция производит перевод из двоичного представления в десятичное.

        /// </summary>

        private void ToInt()

        {

            num = 0;

​

            for (int i = 0; i < len; i++)

                if (bits[len - i - 1].Equals(1))

                    num += (int)Math.Pow(2, i);

        }

​

        public static Bits xor(Bits a, Bits b)

        {

            Bits temp = new Bits(0);

            for (int i = 0; i < a.Length; i++)

                temp[i] = a[i] ^ b[i];

​

            return temp;

        }

    }