using System.Runtime.InteropServices;

using System;

public class Program

{

    public static void Main()

    {

        var  point =0xD500;

​

         Console.WriteLine($"Converted back PointID: 0x{point:X}");

        var register = GetRegisterFromPointId<uint>(point);

        var point2 = GetPointIdFromRegister(register,64,11776);

    Console.WriteLine($"Register: {register}");

    Console.WriteLine($"Converted back PointID: 0x{point2:X}");

    }

        /// <summary> Gets the register from point ID. </summary>

    /// <typeparam name="T"></typeparam>

    /// <param name="pointId">The point id.</param>

    /// <exception cref="TypeLoadException"></exception>

    /// <returns>A register address.</returns>

    public static ushort GetRegisterFromPointId<T>(int pointId) where T : struct, IComparable, IFormattable, IConvertible, IComparable<T>, IEquatable<T>

    {

        return GetNumberOfWordsInValue<T>() switch

        {

            1 => GetRegisterFromPointId(pointId, 32, 3584),

            2 => GetRegisterFromPointId(pointId, 64, 11776),

            _ => throw new TypeLoadException("Incorrect integral numeric type.")

        };

    }

​

    /// <summary> Gets the register address from point id using the given address base shift and logarithmic factor. </summary>

    /// <param name="pointId">The point id.</param>

    /// <param name="factor">The logarithmic factor.</param>

    /// <param name="shift">The address base shift.</param>

    /// <returns>A register address.</returns>

    private static ushort GetRegisterFromPointId(int pointId, int factor, int shift)

    {

        var group = pointId >> 7;

        var offset = pointId & 127;

​

​

        return (ushort)(group * factor + shift + offset * (factor / 32));

    }

        // <summary> Gets the number of 16bit words required by given type. </summary>

    /// <typeparam name="T"></typeparam>

    /// <returns>An ushort.</returns>

    public static ushort GetNumberOfWordsInValue<T>() where T : struct, IComparable, IFormattable, IConvertible, IComparable<T>, IEquatable<T>

    {

        return (ushort)(Marshal.SizeOf(default(T)) / 2);

    }

​

private static int GetPointIdFromRegister(ushort register, int factor, int shift)

{

    var adjustedValue = register - shift;   // Reverse the shift adjustment.

​

    // Calculate group and offset using direct bit operations

    var group = adjustedValue / factor;     // Extract the group.

    var offset = (adjustedValue % factor) / (factor / 32);  // Extract the offset.

​

    // Correct the offset calculation

    return (group << 7) + offset;

}

​

​

​

​

}

​