             overflow || firstBitSegment >> 32 > 0
         )
     }
-    public static func remainderWithOverflow(lhs: UInt128, _ rhs: UInt128) -> (UInt128, overflow: Bool) {
-        return (
-            (lhs /% rhs).remainder, false
-        )
-    }
 }
 public func +(lhs: UInt128, rhs: UInt128) -> UInt128 {
     precondition(~lhs >= rhs, "Addition overflow!")
     let (result, _) = UInt128.addWithOverflow(lhs, rhs)
     return result
 }
+public func +=(inout lhs: UInt128, rhs: UInt128) {
+    lhs = lhs + rhs
+}
+prefix public func ++(inout lhs: UInt128) -> UInt128 {
+    lhs = lhs + 1
+    return lhs
+}
+postfix public func ++(inout lhs: UInt128) -> UInt128 {
+    let result = lhs
+    lhs = lhs + 1
+    return result
+}
 public func -(lhs: UInt128, rhs: UInt128) -> UInt128 {
     precondition(lhs >= rhs, "Integer underflow")
     let (result, _) = UInt128.subtractWithOverflow(lhs, rhs)
     return result
 }
+public func -=(inout lhs: UInt128, rhs: UInt128) {
+    lhs = lhs - rhs
+}
+prefix public func --(inout lhs: UInt128) -> UInt128 {
+    lhs = lhs - 1
+    return lhs
+}
+postfix public func --(inout lhs: UInt128) -> UInt128 {
+    let result = lhs
+    lhs = lhs - 1
+    return result
+}
 public func *(lhs: UInt128, rhs: UInt128) -> UInt128 {
     let result = UInt128.multiplyWithOverflow(lhs, rhs)
     precondition(result.overflow == false, "Multiplication overflow!")
     return result.0
 }
-public func /(lhs: UInt128, rhs: UInt128) -> UInt128 {
-    return (lhs /% rhs).quotient
-}
-public func %(lhs: UInt128, rhs: UInt128) -> UInt128 {
-    return (lhs /% rhs).remainder
-}
-// MARK: - Comparable
-extension UInt128: Comparable {}
-/// Comparable conforming operator that checks if the `lhs` UInt128 is
-/// less than the `rhs` UInt128.
-public func <(lhs: UInt128, rhs: UInt128) -> Bool {
-    if lhs.value.upperBits < rhs.value.upperBits {
-        return true
-    } else if lhs.value.upperBits == rhs.value.upperBits && lhs.value.lowerBits < rhs.value.lowerBits {
-        return true
-    }
-    return false
-}
-// MARK: - Equatable
-extension UInt128: Equatable {}
-/// Equatable conforming operator that checks if the lhs UInt128 is
-/// equal to the rhs UInt128.
-public func ==(lhs: UInt128, rhs: UInt128) -> Bool {
-    if lhs.value.lowerBits == rhs.value.lowerBits && lhs.value.upperBits == rhs.value.upperBits {
-        return true
-    }
-    return false
-}
-// MARK: - CustomStringConvertible
-extension UInt128: CustomStringConvertible {
-    public var description: String {
-        return self.toString()
-    }
-}
-// MARK: - Self Modifying Operators
-public func &=(inout lhs: UInt128, rhs: UInt128) {
-    lhs = lhs & rhs
-}
-public func |=(inout lhs: UInt128, rhs: UInt128) {
-    lhs = lhs | rhs
-}
-public func ^=(inout lhs: UInt128, rhs: UInt128) {
-    lhs = lhs ^ rhs
-}
-public func >>=(inout lhs: UInt128, rhs: UInt128) {
-    lhs = lhs >> rhs
-}
-public func <<=(inout lhs: UInt128, rhs: UInt128) {
-    lhs = lhs << rhs
-}
-public func +=(inout lhs: UInt128, rhs: UInt128) {
-    lhs = lhs + rhs
-}
-prefix public func ++(inout lhs: UInt128) -> UInt128 {
-    lhs = lhs + 1
-    return lhs
-}
-postfix public func ++(inout lhs: UInt128) -> UInt128 {
-    let result = lhs
-    lhs = lhs + 1
-    return result
-}
-public func -=(inout lhs: UInt128, rhs: UInt128) {
-    lhs = lhs - rhs
-}
-prefix public func --(inout lhs: UInt128) -> UInt128 {
-    lhs = lhs - 1
-    return lhs
-}
-postfix public func --(inout lhs: UInt128) -> UInt128 {
-    let result = lhs
-    lhs = lhs - 1
-    return result
-}
 public func *=(inout lhs: UInt128, rhs: UInt128) {
     lhs = lhs * rhs
 }
+public func /(lhs: UInt128, rhs: UInt128) -> UInt128 {
+    let (result, _) = UInt128.divideWithOverflow(lhs, rhs)
+    return result
+}
 public func /=(inout lhs: UInt128, rhs: UInt128) {
     lhs = lhs / rhs
+}
+public func %(lhs: UInt128, rhs: UInt128) -> UInt128 {
+    let (result, _) = UInt128.remainderWithOverflow(lhs, rhs)
+    return result
 }
 public func %=(inout lhs: UInt128, rhs: UInt128) {
     lhs = lhs % rhs

    default: return UInt128(0)
    }
}
// MARK: IntegerArithmeticType Conformance
extension UInt128: IntegerArithmeticType {
    public func toIntMax() -> IntMax {

    }
    return result
}
// MARK: - Comparable
extension UInt128: Comparable {}
/// Comparable conforming operator that checks if the `lhs` UInt128 is
/// less than the `rhs` UInt128.
public func <(lhs: UInt128, rhs: UInt128) -> Bool {
    if lhs.value.upperBits < rhs.value.upperBits {
        return true
    } else if lhs.value.upperBits == rhs.value.upperBits && lhs.value.lowerBits < rhs.value.lowerBits {
        return true
    }
    return false
}
// MARK: - Equatable
extension UInt128: Equatable {}
/// Equatable conforming operator that checks if the lhs UInt128 is
/// equal to the rhs UInt128.
public func ==(lhs: UInt128, rhs: UInt128) -> Bool {
    if lhs.value.lowerBits == rhs.value.lowerBits && lhs.value.upperBits == rhs.value.upperBits {
        return true
    }
    return false
}
// MARK: - CustomStringConvertible
extension UInt128: CustomStringConvertible {
    public var description: String {
        return self.toString()
    }
}
// MARK: - Extend SignedIntegerType for UInt128
extension SignedIntegerType {
    // TODO: Need to break this out into each Signed Type to check for overflows.
