         while sampleIndex + 1 < sample.count - minNeighborSize && prototypeIndex + 1 < prototype.count - minNeighborSize {
             
             // We want to use the same window size to compare all options, so it must be safe for all cases
-            let maxNeighborSize = 5
             let safeNeighborSize = min(sampleIndex, sample.count - 1 - (sampleIndex + 1),
                 prototypeIndex, prototype.count - 1 - (prototypeIndex + 1),
                 maxNeighborSize)

        }
        let scale = min(xScale, yScale)
        
        pointIndex = 0
        return inputDigit.map { subPath in
            return subPath.filter({ point in
                let drop = pointIndex % dropIndexes == 0
                pointIndex++
                return !drop
            }).map({ point in
                let x = (point.x - xMean) * scale
                let y = (point.y - yMean) * scale
                return CGPointMake(x, y)
            })
        }

                        println("Normalizing a troubled digit")
                    }
                    let normalizedDigit = normalizeDigit(prototype)
                    let totalPoints = normalizedDigit.reduce(0) {(total, stroke) -> Int in
                        return total + stroke.count
                    }
                    println("Normalized digit \(label) to \(totalPoints) points")
                    addToLibrary(&self.normalizedPrototypeLibrary, label: label, digit: normalizedDigit)
                }
            }
