             return
         }
         
-        func solutionsAt(x x: Int, y: Int, length: Int, horizontal: Bool) -> [Solution]? {
-            if !board.isValidSpot(x, y: y, length: length, horizontal: horizontal) {
-                return nil
-            }
-            
-            // Collect characters that are filled, return if word is longer than the one we are currently trying to check
-            guard let characters = charactersAt(x, y: y, length: length, horizontal: horizontal) where characters.count == length else {
-                return nil
-            }
-            
-            // Convert to be accepted by anagram method
-            var fixedLetters = [Int: Character]()
-            characters.filter({ $1.value != nil }).forEach({ fixedLetters[$1.index] = $1.value! })
-            guard let firstOffset = characters.keys.sort().first else {
-                return nil
-            }
-            
-            // Get all letters that are possible to be used
-            let anagramLetters = (letters.map({ $0.letter }) + fixedLetters.values)
-
-            // Calculate permutations, then filter any that are lexicographically equivalent to reduce work of anagram dictionary
-            let combinations = Set(anagramLetters.combinations(length).map({ String($0.sort()) }))
-            let words = combinations.flatMap({ anagramDictionary[$0, fixedLetters] }).flatten()
-            
-            var solves = [Solution]()
-            for word in words {
-                var valid = true
-                var intersections = [Word]()
-                if debug {
-                    print("Valid main word: \(word)")
-                }
-                var tempPlayer = Human(rackTiles: letters)
-                var blanks = [(x: Int, y: Int)]()
-                for (index, letter) in Array(word.characters).enumerate() {
-                    let offset = firstOffset + index
-                    let intersectHorizontally = !horizontal
-                    let intersected = wordAt(intersectHorizontally ? x : offset,
-                                             y: intersectHorizontally ? offset : y,
-                                             string: String(letter),
-                                             horizontal: intersectHorizontally)
-                    if intersected.word.characters.count > 1 {
-                        if dictionary.lookup(intersected.word) {
-                            if debug {
-                                print("Valid intersecting word: \(intersected)")
-                            }
-                            intersections.append(intersected)
-                        } else {
-                            if debug {
-                                print("Invalid intersecting word: \(intersected)")
-                            }
-                            valid = false
-                            break
-                        }
-                    }
-                    // Possible improvement here could be to find the most valuable spot to play a `real` letter
-                    // and use the blank in the least valuable spot.
-                    if tempPlayer.removeLetter(letter).wasBlank {
-                        if horizontal {
-                            blanks.append((offset, y))
-                        } else {
-                            blanks.append((x, offset))
-                        }
-                    }
-                }
-                if valid {
-                    let mainWord = Word(word: word,
-                                    x: horizontal ? firstOffset : x,
-                                    y: horizontal ? y : firstOffset,
-                                    horizontal: horizontal)
-                    solves.append(Solution(word: mainWord.word,
-                        x: mainWord.x,
-                        y: mainWord.y,
-                        horizontal: mainWord.horizontal,
-                        score: calculateScore(mainWord, blanks: blanks),
-                        intersections: intersections,
-                        blanks: blanks))
-                    if !board.isFirstPlay {
-                        assert(intersections.count > 0)
-                    }
-                }
-            }
-            return solves
-        }
-        
+        let solutionLetters = letters.map({ $0.letter })
         var solutions = [Solution]()
-        let currentQueue = NSOperationQueue.currentQueue()
         var count = 0
         let range = board.config.boardRange
         let size = board.config.size

            end += 1
            collect()
        }
        if horizontal {
            return Word(word: String(chars), x: start, y: y, horizontal: horizontal)
        } else {
            return Word(word: String(chars), x: x, y: start, horizontal: horizontal)
        }
    }
    
    private func calculateScore(word: WordRepresentation, blanks: [(x: Int, y: Int)]) -> Int {

            tilesUsed += 1
            score += value * letterMultiplier
            scoreMultiplier *= wordMultiplier
            if let intersectingWord = wordAt(x, y: y, string: String(letter), horizontal: !word.horizontal) where intersectingWord.1 == true {
                let wordScore = wordSum(intersectingWord.0) + (value * (letterMultiplier - 1))
                intersectionsScore += wordScore * wordMultiplier
            }
        }
