C#

private ulong m_LBits, m_HBits;

public TestUInt(ulong high, ulong low) {
    m_HBits = high;
    m_LBits = low;
}

private static void Divide(TestUInt dividend, TestUInt divisor, out TestUInt quotient, out TestUInt remainder) {
    if (divisor == 0ul)
        throw new DivideByZeroException();
    quotient = 0;
    remainder = 0;
    if (divisor < dividend) {
        remainder = dividend;
    } else if (dividend == divisor) {
        quotient = 1;
    } else if (dividend != 0ul) {
        int divBits = Log2(dividend);
        int performedOps = 0;
        int requiredOps = divBits - Log2(divisor);
        for (TestUInt comparator = divisor << requiredOps; divBits >= 64
            && performedOps <= requiredOps; comparator >>= 1, ++performedOps, --divBits) {
            quotient <<= 1;
            if (dividend >= comparator) {
                dividend -= comparator;
                quotient.m_LBits |= 1;
            }
        }
        if (performedOps <= requiredOps) {
            quotient <<= requiredOps - performedOps + 1;
            quotient.m_LBits |= dividend.m_LBits / divisor.m_LBits;
            dividend = dividend.m_LBits % divisor.m_LBits;
        }
        remainder = dividend;
    }
}
    
private static int Log2(TestUInt value) {
    if (value.m_HBits != 0)
        return MathExtension.Log2(value.m_HBits) + 64;
    else
        return MathExtension.Log2(value.m_LBits);
}

public static TestUInt operator -(TestUInt a, TestUInt b) {
    ulong old_lbits = a.m_LBits;
    a.m_LBits -= b.m_LBits;
    a.m_HBits -= b.m_HBits;
    if (a.m_LBits > old_lbits)
        --a.m_HBits;
    return a;
}

public static TestUInt operator <<(TestUInt a, int b) {
    b &= 127;
    if (b == 0) {
        return new TestUInt(a.m_HBits, a.m_LBits);
    } else if (b >= 64) {
        return new TestUInt(a.m_LBits << b - 64, 0);
    } else {
        return new TestUInt(a.m_HBits << b | a.m_LBits >> 64 - b, a.m_LBits << b);
    }
}

public static TestUInt operator >>(TestUInt a, int b) {
    b &= 127;
    if (b == 0) {
        return new TestUInt(a.m_HBits, a.m_LBits);
    } else if (b >= 64) {
        return new TestUInt(0, a.m_HBits >> b - 64);
    } else {
        return new TestUInt(a.m_HBits >> b, a.m_HBits << 64 - b | a.m_LBits >> b);
    }
}

public static bool operator ==(TestUInt a, TestUInt b) {
    return (a.m_LBits == b.m_LBits && a.m_HBits == b.m_HBits);
}

public static bool operator !=(TestUInt a, TestUInt b) {
    return (a.m_LBits != b.m_LBits || a.m_HBits != b.m_HBits);
}

public static bool operator <=(TestUInt a, TestUInt b) {
    return (a.m_HBits == b.m_HBits ? a.m_LBits <= b.m_LBits : a.m_HBits <= b.m_HBits);
}

public static bool operator >=(TestUInt a, TestUInt b) {
    return (a.m_HBits == b.m_HBits ? a.m_LBits >= b.m_LBits : a.m_HBits >= b.m_HBits);
}

public static bool operator <(TestUInt a, TestUInt b) {
    return (a.m_HBits == b.m_HBits ? a.m_LBits < b.m_LBits : a.m_HBits < b.m_HBits);
}

public static bool operator >(TestUInt a, TestUInt b) {
    return (a.m_HBits == b.m_HBits ? a.m_LBits > b.m_LBits : a.m_HBits > b.m_HBits);
}

public static implicit operator TestUInt(ulong value) {
    return new TestUInt(0, value);
}
    
public override string ToString() {
    TestUInt quotient = this, remainder;
    string rval = string.Empty;
    while (quotient.m_HBits != 0) {
        Divide(quotient, 1000000000000000000ul, out quotient, out remainder);
        rval = remainder.m_LBits.ToString("D18") + rval;
    }
    rval = quotient.m_LBits.ToString("D") + rval;
    return rval;
}

string line = "{0,-3} {1,-3}\r\n       {2}\r\n       {3}";
// 101739724956510982573881893874860769099
UInt128 c = new UInt128(0x4C8A5BB86B074FBD, 0x7A223174473F3F4B);
// 21804722866621884125668607625
UInt128 d = new UInt128(0x00000000467471AB, 0x1F2DA3680D768689);
// 18446744073709551618 
UInt128 e = new UInt128(1, 2); // 0x10000000000000002
// 68719476736
UInt128 f = 0x1000000000;      // 0x00000001000000000
// 330888471822165082112
UInt128 g = new UInt128(0x11, 0xF000000000000000); // 0x11F000000000000000
// 20476206912383221760
UInt128 h = new UInt128(0x01, 0x1C2A19B300000000); // 0x011C2A19B300000000

Console.WriteLine(string.Format(line, "Var", "Frm", "Result", "Computed"));
// Produces correct output, until I change the divisor to 1000 in ToString
Console.WriteLine(string.Format(line, "c", "", "101739724956510982573881893874860769099", c.ToString()));
// Produces two different but wrong results using either constant within ToString
Console.WriteLine(string.Format(line, "d", "", "21804722866621884125668607625", d.ToString()));
// Produces the same incorrect result using either constant within ToString
Console.WriteLine(string.Format(line, "e", "", "18446744073709551618", e.ToString()));
// Produces the same incorrect result using either constant within ToString
Console.WriteLine(string.Format(line, "h", "", "20476206912383221760", h.ToString()));

private static void _ctrlParent_DragOver(object sender, DragEventArgs e) 
{

...

// Correctly identifies which panel the control it is assigned to so that other code could work correctly. This code provides the need to reassign the control back to the main form again below all within one DragOver method.
	ctrl.Parent.Controls.Remove(ctrl);
	ctrl.Parent = cthis;
	cthis.Controls.Add(ctrl);
	Control ctrlPanelContainer = getPanelContainerName(ctrl);
	string strPanelContainerName = ctrlPanelContainer.Text;
	int intPanelContainerX = ctrlPanelContainer.Left;
	int intPanelContainerY = ctrlPanelContainer.Top;
	Point pt_parent = new Point(intPanelContainerX, intPanelContainerY);				Control panelContainer = ctrl.TopLevelControl.GetChildAtPoint(pt_parent);
	strPanelContainerNameMouseUp = panelContainer.Name;
		
// Attempts to assign the control back to the form so that is could drag over another control	
	frmSolitaireMainForm frm = new frmMainForm();
	ctrl.Parent.Controls.Remove(ctrl);
//	cthis = frm;                         // assigns the control to the form.
	ctrl.Parent = cthis;
	cthis.Controls.Add(ctrl);
	string strCthisNew = cthis.Name;   // correctly retrieves the form assignment.


// Incorrectly places the control back onto the main form.
	Point NewLocation = cthis.PointToScreen(new Point(e.X, e.Y));
	ctrl.Left = NewLocation.X;
	ctrl.Top = NewLocation.Y;
	ctrl.BringToFront();

...
}