         return node
     }
     
+    /// - returns: Serialized data for storage.
     func serialize() -> NSData {
         let data = NSMutableData()
         var finalByte: UInt8 = final ? 1 : 0

    {
        var filled = [Int: DawgLetter]()
        for (key, value) in filledLetters {
            filled[key] = String(value).utf8.first!
        }
        var results = [String]()
        recursiveAnagrams(withLetters: letters.map({ String($0).utf8.first! }),
            wordLength: wordLength, prefix: [DawgLetter](), filled: filled,
            filledCount: filled.count, source: rootNode,
            blankLetter: String(blankLetter).utf8.first!, results: &results)

class DawgNode: CustomStringConvertible, Hashable {
    typealias Edges = [DawgLetter: DawgNode]
    
    private static var nextId: UInt32 = 0
    private var descr: String = ""
    lazy var edges = Edges()
    var final: Bool = false
    var id: UInt32
    
    /// Create a new node while building a new Dawg.
    init() {
        self.id = self.dynamicType.nextId
        self.dynamicType.nextId += 1
        updateDescription()
    }
    
    /// Create a new node with existing data into an existing Dawg.
    /// - parameter id: Node identifier.
    /// - parameter final: Whether this node terminates a word.
    init(withId id: UInt32, final: Bool) {
        self.dynamicType.nextId = max(self.dynamicType.nextId, id)
        self.id = id
        self.final = final
    }
    
    /// Deserialize data, creating node hierarchy.
    /// - parameter data: Buffer instance that handles deserializing data.
    /// - parameter cached: Cache used for minifying nodes.
    /// - returns: Returns root node.
    class func deserialize(data: DataBuffer, inout cached: [UInt32: DawgNode]) -> DawgNode {
        let final = data.getUInt8() == 1
        let id = data.getUInt32()
