             r = ctl.pathPosition[r]!.k
         }
         
-        return EditDistanceContainer(editScripts: traceBack(epc: epc, ctl: ctl, xAxis: xAxis, yAxis: yAxis))
+        return EditDistanceContainer(editScripts: traceBack(epc: epc, ctl: ctl, xAxis: xAxisPointer, yAxis: yAxisPointer))
     }
     
-    private func traceBack<T: Comparable>(epc: [Int: Point], ctl: Ctl, xAxis: [EditDistanceAlgorithmContainer<T>], yAxis: [EditDistanceAlgorithmContainer<T>]) -> [EditScript<T>] {
+    private func traceBack<T: Comparable>(epc: [Int: Point], ctl: Ctl, xAxis: UnsafeMutablePointer<EditDistanceAlgorithmContainer<T>>, yAxis: UnsafeMutablePointer<EditDistanceAlgorithmContainer<T>>) -> [EditScript<T>] {
         var editScript = [EditScript<T>]()
         
         var pxIdx = 0, pyIdx = 0

                    ctl.path[k + offset] = ctl.pathPosition.count
                    let kRes = calcFootPrint(ctl: ctl, fp: fp, index: k + offset)
                    
                    (fp[k + offset], ctl.pathPosition[ctl.pathPosition.count]) = snake(xAxis: xAxis, yAxis: yAxis, xAxisCount: xAxisCount, yAxisCount: yAxisCount, k: k, y: kRes.y, r: kRes.r)
                }
            }
            
            ctl.path[delta + offset] = ctl.pathPosition.count
            let deltaResult = calcFootPrint(ctl: ctl, fp: fp, index: delta + offset)
            
            (fp[delta + offset], ctl.pathPosition[ctl.pathPosition.count]) = snake(xAxis: xAxis, yAxis: yAxis, xAxisCount: xAxisCount, yAxisCount: yAxisCount, k: delta, y: deltaResult.y, r: deltaResult.r)
            
            if fp[delta + offset] >= yAxis.count {
                break
            }
            

                return EditDistanceAlgorithmContainer(indexPath: IndexPath(row: secondIdx, section: firstIdx), element: elm)
            }
        }

        let xAxisPointer: UnsafeMutablePointer<EditDistanceAlgorithmContainer<T>>
        let yAxisPointer: UnsafeMutablePointer<EditDistanceAlgorithmContainer<T>>
        
        let xAxisCount: Int
        let yAxisCount: Int
        
        var ctl: Ctl
        if _from.count >= _to.count {
            xAxisPointer = UnsafeMutablePointer(mutating: _to)
            yAxisPointer = UnsafeMutablePointer(mutating: _from)
            xAxisCount = _to.count
            yAxisCount = _from.count
            ctl = Ctl(reverse: true, path: [], pathPosition: [:])
        } else {
            xAxisPointer = UnsafeMutablePointer(mutating: _from)
            yAxisPointer = UnsafeMutablePointer(mutating: _to)
            xAxisCount = _from.count
            yAxisCount = _to.count
            ctl = Ctl(reverse: false, path: [], pathPosition: [:])
        }
        let offset = xAxisCount + 1
        let delta = yAxisCount - xAxisCount
        let size = xAxisCount + yAxisCount + 3
        var fp = Array(repeating: -1, count: size)
        ctl.path = Array(repeating: -1, count: size)
        ctl.pathPosition = [:]

        
        var p = 0
        while(true) {
