package redis.clients.jedis;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.Iterator;

import java.util.LinkedHashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import redis.clients.util.SafeEncoder;

import redis.clients.util.Slowlog;

public class Jedis extends BinaryJedis implements JedisCommands

{

  public Jedis(String host)

  {

    super(host);

  }

  public Jedis(String host, int port) {

    super(host, port);

  }

  public Jedis(String host, int port, int timeout) {

    super(host, port, timeout);

  }

  public Jedis(JedisShardInfo shardInfo) {

    super(shardInfo);

  }

  public String ping() {

    checkIsInMulti();

    this.client.ping();

    return this.client.getStatusCodeReply();

  }

  public String set(String key, String value)

  {

    checkIsInMulti();

    this.client.set(key, value);

    return this.client.getStatusCodeReply();

  }

  public String get(String key)

  {

    checkIsInMulti();

    this.client.sendCommand(Protocol.Command.GET, new String[] { key });

    return this.client.getBulkReply();

  }

  public String quit()

  {

    checkIsInMulti();

    this.client.quit();

    return this.client.getStatusCodeReply();

  }

  public Boolean exists(String key)

  {

    checkIsInMulti();

    this.client.exists(key);

    return Boolean.valueOf(this.client.getIntegerReply().longValue() == 1L);

  }

  public Long del(String... keys)

  {

    checkIsInMulti();

    this.client.del(keys);

    return this.client.getIntegerReply();

  }

  public String type(String key)

  {

    checkIsInMulti();

    this.client.type(key);

    return this.client.getStatusCodeReply();

  }

  public String flushDB()

  {

    checkIsInMulti();

    this.client.flushDB();

    return this.client.getStatusCodeReply();

  }

  public Set<String> keys(String pattern)

  {

    checkIsInMulti();

    this.client.keys(pattern);

    return (Set)BuilderFactory.STRING_SET.build(this.client.getBinaryMultiBulkReply());

  }

  public String randomKey()

  {

    checkIsInMulti();

    this.client.randomKey();

    return this.client.getBulkReply();

  }

  public String rename(String oldkey, String newkey)

  {

    checkIsInMulti();

    this.client.rename(oldkey, newkey);

    return this.client.getStatusCodeReply();

  }

  public Long renamenx(String oldkey, String newkey)

  {

    checkIsInMulti();

    this.client.renamenx(oldkey, newkey);

    return this.client.getIntegerReply();

  }

  public Long expire(String key, int seconds)

  {

    checkIsInMulti();

    this.client.expire(key, seconds);

    return this.client.getIntegerReply();

  }

  public Long expireAt(String key, long unixTime)

  {

    checkIsInMulti();

    this.client.expireAt(key, unixTime);

    return this.client.getIntegerReply();

  }

  public Long ttl(String key)

  {

    checkIsInMulti();

    this.client.ttl(key);

    return this.client.getIntegerReply();

  }

  public String select(int index)

  {

    checkIsInMulti();

    this.client.select(index);

    return this.client.getStatusCodeReply();

  }

  public Long move(String key, int dbIndex)

  {

    checkIsInMulti();

    this.client.move(key, dbIndex);

    return this.client.getIntegerReply();

  }

  public String flushAll()

  {

    checkIsInMulti();

    this.client.flushAll();

    return this.client.getStatusCodeReply();

  }

  public String getSet(String key, String value)

  {

    checkIsInMulti();

    this.client.getSet(key, value);

    return this.client.getBulkReply();

  }

  public List<String> mget(String... keys)

  {

    checkIsInMulti();

    this.client.mget(keys);

    return this.client.getMultiBulkReply();

  }

  public Long setnx(String key, String value)

  {

    checkIsInMulti();

    this.client.setnx(key, value);

    return this.client.getIntegerReply();

  }

  public String setex(String key, int seconds, String value)

  {

    checkIsInMulti();

    this.client.setex(key, seconds, value);

    return this.client.getStatusCodeReply();

  }

  public String mset(String... keysvalues)

