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()));