         
         let u = 1 - 2 * source
         
-        if source <= 0.5 {
+        if source < 0.5 {
             return destination - u * destination * (1 - destination)
         }
         return destination - u * (db - destination)

        
        let db: T
        
        if destination <= 0.25 {
            let s = 16 * destination - 12
            let t = s * destination + 4
            db = t * destination

    @_versioned
    @inline(__always)
    static func HardLight<T: BinaryFloatingPoint>(_ destination: T, _ source: T) -> T {
        return Overlay(source, destination)
    }
    
    @_versioned
    @inline(__always)
    static func Difference<T: BinaryFloatingPoint>(_ destination: T, _ source: T) -> T {
        return abs(destination - source)
    }
    
    @_versioned
    @inline(__always)
    static func Exclusion<T: BinaryFloatingPoint>(_ destination: T, _ source: T) -> T {
        return destination + source - 2 * destination * source
    }
    
    @_versioned
    @inline(__always)
    static func PlusDarker<T: BinaryFloatingPoint>(_ destination: T, _ source: T) -> T {
        return max(0, 1 - ((1 - destination) + (1 - source)))
    }
    
    @_versioned
    @inline(__always)
    static func PlusLighter<T: BinaryFloatingPoint>(_ destination: T, _ source: T) -> T {
        return min(1, destination + source)
    }
}
