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

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

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