OOP Method hidden and overloaded

I'm new to programming. I study books. Sometimes some examples raise questions. I ask for help, the explanation on the Habr is not very clear.
Found an example [on a habr] [1] - the fourth question on C#.

class Program
    {
        static void Main(string[] args)
        {
            var x1 = new C(); 
            x1.Print(); //C

            B x2 = new C(); 
            x2.Print(); //C

            A x3 = new C(); 
            x3.Print(); //A
        }
    }



    class A
    {
        public void Print()
        {
            Console.WriteLine("A");
        }
    }

    class B : A
    {
        new public virtual void Print()
        {
            Console.WriteLine("B");
        }
    }

    class C : B
    {
        override public void Print()
        {
            Console.WriteLine("C");
        }
    }

Explained as follows:
In the first call, “C” will be displayed, since for var the compiler will infer the type of the object from the right side of the expression, and this will be type C. // Everything is clear with that.

For the second call, the value “C” will also be displayed, since the CLR will determine that the actual type of the object is C, and will invoke the necessary virtual method overload. //So...

//Further a little incomprehensible
In the third case, “A” will be displayed, since the declaration of the B.Print method (and hence its overloading in C) hides the A.Print method. Accordingly, the CLR does not consider B.Print and C.Print to be overloads and calls a class A method.

I’m already trying to describe step by step what is happening in the context of the stack and the heap:

x2:

• on the heap memory is allocated for an instance of class C;
• default constructor writes an instance of class C to this section;
• a link to this piece of memory is written to the variable x2 (type B) on the stack, this is possible because B is the base class for C;
• Next, you need to decide which Print method of all Print methods will be called and why.
  The CLR looks at the type of the variable and tries to call the method by type, that is, in the case of x2 it is B.Print (), but since the link we have is an instance of class C, and for it there is overload of this method, then C.Print () method is called;

x3:

• on the heap memory is allocated for an instance of class C;
• default constructor writes an instance of class C to this section;
• a link to this piece of memory is written to the variable x3 (type A) on the stack, this is possible because A is the base class for B, B is the base class for C;
• Next, you need to decide which Print method of all Print methods will be called and why.
  The CLR looks at the type of the variable and tries to call the method by type, that is, in the case of x3 it is A.Print (), but since the link we have is an instance of class C, and for it there is no overload of this method, then A.Print () method is called.

1. Is my description true? If not, please explain with this example how it works.

2. Do you fully agree with the explanation of the answer on the Habr or would you remove / add / replace something?
   [1]: https://habr.com/ru/article/474182/

As in class B is written 'new' keyword in print function declaration, its brokes the inheritance connection between A and C print functions.

Yes, judging by how it works and the links, my explanation is correct.

The runtime (not the compiler) works out which version of method to call when invoking it through a variable, based on the real type of the object referenced by this variable. (MS Visual C# Step by Step 9ed, CHAPTER 12
Working with inheritance)

https://stackoverflow.com/questions/59541044/why-is-dynamic-binding-not-working-the-way-i-expect-it-to-in-the-following-code

https://stackoverflow.com/questions/45872841/will-clr-check-the-whole-inheritance-chain-to-determine-which-virtual-method-to