         for (index, value) in enumerate(numbers)
         {
             shuffle(&alphabet, lsalt, lsaltRange);
-            let last = _hash(value, alphabet);
-            ret += last;
+            let lastIndex = hash.endIndex;
+            _hash(&hash, value, alphabet);
             
             if(index + 1 < numbers.count)
             {
-                let number = value % (numericCast(last[0]) + index);
+                let number = value % (numericCast(hash[lastIndex]) + index);
                 let seps_index = number % self.seps.count;
-                ret.append(self.seps[seps_index]);
+                hash.append(self.seps[seps_index]);
             }
             
             lsalt.replaceRange(lsaltARange, with: alphabet);

        return ret;
    }
    
    private func _hash(var number:Int, _ alphabet:[Char]) -> [Char]
    {
        var hash = [Char]();
        let length = alphabet.count
        
        do {
            hash.insert(alphabet[number % length], atIndex: 0);
            number = number / length;
        } while( number != 0 );
        
        return hash;
    }

    private func _unhash<U:CollectionType where U.Index == Int, U.Generator.Element == Char>(hash:U, _ alphabet:[Char]) -> Int

        }
        
        let lottery = alphabet[numbers_hash_int % alphabet.count];
        var hash = [lottery];
  
        var lsalt = [Char]();
        let (lsaltARange, lsaltRange) = _saltify(&lsalt, lottery, alphabet);
