                 for run in runs {
                     let leadingSpace = (firstRun ? 0 : 1) + run.extraLeadingSpace
                     firstRun = false
-
+                    
                     if (i < leadingSpace) {
                         return false
                     }
                     i -= leadingSpace
-
+                    
                     if (i < run.length) {
                         return true
                     }
                     i -= run.length
                 }
-
+                
                 return false
             }
         }
-
+        
         private func trailingSpaceOnLine() -> Int {
             return totalLineSlop - runs.reduce(0) {
                 return $0 + $1.extraLeadingSpace; }
         }
-
+        
         func expand() -> PartialLine {
             // TODO: make this class a SequenceType
             var result: [Bool?] = []

            }
            totalLineSlop = lineLength - consumedSpace
        }

        private func runOffset(targetRun: Run) -> Int {
            var i = 0
            var firstRun = true

        while (true) {
            let beforeCount = currentBestSolution.knownCellCount()
            for rowNumber in 0 ..< context.rows {
                currentBestSolution = applyAlgorithm(OperlapAlgorithm.execute,
                                                     lineNumber: rowNumber,
                                                     currentBestSolution: currentBestSolution,
                                                     lineGetter: context.rowHelper)
                currentBestSolution = applyAlgorithm(MinMaxRangeAlgorithm.execute,
                                                     lineNumber: rowNumber,
                                                     currentBestSolution: currentBestSolution,
                                                     lineGetter: context.rowHelper)
            }

            for colNumber in 0 ..< context.columns {
                currentBestSolution = applyAlgorithm(OperlapAlgorithm.execute,
                                                     lineNumber: colNumber,
                                                     currentBestSolution: currentBestSolution,
                                                     lineGetter: context.columnHelper
                )
                currentBestSolution = applyAlgorithm(MinMaxRangeAlgorithm.execute,
                                                     lineNumber: colNumber,
                                                     currentBestSolution: currentBestSolution,
                                                     lineGetter: context.columnHelper)
