     
     init(_ processor: BaseEliminationProcessor<R, n, m>) {
         self.p = processor
-        
-        switch p.mode {
-        case .Both:
-            current = (p.itr, p.itr)
-        case .Rows:
-            current = (p.itr, 0)
-        case .Cols:
-            current = (0, p.itr)
-        }
+        self.current = (p.itr, p.itr)
     }
     
     mutating func next() -> (Int, Int)? {

        }
    
        return true
    }
    
    private func eliminateRow(_ i0: Int, _ j0: Int) {
        let a = result[i0, j0]
        if a != R.identity {
            apply(.MulRow(at: i0, by: a.inverse))
        }
        
        for i in 0 ..< rows {
            if i == i0 || result[i, j0] == 0 {
                continue
            }
            
            apply(.AddRow(at: i0, to: i, mul: -result[i, j0]))
        }
    }
    
    private func eliminateCol(_ i0: Int, _ j0: Int) {
        let a = result[i0, j0]
        if a != R.identity {
            apply(.MulCol(at: i0, by: a.inverse))
        }
        
        for j in 0 ..< cols {
            if j == j0 || result[i0, j] == 0 {
                continue
            }
            
            apply(.AddCol(at: j0, to: j, mul: -result[i0, j]))
        }
    }
    
    private func next() -> (row: Int, col: Int)? {

        let doCols = (mode != .Rows)
        
        guard var (i0, j0) = next() else {
            if mode == .Both { // The area left is O. Exit iteration.
                return false
            } else {           // The target row/col is O. Continue iteration.
                return true
            }
        }
        
        if doRows && i0 > itr {
