---

1 вариант
using System;

class Value : IComparable<Value>
{
    public long Whole { get; private set; }
    public ushort Fraction { get; private set; }

    public Value(long whole, ushort fraction)
    {
        Whole = whole;
        Fraction = fraction;
        Normalize();
    }

    private double ToDouble()
    {
        double frac = Fraction / 1000.0;
        return Whole < 0 ? Whole - frac : Whole + frac;
    }

    private static Value FromDouble(double number)
    {
        long whole = (long)Math.Truncate(number);
        ushort fraction = (ushort)Math.Round(Math.Abs(number - whole) * 1000);
        return new Value(whole, fraction);
    }

    private void Normalize()
    {
        if (Fraction >= 1000)
        {
            Whole += Fraction / 1000;
            Fraction %= 1000;
        }
    }

    public static Value operator +(Value a, Value b)
        => FromDouble(a.ToDouble() + b.ToDouble());

    public static Value operator -(Value a, Value b)
        => FromDouble(a.ToDouble() - b.ToDouble());

    public static Value operator *(Value a, Value b)
        => FromDouble(a.ToDouble() * b.ToDouble());

    public int CompareTo(Value other)
        => ToDouble().CompareTo(other.ToDouble());

    public static bool operator >(Value a, Value b) => a.CompareTo(b) > 0;
    public static bool operator <(Value a, Value b) => a.CompareTo(b) < 0;
    public static bool operator ==(Value a, Value b) => a.ToDouble() == b.ToDouble();
    public static bool operator !=(Value a, Value b) => !(a == b);

    public override bool Equals(object obj)
        => obj is Value v && this == v;

    public override int GetHashCode()
        => ToDouble().GetHashCode();

    public override string ToString()
        => $"{Whole},{Fraction:D3}";
}

abstract class Triangle
{
    protected double a;
    protected double b;
    protected double angle;

    public Triangle(double a, double b, double angle)
    {
        this.a = a;
        this.b = b;
        this.angle = angle;
    }

    public abstract double Area();
    public abstract double Perimeter();

    protected double ThirdSide()
    {
        double rad = angle * Math.PI / 180;
        return Math.Sqrt(a * a + b * b - 2 * a * b * Math.Cos(rad));
    }
}

class RightTriangle : Triangle
{
    public RightTriangle(double a, double b) : base(a, b, 90) { }

    public override double Area() => a * b / 2;

    public override double Perimeter()
        => a + b + Math.Sqrt(a * a + b * b);
}

class IsoscelesTriangle : Triangle
{
    public IsoscelesTriangle(double side, double baseSide, double angle)
        : base(side, baseSide, angle) { }

    public override double Area()
    {
        double rad = angle * Math.PI / 180;
        return a * b * Math.Sin(rad) / 2;
    }

    public override double Perimeter()
        => a + b + ThirdSide();
}

class EquilateralTriangle : Triangle
{
    public EquilateralTriangle(double side) : base(side, side, 60) { }

    public override double Area()
        => Math.Sqrt(3) * a * a / 4;

    public override double Perimeter()
        => 3 * a;
}

class Program
{
    static void Main()
    {
        Value x = new Value(5, 250);
        Value y = new Value(2, 500);

        Console.WriteLine($"x = {x}");
        Console.WriteLine($"y = {y}");
        Console.WriteLine($"x + y = {x + y}");
        Console.WriteLine($"x - y = {x - y}");
        Console.WriteLine($"x * y = {x * y}");
        Console.WriteLine($"x > y: {x > y}");

        Triangle t1 = new RightTriangle(3, 4);
        Triangle t2 = new IsoscelesTriangle(5, 5, 60);
        Triangle t3 = new EquilateralTriangle(6);

        Console.WriteLine($"Прямоугольный: S = {t1.Area()}, P = {t1.Perimeter()}");
        Console.WriteLine($"Равнобедренный: S = {t2.Area()}, P = {t2.Perimeter()}");
        Console.WriteLine($"Равносторонний: S = {t3.Area()}, P = {t3.Perimeter()}");
    }
}


2 вариант

using System;

class Money : IComparable<Money>
{
    public long Rubles { get; private set; }
    public byte Kopecks { get; private set; }

    public Money(long rubles, byte kopecks)
    {
        Rubles = rubles;
        Kopecks = kopecks;
        Normalize();
    }

