using System;

public class Program

{

    public static void Main()

    {

        Metres metres = 10;

        Centimetres centimetres = metres;

        Console.WriteLine(centimetres); // Prints "1000cm"

​

        metres = centimetres;

        Console.WriteLine(metres); // Prints "10m"

​

        var kilometres = (Kilometres) centimetres;

        Console.WriteLine(kilometres); // Prints "0.01km"

​

        var addedMetres = metres + 10;

        Console.WriteLine(addedMetres); // Prints "20m"

        var subtractedCm = centimetres - 100;

        Console.WriteLine(subtractedCm); // Prints "900cm"

​

        // This would be an ambiguous call - should the result be Centimetres or Metres?

        //     var difference = addedMetres - subtractedCm;

        // So fix it by casting one of the operands to the result type that you want:

​

        var diffCm = (Centimetres)addedMetres - subtractedCm;

        Console.WriteLine(diffCm); // Prints "1100cm" 

​

        var diffM = addedMetres - (Metres)subtractedCm;

        Console.WriteLine(diffM); // Prints "11m" 

    }

}

​

public sealed class Metres

{

    public Metres(float metres)

    {

        _metres = metres;

    }

​

    public float Distance => _metres;

​

    public static implicit operator Metres(Centimetres centimetres) => new (centimetres.Distance / 100.0f);

    public static implicit operator Metres(Kilometres kilometres)   => new (kilometres.Distance / 100_000.0f);

    public static implicit operator Metres(float metres)            => new (metres);

​

    public static Metres operator +(Metres a, Metres b) => new (a.Distance + b.Distance);

    public static Metres operator -(Metres a, Metres b) => new (a.Distance - b.Distance);

​

    public override string ToString()

    {

        return $"{_metres}m";

    }

​

    readonly float _metres;

}

​

public sealed class Centimetres

{

    public Centimetres(float centimetres)

    {

        _centimetres = centimetres;

    }

​

    public float Distance => _centimetres;

​

    public static implicit operator Centimetres(Metres metres)         => new (metres.Distance * 100.0f);

    public static implicit operator Centimetres(Kilometres kilometres) => new (kilometres.Distance * 100_000.0f);

    public static implicit operator Centimetres(float centimetres)     => new (centimetres);

​

    public static Centimetres operator +(Centimetres a, Centimetres b) => new (a.Distance + b.Distance);

    public static Centimetres operator -(Centimetres a, Centimetres b) => new (a.Distance - b.Distance);

​

    public override string ToString()

    {

        return $"{_centimetres}cm";

    }

​

    readonly float _centimetres;

}

​

public sealed class Kilometres

{

    public Kilometres(float kilometres)

    {

        _kilometres = kilometres;

    }

​

    public float Distance => _kilometres;

​

    public static implicit operator Kilometres(Metres metres)           => new (metres.Distance / 1000.0f);

    public static implicit operator Kilometres(Centimetres centimetres) => new (centimetres.Distance /100_000.0f);

    public static implicit operator Kilometres(float kilometres)        => new (kilometres);

​

    public static Kilometres operator +(Kilometres a, Kilometres b) => new (a.Distance + b.Distance);

    public static Kilometres operator -(Kilometres a, Kilometres b) => new (a.Distance - b.Distance);

​

    public override string ToString()

    {

        return $"{_kilometres}km";

    }

​

    readonly float _kilometres;

}

​