  {

    checkIsInMulti();

    this.client.mset(keysvalues);

    return this.client.getStatusCodeReply();

  }

  public Long msetnx(String... keysvalues)

  {

    checkIsInMulti();

    this.client.msetnx(keysvalues);

    return this.client.getIntegerReply();

  }

  public Long decrBy(String key, long integer)

  {

    checkIsInMulti();

    this.client.decrBy(key, integer);

    return this.client.getIntegerReply();

  }

  public Long decr(String key)

  {

    checkIsInMulti();

    this.client.decr(key);

    return this.client.getIntegerReply();

  }

  public Long incrBy(String key, long integer)

  {

    checkIsInMulti();

    this.client.incrBy(key, integer);

    return this.client.getIntegerReply();

  }

  public Long incr(String key)

  {

    checkIsInMulti();

    this.client.incr(key);

    return this.client.getIntegerReply();

  }

  public Long append(String key, String value)

  {

    checkIsInMulti();

    this.client.append(key, value);

    return this.client.getIntegerReply();

  }

  public String substr(String key, int start, int end)

  {

    checkIsInMulti();

    this.client.substr(key, start, end);

    return this.client.getBulkReply();

  }

  public Long hset(String key, String field, String value)

  {

    checkIsInMulti();

    this.client.hset(key, field, value);

    return this.client.getIntegerReply();

  }

  public String hget(String key, String field)

  {

    checkIsInMulti();

    this.client.hget(key, field);

    return this.client.getBulkReply();

  }

  public Long hsetnx(String key, String field, String value)

  {

    checkIsInMulti();

    this.client.hsetnx(key, field, value);

    return this.client.getIntegerReply();

  }

  public String hmset(String key, Map<String, String> hash)

  {

    checkIsInMulti();

    this.client.hmset(key, hash);

    return this.client.getStatusCodeReply();

  }

  public List<String> hmget(String key, String... fields)

  {

    checkIsInMulti();

    this.client.hmget(key, fields);

    return this.client.getMultiBulkReply();

  }

  public Long hincrBy(String key, String field, long value)

  {

    checkIsInMulti();

    this.client.hincrBy(key, field, value);

    return this.client.getIntegerReply();

  }

  public Boolean hexists(String key, String field)

  {

    checkIsInMulti();

    this.client.hexists(key, field);

    return Boolean.valueOf(this.client.getIntegerReply().longValue() == 1L);

  }

  public Long hdel(String key, String... fields)

  {

    checkIsInMulti();

    this.client.hdel(key, fields);

    return this.client.getIntegerReply();

  }

  public Long hlen(String key)

  {

    checkIsInMulti();

    this.client.hlen(key);

    return this.client.getIntegerReply();

  }

  public Set<String> hkeys(String key)

  {

    checkIsInMulti();

    this.client.hkeys(key);

    return (Set)BuilderFactory.STRING_SET.build(this.client.getBinaryMultiBulkReply());

  }

  public List<String> hvals(String key)

  {

    checkIsInMulti();

    this.client.hvals(key);

    List<String> lresult = this.client.getMultiBulkReply();

    return lresult;

  }

  public Map<String, String> hgetAll(String key)

  {

    checkIsInMulti();

    this.client.hgetAll(key);

    return (Map)BuilderFactory.STRING_MAP.build(this.client.getBinaryMultiBulkReply());

  }

  public Long rpush(String key, String... strings)

  {

    checkIsInMulti();

    this.client.rpush(key, strings);

    return this.client.getIntegerReply();

  }

  public Long lpush(String key, String... strings)

  {

    checkIsInMulti();

    this.client.lpush(key, strings);

    return this.client.getIntegerReply();

  }

  public Long llen(String key)

  {

    checkIsInMulti();

    this.client.llen(key);

    return this.client.getIntegerReply();

  }

  public List<String> lrange(String key, long start, long end)

  {

    checkIsInMulti();

    this.client.lrange(key, start, end);

    return this.client.getMultiBulkReply();

  }

