     @_versioned
     @inline(__always)
     static func Multiply<T: BinaryFloatingPoint>(_ destination: T, _ source: T) -> T {
-        
         return destination * source
     }
     
     @_versioned
     @inline(__always)
     static func Screen<T: BinaryFloatingPoint>(_ destination: T, _ source: T) -> T {
-        
-        return destination + source - (destination * source)
+        return destination + source - destination * source
     }
     
     @_versioned
     @inline(__always)
     static func Overlay<T: BinaryFloatingPoint>(_ destination: T, _ source: T) -> T {
         
-        return HardLight(destination, source)
+        if destination < 0.5 {
+            return 2 * destination * source
+        }
+        let u = 1 - destination
+        let v = 1 - source
+        return 1 - 2 * u * v
     }
     
     @_versioned
     @inline(__always)
     static func Darken<T: BinaryFloatingPoint>(_ destination: T, _ source: T) -> T {
-        
         return min(destination, source)
     }
     
     @_versioned
     @inline(__always)
     static func Lighten<T: BinaryFloatingPoint>(_ destination: T, _ source: T) -> T {
-        
         return max(destination, source)
     }
     
     @_versioned
     @inline(__always)
     static func ColorDodge<T: BinaryFloatingPoint>(_ destination: T, _ source: T) -> T {
-        
-        if source < 1 {
-            return min(1, destination / (1 - source))
-        }
-        return 1
+        return source < 1 ? min(1, destination / (1 - source)) : 1
     }
     
     @_versioned
     @inline(__always)
     static func ColorBurn<T: BinaryFloatingPoint>(_ destination: T, _ source: T) -> T {
-        
-        if source > 0 {
-            return 1 - min(1, (1 - destination) / source)
-        }
-        return 0
+        return source > 0 ? 1 - min(1, (1 - destination) / source) : 0
     }
     
     @_versioned

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

    
    case multiply /* B(cb, cs) = cb * cs */
    
    case screen /* B(cb, cs) = cb + cs – cb * cs */
    
    case overlay /* B(cb, cs) = cs < 0.5 ? 2 * cb * cs : 1 - 2 * (1 - cb) * (1 - cs) */
    
    case darken /* B(cb, cs) = min(cb, cs) */
    
