         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);

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

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