  public String ltrim(String key, long start, long end)

  {

    checkIsInMulti();

    this.client.ltrim(key, start, end);

    return this.client.getStatusCodeReply();

  }

  public String lindex(String key, long index)

  {

    checkIsInMulti();

    this.client.lindex(key, index);

    return this.client.getBulkReply();

  }

  public String lset(String key, long index, String value)

  {

    checkIsInMulti();

    this.client.lset(key, index, value);

    return this.client.getStatusCodeReply();

  }

  public Long lrem(String key, long count, String value)

  {

    checkIsInMulti();

    this.client.lrem(key, count, value);

    return this.client.getIntegerReply();

  }

  public String lpop(String key)

  {

    checkIsInMulti();

    this.client.lpop(key);

    return this.client.getBulkReply();

  }

  public String rpop(String key)

  {

    checkIsInMulti();

    this.client.rpop(key);

    return this.client.getBulkReply();

  }

  public String rpoplpush(String srckey, String dstkey)

  {

    checkIsInMulti();

    this.client.rpoplpush(srckey, dstkey);

    return this.client.getBulkReply();

  }

  public Long sadd(String key, String... members)

  {

    checkIsInMulti();

    this.client.sadd(key, members);

    return this.client.getIntegerReply();

  }

  public Set<String> smembers(String key)

  {

    checkIsInMulti();

    this.client.smembers(key);

    List<String> members = this.client.getMultiBulkReply();

    return new HashSet(members);

  }

  public Long srem(String key, String... members)

  {

    checkIsInMulti();

    this.client.srem(key, members);

    return this.client.getIntegerReply();

  }

  public String spop(String key)

  {

    checkIsInMulti();

    this.client.spop(key);

    return this.client.getBulkReply();

  }

  public Long smove(String srckey, String dstkey, String member)

  {

    checkIsInMulti();

    this.client.smove(srckey, dstkey, member);

    return this.client.getIntegerReply();

  }

  public Long scard(String key)

  {

    checkIsInMulti();

    this.client.scard(key);

    return this.client.getIntegerReply();

  }

  public Boolean sismember(String key, String member)

  {

    checkIsInMulti();

    this.client.sismember(key, member);

    return Boolean.valueOf(this.client.getIntegerReply().longValue() == 1L);

  }

  public Set<String> sinter(String... keys)

  {

    checkIsInMulti();

    this.client.sinter(keys);

    List<String> members = this.client.getMultiBulkReply();

    return new HashSet(members);

  }

  public Long sinterstore(String dstkey, String... keys)

  {

    checkIsInMulti();

    this.client.sinterstore(dstkey, keys);

    return this.client.getIntegerReply();

  }

  public Set<String> sunion(String... keys)

  {

    checkIsInMulti();

    this.client.sunion(keys);

    List<String> members = this.client.getMultiBulkReply();

    return new HashSet(members);

  }

  public Long sunionstore(String dstkey, String... keys)

  {

    checkIsInMulti();

    this.client.sunionstore(dstkey, keys);

    return this.client.getIntegerReply();

  }

  public Set<String> sdiff(String... keys)

  {

    checkIsInMulti();

    this.client.sdiff(keys);

    return (Set)BuilderFactory.STRING_SET.build(this.client.getBinaryMultiBulkReply());

  }

  public Long sdiffstore(String dstkey, String... keys)

  {

    checkIsInMulti();

    this.client.sdiffstore(dstkey, keys);

    return this.client.getIntegerReply();

  }

  public String srandmember(String key)

  {

    checkIsInMulti();

    this.client.srandmember(key);

    return this.client.getBulkReply();

  }

  public Long zadd(String key, double score, String member)

  {

    checkIsInMulti();

    this.client.zadd(key, score, member);

    return this.client.getIntegerReply();

  }

  public Long zadd(String key, Map<Double, String> scoreMembers) {

    checkIsInMulti();

    this.client.zadd(key, scoreMembers);

    return this.client.getIntegerReply();

  }