    private void Normalize()
    {
        if (Kopecks >= 100)
        {
            Rubles += Kopecks / 100;
            Kopecks = (byte)(Kopecks % 100);
        }
    }

    private double ToDouble()
    {
        return Rubles + Kopecks / 100.0;
    }

    private static Money FromDouble(double value)
    {
        long rubles = (long)Math.Truncate(value);
        byte kopecks = (byte)Math.Round(Math.Abs(value - rubles) * 100);
        return new Money(rubles, kopecks);
    }

    public static Money operator +(Money a, Money b)
        => FromDouble(a.ToDouble() + b.ToDouble());

    public static Money operator -(Money a, Money b)
        => FromDouble(a.ToDouble() - b.ToDouble());

    public static Money operator /(Money a, Money b)
        => FromDouble(a.ToDouble() / b.ToDouble());

    public static Money operator /(Money a, double number)
        => FromDouble(a.ToDouble() / number);

    public static Money operator *(Money a, double number)
        => FromDouble(a.ToDouble() * number);

    public int CompareTo(Money other)
        => ToDouble().CompareTo(other.ToDouble());

    public static bool operator >(Money a, Money b) => a.CompareTo(b) > 0;
    public static bool operator <(Money a, Money b) => a.CompareTo(b) < 0;
    public static bool operator ==(Money a, Money b) => a.ToDouble() == b.ToDouble();
    public static bool operator !=(Money a, Money b) => !(a == b);

    public override bool Equals(object obj)
        => obj is Money m && this == m;

    public override int GetHashCode()
        => ToDouble().GetHashCode();

    public override string ToString()
        => $"{Rubles},{Kopecks:D2}";
}

abstract class Payment
{
    public abstract void CalculateRoots();
    public abstract void PrintResult();
}

class Linear : Payment
{
    private double a, b;
    private double root;
    private bool hasRoot;

    public Linear(double a, double b)
    {
        this.a = a;
        this.b = b;
    }

    public override void CalculateRoots()
    {
        if (a == 0)
            hasRoot = false;
        else
        {
            root = -b / a;
            hasRoot = true;
        }
    }

    public override void PrintResult()
    {
        if (hasRoot)
            Console.WriteLine($"Линейное уравнение: x = {root}");
        else
            Console.WriteLine("Линейное уравнение не имеет единственного корня");
    }
}

class Square : Payment
{
    private double a, b, c;
    private double x1, x2;
    private int rootsCount;

    public Square(double a, double b, double c)
    {
        this.a = a;
        this.b = b;
        this.c = c;
    }

    public override void CalculateRoots()
    {
        double d = b * b - 4 * a * c;

        if (d < 0)
            rootsCount = 0;
        else if (d == 0)
        {
            x1 = -b / (2 * a);
            rootsCount = 1;
        }
        else
        {
            x1 = (-b + Math.Sqrt(d)) / (2 * a);
            x2 = (-b - Math.Sqrt(d)) / (2 * a);
            rootsCount = 2;
        }
    }

    public override void PrintResult()
    {
        if (rootsCount == 0)
            Console.WriteLine("Квадратное уравнение не имеет корней");
        else if (rootsCount == 1)
            Console.WriteLine($"Квадратное уравнение: x = {x1}");
        else
            Console.WriteLine($"Квадратное уравнение: x1 = {x1}, x2 = {x2}");
    }
}

class Program
{
    static void Main()
    {
        Money m1 = new Money(10, 50);
        Money m2 = new Money(3, 25);

        Console.WriteLine($"m1 = {m1}");
        Console.WriteLine($"m2 = {m2}");
        Console.WriteLine($"m1 + m2 = {m1 + m2}");
        Console.WriteLine($"m1 - m2 = {m1 - m2}");
        Console.WriteLine($"m1 / m2 = {m1 / m2}");
        Console.WriteLine($"m1 / 2.5 = {m1 / 2.5}");
        Console.WriteLine($"m1 * 1.5 = {m1 * 1.5}");
        Console.WriteLine($"m1 > m2: {m1 > m2}");

        Payment p1 = new Linear(2, -6);
        p1.CalculateRoots();
        p1.PrintResult();

        Payment p2 = new Square(1, -5, 6);
        p2.CalculateRoots();
        p2.PrintResult();
    }
}