         }
         
         return result
-    }
-}
-
-@inlinable
-@inline(__always)
-func _Radix2FiniteImpulseFilter<T: BinaryFloatingPoint>(_ log2n: Int, _ row: Int, _ signal: UnsafePointer<T>, _ signal_stride: Int, _ signal_row_stride: Int, _ signal_count: Int, _ kreal: UnsafePointer<T>, _ kimag: UnsafePointer<T>, _ kernel_stride: Int, _ kernel_row_stride: Int, _ output: UnsafeMutablePointer<T>, _ out_stride: Int, _ out_row_stride: Int) where T : FloatingMathProtocol {
-    var signal = signal
-    var kreal = kreal
-    var kimag = kimag
-    var output = output
-    for _ in 0..<row {
-        Radix2FiniteImpulseFilter(log2n, signal, signal_stride, signal_count, kreal, kimag, kernel_stride, output, out_stride)
-        signal += signal_row_stride
-        kreal += kernel_row_stride
-        kimag += kernel_row_stride
-        output += out_row_stride
     }
 }
 

                    
                    guard var output = $0.bindMemory(to: RawPixel.Scalar.self).baseAddress else { return }
                    
                    let log2n1 = log2(length1)
                    let log2n2 = log2(length2)
                    
                    let _kreal1 = buffer
                    let _kimag1 = buffer + 1
                    let _kreal2 = buffer + length1
                    let _kimag2 = _kreal2 + 1
                    let _temp = _kreal2 + length2
                    
                    HalfRadix2CooleyTukey(log2n1, horizontal_filter, 1, horizontal_filter.count, _kreal1, _kimag1, 2)
                    HalfRadix2CooleyTukey(log2n2, vertical_filter, 1, vertical_filter.count, _kreal2, _kimag2, 2)
                    
                    for _ in 0..<numberOfComponents {
                        
                        _Radix2FiniteImpulseFilter(log2n1, height, source, numberOfComponents, numberOfComponents * width, width, _kreal1, _kimag1, 2, 0, _temp, 1, length1)
                        _Radix2FiniteImpulseFilter(log2n2, n_width, _temp, length1, 1, height, _kreal2, _kimag2, 2, 0, output, numberOfComponents * n_width, numberOfComponents)
                        
                        source += 1
                        output += 1

            }
        }
        
        result.removeLast(result.count - n_width * height)
        
        return Self(width: n_width, height: height, pixels: result, resamplingAlgorithm: self.resamplingAlgorithm)
    }
    
    @inlinable
    @inline(__always)
    func _cooleyTukey_convolution_vertical(_ filter: [RawPixel.Scalar]) -> Self {
        
        let width = self.width
        let height = self.height
        let numberOfComponents = self.numberOfComponents
        
        let n_height = height + filter.count - 1
        
        guard width > 0 && height > 0 else { return self }
        
        let length = Radix2CircularConvolveLength(height, filter.count)
        
        var buffer = MappedBuffer<RawPixel.Scalar>(repeating: 0, count: length, fileBacked: self.fileBacked)
        var result = MappedBuffer<RawPixel>(repeating: RawPixel.zero, count: width * length, fileBacked: self.fileBacked)
        
        buffer.withUnsafeMutableBufferPointer {
            