  public Set<String> zrange(String key, long start, long end) {

    checkIsInMulti();

    this.client.zrange(key, start, end);

    List<String> members = this.client.getMultiBulkReply();

    return new LinkedHashSet(members);

  }

  public Long zrem(String key, String... members)

  {

    checkIsInMulti();

    this.client.zrem(key, members);

    return this.client.getIntegerReply();

  }

  public Double zincrby(String key, double score, String member)

  {

    checkIsInMulti();

    this.client.zincrby(key, score, member);

    String newscore = this.client.getBulkReply();

    return Double.valueOf(newscore);

  }

  public Long zrank(String key, String member)

  {

    checkIsInMulti();

    this.client.zrank(key, member);

    return this.client.getIntegerReply();

  }

  public Long zrevrank(String key, String member)

  {

    checkIsInMulti();

    this.client.zrevrank(key, member);

    return this.client.getIntegerReply();

  }

  public Set<String> zrevrange(String key, long start, long end)

  {

    checkIsInMulti();

    this.client.zrevrange(key, start, end);

    List<String> members = this.client.getMultiBulkReply();

    return new LinkedHashSet(members);

  }

  public Set<Tuple> zrangeWithScores(String key, long start, long end)

  {

    checkIsInMulti();

    this.client.zrangeWithScores(key, start, end);

    Set<Tuple> set = getTupledSet();

    return set;

  }

  public Set<Tuple> zrevrangeWithScores(String key, long start, long end)

  {

    checkIsInMulti();

    this.client.zrevrangeWithScores(key, start, end);

    Set<Tuple> set = getTupledSet();

    return set;

  }

  public Long zcard(String key)

  {

    checkIsInMulti();

    this.client.zcard(key);

    return this.client.getIntegerReply();

  }

  public Double zscore(String key, String member)

  {

    checkIsInMulti();

    this.client.zscore(key, member);

    String score = this.client.getBulkReply();

    return score != null ? new Double(score) : null;

  }

  public String watch(String... keys) {

    this.client.watch(keys);

    return this.client.getStatusCodeReply();

  }

  public List<String> sort(String key)

  {

    checkIsInMulti();

    this.client.sort(key);

    return this.client.getMultiBulkReply();

  }

  public List<String> sort(String key, SortingParams sortingParameters)

  {

    checkIsInMulti();

    this.client.sort(key, sortingParameters);

    return this.client.getMultiBulkReply();

  }

  public List<String> blpop(int timeout, String... keys)

  {

    checkIsInMulti();

    List<String> args = new ArrayList();

    for (String arg : keys) {

      args.add(arg);

    }

    args.add(String.valueOf(timeout));

    this.client.blpop((String[])args.toArray(new String[args.size()]));

    this.client.setTimeoutInfinite();

    List<String> multiBulkReply = this.client.getMultiBulkReply();

    this.client.rollbackTimeout();

    return multiBulkReply;

  }

  public Long sort(String key, SortingParams sortingParameters, String dstkey)

  {

    checkIsInMulti();

    this.client.sort(key, sortingParameters, dstkey);

    return this.client.getIntegerReply();

  }

  public Long sort(String key, String dstkey)

  {

    checkIsInMulti();

    this.client.sort(key, dstkey);

    return this.client.getIntegerReply();

  }

  public List<String> brpop(int timeout, String... keys)

  {

    checkIsInMulti();

    List<String> args = new ArrayList();

    for (String arg : keys) {

      args.add(arg);

    }

    args.add(String.valueOf(timeout));

    this.client.brpop((String[])args.toArray(new String[args.size()]));

    this.client.setTimeoutInfinite();

    List<String> multiBulkReply = this.client.getMultiBulkReply();

    this.client.rollbackTimeout();

    return multiBulkReply;

  }

  public String auth(String password)

  {

    checkIsInMulti();

    this.client.auth(password);

    return this.client.getStatusCodeReply();

  }

