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

namespace Zadanie4
{
    class Zespolona : IEquatable<Zespolona>
    {
        private float im;
        private float re;

        public Zespolona(float im, float re)
        {
            this.im = im;
            this.re = re;
        }

        public float Re
        {
            set { re = value; }
            get { return re; }
        }

        public float Im
        {
            set { im = value; }
            get { return im; }
        }

        public static Zespolona operator +(Zespolona z1, Zespolona z2)
        {
            z1.re = z1.re + z2.re;
            z1.im = z1.im + z2.im;
            return z1;
        }

        public static Zespolona operator -(Zespolona z1, Zespolona z2)
        {
            z1.re = z1.re - z2.re;
            z1.im = z1.im - z2.im;
            return z1;
        }

        public static Zespolona operator *(Zespolona z1, Zespolona z2)
        {
            z1.re = z1.re * z2.re - z1.im * z2.im;
            z1.im = z1.re * z2.im + z1.im * z2.re;
            return z1;
        }

        public static Zespolona operator /(Zespolona z1, Zespolona z2)
        {
            z1.re = (z1.re * z2.re + z1.im * z2.im) / (z2.re * z2.re + z2.im * z2.im);
            z1.im = (z1.im * z2.re + z1.re * z2.im) / (z2.re * z2.re + z2.im * z2.im);
            return z1;
        }

        public static Zespolona operator +(Zespolona z1, float x)
        {
            z1.re = z1.re + x;
            return z1;
        }

        public static Zespolona operator -(Zespolona z1, float x)
        {
            z1.re = z1.re - x;
            return z1;
        }

        public static Zespolona operator *(Zespolona z1, float x)
        {
            z1.re = z1.re * x;
            z1.im = z1.im * x;
            return z1;
        }

        public static Zespolona operator /(Zespolona z1, float x)
        {
            z1.re = z1.re / x;
            z1.im = z1.im / x;
            return z1;
        }

        public override bool Equals(object obj)
        {
            return this.Equals(obj as Zespolona);
        }

        public bool Equals(Zespolona z)
        {
            if (Object.ReferenceEquals(z, null))
            {
                return false;
            }

            if (Object.ReferenceEquals(this, z))
            {
                return true;
            }

            if (this.GetType() != z.GetType())
            {
                return false;
            }

            return (re == z.re) && (im == z.im);
        }

        public override int GetHashCode()
        {
            return (re, im).GetHashCode();
        }

        public static bool operator ==(Zespolona z1, Zespolona z2)
        {
            if (Object.ReferenceEquals(z1, null))
            {
                if (Object.ReferenceEquals(z2, null))
                {
                    return true;
                }

                return false;
            }

            return z1.Equals(z2);
        }

        public static bool operator !=(Zespolona z1, Zespolona z2)
        {
            return !(z1 == z2);
        }

        public static bool operator <(Zespolona z1, Zespolona z2)
        {
            if (z1.re < z2.re)
                return true;
            else
                return false;
        }

        public static bool operator >(Zespolona z1, Zespolona z2)
        {
            if (z1.re > z2.re)
                return true;
            else
                return false;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
        }
    }
}