         
         let minLength:Int = numericCast(self.minHashLength);
         
-        if(ret.count < minLength)
-        {
-            let guard_index = (numbers_hash_int + numericCast(ret[0])) % self.guards.count;
+        if(hash.count < minLength)
+        {
+            let guard_index = (numbers_hash_int + numericCast(hash[0])) % self.guards.count;
             let guard = self.guards[guard_index];
-            ret.insert(guard, atIndex: 0);
-            
-            if(ret.count < minLength)
-            {
-                let guard_index = (numbers_hash_int + numericCast(ret[2])) % self.guards.count;
+            hash.insert(guard, atIndex: 0);
+            
+            if(hash.count < minLength)
+            {
+                let guard_index = (numbers_hash_int + numericCast(hash[2])) % self.guards.count;
                 let guard = self.guards[guard_index];
-                ret.append(guard);
+                hash.append(guard);
             }
         }
         
         let half_length = alphabet.count >> 1;
-        while( ret.count < minLength )
+        while( hash.count < minLength )
         {
             shuffle(&alphabet, alphabet);
             let lrange = 0..<half_length;
             let rrange = half_length..<(alphabet.count);
-            ret = alphabet[rrange] + ret + alphabet[lrange];
-            
-            let excess = ret.count - minLength;
+            hash = alphabet[rrange] + hash + alphabet[lrange];
+            
+            let excess = hash.count - minLength;
             if( excess > 0 )
             {
                 let start = excess >> 1;
-                ret = [Char](ret[start..<(start+minLength)])
-            }
-        }
-        
-        return ret;
+                hash = [Char](hash[start..<(start+minLength)])
+            }
+        }
+        
+        return hash;
     }
     
     private func _decode(hash:[Char]) -> [Int]

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

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

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