  public void subscribe(JedisPubSub jedisPubSub, String... channels) {

    checkIsInMulti();

    connect();

    this.client.setTimeoutInfinite();

    jedisPubSub.proceed(this.client, channels);

    this.client.rollbackTimeout();

  }

  public Long publish(String channel, String message) {

    checkIsInMulti();

    this.client.publish(channel, message);

    return this.client.getIntegerReply();

  }

  public void psubscribe(JedisPubSub jedisPubSub, String... patterns) {

    checkIsInMulti();

    connect();

    this.client.setTimeoutInfinite();

    jedisPubSub.proceedWithPatterns(this.client, patterns);

    this.client.rollbackTimeout();

  }

  public Long zcount(String key, double min, double max) {

    checkIsInMulti();

    this.client.zcount(key, min, max);

    return this.client.getIntegerReply();

  }

  public Long zcount(String key, String min, String max) {

    checkIsInMulti();

    this.client.zcount(key, min, max);

    return this.client.getIntegerReply();

  }

  public Set<String> zrangeByScore(String key, double min, double max)

  {

    checkIsInMulti();

    this.client.zrangeByScore(key, min, max);

    return new LinkedHashSet(this.client.getMultiBulkReply());

  }

  public Set<String> zrangeByScore(String key, String min, String max)

  {

    checkIsInMulti();

    this.client.zrangeByScore(key, min, max);

    return new LinkedHashSet(this.client.getMultiBulkReply());

  }

  public Set<String> zrangeByScore(String key, double min, double max, int offset, int count)

  {

    checkIsInMulti();

    this.client.zrangeByScore(key, min, max, offset, count);

    return new LinkedHashSet(this.client.getMultiBulkReply());

  }

  public Set<String> zrangeByScore(String key, String min, String max, int offset, int count)

  {

    checkIsInMulti();

    this.client.zrangeByScore(key, min, max, offset, count);

    return new LinkedHashSet(this.client.getMultiBulkReply());

  }

  public Set<Tuple> zrangeByScoreWithScores(String key, double min, double max)

  {

    checkIsInMulti();

    this.client.zrangeByScoreWithScores(key, min, max);

    Set<Tuple> set = getTupledSet();

    return set;

  }

  public Set<Tuple> zrangeByScoreWithScores(String key, String min, String max)

  {

    checkIsInMulti();

    this.client.zrangeByScoreWithScores(key, min, max);

    Set<Tuple> set = getTupledSet();

    return set;

  }

  public Set<Tuple> zrangeByScoreWithScores(String key, double min, double max, int offset, int count)

  {

    checkIsInMulti();

    this.client.zrangeByScoreWithScores(key, min, max, offset, count);

    Set<Tuple> set = getTupledSet();

    return set;

  }

  public Set<Tuple> zrangeByScoreWithScores(String key, String min, String max, int offset, int count)

  {

    checkIsInMulti();

    this.client.zrangeByScoreWithScores(key, min, max, offset, count);

    Set<Tuple> set = getTupledSet();

    return set;

  }

  private Set<Tuple> getTupledSet() {

    checkIsInMulti();

    List<String> membersWithScores = this.client.getMultiBulkReply();

    Set<Tuple> set = new LinkedHashSet();

    Iterator<String> iterator = membersWithScores.iterator();

    while (iterator.hasNext()) {

      set.add(new Tuple((String)iterator.next(), Double.valueOf((String)iterator.next())));

    }

    return set;

  }

  public Set<String> zrevrangeByScore(String key, double max, double min)

  {

    checkIsInMulti();

    this.client.zrevrangeByScore(key, max, min);

    return new LinkedHashSet(this.client.getMultiBulkReply());

  }

  public Set<String> zrevrangeByScore(String key, String max, String min)

  {

    checkIsInMulti();

    this.client.zrevrangeByScore(key, max, min);

    return new LinkedHashSet(this.client.getMultiBulkReply());

  }

  public Set<String> zrevrangeByScore(String key, double max, double min, int offset, int count)

