                 if candidate == truth {
                     continue
                 }
-
+                
                 let run: PackedLine.Run
                 let offsetToShift: Int
                 if truth {

                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?] = []

                }
                i += run.length
            }
            
            fatalError("Couldn't find target run")
        }
        
        private func runPriorToOffset(offset: Int) -> Run? {
            if (offset == 0) {
                return nil
            }
            
            for i in (0 ... offset - 1).reverse() {
                let run = runAtOffset(i)
                if (run != nil) {
                    return run
                }
            }
            
            return nil
        }
        
        private func runAtOffset(offset: Int) -> Run? {
            var i = offset
            var firstRun = true
