     public func diffTraces(
         to: Self,
         isEqual: EqualityChecker<Self>
-    ) -> [Trace] {
+        ) -> [Trace] {
         if count == 0 && to.count == 0 {
             return []
         } else if count == 0 {

    fileprivate func myersDiffTraces(
        to: Self,
        isEqual: (Iterator.Element, Iterator.Element) -> Bool
    ) -> [Trace] {

        let fromCount = Int(count)
        let toCount = Int(to.count)
        var traces = Array<Trace>()

        let max = fromCount + toCount // this is arbitrary, maximum difference between from and to. N+M assures that this algorithm always finds from diff

        var vertices = Array(repeating: -1, count: 2 * Int(max) + 1) // from [0...2*max], it is -max...max in the whitepaper

        vertices[max + 1] = 0

        for numberOfDifferences in 0 ... max {
            for k in stride(from: (-numberOfDifferences), through: numberOfDifferences, by: 2) {

                let index = k + max
                let traceStep = TraceStep(D: numberOfDifferences, k: k, previousX: vertices.value(at: index - 1), nextX: vertices.value(at: index + 1))
                if let trace = bound(trace: nextTrace(traceStep), maxX: fromCount, maxY: toCount) {
                    var x = trace.to.x

    /// - SeeAlso: `diff(_:isEqual:)`
    public func diff(
        _ other: Self
        ) -> Diff {
        return diff(other, isEqual: { $0 == $1 })
    }

    /// - SeeAlso: `diffTraces(to:isEqual:)`
    public func diffTraces(
        to: Self
        ) -> [Trace] {
        return diffTraces(to: to, isEqual: { $0 == $1 })
    }

    /// - SeeAlso: `outputDiffPathTraces(to:isEqual:)`
    public func outputDiffPathTraces(
        to: Self
        ) -> [Trace] {
        return outputDiffPathTraces(to: to, isEqual: { $0 == $1 })
    }
}