  {

    checkIsInMulti();

    this.client.zrevrangeByScore(key, max, min, offset, count);

    return new LinkedHashSet(this.client.getMultiBulkReply());

  }

  public Set<Tuple> zrevrangeByScoreWithScores(String key, double max, double min)

  {

    checkIsInMulti();

    this.client.zrevrangeByScoreWithScores(key, max, min);

    Set<Tuple> set = getTupledSet();

    return set;

  }

  public Set<Tuple> zrevrangeByScoreWithScores(String key, double max, double min, int offset, int count)

  {

    checkIsInMulti();

    this.client.zrevrangeByScoreWithScores(key, max, min, offset, count);

    Set<Tuple> set = getTupledSet();

    return set;

  }

  public Set<Tuple> zrevrangeByScoreWithScores(String key, String max, String min, int offset, int count)

  {

    checkIsInMulti();

    this.client.zrevrangeByScoreWithScores(key, max, min, offset, count);

    Set<Tuple> set = getTupledSet();

    return set;

  }

  public Set<String> zrevrangeByScore(String key, String max, String min, int offset, int count)

  {

    checkIsInMulti();

    this.client.zrevrangeByScore(key, max, min, offset, count);

    return new LinkedHashSet(this.client.getMultiBulkReply());

  }

  public Set<Tuple> zrevrangeByScoreWithScores(String key, String max, String min)

  {

    checkIsInMulti();

    this.client.zrevrangeByScoreWithScores(key, max, min);

    Set<Tuple> set = getTupledSet();

    return set;

  }

  public Long zremrangeByRank(String key, long start, long end)

  {

    checkIsInMulti();

    this.client.zremrangeByRank(key, start, end);

    return this.client.getIntegerReply();

  }

  public Long zremrangeByScore(String key, double start, double end)

  {

    checkIsInMulti();

    this.client.zremrangeByScore(key, start, end);

    return this.client.getIntegerReply();

  }

  public Long zremrangeByScore(String key, String start, String end)

  {

    checkIsInMulti();

    this.client.zremrangeByScore(key, start, end);

    return this.client.getIntegerReply();

  }

  public Long zunionstore(String dstkey, String... sets)

  {

    checkIsInMulti();

    this.client.zunionstore(dstkey, sets);

    return this.client.getIntegerReply();

  }

  public Long zunionstore(String dstkey, ZParams params, String... sets)

  {

    checkIsInMulti();

    this.client.zunionstore(dstkey, params, sets);

    return this.client.getIntegerReply();

  }

  public Long zinterstore(String dstkey, String... sets)

  {

    checkIsInMulti();

    this.client.zinterstore(dstkey, sets);

    return this.client.getIntegerReply();

  }

  public Long zinterstore(String dstkey, ZParams params, String... sets)

  {

    checkIsInMulti();

    this.client.zinterstore(dstkey, params, sets);

    return this.client.getIntegerReply();

  }

  public Long strlen(String key) {

    this.client.strlen(key);

    return this.client.getIntegerReply();

  }

  public Long lpushx(String key, String string) {

    this.client.lpushx(key, string);

    return this.client.getIntegerReply();

  }

  public Long persist(String key)

  {

    this.client.persist(key);

    return this.client.getIntegerReply();

  }

  public Long rpushx(String key, String string) {

    this.client.rpushx(key, string);

    return this.client.getIntegerReply();

  }

  public String echo(String string) {

    this.client.echo(string);

    return this.client.getBulkReply();

  }

  public Long linsert(String key, BinaryClient.LIST_POSITION where, String pivot, String value)

  {

    this.client.linsert(key, where, pivot, value);

    return this.client.getIntegerReply();

  }

  public String brpoplpush(String source, String destination, int timeout)

  {

    this.client.brpoplpush(source, destination, timeout);

    this.client.setTimeoutInfinite();

    String reply = this.client.getBulkReply();

    this.client.rollbackTimeout();

    return reply;

  }

  public Boolean setbit(String key, long offset, boolean value)

  {

    this.client.setbit(key, offset, value);

    return Boolean.valueOf(this.client.getIntegerReply().longValue() == 1L);

  }

  public Boolean getbit(String key, long offset)

  {

    this.client.getbit(key, offset);

    return Boolean.valueOf(this.client.getIntegerReply().longValue() == 1L);

  }

  public Long setrange(String key, long offset, String value) {

    this.client.setrange(key, offset, value);

    return this.client.getIntegerReply();

  }

  public String getrange(String key, long startOffset, long endOffset) {

    this.client.getrange(key, startOffset, endOffset);

    return this.client.getBulkReply();

  }

  public List<String> configGet(String pattern)

  {

    this.client.configGet(pattern);

    return this.client.getMultiBulkReply();

  }

  public String configSet(String parameter, String value)

  {

    this.client.configSet(parameter, value);

    return this.client.getStatusCodeReply();

  }

  public Object eval(String script, int keyCount, String... params) {

    this.client.setTimeoutInfinite();

    this.client.eval(script, keyCount, params);

    return getEvalResult();

  }

  private String[] getParams(List<String> keys, List<String> args) {

    int keyCount = keys.size();

    int argCount = args.size();

    String[] params = new String[keyCount + args.size()];

    for (int i = 0; i < keyCount; i++) {

      params[i] = ((String)keys.get(i));

    }

    for (int i = 0; i < argCount; i++) {

      params[(keyCount + i)] = ((String)args.get(i));

    }

    return params;

  }

  public Object eval(String script, List<String> keys, List<String> args) {

    return eval(script, keys.size(), getParams(keys, args));

  }

  public Object eval(String script) {

    return eval(script, 0, new String[0]);

  }

  public Object evalsha(String script) {

    return evalsha(script, 0, new String[0]);

  }

  private Object getEvalResult() {

    Object result = this.client.getOne();

    if ((result instanceof byte[])) {

      return SafeEncoder.encode((byte[])result);

    }

    if ((result instanceof List)) {

      List<?> list = (List)result;

      List<String> listResult = new ArrayList(list.size());

      for (Iterator i$ = list.iterator(); i$.hasNext();) { Object bin = i$.next();

        listResult.add(SafeEncoder.encode((byte[])bin));

      }

      return listResult;

    }

    return result;

  }

  public Object evalsha(String sha1, List<String> keys, List<String> args) {

    return evalsha(sha1, keys.size(), getParams(keys, args));

  }

  public Object evalsha(String sha1, int keyCount, String... params) {

    checkIsInMulti();

    this.client.evalsha(sha1, keyCount, params);

    return getEvalResult();

  }

  public Boolean scriptExists(String sha1) {

    String[] a = new String[1];

    a[0] = sha1;

    return (Boolean)scriptExists(a).get(0);

  }

  public List<Boolean> scriptExists(String... sha1) {

    this.client.scriptExists(sha1);

    List<Long> result = this.client.getIntegerMultiBulkReply();

    List<Boolean> exists = new ArrayList();

    for (Long value : result) {

      exists.add(Boolean.valueOf(value.longValue() == 1L));

    }

    return exists;

  }

  public String scriptLoad(String script) {

    this.client.scriptLoad(script);

    return this.client.getBulkReply();

  }

  public List<Slowlog> slowlogGet() {

    this.client.slowlogGet();

    return Slowlog.from(this.client.getObjectMultiBulkReply());

  }

  public List<Slowlog> slowlogGet(long entries) {

    this.client.slowlogGet(entries);

    return Slowlog.from(this.client.getObjectMultiBulkReply());

  }

  public Long objectRefcount(String string) {

    this.client.objectRefcount(string);

    return this.client.getIntegerReply();

  }

  public String objectEncoding(String string) {

    this.client.objectEncoding(string);

    return this.client.getBulkReply();

  }

  public Long objectIdletime(String string) {

    this.client.objectIdletime(string);

    return this.client.getIntegerReply();

  }

}