diff --git a/.gitignore b/.gitignore
index d77754e..982e6b6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -8,3 +8,4 @@
 target/
 build/
 bin/
+tags
diff --git a/Makefile b/Makefile
index 0e31379..00f29bf 100644
--- a/Makefile
+++ b/Makefile
@@ -12,15 +12,31 @@ requirepass foobared
 pidfile /tmp/redis2.pid
 endef
 
+
+define REDIS_SENTINEL1
+port 26379
+daemonize yes
+sentinel monitor mymaster 127.0.0.1 6379 2
+sentinel auth-pass mymaster foobared
+sentinel down-after-milliseconds mymaster 5000
+sentinel failover-timeout mymaster 900000
+sentinel can-failover mymaster yes
+sentinel parallel-syncs mymaster 1
+pidfile /tmp/sentinel1.pid
+endef
+
 export REDIS1_CONF
 export REDIS2_CONF
+export REDIS_SENTINEL1
 test:
 	echo "$$REDIS1_CONF" | redis-server -
 	echo "$$REDIS2_CONF" | redis-server -
+	echo "$$REDIS_SENTINEL1" | redis-sentinel -
 
 	mvn clean compile test
 
 	kill `cat /tmp/redis1.pid`
 	kill `cat /tmp/redis2.pid`
+	kill `cat /tmp/sentinel1.pid`
 
 .PHONY: test
diff --git a/src/main/java/redis/clients/jedis/AdvancedBinaryJedisCommands.java b/src/main/java/redis/clients/jedis/AdvancedBinaryJedisCommands.java
new file mode 100644
index 0000000..51b4879
--- /dev/null
+++ b/src/main/java/redis/clients/jedis/AdvancedBinaryJedisCommands.java
@@ -0,0 +1,25 @@
+package redis.clients.jedis;
+
+
+import java.util.List;
+
+public interface AdvancedBinaryJedisCommands {
+
+    List<byte[]> configGet(byte[] pattern);
+
+    byte[] configSet(byte[] parameter, byte[] value);
+
+    String slowlogReset();
+
+    Long slowlogLen();
+
+    List<byte[]> slowlogGetBinary();
+
+    List<byte[]> slowlogGetBinary(long entries);
+
+    Long objectRefcount(byte[] key);
+
+    byte[] objectEncoding(byte[] key);
+
+    Long objectIdletime(byte[] key);
+}
diff --git a/src/main/java/redis/clients/jedis/AdvancedJedisCommands.java b/src/main/java/redis/clients/jedis/AdvancedJedisCommands.java
new file mode 100644
index 0000000..5ed50eb
--- /dev/null
+++ b/src/main/java/redis/clients/jedis/AdvancedJedisCommands.java
@@ -0,0 +1,26 @@
+package redis.clients.jedis;
+
+import redis.clients.util.Slowlog;
+
+import java.util.List;
+
+
+public interface AdvancedJedisCommands {
+    List<String> configGet(String pattern);
+
+    String configSet(String parameter, String value);
+
+    String slowlogReset();
+
+    Long slowlogLen();
+
+    List<Slowlog> slowlogGet();
+
+    List<Slowlog> slowlogGet(long entries);
+
+    Long objectRefcount(String string);
+
+    String objectEncoding(String string);
+
+    Long objectIdletime(String string);
+}
diff --git a/src/main/java/redis/clients/jedis/BasicCommands.java b/src/main/java/redis/clients/jedis/BasicCommands.java
new file mode 100644
index 0000000..482d43b
--- /dev/null
+++ b/src/main/java/redis/clients/jedis/BasicCommands.java
@@ -0,0 +1,42 @@
+package redis.clients.jedis;
+
+public interface BasicCommands {
+
+    String ping();
+
+    String quit();
+
+    String flushDB();
+
+    Long dbSize();
+
+    String select(int index);
+
+    String flushAll();
+
+    String auth(String password);
+
+    String save();
+
+    String bgsave();
+
+    String bgrewriteaof();
+
+    Long lastsave();
+
+    String shutdown();
+
+    String info();
+    
+    String info(String section);
+
+    String slaveof(String host, int port);
+
+    String slaveofNoOne();
+
+    Long getDB();
+
+    String debug(DebugParams params);
+
+    String configResetStat();
+}
diff --git a/src/main/java/redis/clients/jedis/BasicRedisPipeline.java b/src/main/java/redis/clients/jedis/BasicRedisPipeline.java
new file mode 100644
index 0000000..97658d8
--- /dev/null
+++ b/src/main/java/redis/clients/jedis/BasicRedisPipeline.java
@@ -0,0 +1,38 @@
+package redis.clients.jedis;
+
+
+import java.util.List;
+
+/**
+ * Pipelined responses for all of the low level, non key related commands
+ */
+public interface BasicRedisPipeline {
+
+    Response<String> bgrewriteaof();
+
+    Response<String> bgsave();
+
+    Response<String> configGet(String pattern);
+
+    Response<String> configSet(String parameter, String value);
+
+    Response<String> configResetStat();
+
+    Response<String> save();
+
+    Response<Long> lastsave();
+
+    Response<String> flushDB();
+
+    Response<String> flushAll();
+
+    Response<String> info();
+
+    Response<Long> dbSize();
+
+    Response<String> shutdown();
+
+    Response<String> ping();
+
+    Response<String> select(int index);
+}
diff --git a/src/main/java/redis/clients/jedis/BinaryClient.java b/src/main/java/redis/clients/jedis/BinaryClient.java
index 56be470..ab5bd8d 100644
--- a/src/main/java/redis/clients/jedis/BinaryClient.java
+++ b/src/main/java/redis/clients/jedis/BinaryClient.java
@@ -79,7 +79,7 @@ public class BinaryClient extends Connection {
     }
 
     public void ping() {
-	sendCommand(PING);
+	sendCommand(Command.PING);
     }
 
     public void set(final byte[] key, final byte[] value) {
@@ -656,6 +656,10 @@ public class BinaryClient extends Connection {
     public void info() {
 	sendCommand(INFO);
     }
+    
+    public void info(final String section) {
+	sendCommand(INFO, section);
+    }
 
     public void monitor() {
 	sendCommand(MONITOR);
@@ -685,16 +689,16 @@ public class BinaryClient extends Connection {
 	sendCommand(SYNC);
     }
 
-    public void lpushx(final byte[] key, final byte[] string) {
-	sendCommand(LPUSHX, key, string);
+    public void lpushx(final byte[] key, final byte[]... string) {
+	sendCommand(LPUSHX, joinParameters(key, string));
     }
 
     public void persist(final byte[] key) {
 	sendCommand(PERSIST, key);
     }
 
-    public void rpushx(final byte[] key, final byte[] string) {
-	sendCommand(RPUSHX, key, string);
+    public void rpushx(final byte[] key, final byte[]... string) {
+	sendCommand(RPUSHX, joinParameters(key, string));
     }
 
     public void echo(final byte[] string) {
@@ -723,6 +727,10 @@ public class BinaryClient extends Connection {
 	sendCommand(SETBIT, key, toByteArray(offset), value);
     }
 
+    public void setbit(byte[] key, long offset, boolean value) {
+    sendCommand(SETBIT, key, toByteArray(offset), toByteArray(value));
+    }
+
     public void getbit(byte[] key, long offset) {
 	sendCommand(GETBIT, key, toByteArray(offset));
     }
@@ -763,10 +771,18 @@ public class BinaryClient extends Connection {
 	sendEvalCommand(EVAL, script, keyCount, params);
     }
 
-    public void evalsha(byte[] sha1, byte[] keyCount, byte[][] params) {
+    public void eval(byte[] script, int keyCount, byte[]... params) {
+    	eval(script, toByteArray(keyCount), params);
+    }
+
+    public void evalsha(byte[] sha1, byte[] keyCount, byte[]... params) {
 	sendEvalCommand(EVALSHA, sha1, keyCount, params);
     }
 
+    public void evalsha(byte[] sha1, int keyCount, byte[]... params) {
+    sendEvalCommand(EVALSHA, sha1, toByteArray(keyCount), params);
+    }
+
     public void scriptFlush() {
 	sendCommand(SCRIPT, Keyword.FLUSH.raw);
     }
@@ -815,4 +831,45 @@ public class BinaryClient extends Connection {
     public void objectEncoding(byte[] key) {
 	sendCommand(OBJECT, ENCODING.raw, key);
     }
+
+    public void bitcount(byte[] key) {
+        sendCommand(BITCOUNT, key);
+    }
+
+    public void bitcount(byte[] key, long start, long end) {
+        sendCommand(BITCOUNT, key, toByteArray(start), toByteArray(end));
+    }
+
+    public void bitop(BitOP op, byte[] destKey, byte[]... srcKeys) {
+        Keyword kw = Keyword.AND;
+        int len = srcKeys.length;
+        switch (op) {
+            case AND:
+                kw = Keyword.AND;
+                break;
+            case OR:
+                kw = Keyword.OR;
+                break;
+            case XOR:
+                kw = Keyword.XOR;
+                break;
+            case NOT:
+                kw = Keyword.NOT;
+                len = Math.min(1, len);
+                break;
+        }
+
+        byte[][] bargs = new byte[len + 2][];
+        bargs[0] = kw.raw;
+        bargs[1] = destKey;
+        for (int i = 0; i < len; ++i) {
+            bargs[i + 2] = srcKeys[i];
+        }
+
+        sendCommand(BITOP, bargs);
+    }
+
+    public void sentinel(final byte[]... args) {
+	sendCommand(SENTINEL, args);
+    }
 }
diff --git a/src/main/java/redis/clients/jedis/BinaryJedis.java b/src/main/java/redis/clients/jedis/BinaryJedis.java
index c959f47..c72d769 100644
--- a/src/main/java/redis/clients/jedis/BinaryJedis.java
+++ b/src/main/java/redis/clients/jedis/BinaryJedis.java
@@ -17,7 +17,7 @@ import redis.clients.jedis.exceptions.JedisException;
 import redis.clients.util.JedisByteHashMap;
 import redis.clients.util.SafeEncoder;
 
-public class BinaryJedis implements BinaryJedisCommands {
+public class BinaryJedis implements BasicCommands, BinaryJedisCommands, MultiKeyBinaryCommands, AdvancedBinaryJedisCommands, BinaryScriptingCommands {
     protected Client client = null;
 
     public BinaryJedis(final String host) {
@@ -135,6 +135,12 @@ public class BinaryJedis implements BinaryJedisCommands {
 	return client.getIntegerReply();
     }
 
+    public Long del(final byte[] key) {
+    checkIsInMulti();
+    client.del(key);
+    return client.getIntegerReply();
+    }
+
     /**
      * Return the type of the value stored at key in form of a string. The type
      * can be one of "none", "string", "list", "set". "none" is returned if the
@@ -1045,7 +1051,7 @@ public class BinaryJedis implements BinaryJedisCommands {
      * @return Multi bulk reply, specifically a list of elements in the
      *         specified range.
      */
-    public List<byte[]> lrange(final byte[] key, final int start, final int end) {
+    public List<byte[]> lrange(final byte[] key, final long start, final long end) {
 	checkIsInMulti();
 	client.lrange(key, start, end);
 	return client.getBinaryMultiBulkReply();
@@ -1085,7 +1091,7 @@ public class BinaryJedis implements BinaryJedisCommands {
      * @param end
      * @return Status code reply
      */
-    public String ltrim(final byte[] key, final int start, final int end) {
+    public String ltrim(final byte[] key, final long start, final long end) {
 	checkIsInMulti();
 	client.ltrim(key, start, end);
 	return client.getStatusCodeReply();
@@ -1109,7 +1115,7 @@ public class BinaryJedis implements BinaryJedisCommands {
      * @param index
      * @return Bulk reply, specifically the requested element
      */
-    public byte[] lindex(final byte[] key, final int index) {
+    public byte[] lindex(final byte[] key, final long index) {
 	checkIsInMulti();
 	client.lindex(key, index);
 	return client.getBinaryBulkReply();
@@ -1136,7 +1142,7 @@ public class BinaryJedis implements BinaryJedisCommands {
      * @param value
      * @return Status code reply
      */
-    public String lset(final byte[] key, final int index, final byte[] value) {
+    public String lset(final byte[] key, final long index, final byte[] value) {
 	checkIsInMulti();
 	client.lset(key, index, value);
 	return client.getStatusCodeReply();
@@ -1161,7 +1167,7 @@ public class BinaryJedis implements BinaryJedisCommands {
      * @return Integer Reply, specifically: The number of removed elements if
      *         the operation succeeded
      */
-    public Long lrem(final byte[] key, final int count, final byte[] value) {
+    public Long lrem(final byte[] key, final long count, final byte[] value) {
 	checkIsInMulti();
 	client.lrem(key, count, value);
 	return client.getIntegerReply();
@@ -1541,7 +1547,7 @@ public class BinaryJedis implements BinaryJedisCommands {
 	return client.getIntegerReply();
     }
 
-    public Set<byte[]> zrange(final byte[] key, final int start, final int end) {
+    public Set<byte[]> zrange(final byte[] key, final long start, final long end) {
 	checkIsInMulti();
 	client.zrange(key, start, end);
 	final List<byte[]> members = client.getBinaryMultiBulkReply();
@@ -1653,24 +1659,24 @@ public class BinaryJedis implements BinaryJedisCommands {
 	return client.getIntegerReply();
     }
 
-    public Set<byte[]> zrevrange(final byte[] key, final int start,
-	    final int end) {
+    public Set<byte[]> zrevrange(final byte[] key, final long start,
+	    final long end) {
 	checkIsInMulti();
 	client.zrevrange(key, start, end);
 	final List<byte[]> members = client.getBinaryMultiBulkReply();
 	return new LinkedHashSet<byte[]>(members);
     }
 
-    public Set<Tuple> zrangeWithScores(final byte[] key, final int start,
-	    final int end) {
+    public Set<Tuple> zrangeWithScores(final byte[] key, final long start,
+	    final long end) {
 	checkIsInMulti();
 	client.zrangeWithScores(key, start, end);
 	Set<Tuple> set = getBinaryTupledSet();
 	return set;
     }
 
-    public Set<Tuple> zrevrangeWithScores(final byte[] key, final int start,
-	    final int end) {
+    public Set<Tuple> zrevrangeWithScores(final byte[] key, final long start,
+	    final long end) {
 	checkIsInMulti();
 	client.zrevrangeWithScores(key, start, end);
 	Set<Tuple> set = getBinaryTupledSet();
@@ -2076,6 +2082,46 @@ public class BinaryJedis implements BinaryJedisCommands {
 	return multiBulkReply;
     }
 
+    public List<byte[]> blpop(byte[] arg) {
+        checkIsInMulti();
+        byte[][] args = new byte[1][];
+        args[0] = arg;
+        client.blpop(args);
+        client.setTimeoutInfinite();
+        final List<byte[]> multiBulkReply = client.getBinaryMultiBulkReply();
+        client.rollbackTimeout();
+        return multiBulkReply;
+    }
+
+    public List<byte[]> brpop(byte[] arg) {
+        checkIsInMulti();
+        byte[][] args = new byte[1][];
+        args[0] = arg;
+        client.brpop(args);
+        client.setTimeoutInfinite();
+        final List<byte[]> multiBulkReply = client.getBinaryMultiBulkReply();
+        client.rollbackTimeout();
+        return multiBulkReply;
+    }
+
+    public List<byte[]> blpop(byte[]... args) {
+        checkIsInMulti();
+        client.blpop(args);
+        client.setTimeoutInfinite();
+        final List<byte[]> multiBulkReply = client.getBinaryMultiBulkReply();
+        client.rollbackTimeout();
+        return multiBulkReply;
+    }
+
+    public List<byte[]> brpop(byte[]... args) {
+        checkIsInMulti();
+        client.brpop(args);
+        client.setTimeoutInfinite();
+        final List<byte[]> multiBulkReply = client.getBinaryMultiBulkReply();
+        client.rollbackTimeout();
+        return multiBulkReply;
+    }
+
     /**
      * Request for authentication in a password protected Redis server. A Redis
      * server can be instructed to require a password before to allow clients to
@@ -2118,25 +2164,6 @@ public class BinaryJedis implements BinaryJedisCommands {
 	return pipeline;
     }
 
-    public void subscribe(final JedisPubSub jedisPubSub,
-	    final String... channels) {
-	client.setTimeoutInfinite();
-	jedisPubSub.proceed(client, channels);
-	client.rollbackTimeout();
-    }
-
-    public Long publish(final String channel, final String message) {
-	client.publish(channel, message);
-	return client.getIntegerReply();
-    }
-
-    public void psubscribe(final JedisPubSub jedisPubSub,
-	    final String... patterns) {
-	client.setTimeoutInfinite();
-	jedisPubSub.proceedWithPatterns(client, patterns);
-	client.rollbackTimeout();
-    }
-
     public Long zcount(final byte[] key, final double min, final double max) {
     	return zcount(key, toByteArray(min), toByteArray(max));
     }
@@ -2500,7 +2527,7 @@ public class BinaryJedis implements BinaryJedisCommands {
      * operation
      * 
      */
-    public Long zremrangeByRank(final byte[] key, final int start, final int end) {
+    public Long zremrangeByRank(final byte[] key, final long start, final long end) {
 	checkIsInMulti();
 	client.zremrangeByRank(key, start, end);
 	return client.getIntegerReply();
@@ -2854,6 +2881,11 @@ public class BinaryJedis implements BinaryJedisCommands {
 	client.info();
 	return client.getBulkReply();
     }
+    
+    public String info(final String section) {
+	client.info(section);
+	return client.getBulkReply();
+    }
 
     /**
      * Dump all the received requests in real time.
@@ -3008,7 +3040,7 @@ public class BinaryJedis implements BinaryJedisCommands {
 	client.sync();
     }
 
-    public Long lpushx(final byte[] key, final byte[] string) {
+    public Long lpushx(final byte[] key, final byte[]... string) {
 	client.lpushx(key, string);
 	return client.getIntegerReply();
     }
@@ -3028,7 +3060,7 @@ public class BinaryJedis implements BinaryJedisCommands {
 	return client.getIntegerReply();
     }
 
-    public Long rpushx(final byte[] key, final byte[] string) {
+    public Long rpushx(final byte[] key, final byte[]... string) {
 	client.rpushx(key, string);
 	return client.getIntegerReply();
     }
@@ -3078,11 +3110,16 @@ public class BinaryJedis implements BinaryJedisCommands {
      * @param value
      * @return
      */
-    public Boolean setbit(byte[] key, long offset, byte[] value) {
+    public Boolean setbit(byte[] key, long offset, boolean value) {
 	client.setbit(key, offset, value);
 	return client.getIntegerReply() == 1;
     }
 
+    public Boolean setbit(byte[] key, long offset, byte[] value) {
+    client.setbit(key, offset, value);
+    return client.getIntegerReply() == 1;
+    }
+
     /**
      * Returns the bit value at offset in the string value stored at key
      * 
@@ -3100,9 +3137,9 @@ public class BinaryJedis implements BinaryJedisCommands {
 	return client.getIntegerReply();
     }
 
-    public String getrange(byte[] key, long startOffset, long endOffset) {
+    public byte[] getrange(byte[] key, long startOffset, long endOffset) {
 	client.getrange(key, startOffset, endOffset);
-	return client.getBulkReply();
+	return client.getBinaryBulkReply();
     }
 
     public Long publish(byte[] channel, byte[] message) {
@@ -3152,20 +3189,50 @@ public class BinaryJedis implements BinaryJedisCommands {
 	return params;
     }
 
-    public Object eval(byte[] script, byte[] keyCount, byte[][] params) {
+    public Object eval(byte[] script, byte[] keyCount, byte[]... params) {
 	client.setTimeoutInfinite();
 	client.eval(script, keyCount, params);
 	return client.getOne();
     }
 
-    public byte[] scriptFlush() {
+    public Object eval(byte[] script, int keyCount, byte[]... params) {
+        client.setTimeoutInfinite();
+        client.eval(script, SafeEncoder.encode(Integer.toString(keyCount)), params);
+        return client.getOne();
+    }
+
+    public Object eval(byte[] script) {
+        client.setTimeoutInfinite();
+        client.eval(script, 0);
+        return client.getOne();
+    }
+
+    public Object evalsha(byte[] sha1) {
+        client.setTimeoutInfinite();
+        client.evalsha(sha1, 0);
+        return client.getOne();
+    }
+
+    public Object evalsha(byte[] sha1, List<byte[]> keys, List<byte[]> args) {
+        client.setTimeoutInfinite();
+        client.evalsha(sha1, keys.size(), keys.toArray(new byte[0][]));
+        return client.getOne();
+    }
+
+    public Object evalsha(byte[] sha1, int keyCount, byte[]... params) {
+        client.setTimeoutInfinite();
+        client.evalsha(sha1, keyCount, params);
+        return client.getOne();
+    }
+
+    public String scriptFlush() {
 	client.scriptFlush();
-	return client.getBinaryBulkReply();
+	return client.getStatusCodeReply();
     }
 
     public List<Long> scriptExists(byte[]... sha1) {
 	client.scriptExists(sha1);
-	return client.getIntegerMultiBulkReply();
+    return client.getIntegerMultiBulkReply();
     }
 
     public byte[] scriptLoad(byte[] script) {
@@ -3173,17 +3240,17 @@ public class BinaryJedis implements BinaryJedisCommands {
 	return client.getBinaryBulkReply();
     }
 
-    public byte[] scriptKill() {
+    public String scriptKill() {
 	client.scriptKill();
-	return client.getBinaryBulkReply();
+	return client.getStatusCodeReply();
     }
 
-    public byte[] slowlogReset() {
+    public String slowlogReset() {
 	client.slowlogReset();
-	return client.getBinaryBulkReply();
+	return client.getBulkReply();
     }
 
-    public long slowlogLen() {
+    public Long slowlogLen() {
 	client.slowlogLen();
 	return client.getIntegerReply();
     }
@@ -3212,4 +3279,19 @@ public class BinaryJedis implements BinaryJedisCommands {
 		client.objectIdletime(key);
 		return client.getIntegerReply();
 	}
+
+    public Long bitcount(final byte[] key) {
+        client.bitcount(key);
+        return client.getIntegerReply();
+    }
+
+    public Long bitcount(final byte[] key, long start, long end) {
+        client.bitcount(key, start, end);
+        return client.getIntegerReply();
+    }
+
+    public Long bitop(BitOP op, final byte[] destKey, byte[]... srcKeys) {
+        client.bitop(op, destKey, srcKeys);
+        return client.getIntegerReply();
+    }
 }
diff --git a/src/main/java/redis/clients/jedis/BinaryJedisCommands.java b/src/main/java/redis/clients/jedis/BinaryJedisCommands.java
index 1a5f079..1c27847 100644
--- a/src/main/java/redis/clients/jedis/BinaryJedisCommands.java
+++ b/src/main/java/redis/clients/jedis/BinaryJedisCommands.java
@@ -17,6 +17,8 @@ public interface BinaryJedisCommands {
 
     Boolean exists(byte[] key);
 
+    Long persist(byte[] key);
+
     String type(byte[] key);
 
     Long expire(byte[] key, int seconds);
@@ -25,6 +27,16 @@ public interface BinaryJedisCommands {
 
     Long ttl(byte[] key);
 
+    Boolean setbit(byte[] key, long offset, boolean value);
+
+    Boolean setbit(byte[] key, long offset, byte[] value);
+
+    Boolean getbit(byte[] key, long offset);
+
+    Long setrange(byte[] key, long offset, byte[] value);
+
+    byte[] getrange(byte[] key, long startOffset, long endOffset);
+
     byte[] getSet(byte[] key, byte[] value);
 
     Long setnx(byte[] key, byte[] value);
@@ -71,21 +83,21 @@ public interface BinaryJedisCommands {
 
     Map<byte[], byte[]> hgetAll(byte[] key);
 
-    Long rpush(byte[] key, byte[]... string);
+    Long rpush(byte[] key, byte[]... args);
 
-    Long lpush(byte[] key, byte[]... string);
+    Long lpush(byte[] key, byte[]... args);
 
     Long llen(byte[] key);
 
-    List<byte[]> lrange(byte[] key, int start, int end);
+    List<byte[]> lrange(byte[] key, long start, long end);
 
-    String ltrim(byte[] key, int start, int end);
+    String ltrim(byte[] key, long start, long end);
 
-    byte[] lindex(byte[] key, int index);
+    byte[] lindex(byte[] key, long index);
 
-    String lset(byte[] key, int index, byte[] value);
+    String lset(byte[] key, long index, byte[] value);
 
-    Long lrem(byte[] key, int count, byte[] value);
+    Long lrem(byte[] key, long count, byte[] value);
 
     byte[] lpop(byte[] key);
 
@@ -105,11 +117,13 @@ public interface BinaryJedisCommands {
 
     byte[] srandmember(byte[] key);
 
-    Long zadd(byte[] key, double score, byte[] member);
+    Long strlen(byte[] key);
 
+    Long zadd(byte[] key, double score, byte[] member);
+    
     Long zadd(byte[] key, Map<Double, byte[]> scoreMembers);
 
-    Set<byte[]> zrange(byte[] key, int start, int end);
+    Set<byte[]> zrange(byte[] key, long start, long end);
 
     Long zrem(byte[] key, byte[]... member);
 
@@ -119,11 +133,11 @@ public interface BinaryJedisCommands {
 
     Long zrevrank(byte[] key, byte[] member);
 
-    Set<byte[]> zrevrange(byte[] key, int start, int end);
+    Set<byte[]> zrevrange(byte[] key, long start, long end);
 
-    Set<Tuple> zrangeWithScores(byte[] key, int start, int end);
+    Set<Tuple> zrangeWithScores(byte[] key, long start, long end);
 
-    Set<Tuple> zrevrangeWithScores(byte[] key, int start, int end);
+    Set<Tuple> zrevrangeWithScores(byte[] key, long start, long end);
 
     Long zcard(byte[] key);
 
@@ -139,54 +153,68 @@ public interface BinaryJedisCommands {
 
     Set<byte[]> zrangeByScore(byte[] key, double min, double max);
 
-    Set<byte[]> zrangeByScore(byte[] key, double min, double max, int offset,
-	    int count);
-
-    Set<Tuple> zrangeByScoreWithScores(byte[] key, double min, double max);
-
-    Set<Tuple> zrangeByScoreWithScores(byte[] key, double min, double max,
-	    int offset, int count);
-
-    Set<Tuple> zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max);
-
-    Set<Tuple> zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max,
-	    int offset, int count);
+    Set<byte[]> zrangeByScore(byte[] key, byte[] min, byte[] max);
 
     Set<byte[]> zrevrangeByScore(byte[] key, double max, double min);
 
-    Set<byte[]> zrevrangeByScore(byte[] key, double max, double min,
-	    int offset, int count);
+    Set<byte[]> zrangeByScore(byte[] key, double min, double max, int offset,
+	    int count);
 
     Set<byte[]> zrevrangeByScore(byte[] key, byte[] max, byte[] min);
 
-    Set<byte[]> zrevrangeByScore(byte[] key, byte[] max, byte[] min,
-	    int offset, int count);
+    Set<byte[]> zrangeByScore(byte[] key, byte[] min, byte[] max, int offset,
+            int count);
+
+    Set<byte[]> zrevrangeByScore(byte[] key, double max, double min,
+            int offset, int count);
+
+    Set<Tuple> zrangeByScoreWithScores(byte[] key, double min, double max);
 
     Set<Tuple> zrevrangeByScoreWithScores(byte[] key, double max, double min);
 
-    Set<Tuple> zrevrangeByScoreWithScores(byte[] key, double max, double min,
-	    int offset, int count);
+    Set<Tuple> zrangeByScoreWithScores(byte[] key, double min, double max,
+            int offset, int count);
+    
+    Set<byte[]> zrevrangeByScore(byte[] key, byte[] max, byte[] min,
+            int offset, int count);
 
+    Set<Tuple> zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max);
+    
     Set<Tuple> zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min);
 
-    Set<Tuple> zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min,
-	    int offset, int count);
+    Set<Tuple> zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max,
+            int offset, int count);
 
-    Long zremrangeByRank(byte[] key, int start, int end);
+    Set<Tuple> zrevrangeByScoreWithScores(byte[] key, double max, double min,
+            int offset, int count);
+    
+    Set<Tuple> zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min,
+            int offset, int count);
+
+    Long zremrangeByRank(byte[] key, long start, long end);
 
     Long zremrangeByScore(byte[] key, double start, double end);
-
+    
     Long zremrangeByScore(byte[] key, byte[] start, byte[] end);
 
-    Long linsert(byte[] key, LIST_POSITION where, byte[] pivot, byte[] value);
+    Long linsert(byte[] key, Client.LIST_POSITION where, byte[] pivot,
+            byte[] value);
+    
+    Long lpushx(byte[] key, byte[]... arg);
+    
+    Long rpushx(byte[] key, byte[]... arg);
 
-    Long objectRefcount(byte[] key);
+    List<byte[]> blpop(byte[] arg);
 
-    Long objectIdletime(byte[] key);
+    List<byte[]> brpop(byte[] arg);
 
-    byte[] objectEncoding(byte[] key);
+    Long del(byte[] key);
 
-    Long lpushx(byte[] key, byte[] string);
+    byte[] echo(byte[] arg);
 
-    Long rpushx(byte[] key, byte[] string);
+    Long move(byte[] key, int dbIndex);
+
+    Long bitcount(final byte[] key);
+
+    Long bitcount(final byte[] key, long start, long end);
 }
diff --git a/src/main/java/redis/clients/jedis/BinaryRedisPipeline.java b/src/main/java/redis/clients/jedis/BinaryRedisPipeline.java
new file mode 100644
index 0000000..6f4fd90
--- /dev/null
+++ b/src/main/java/redis/clients/jedis/BinaryRedisPipeline.java
@@ -0,0 +1,219 @@
+package redis.clients.jedis;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * @author guy
+ */
+public interface BinaryRedisPipeline {
+    Response<Long> append(byte[] key, byte[] value);
+
+    Response<List<byte[]>> blpop(byte[] arg);
+
+    Response<List<byte[]>> brpop(byte[] arg);
+
+    Response<Long> decr(byte[] key);
+
+    Response<Long> decrBy(byte[] key, long integer);
+
+    Response<Long> del(byte[] keys);
+
+    Response<byte[]> echo(byte[] string);
+
+    Response<Boolean> exists(byte[] key);
+
+    Response<Long> expire(byte[] key, int seconds);
+
+    Response<Long> expireAt(byte[] key, long unixTime);
+
+    Response<byte[]> get(byte[] key);
+
+    Response<Boolean> getbit(byte[] key, long offset);
+
+    Response<byte[]> getSet(byte[] key, byte[] value);
+
+    Response<Long> getrange(byte[] key, long startOffset, long endOffset);
+
+    Response<Long> hdel(byte[] key, byte[] field);
+
+    Response<Boolean> hexists(byte[] key, byte[] field);
+
+    Response<byte[]> hget(byte[] key, byte[] field);
+
+    Response<Map<byte[], byte[]>> hgetAll(byte[] key);
+
+    Response<Long> hincrBy(byte[] key, byte[] field, long value);
+
+    Response<Set<byte[]>> hkeys(byte[] key);
+
+    Response<Long> hlen(byte[] key);
+
+    Response<List<byte[]>> hmget(byte[] key, byte[]... fields);
+
+    Response<String> hmset(byte[] key, Map<byte[], byte[]> hash);
+
+    Response<Long> hset(byte[] key, byte[] field, byte[] value);
+
+    Response<Long> hsetnx(byte[] key, byte[] field, byte[] value);
+
+    Response<List<byte[]>> hvals(byte[] key);
+
+    Response<Long> incr(byte[] key);
+
+    Response<Long> incrBy(byte[] key, long integer);
+
+    Response<byte[]> lindex(byte[] key, int index);
+
+    Response<Long> linsert(byte[] key, BinaryClient.LIST_POSITION where,
+                           byte[] pivot, byte[] value);
+
+    Response<Long> llen(byte[] key);
+
+    Response<byte[]> lpop(byte[] key);
+
+    Response<Long> lpush(byte[] key, byte[]... string);
+
+    Response<Long> lpushx(byte[] key, byte[]... bytes);
+
+    Response<List<byte[]>> lrange(byte[] key, long start, long end);
+
+    Response<Long> lrem(byte[] key, long count, byte[] value);
+
+    Response<String> lset(byte[] key, long index, byte[] value);
+
+    Response<String> ltrim(byte[] key, long start, long end);
+
+    Response<Long> move(byte[] key, int dbIndex);
+
+    Response<Long> persist(byte[] key);
+
+    Response<byte[]> rpop(byte[] key);
+
+    Response<Long> rpush(byte[] key, byte[]... string);
+
+    Response<Long> rpushx(byte[] key, byte[]... string);
+
+    Response<Long> sadd(byte[] key, byte[]... member);
+
+    Response<Long> scard(byte[] key);
+
+    Response<String> set(byte[] key, byte[] value);
+
+    Response<Boolean> setbit(byte[] key, long offset, byte[] value);
+
+    Response<Long> setrange(byte[] key, long offset, byte[] value);
+
+    Response<String> setex(byte[] key, int seconds, byte[] value);
+
+    Response<Long> setnx(byte[] key, byte[] value);
+
+    Response<Long> setrange(String key, long offset, String value);
+
+    Response<Set<byte[]>> smembers(byte[] key);
+
+    Response<Boolean> sismember(byte[] key, byte[] member);
+
+    Response<List<byte[]>> sort(byte[] key);
+
+    Response<List<byte[]>> sort(byte[] key,
+                                SortingParams sortingParameters);
+
+    Response<byte[]> spop(byte[] key);
+
+    Response<byte[]> srandmember(byte[] key);
+
+    Response<Long> srem(byte[] key, byte[] member);
+
+    Response<Long> strlen(byte[] key);
+
+    Response<String> substr(byte[] key, int start, int end);
+
+    Response<Long> ttl(byte[] key);
+
+    Response<String> type(byte[] key);
+
+    Response<Long> zadd(byte[] key, double score, byte[] member);
+
+    Response<Long> zcard(byte[] key);
+
+    Response<Long> zcount(byte[] key, double min, double max);
+
+    Response<Double> zincrby(byte[] key, double score, byte[] member);
+
+    Response<Set<byte[]>> zrange(byte[] key, int start, int end);
+
+    Response<Set<byte[]>> zrangeByScore(byte[] key, double min,
+                                        double max);
+
+    Response<Set<byte[]>> zrangeByScore(byte[] key, byte[] min,
+                                        byte[] max);
+
+    Response<Set<byte[]>> zrangeByScore(byte[] key, double min,
+                                        double max, int offset, int count);
+
+    Response<Set<byte[]>> zrangeByScore(byte[] key, byte[] min,
+                                        byte[] max, int offset, int count);
+
+    Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, double min,
+                                                 double max);
+
+    Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, byte[] min,
+                                                 byte[] max);
+
+    Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, double min,
+                                                 double max, int offset, int count);
+
+    Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, byte[] min,
+                                                 byte[] max, int offset, int count);
+
+    Response<Set<byte[]>> zrevrangeByScore(byte[] key, double max,
+                                           double min);
+
+    Response<Set<byte[]>> zrevrangeByScore(byte[] key, byte[] max,
+                                           byte[] min);
+
+    Response<Set<byte[]>> zrevrangeByScore(byte[] key, double max,
+                                           double min, int offset, int count);
+
+    Response<Set<byte[]>> zrevrangeByScore(byte[] key, byte[] max,
+                                           byte[] min, int offset, int count);
+
+    Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
+                                                    double max, double min);
+
+    Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
+                                                    byte[] max, byte[] min);
+
+    Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
+                                                    double max, double min, int offset, int count);
+
+    Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
+                                                    byte[] max, byte[] min, int offset, int count);
+
+    Response<Set<Tuple>> zrangeWithScores(byte[] key, int start, int end);
+
+    Response<Long> zrank(byte[] key, byte[] member);
+
+    Response<Long> zrem(byte[] key, byte[] member);
+
+    Response<Long> zremrangeByRank(byte[] key, int start, int end);
+
+    Response<Long> zremrangeByScore(byte[] key, double start, double end);
+
+    Response<Long> zremrangeByScore(byte[] key, byte[] start, byte[] end);
+
+    Response<Set<byte[]>> zrevrange(byte[] key, int start, int end);
+
+    Response<Set<Tuple>> zrevrangeWithScores(byte[] key, int start,
+                                             int end);
+
+    Response<Long> zrevrank(byte[] key, byte[] member);
+
+    Response<Double> zscore(byte[] key, byte[] member);
+
+    Response<Long> bitcount(byte[] key);
+
+    Response<Long> bitcount(byte[] key, long start, long end);
+}
diff --git a/src/main/java/redis/clients/jedis/BinaryScriptingCommands.java b/src/main/java/redis/clients/jedis/BinaryScriptingCommands.java
new file mode 100644
index 0000000..092ce7a
--- /dev/null
+++ b/src/main/java/redis/clients/jedis/BinaryScriptingCommands.java
@@ -0,0 +1,30 @@
+package redis.clients.jedis;
+
+
+import java.util.List;
+
+public interface BinaryScriptingCommands {
+
+    Object eval(byte[] script, byte[] keyCount, byte[]... params);
+
+    Object eval(byte[] script, int keyCount, byte[]... params);
+    
+    Object eval(byte[] script, List<byte[]> keys, List<byte[]> args);
+
+    Object eval(byte[] script);
+
+    Object evalsha(byte[] script);
+
+    Object evalsha(byte[] sha1, List<byte[]> keys, List<byte[]> args);
+
+    Object evalsha(byte[] sha1, int keyCount, byte[]... params);
+
+    // TODO: should be Boolean, add singular version
+    List<Long> scriptExists(byte[]... sha1);
+
+    byte[] scriptLoad(byte[] script);
+
+    String scriptFlush();
+
+    String scriptKill();
+}
diff --git a/src/main/java/redis/clients/jedis/BinaryShardedJedis.java b/src/main/java/redis/clients/jedis/BinaryShardedJedis.java
index 1b6ad9a..fb882c8 100644
--- a/src/main/java/redis/clients/jedis/BinaryShardedJedis.java
+++ b/src/main/java/redis/clients/jedis/BinaryShardedJedis.java
@@ -1,5 +1,9 @@
 package redis.clients.jedis;
 
+import redis.clients.jedis.BinaryClient.LIST_POSITION;
+import redis.clients.util.Hashing;
+import redis.clients.util.Sharded;
+
 import java.io.IOException;
 import java.util.Collection;
 import java.util.List;
@@ -7,10 +11,6 @@ import java.util.Map;
 import java.util.Set;
 import java.util.regex.Pattern;
 
-import redis.clients.jedis.BinaryClient.LIST_POSITION;
-import redis.clients.util.Hashing;
-import redis.clients.util.Sharded;
-
 public class BinaryShardedJedis extends Sharded<Jedis, JedisShardInfo>
 	implements BinaryJedisCommands {
     public BinaryShardedJedis(List<JedisShardInfo> shards) {
@@ -30,10 +30,11 @@ public class BinaryShardedJedis extends Sharded<Jedis, JedisShardInfo>
 	super(shards, algo, keyTagPattern);
     }
 
-    public void disconnect() throws IOException {
-	for (Jedis jedis : getAllShards()) {
-	    jedis.disconnect();
-	}
+    public void disconnect() {
+    for (Jedis jedis : getAllShards()) {
+        jedis.quit();
+        jedis.disconnect();
+    }
     }
 
     protected Jedis create(JedisShardInfo shard) {
@@ -205,13 +206,22 @@ public class BinaryShardedJedis extends Sharded<Jedis, JedisShardInfo>
 	return j.lpush(key, strings);
     }
 
-    public Long lpushx(byte[] key, byte[] string) {
+    public Long strlen(final byte[] key) {
+    Jedis j = getShard(key);
+    return j.strlen(key);
+    }
+
+    public Long lpushx(byte[] key, byte[]... string) {
         Jedis j = getShard(key);
         return j.lpushx(key, string);
     }
-    
 
-    public Long rpushx(byte[] key, byte[] string) {
+    public Long persist(final byte[] key) {
+        Jedis j = getShard(key);
+    	return j.persist(key);
+    }
+
+    public Long rpushx(byte[] key, byte[]... string) {
         Jedis j = getShard(key);
         return j.rpushx(key, string);
     }
@@ -221,27 +231,27 @@ public class BinaryShardedJedis extends Sharded<Jedis, JedisShardInfo>
 	return j.llen(key);
     }
 
-    public List<byte[]> lrange(byte[] key, int start, int end) {
+    public List<byte[]> lrange(byte[] key, long start, long end) {
 	Jedis j = getShard(key);
 	return j.lrange(key, start, end);
     }
 
-    public String ltrim(byte[] key, int start, int end) {
+    public String ltrim(byte[] key, long start, long end) {
 	Jedis j = getShard(key);
 	return j.ltrim(key, start, end);
     }
 
-    public byte[] lindex(byte[] key, int index) {
+    public byte[] lindex(byte[] key, long index) {
 	Jedis j = getShard(key);
 	return j.lindex(key, index);
     }
 
-    public String lset(byte[] key, int index, byte[] value) {
+    public String lset(byte[] key, long index, byte[] value) {
 	Jedis j = getShard(key);
 	return j.lset(key, index, value);
     }
 
-    public Long lrem(byte[] key, int count, byte[] value) {
+    public Long lrem(byte[] key, long count, byte[] value) {
 	Jedis j = getShard(key);
 	return j.lrem(key, count, value);
     }
@@ -301,7 +311,7 @@ public class BinaryShardedJedis extends Sharded<Jedis, JedisShardInfo>
 	return j.zadd(key, scoreMembers);
     }
 
-    public Set<byte[]> zrange(byte[] key, int start, int end) {
+    public Set<byte[]> zrange(byte[] key, long start, long end) {
 	Jedis j = getShard(key);
 	return j.zrange(key, start, end);
     }
@@ -326,17 +336,17 @@ public class BinaryShardedJedis extends Sharded<Jedis, JedisShardInfo>
 	return j.zrevrank(key, member);
     }
 
-    public Set<byte[]> zrevrange(byte[] key, int start, int end) {
+    public Set<byte[]> zrevrange(byte[] key, long start, long end) {
 	Jedis j = getShard(key);
 	return j.zrevrange(key, start, end);
     }
 
-    public Set<Tuple> zrangeWithScores(byte[] key, int start, int end) {
+    public Set<Tuple> zrangeWithScores(byte[] key, long start, long end) {
 	Jedis j = getShard(key);
 	return j.zrangeWithScores(key, start, end);
     }
 
-    public Set<Tuple> zrevrangeWithScores(byte[] key, int start, int end) {
+    public Set<Tuple> zrevrangeWithScores(byte[] key, long start, long end) {
 	Jedis j = getShard(key);
 	return j.zrevrangeWithScores(key, start, end);
     }
@@ -392,7 +402,11 @@ public class BinaryShardedJedis extends Sharded<Jedis, JedisShardInfo>
 	Jedis j = getShard(key);
 	return j.zrangeByScoreWithScores(key, min, max, offset, count);
     }
-    
+
+    public Set<byte[]> zrangeByScore(byte[] key, byte[] min, byte[] max) {
+        Jedis j = getShard(key);
+        return j.zrangeByScore(key, min, max);
+    }
 
     public Set<Tuple> zrangeByScoreWithScores(byte[] key, byte[] min, byte[] max) {
 	Jedis j = getShard(key);
@@ -405,6 +419,11 @@ public class BinaryShardedJedis extends Sharded<Jedis, JedisShardInfo>
 	return j.zrangeByScoreWithScores(key, min, max, offset, count);
     }
 
+    public Set<byte[]> zrangeByScore(byte[] key, byte[] min, byte[] max, int offset, int count) {
+        Jedis j = getShard(key);
+        return j.zrangeByScore(key, min, max, offset, count);
+    }
+
     public Set<byte[]> zrevrangeByScore(byte[] key, double max, double min) {
 	Jedis j = getShard(key);
 	return j.zrevrangeByScore(key, max, min);
@@ -451,7 +470,7 @@ public class BinaryShardedJedis extends Sharded<Jedis, JedisShardInfo>
 	return j.zrevrangeByScoreWithScores(key, max, min, offset, count);
     }
 
-    public Long zremrangeByRank(byte[] key, int start, int end) {
+    public Long zremrangeByRank(byte[] key, long start, long end) {
 	Jedis j = getShard(key);
 	return j.zremrangeByRank(key, start, end);
     }
@@ -499,4 +518,59 @@ public class BinaryShardedJedis extends Sharded<Jedis, JedisShardInfo>
 	Jedis j = getShard(key);
 	return j.objectIdletime(key);
     }
+
+    public Boolean setbit(byte[] key, long offset, boolean value) {
+    Jedis j = getShard(key);
+    return j.setbit(key, offset, value);
+    }
+
+    public Boolean setbit(byte[] key, long offset, byte[] value) {
+    Jedis j = getShard(key);
+    return j.setbit(key, offset, value);
+    }
+
+    public Boolean getbit(byte[] key, long offset) {
+    Jedis j = getShard(key);
+    return j.getbit(key, offset);
+    }
+
+    public Long setrange(byte[] key, long offset, byte[] value) {
+    Jedis j = getShard(key);
+    return j.setrange(key, offset, value);
+    }
+
+    public byte[] getrange(byte[] key, long startOffset, long endOffset) {
+    Jedis j = getShard(key);
+    return j.getrange(key, startOffset, endOffset);
+    }
+
+    public Long move(byte[] key, int dbIndex) {
+        Jedis j = getShard(key);
+        return j.move(key, dbIndex);
+    }
+
+    public byte[] echo(byte[] arg) {
+        Jedis j = getShard(arg);
+        return j.echo(arg);
+    }
+
+    public List<byte[]> brpop(byte[] arg) {
+        Jedis j = getShard(arg);
+        return j.brpop(arg);
+    }
+
+    public List<byte[]> blpop(byte[] arg) {
+        Jedis j = getShard(arg);
+        return j.blpop(arg);
+    }
+
+    public Long bitcount(byte[] key) {
+        Jedis j = getShard(key);
+        return j.bitcount(key);
+    }
+
+    public Long bitcount(byte[] key, long start, long end) {
+        Jedis j = getShard(key);
+        return j.bitcount(key, start, end);
+    }
 }
\ No newline at end of file
diff --git a/src/main/java/redis/clients/jedis/BinaryTransaction.java b/src/main/java/redis/clients/jedis/BinaryTransaction.java
deleted file mode 100644
index 96bdf2b..0000000
--- a/src/main/java/redis/clients/jedis/BinaryTransaction.java
+++ /dev/null
@@ -1,675 +0,0 @@
-package redis.clients.jedis;
-
-import static redis.clients.jedis.Protocol.toByteArray;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import redis.clients.jedis.BinaryClient.LIST_POSITION;
-import redis.clients.jedis.exceptions.JedisDataException;
-
-public class BinaryTransaction extends Queable {
-    protected Client client = null;
-    protected boolean inTransaction = true;
-
-    public BinaryTransaction() {
-    }
-
-    public BinaryTransaction(final Client client) {
-        this.client = client;
-    }
-
-    public List<Object> exec() {
-        client.exec();
-        client.getAll(1); // Discard all but the last reply
-
-        List<Object> unformatted = client.getObjectMultiBulkReply();
-        if (unformatted == null) {
-            return null;
-        }
-        List<Object> formatted = new ArrayList<Object>();
-        for (Object o : unformatted) {
-        	try{
-        		formatted.add(generateResponse(o).get());
-        	}catch(JedisDataException e){
-        		formatted.add(e);
-        	}
-        }
-        return formatted;
-    }
-    
-    public List<Response<?>> execGetResponse() {
-        client.exec();
-        client.getAll(1); // Discard all but the last reply
-
-        List<Object> unformatted = client.getObjectMultiBulkReply();
-        if (unformatted == null) {
-            return null;
-        }
-        List<Response<?>> response = new ArrayList<Response<?>>();
-        for (Object o : unformatted) {
-        	response.add(generateResponse(o));
-        }
-        return response;
-    }
-
-    public String discard() {
-        client.discard();
-        client.getAll(1); // Discard all but the last reply
-        inTransaction = false;
-        clean();
-        return client.getStatusCodeReply();
-    }
-
-    public Response<Long> append(byte[] key, byte[] value) {
-        client.append(key, value);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<List<String>> blpop(byte[]... args) {
-        client.blpop(args);
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<List<String>> brpop(byte[]... args) {
-        client.brpop(args);
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<Long> decr(byte[] key) {
-        client.decr(key);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> decrBy(byte[] key, long integer) {
-        client.decrBy(key, integer);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> del(byte[]... keys) {
-        client.del(keys);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> echo(byte[] string) {
-        client.echo(string);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Boolean> exists(byte[] key) {
-        client.exists(key);
-        return getResponse(BuilderFactory.BOOLEAN);
-    }
-
-    public Response<Long> expire(byte[] key, int seconds) {
-        client.expire(key, seconds);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> expireAt(byte[] key, long unixTime) {
-        client.expireAt(key, unixTime);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<byte[]> get(byte[] key) {
-        client.get(key);
-        return getResponse(BuilderFactory.BYTE_ARRAY);
-    }
-
-    public Response<String> getSet(byte[] key, byte[] value) {
-        client.getSet(key, value);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> hdel(byte[] key, byte[] field) {
-        client.hdel(key, field);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Boolean> hexists(byte[] key, byte[] field) {
-        client.hexists(key, field);
-        return getResponse(BuilderFactory.BOOLEAN);
-    }
-
-    public Response<byte[]> hget(byte[] key, byte[] field) {
-        client.hget(key, field);
-        return getResponse(BuilderFactory.BYTE_ARRAY);
-    }
-
-    public Response<Map<String, String>> hgetAll(byte[] key) {
-        client.hgetAll(key);
-        return getResponse(BuilderFactory.STRING_MAP);
-    }
-
-    public Response<Long> hincrBy(byte[] key, byte[] field, long value) {
-        client.hincrBy(key, field, value);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Set<byte[]>> hkeys(byte[] key) {
-        client.hkeys(key);
-        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
-    }
-
-    public Response<Long> hlen(byte[] key) {
-        client.hlen(key);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<List<byte[]>> hmget(byte[] key, byte[]... fields) {
-        client.hmget(key, fields);
-        return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
-    }
-
-    public Response<byte[]> hmset(byte[] key, Map<byte[], byte[]> hash) {
-        client.hmset(key, hash);
-        return getResponse(BuilderFactory.BYTE_ARRAY);
-    }
-
-    public Response<Long> hset(byte[] key, byte[] field, byte[] value) {
-        client.hset(key, field, value);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> hsetnx(byte[] key, byte[] field, byte[] value) {
-        client.hsetnx(key, field, value);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<List<byte[]>> hvals(byte[] key) {
-        client.hvals(key);
-        return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
-    }
-
-    public Response<Long> incr(byte[] key) {
-        client.incr(key);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> incrBy(byte[] key, long integer) {
-        client.incrBy(key, integer);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Set<byte[]>> keys(byte[] pattern) {
-        client.keys(pattern);
-        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
-    }
-
-    public Response<byte[]> lindex(byte[] key, long index) {
-        client.lindex(key, index);
-        return getResponse(BuilderFactory.BYTE_ARRAY);
-    }
-
-    public Response<Long> linsert(byte[] key, LIST_POSITION where,
-            byte[] pivot, byte[] value) {
-        client.linsert(key, where, pivot, value);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> llen(byte[] key) {
-        client.llen(key);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<byte[]> lpop(byte[] key) {
-        client.lpop(key);
-        return getResponse(BuilderFactory.BYTE_ARRAY);
-    }
-
-    public Response<Long> lpush(byte[] key, byte[] string) {
-        client.lpush(key, string);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> lpushx(byte[] key, byte[] bytes) {
-        client.lpushx(key, bytes);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<List<byte[]>> lrange(byte[] key, long start, long end) {
-        client.lrange(key, start, end);
-        return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
-    }
-
-    public Response<Long> lrem(byte[] key, long count, byte[] value) {
-        client.lrem(key, count, value);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> lset(byte[] key, long index, byte[] value) {
-        client.lset(key, index, value);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> ltrim(byte[] key, long start, long end) {
-        client.ltrim(key, start, end);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<List<byte[]>> mget(byte[]... keys) {
-        client.mget(keys);
-        return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
-    }
-
-    public Response<Long> move(byte[] key, int dbIndex) {
-        client.move(key, dbIndex);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> mset(byte[]... keysvalues) {
-        client.mset(keysvalues);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> msetnx(byte[]... keysvalues) {
-        client.msetnx(keysvalues);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> persist(byte[] key) {
-        client.persist(key);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> rename(byte[] oldkey, byte[] newkey) {
-        client.rename(oldkey, newkey);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> renamenx(byte[] oldkey, byte[] newkey) {
-        client.renamenx(oldkey, newkey);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<byte[]> rpop(byte[] key) {
-        client.rpop(key);
-        return getResponse(BuilderFactory.BYTE_ARRAY);
-    }
-
-    public Response<byte[]> rpoplpush(byte[] srckey, byte[] dstkey) {
-        client.rpoplpush(srckey, dstkey);
-        return getResponse(BuilderFactory.BYTE_ARRAY);
-    }
-
-    public Response<Long> rpush(byte[] key, byte[] string) {
-        client.rpush(key, string);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> rpushx(byte[] key, byte[] string) {
-        client.rpushx(key, string);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> sadd(byte[] key, byte[] member) {
-        client.sadd(key, member);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> scard(byte[] key) {
-        client.scard(key);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Set<byte[]>> sdiff(byte[]... keys) {
-        client.sdiff(keys);
-        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
-    }
-
-    public Response<Long> sdiffstore(byte[] dstkey, byte[]... keys) {
-        client.sdiffstore(dstkey, keys);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<byte[]> set(byte[] key, byte[] value) {
-        client.set(key, value);
-        return getResponse(BuilderFactory.BYTE_ARRAY);
-    }
-
-    public Response<Boolean> setbit(String key, long offset, boolean value) {
-        client.setbit(key, offset, value);
-        return getResponse(BuilderFactory.BOOLEAN);
-    }
-
-    public Response<String> setex(byte[] key, int seconds, byte[] value) {
-        client.setex(key, seconds, value);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> setnx(byte[] key, byte[] value) {
-        client.setnx(key, value);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Set<byte[]>> sinter(byte[]... keys) {
-        client.sinter(keys);
-        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
-    }
-
-    public Response<Long> sinterstore(byte[] dstkey, byte[]... keys) {
-        client.sinterstore(dstkey, keys);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Boolean> sismember(byte[] key, byte[] member) {
-        client.sismember(key, member);
-        return getResponse(BuilderFactory.BOOLEAN);
-    }
-
-    public Response<Set<byte[]>> smembers(byte[] key) {
-        client.smembers(key);
-        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
-    }
-
-    public Response<Long> smove(byte[] srckey, byte[] dstkey, byte[] member) {
-        client.smove(srckey, dstkey, member);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<List<byte[]>> sort(byte[] key) {
-        client.sort(key);
-        return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
-    }
-
-    public Response<List<byte[]>> sort(byte[] key,
-            SortingParams sortingParameters) {
-        client.sort(key, sortingParameters);
-        return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
-    }
-
-    public Response<List<byte[]>> sort(byte[] key,
-            SortingParams sortingParameters, byte[] dstkey) {
-        client.sort(key, sortingParameters, dstkey);
-        return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
-    }
-
-    public Response<List<byte[]>> sort(byte[] key, byte[] dstkey) {
-        client.sort(key, dstkey);
-        return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
-    }
-
-    public Response<byte[]> spop(byte[] key) {
-        client.spop(key);
-        return getResponse(BuilderFactory.BYTE_ARRAY);
-    }
-
-    public Response<byte[]> srandmember(byte[] key) {
-        client.srandmember(key);
-        return getResponse(BuilderFactory.BYTE_ARRAY);
-    }
-
-    public Response<Long> srem(byte[] key, byte[] member) {
-        client.srem(key, member);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> strlen(byte[] key) {
-        client.strlen(key);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> substr(byte[] key, int start, int end) { // what's
-        // that?
-        client.substr(key, start, end);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Set<byte[]>> sunion(byte[]... keys) {
-        client.sunion(keys);
-        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
-    }
-
-    public Response<Long> sunionstore(byte[] dstkey, byte[]... keys) {
-        client.sunionstore(dstkey, keys);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> ttl(byte[] key) {
-        client.ttl(key);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> type(byte[] key) {
-        client.type(key);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> zadd(byte[] key, double score, byte[] member) {
-        client.zadd(key, score, member);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zcard(byte[] key) {
-        client.zcard(key);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zcount(byte[] key, double min, double max) {
-        return zcount(key, toByteArray(min), toByteArray(max));
-    }
-    
-    public Response<Long> zcount(byte[] key, byte[] min, byte[] max) {
-        client.zcount(key, min, max);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Double> zincrby(byte[] key, double score, byte[] member) {
-        client.zincrby(key, score, member);
-        return getResponse(BuilderFactory.DOUBLE);
-    }
-
-    public Response<Long> zinterstore(byte[] dstkey, byte[]... sets) {
-        client.zinterstore(dstkey, sets);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zinterstore(byte[] dstkey, ZParams params,
-            byte[]... sets) {
-        client.zinterstore(dstkey, params, sets);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Set<byte[]>> zrange(byte[] key, int start, int end) {
-        client.zrange(key, start, end);
-        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
-    }
-
-    public Response<Set<byte[]>> zrangeByScore(byte[] key, double min,
-            double max) {
-        return zrangeByScore(key, toByteArray(min), toByteArray(max));
-    }
-    
-    public Response<Set<byte[]>> zrangeByScore(byte[] key, byte[] min,
-    		byte[] max) {
-        client.zrangeByScore(key, min, max);
-        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
-    }
-
-    public Response<Set<byte[]>> zrangeByScore(byte[] key, byte[] min,
-    		byte[] max, int offset, int count) {
-        client.zrangeByScore(key, min, max, offset, count);
-        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
-    }
-    
-    public Response<Set<byte[]>> zrangeByScore(byte[] key, double min,
-            double max, int offset, int count) {
-        return zrangeByScore(key, toByteArray(min), toByteArray(max), offset, count);
-    }
-
-    public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, double min,
-            double max) {
-        return zrangeByScoreWithScores(key, toByteArray(min), toByteArray(max));
-    }
-
-    public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, double min,
-            double max, int offset, int count) {
-        return zrangeByScoreWithScores(key, toByteArray(min), toByteArray(max), offset, count);
-    }
-    
-    public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, byte[] min,
-    		byte[] max) {
-        client.zrangeByScoreWithScores(key, min, max);
-        return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
-    }
-
-    public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, byte[] min,
-    		byte[] max, int offset, int count) {
-        client.zrangeByScoreWithScores(key, min, max, offset, count);
-        return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
-    }
-
-    public Response<Set<Tuple>> zrangeWithScores(byte[] key, int start, int end) {
-        client.zrangeWithScores(key, start, end);
-        return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
-    }
-
-    public Response<Long> zrank(byte[] key, byte[] member) {
-        client.zrank(key, member);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zrem(byte[] key, byte[] member) {
-        client.zrem(key, member);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zremrangeByRank(byte[] key, int start, int end) {
-        client.zremrangeByRank(key, start, end);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zremrangeByScore(byte[] key, double start, double end) {
-        return zremrangeByScore(key, toByteArray(start), toByteArray(end));
-    }
-    
-    public Response<Long> zremrangeByScore(byte[] key, byte[] start, byte[] end) {
-        client.zremrangeByScore(key, start, end);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Set<byte[]>> zrevrange(byte[] key, int start, int end) {
-        client.zrevrange(key, start, end);
-        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
-    }
-
-    public Response<Set<Tuple>> zrevrangeWithScores(byte[] key, int start,
-            int end) {
-        client.zrevrangeWithScores(key, start, end);
-        return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
-    }
-
-    public Response<Long> zrevrank(byte[] key, byte[] member) {
-        client.zrevrank(key, member);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Double> zscore(byte[] key, byte[] member) {
-        client.zscore(key, member);
-        return getResponse(BuilderFactory.DOUBLE);
-    }
-
-    public Response<Long> zunionstore(byte[] dstkey, byte[]... sets) {
-        client.zunionstore(dstkey, sets);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zunionstore(byte[] dstkey, ZParams params,
-            byte[]... sets) {
-        client.zunionstore(dstkey, params, sets);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<byte[]> brpoplpush(byte[] source, byte[] destination,
-            int timeout) {
-        client.brpoplpush(source, destination, timeout);
-        return getResponse(BuilderFactory.BYTE_ARRAY);
-    }
-    
-    public Response<String> select(final int index) {
-        client.select(index);
-        return getResponse(BuilderFactory.STRING);
-    }
-    
-    public Response<String> flushDB() {
-        client.flushDB();
-        return getResponse(BuilderFactory.STRING);
-    }
-    
-    public Response<String> flushAll() {
-        client.flushAll();
-        return getResponse(BuilderFactory.STRING);
-    }
-    
-    public Response<String> save() {
-        client.save();
-        return getResponse(BuilderFactory.STRING);
-    }
-    
-    public Response<String> info() {
-        client.info();
-        return getResponse(BuilderFactory.STRING);
-    }
-    
-    public Response<Long> lastsave() {
-        client.lastsave();
-        return getResponse(BuilderFactory.LONG);
-    }
-    
-    public Response<Long> dbSize() {
-        client.dbSize();
-        return getResponse(BuilderFactory.LONG);
-    }
-    
-    public Response<List<byte[]>> configGet(final byte[] pattern) {
-        client.configGet(pattern);
-        return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
-    }
-    
-    public Response<byte[]> configSet(final byte[] parameter, final byte[] value) {
-        client.configSet(parameter, value);
-        return getResponse(BuilderFactory.BYTE_ARRAY);
-    }
-    
-    public Response<String> configResetStat() {
-        client.configResetStat();
-        return getResponse(BuilderFactory.STRING);
-    }
-    
-    public Response<String> shutdown() {
-        client.shutdown();
-        return getResponse(BuilderFactory.STRING);
-    }
-    
-    public Response<Boolean> getbit(final byte[] key, final long offset) {
-        client.getbit(key, offset);
-        return getResponse(BuilderFactory.BOOLEAN);
-    }
-    
-    public Response<Boolean> setbit(final byte[] key, final long offset, final byte[] value) {
-        client.setbit(key, offset, value);
-        return getResponse(BuilderFactory.BOOLEAN);
-    }
-    
-    public Response<String> ping() {
-        client.ping();
-        return getResponse(BuilderFactory.STRING);
-    }
-    
-    public Response<Long> setrange(byte[] key, long offset, byte[] value) {
-        client.setrange(key, offset, value);
-        return getResponse(BuilderFactory.LONG);
-    }
-    
-    public Response<String> randomKey() {
-        client.randomKey();
-        return getResponse(BuilderFactory.STRING);
-    }
-    
-    public Response<Long> publish(byte[] channel, byte[] message) {
-        client.publish(channel, message);
-        return getResponse(BuilderFactory.LONG);
-    }
-}
\ No newline at end of file
diff --git a/src/main/java/redis/clients/jedis/BitOP.java b/src/main/java/redis/clients/jedis/BitOP.java
new file mode 100644
index 0000000..5e3ee89
--- /dev/null
+++ b/src/main/java/redis/clients/jedis/BitOP.java
@@ -0,0 +1,8 @@
+package redis.clients.jedis;
+
+public enum BitOP {
+    AND,
+    OR,
+    XOR,
+    NOT;
+}
diff --git a/src/main/java/redis/clients/jedis/BuilderFactory.java b/src/main/java/redis/clients/jedis/BuilderFactory.java
old mode 100644
new mode 100755
index 8a2320a..bebd2d6
--- a/src/main/java/redis/clients/jedis/BuilderFactory.java
+++ b/src/main/java/redis/clients/jedis/BuilderFactory.java
@@ -144,6 +144,13 @@ public class BuilderFactory {
             }
             List<byte[]> l = (List<byte[]>) data;
             final Set<byte[]> result = new LinkedHashSet<byte[]>(l);
+            for (final byte[] barray : l) {
+                if (barray == null) {
+                    result.add(null);
+                } else {
+                    result.add(barray);
+                }
+            }
             return result;
         }
 
@@ -151,6 +158,24 @@ public class BuilderFactory {
             return "ZSet<byte[]>";
         }
     };
+    public static final Builder<Map<byte[], byte[]>> BYTE_ARRAY_MAP = new Builder<Map<byte[], byte[]>>() {
+        @SuppressWarnings("unchecked")
+        public Map<byte[], byte[]> build(Object data) {
+            final List<byte[]> flatHash = (List<byte[]>) data;
+            final Map<byte[], byte[]> hash = new HashMap<byte[], byte[]>();
+            final Iterator<byte[]> iterator = flatHash.iterator();
+            while (iterator.hasNext()) {
+                hash.put(iterator.next(), iterator.next());
+            }
+
+            return hash;
+        }
+
+        public String toString() {
+            return "Map<byte[], byte[]>";
+        }
+
+    };
 
     public static final Builder<Set<String>> STRING_ZSET = new Builder<Set<String>>() {
         @SuppressWarnings("unchecked")
diff --git a/src/main/java/redis/clients/jedis/Client.java b/src/main/java/redis/clients/jedis/Client.java
index 992d10d..d0a6228 100644
--- a/src/main/java/redis/clients/jedis/Client.java
+++ b/src/main/java/redis/clients/jedis/Client.java
@@ -572,16 +572,16 @@ public class Client extends BinaryClient implements Commands {
 	strlen(SafeEncoder.encode(key));
     }
 
-    public void lpushx(final String key, final String string) {
-	lpushx(SafeEncoder.encode(key), SafeEncoder.encode(string));
+    public void lpushx(final String key, final String... string) {
+	lpushx(SafeEncoder.encode(key), getByteParams(string));
     }
 
     public void persist(final String key) {
 	persist(SafeEncoder.encode(key));
     }
 
-    public void rpushx(final String key, final String string) {
-	rpushx(SafeEncoder.encode(key), SafeEncoder.encode(string));
+    public void rpushx(final String key, final String... string) {
+	rpushx(SafeEncoder.encode(key), getByteParams(string));
     }
 
     public void echo(final String string) {
@@ -600,7 +600,11 @@ public class Client extends BinaryClient implements Commands {
     }
 
     public void setbit(final String key, final long offset, final boolean value) {
-	setbit(SafeEncoder.encode(key), offset, toByteArray(value ? 1 : 0));
+	setbit(SafeEncoder.encode(key), offset, value);
+    }
+
+    public void setbit(final String key, final long offset, final String value) {
+    setbit(SafeEncoder.encode(key), offset, SafeEncoder.encode(value));
     }
 
     public void getbit(String key, long offset) {
@@ -711,4 +715,29 @@ public class Client extends BinaryClient implements Commands {
     public void objectEncoding(String key) {
 	objectEncoding(SafeEncoder.encode(key));
     }
+
+    public void bitcount(final String key) {
+        bitcount(SafeEncoder.encode(key));
+    }
+
+    public void bitcount(final String key, long start, long end) {
+        bitcount(SafeEncoder.encode(key), start, end);
+    }
+
+    public void bitop(BitOP op, final String destKey, String... srcKeys) {
+        bitop(op, SafeEncoder.encode(destKey), getByteParams(srcKeys));
+    }
+
+    public void sentinel(final String... args) {
+	final byte[][] arg = new byte[args.length][];
+	for (int i = 0; i < arg.length; i++) {
+	    arg[i] = SafeEncoder.encode(args[i]);
+	}
+	sentinel(arg);
+    }
+
+    public void sentinel(final String cmd, String arg1, int arg2) {
+	sentinel(SafeEncoder.encode(cmd), SafeEncoder.encode(arg1),
+		toByteArray(arg2));
+    }
 }
diff --git a/src/main/java/redis/clients/jedis/Commands.java b/src/main/java/redis/clients/jedis/Commands.java
index 3776342..7f5f283 100644
--- a/src/main/java/redis/clients/jedis/Commands.java
+++ b/src/main/java/redis/clients/jedis/Commands.java
@@ -30,6 +30,8 @@ public interface Commands {
 
     public void setbit(String key, long offset, boolean value);
 
+    public void setbit(String key, long offset, String value);
+
     public void getbit(String key, long offset);
 
     public void setrange(String key, long offset, String value);
@@ -253,11 +255,11 @@ public interface Commands {
 
     public void strlen(final String key);
 
-    public void lpushx(final String key, final String string);
+    public void lpushx(final String key, final String... string);
 
     public void persist(final String key);
 
-    public void rpushx(final String key, final String string);
+    public void rpushx(final String key, final String... string);
 
     public void echo(final String string);
 
@@ -289,4 +291,10 @@ public interface Commands {
     public void objectIdletime(String key);
 
     public void objectEncoding(String key);
-}
\ No newline at end of file
+
+    public void bitcount(final String key);
+
+    public void bitcount(final String key, long start, long end);
+
+    public void bitop(BitOP op, final String destKey, String... srcKeys);
+}
diff --git a/src/main/java/redis/clients/jedis/Jedis.java b/src/main/java/redis/clients/jedis/Jedis.java
index 62040f9..db8cf37 100644
--- a/src/main/java/redis/clients/jedis/Jedis.java
+++ b/src/main/java/redis/clients/jedis/Jedis.java
@@ -2,6 +2,7 @@ package redis.clients.jedis;
 
 import java.net.URI;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.LinkedHashSet;
@@ -13,7 +14,7 @@ import redis.clients.jedis.BinaryClient.LIST_POSITION;
 import redis.clients.util.SafeEncoder;
 import redis.clients.util.Slowlog;
 
-public class Jedis extends BinaryJedis implements JedisCommands {
+public class Jedis extends BinaryJedis implements JedisCommands, MultiKeyCommands, AdvancedJedisCommands, ScriptingCommands {
     public Jedis(final String host) {
 	super(host);
     }
@@ -34,12 +35,6 @@ public class Jedis extends BinaryJedis implements JedisCommands {
 	super(uri);
     }
 
-    public String ping() {
-	checkIsInMulti();
-	client.ping();
-	return client.getStatusCodeReply();
-    }
-
     /**
      * Set the string value as value of the key. The string can't be longer than
      * 1073741824 bytes (1 GB).
@@ -72,16 +67,6 @@ public class Jedis extends BinaryJedis implements JedisCommands {
 	return client.getBulkReply();
     }
 
-    /**
-     * Ask the server to silently close the connection.
-     */
-
-    public String quit() {
-	checkIsInMulti();
-	client.quit();
-	return client.getStatusCodeReply();
-    }
-
     /**
      * Test if the specified key exists. The command returns "1" if the key
      * exists, otherwise "0" is returned. Note that even keys set with an empty
@@ -114,6 +99,11 @@ public class Jedis extends BinaryJedis implements JedisCommands {
 	return client.getIntegerReply();
     }
 
+    public Long del(String key) {
+        client.del(key);
+        return client.getIntegerReply();
+    }
+
     /**
      * Return the type of the value stored at key in form of a string. The type
      * can be one of "none", "string", "list", "set". "none" is returned if the
@@ -134,19 +124,6 @@ public class Jedis extends BinaryJedis implements JedisCommands {
 	return client.getStatusCodeReply();
     }
 
-    /**
-     * Delete all the keys of the currently selected DB. This command never
-     * fails.
-     * 
-     * @return Status code reply
-     */
-
-    public String flushDB() {
-	checkIsInMulti();
-	client.flushDB();
-	return client.getStatusCodeReply();
-    }
-
     /**
      * Returns all the keys matching the glob-style pattern as space separated
      * strings. For example if you have in the database the keys "foo" and
@@ -320,20 +297,6 @@ public class Jedis extends BinaryJedis implements JedisCommands {
 	return client.getIntegerReply();
     }
 
-    /**
-     * Select the DB with having the specified zero-based numeric index. For
-     * default every new client connection is automatically selected to DB 0.
-     * 
-     * @param index
-     * @return Status code reply
-     */
-
-    public String select(final int index) {
-	checkIsInMulti();
-	client.select(index);
-	return client.getStatusCodeReply();
-    }
-
     /**
      * Move the specified key from the currently selected DB to the specified
      * destination DB. Note that this command returns 1 only if the key was
@@ -353,19 +316,6 @@ public class Jedis extends BinaryJedis implements JedisCommands {
 	return client.getIntegerReply();
     }
 
-    /**
-     * Delete all the keys of all the existing databases, not just the currently
-     * selected one. This command never fails.
-     * 
-     * @return Status code reply
-     */
-
-    public String flushAll() {
-	checkIsInMulti();
-	client.flushAll();
-	return client.getStatusCodeReply();
-    }
-
     /**
      * GETSET is an atomic set this value and return the old value command. Set
      * key to the string value and return the old value stored at key. The
@@ -916,8 +866,6 @@ public class Jedis extends BinaryJedis implements JedisCommands {
      * <p>
      * Time complexity: O(1)
      * 
-     * @see Jedis#lpush(String, String)
-     * 
      * @param key
      * @param strings
      * @return Integer reply, specifically, the number of elements inside the
@@ -937,8 +885,6 @@ public class Jedis extends BinaryJedis implements JedisCommands {
      * <p>
      * Time complexity: O(1)
      * 
-     * @see Jedis#rpush(String, String)
-     * 
      * @param key
      * @param strings
      * @return Integer reply, specifically, the number of elements inside the
@@ -1868,6 +1814,42 @@ public class Jedis extends BinaryJedis implements JedisCommands {
 	return multiBulkReply;
     }
 
+    public List<String> blpop(String... args) {
+        client.blpop(args);
+        client.setTimeoutInfinite();
+        final List<String> multiBulkReply = client.getMultiBulkReply();
+        client.rollbackTimeout();
+        return multiBulkReply;
+    }
+
+    public List<String> brpop(String... args) {
+        client.brpop(args);
+        client.setTimeoutInfinite();
+        final List<String> multiBulkReply = client.getMultiBulkReply();
+        client.rollbackTimeout();
+        return multiBulkReply;
+    }
+
+    public List<String> blpop(String arg) {
+        String[] args = new String[1];
+        args[0] = arg;
+        client.blpop(args);
+        client.setTimeoutInfinite();
+        final List<String> multiBulkReply = client.getMultiBulkReply();
+        client.rollbackTimeout();
+        return multiBulkReply;
+    }
+
+    public List<String> brpop(String arg) {
+        String[] args = new String[1];
+        args[0] = arg;
+        client.brpop(args);
+        client.setTimeoutInfinite();
+        final List<String> multiBulkReply = client.getMultiBulkReply();
+        client.rollbackTimeout();
+        return multiBulkReply;
+    }
+
     /**
      * Sort a Set or a List accordingly to the specified parameters and store
      * the result at dstkey.
@@ -1998,49 +1980,7 @@ public class Jedis extends BinaryJedis implements JedisCommands {
 	return multiBulkReply;
     }
 
-    /**
-     * Request for authentication in a password protected Redis server. A Redis
-     * server can be instructed to require a password before to allow clients to
-     * issue commands. This is done using the requirepass directive in the Redis
-     * configuration file. If the password given by the client is correct the
-     * server replies with an OK status code reply and starts accepting commands
-     * from the client. Otherwise an error is returned and the clients needs to
-     * try a new password. Note that for the high performance nature of Redis it
-     * is possible to try a lot of passwords in parallel in very short time, so
-     * make sure to generate a strong and very long password so that this attack
-     * is infeasible.
-     * 
-     * @param password
-     * @return Status code reply
-     */
 
-    public String auth(final String password) {
-	checkIsInMulti();
-	client.auth(password);
-	return client.getStatusCodeReply();
-    }
-
-    public void subscribe(JedisPubSub jedisPubSub, String... channels) {
-	checkIsInMulti();
-	connect();
-	client.setTimeoutInfinite();
-	jedisPubSub.proceed(client, channels);
-	client.rollbackTimeout();
-    }
-
-    public Long publish(String channel, String message) {
-	checkIsInMulti();
-	client.publish(channel, message);
-	return client.getIntegerReply();
-    }
-
-    public void psubscribe(JedisPubSub jedisPubSub, String... patterns) {
-	checkIsInMulti();
-	connect();
-	client.setTimeoutInfinite();
-	jedisPubSub.proceedWithPatterns(client, patterns);
-	client.rollbackTimeout();
-    }
 
     public Long zcount(final String key, final double min, final double max) {
 	checkIsInMulti();
@@ -2647,7 +2587,7 @@ public class Jedis extends BinaryJedis implements JedisCommands {
 	return client.getIntegerReply();
     }
 
-    public Long lpushx(final String key, final String string) {
+    public Long lpushx(final String key, final String... string) {
 	client.lpushx(key, string);
 	return client.getIntegerReply();
     }
@@ -2667,7 +2607,7 @@ public class Jedis extends BinaryJedis implements JedisCommands {
 	return client.getIntegerReply();
     }
 
-    public Long rpushx(final String key, final String string) {
+    public Long rpushx(final String key, final String... string) {
 	client.rpushx(key, string);
 	return client.getIntegerReply();
     }
@@ -2713,6 +2653,11 @@ public class Jedis extends BinaryJedis implements JedisCommands {
 	return client.getIntegerReply() == 1;
     }
 
+    public Boolean setbit(String key, long offset, String value) {
+    client.setbit(key, offset, value);
+    return client.getIntegerReply() == 1;
+    }
+
     /**
      * Returns the bit value at offset in the string value stored at key
      * 
@@ -2822,6 +2767,29 @@ public class Jedis extends BinaryJedis implements JedisCommands {
 	return getEvalResult();
     }
 
+    public void subscribe(final JedisPubSub jedisPubSub,
+        final String... channels) {
+    client.setTimeoutInfinite();
+    jedisPubSub.proceed(client, channels);
+    client.rollbackTimeout();
+    }
+
+    public Long publish(final String channel, final String message) {
+    checkIsInMulti();
+    connect();
+    client.publish(channel, message);
+    return client.getIntegerReply();
+    }
+
+    public void psubscribe(final JedisPubSub jedisPubSub,
+        final String... patterns) {
+    checkIsInMulti();
+    connect();
+    client.setTimeoutInfinite();
+    jedisPubSub.proceedWithPatterns(client, patterns);
+    client.rollbackTimeout();
+    }
+
     private String[] getParams(List<String> keys, List<String> args) {
 	int keyCount = keys.size();
 	int argCount = args.size();
@@ -2851,15 +2819,17 @@ public class Jedis extends BinaryJedis implements JedisCommands {
 
     private Object getEvalResult() {
 	Object result = client.getOne();
-
+	
 	if (result instanceof byte[])
 	    return SafeEncoder.encode((byte[]) result);
 
 	if (result instanceof List<?>) {
 	    List<?> list = (List<?>) result;
 	    List<String> listResult = new ArrayList<String>(list.size());
-	    for (Object bin : list)
-		listResult.add(SafeEncoder.encode((byte[]) bin));
+	    for (Object bin : list) {
+		listResult.add((bin == null ? null : SafeEncoder
+			.encode((byte[]) bin)));
+	    }
 
 	    return listResult;
 	}
@@ -2924,4 +2894,159 @@ public class Jedis extends BinaryJedis implements JedisCommands {
 	client.objectIdletime(string);
 	return client.getIntegerReply();
     }
+
+    public Long bitcount(final String key) {
+        client.bitcount(key);
+        return client.getIntegerReply();
+    }
+
+    public Long bitcount(final String key, long start, long end) {
+        client.bitcount(key, start, end);
+        return client.getIntegerReply();
+    }
+
+    public Long bitop(BitOP op, final String destKey, String... srcKeys) {
+        client.bitop(op, destKey, srcKeys);
+        return client.getIntegerReply();
+    }
+
+    /**
+     * <pre>
+     * redis 127.0.0.1:26381> sentinel masters
+     * 1)  1) "name"
+     *     2) "mymaster"
+     *     3) "ip"
+     *     4) "127.0.0.1"
+     *     5) "port"
+     *     6) "6379"
+     *     7) "runid"
+     *     8) "93d4d4e6e9c06d0eea36e27f31924ac26576081d"
+     *     9) "flags"
+     *    10) "master"
+     *    11) "pending-commands"
+     *    12) "0"
+     *    13) "last-ok-ping-reply"
+     *    14) "423"
+     *    15) "last-ping-reply"
+     *    16) "423"
+     *    17) "info-refresh"
+     *    18) "6107"
+     *    19) "num-slaves"
+     *    20) "1"
+     *    21) "num-other-sentinels"
+     *    22) "2"
+     *    23) "quorum"
+     *    24) "2"
+     * 
+     * </pre>
+     * 
+     * @return
+     */
+    public List<Map<String, String>> sentinelMasters() {
+	client.sentinel(Protocol.SENTINEL_MASTERS);
+	final List<Object> reply = client.getObjectMultiBulkReply();
+
+	final List<Map<String, String>> masters = new ArrayList<Map<String, String>>();
+	for (Object obj : reply) {
+	    masters.add(BuilderFactory.STRING_MAP.build((List) obj));
+	}
+	return masters;
+    }
+
+    /**
+     * <pre>
+     * redis 127.0.0.1:26381> sentinel get-master-addr-by-name mymaster
+     * 1) "127.0.0.1"
+     * 2) "6379"
+     * </pre>
+     * 
+     * @param masterName
+     * @return two elements list of strings : host and port.
+     */
+    public List<String> sentinelGetMasterAddrByName(String masterName) {
+	client.sentinel(Protocol.SENTINEL_GET_MASTER_ADDR_BY_NAME, masterName);
+	final List<Object> reply = client.getObjectMultiBulkReply();
+	return BuilderFactory.STRING_LIST.build(reply);
+    }
+
+    /**
+     * <pre>
+     * redis 127.0.0.1:26381> sentinel reset mymaster
+     * (integer) 1
+     * </pre>
+     * 
+     * @param pattern
+     * @return
+     */
+    public Long sentinelReset(String pattern) {
+	client.sentinel(Protocol.SENTINEL_RESET, pattern);
+	return client.getIntegerReply();
+    }
+
+    /**
+     * <pre>
+     * redis 127.0.0.1:26381> sentinel slaves mymaster
+     * 1)  1) "name"
+     *     2) "127.0.0.1:6380"
+     *     3) "ip"
+     *     4) "127.0.0.1"
+     *     5) "port"
+     *     6) "6380"
+     *     7) "runid"
+     *     8) "d7f6c0ca7572df9d2f33713df0dbf8c72da7c039"
+     *     9) "flags"
+     *    10) "slave"
+     *    11) "pending-commands"
+     *    12) "0"
+     *    13) "last-ok-ping-reply"
+     *    14) "47"
+     *    15) "last-ping-reply"
+     *    16) "47"
+     *    17) "info-refresh"
+     *    18) "657"
+     *    19) "master-link-down-time"
+     *    20) "0"
+     *    21) "master-link-status"
+     *    22) "ok"
+     *    23) "master-host"
+     *    24) "localhost"
+     *    25) "master-port"
+     *    26) "6379"
+     *    27) "slave-priority"
+     *    28) "100"
+     * </pre>
+     * 
+     * @param masterName
+     * @return
+     */
+    public List<Map<String, String>> sentinelSlaves(String masterName) {
+	client.sentinel(Protocol.SENTINEL_SLAVES, masterName);
+	final List<Object> reply = client.getObjectMultiBulkReply();
+
+	final List<Map<String, String>> slaves = new ArrayList<Map<String, String>>();
+	for (Object obj : reply) {
+	    slaves.add(BuilderFactory.STRING_MAP.build((List) obj));
+	}
+	return slaves;
+    }
+
+    /**
+     * <pre>
+     * redis 127.0.0.1:26381> SENTINEL is-master-down-by-addr 127.0.0.1 1
+     * 1) (integer) 0
+     * 2) "?"
+     * redis 127.0.0.1:26381> SENTINEL is-master-down-by-addr 127.0.0.1 6379
+     * 1) (integer) 0
+     * 2) "aaef11fbb2712346a386078c7f9834e72ed51e96"
+     * </pre>
+     * 
+     * @return Long followed by the String (runid)
+     */
+    public List<? extends Object> sentinelIsMasterDownByAddr(String host,
+	    int port) {
+	client.sentinel(Protocol.SENTINEL_IS_MASTER_DOWN_BY_ADDR, host, port);
+	final List<Object> reply = client.getObjectMultiBulkReply();
+	return Arrays.asList(BuilderFactory.LONG.build(reply.get(0)),
+		BuilderFactory.STRING.build(reply.get(1)));
+    }
 }
diff --git a/src/main/java/redis/clients/jedis/JedisCommands.java b/src/main/java/redis/clients/jedis/JedisCommands.java
index d4c07f3..ea5016b 100644
--- a/src/main/java/redis/clients/jedis/JedisCommands.java
+++ b/src/main/java/redis/clients/jedis/JedisCommands.java
@@ -14,6 +14,8 @@ public interface JedisCommands {
 
     Boolean exists(String key);
 
+    Long persist(String key);
+
     String type(String key);
 
     Long expire(String key, int seconds);
@@ -24,6 +26,8 @@ public interface JedisCommands {
 
     Boolean setbit(String key, long offset, boolean value);
 
+    Boolean setbit(String key, long offset, String value);
+
     Boolean getbit(String key, long offset);
 
     Long setrange(String key, long offset, String value);
@@ -106,6 +110,8 @@ public interface JedisCommands {
 
     String srandmember(String key);
 
+    Long strlen(String key);
+
     Long zadd(String key, double score, String member);
     
     Long zadd(String key, Map<Double, String> scoreMembers);
@@ -187,7 +193,21 @@ public interface JedisCommands {
     Long linsert(String key, Client.LIST_POSITION where, String pivot,
             String value);
     
-    Long lpushx(String key, String string);
+    Long lpushx(String key, String... string);
     
-    Long rpushx(String key, String string); 
+    Long rpushx(String key, String... string);
+
+    List<String> blpop(String arg);
+
+    List<String> brpop(String arg);
+
+    Long del(String key);
+
+    String echo(String string);
+
+    Long move(String key, int dbIndex);
+
+    Long bitcount(final String key);
+
+    Long bitcount(final String key, long start, long end);
 }
diff --git a/src/main/java/redis/clients/jedis/MultiKeyBinaryCommands.java b/src/main/java/redis/clients/jedis/MultiKeyBinaryCommands.java
new file mode 100644
index 0000000..1b3c158
--- /dev/null
+++ b/src/main/java/redis/clients/jedis/MultiKeyBinaryCommands.java
@@ -0,0 +1,73 @@
+package redis.clients.jedis;
+
+
+import java.util.List;
+import java.util.Set;
+
+public interface MultiKeyBinaryCommands {
+    Long del(byte[]... keys);
+
+    List<byte[]> blpop(int timeout, byte[]... keys);
+
+    List<byte[]> brpop(int timeout, byte[]... keys);
+
+    List<byte[]> blpop(byte[]... args);
+
+    List<byte[]> brpop(byte[]... args);
+
+    Set<byte[]> keys(byte[] pattern);
+
+    List<byte[]> mget(byte[]... keys);
+
+    String mset(byte[]... keysvalues);
+
+    Long msetnx(byte[]... keysvalues);
+
+    String rename(byte[] oldkey, byte[] newkey);
+
+    Long renamenx(byte[] oldkey, byte[] newkey);
+
+    byte[] rpoplpush(byte[] srckey, byte[] dstkey);
+
+    Set<byte[]> sdiff(byte[]... keys);
+
+    Long sdiffstore(byte[] dstkey, byte[]... keys);
+
+    Set<byte[]> sinter(byte[]... keys);
+
+    Long sinterstore(byte[] dstkey, byte[]... keys);
+
+    Long smove(byte[] srckey, byte[] dstkey, byte[] member);
+
+    Long sort(byte[] key, SortingParams sortingParameters, byte[] dstkey);
+
+    Long sort(byte[] key, byte[] dstkey);
+
+    Set<byte[]> sunion(byte[]... keys);
+
+    Long sunionstore(byte[] dstkey, byte[]... keys);
+
+    String watch(byte[]... keys);
+
+    String unwatch();
+
+    Long zinterstore(byte[] dstkey, byte[]... sets);
+
+    Long zinterstore(byte[] dstkey, ZParams params, byte[]... sets);
+
+    Long zunionstore(byte[] dstkey, byte[]... sets);
+
+    Long zunionstore(byte[] dstkey, ZParams params, byte[]... sets);
+
+    byte[] brpoplpush(byte[] source, byte[] destination, int timeout);
+
+    Long publish(byte[] channel, byte[] message);
+
+    void subscribe(BinaryJedisPubSub jedisPubSub, byte[]... channels);
+
+    void psubscribe(BinaryJedisPubSub jedisPubSub, byte[]... patterns);
+
+    byte[] randomBinaryKey();
+
+    Long bitop(BitOP op, final byte[] destKey, byte[]... srcKeys);
+}
diff --git a/src/main/java/redis/clients/jedis/MultiKeyBinaryRedisPipeline.java b/src/main/java/redis/clients/jedis/MultiKeyBinaryRedisPipeline.java
new file mode 100644
index 0000000..85d004b
--- /dev/null
+++ b/src/main/java/redis/clients/jedis/MultiKeyBinaryRedisPipeline.java
@@ -0,0 +1,67 @@
+package redis.clients.jedis;
+
+
+import java.util.List;
+import java.util.Set;
+
+/**
+ * Multikey related commands (these are split out because they are non-shardable)
+ */
+public interface MultiKeyBinaryRedisPipeline {
+
+    Response<Long> del(byte[]... keys);
+    
+    Response<List<byte[]>> blpop(byte[]... args);
+
+    Response<List<byte[]>> brpop(byte[]... args);
+
+    Response<Set<byte[]>> keys(byte[] pattern);
+
+    Response<List<byte[]>> mget(byte[]... keys);
+
+    Response<String> mset(byte[]... keysvalues);
+
+    Response<Long> msetnx(byte[]... keysvalues);
+
+    Response<String> rename(byte[] oldkey, byte[] newkey);
+
+    Response<Long> renamenx(byte[] oldkey, byte[] newkey);
+
+    Response<byte[]> rpoplpush(byte[] srckey, byte[] dstkey);
+
+    Response<Set<byte[]>> sdiff(byte[]... keys);
+
+    Response<Long> sdiffstore(byte[] dstkey, byte[]... keys);
+
+    Response<Set<byte[]>> sinter(byte[]... keys);
+
+    Response<Long> sinterstore(byte[] dstkey, byte[]... keys);
+
+    Response<Long> smove(byte[] srckey, byte[] dstkey, byte[] member);
+
+    Response<List<byte[]>> sort(byte[] key, SortingParams sortingParameters, byte[] dstkey);
+
+    Response<List<byte[]>> sort(byte[] key, byte[] dstkey);
+
+    Response<Set<byte[]>> sunion(byte[]... keys);
+
+    Response<Long> sunionstore(byte[] dstkey, byte[]... keys);
+
+    Response<String> watch(byte[]... keys);
+
+    Response<Long> zinterstore(byte[] dstkey, byte[]... sets);
+
+    Response<Long> zinterstore(byte[] dstkey, ZParams params, byte[]... sets);
+
+    Response<Long> zunionstore(byte[] dstkey, byte[]... sets);
+
+    Response<Long> zunionstore(byte[] dstkey, ZParams params, byte[]... sets);
+
+    Response<byte[]> brpoplpush(byte[] source, byte[] destination, int timeout);
+
+    Response<Long> publish(byte[] channel, byte[] message);
+
+    Response<byte[]> randomKeyBinary();
+
+    Response<Long> bitop(BitOP op, final byte[] destKey, byte[]... srcKeys);
+}
diff --git a/src/main/java/redis/clients/jedis/MultiKeyCommands.java b/src/main/java/redis/clients/jedis/MultiKeyCommands.java
new file mode 100644
index 0000000..c98017f
--- /dev/null
+++ b/src/main/java/redis/clients/jedis/MultiKeyCommands.java
@@ -0,0 +1,73 @@
+package redis.clients.jedis;
+
+
+import java.util.List;
+import java.util.Set;
+
+public interface MultiKeyCommands {
+    Long del(String... keys);
+
+    List<String> blpop(int timeout, String... keys);
+
+    List<String> brpop(int timeout, String... keys);
+
+    List<String> blpop(String... args);
+
+    List<String> brpop(String... args);
+
+    Set<String> keys(String pattern);
+
+    List<String> mget(String... keys);
+
+    String mset(String... keysvalues);
+
+    Long msetnx(String... keysvalues);
+
+    String rename(String oldkey, String newkey);
+
+    Long renamenx(String oldkey, String newkey);
+
+    String rpoplpush(String srckey, String dstkey);
+
+    Set<String> sdiff(String... keys);
+
+    Long sdiffstore(String dstkey, String... keys);
+
+    Set<String> sinter(String... keys);
+
+    Long sinterstore(String dstkey, String... keys);
+
+    Long smove(String srckey, String dstkey, String member);
+
+    Long sort(String key, SortingParams sortingParameters, String dstkey);
+
+    Long sort(String key, String dstkey);
+
+    Set<String> sunion(String... keys);
+
+    Long sunionstore(String dstkey, String... keys);
+
+    String watch(String... keys);
+
+    String unwatch();
+
+    Long zinterstore(String dstkey, String... sets);
+
+    Long zinterstore(String dstkey, ZParams params, String... sets);
+
+    Long zunionstore(String dstkey, String... sets);
+
+    Long zunionstore(String dstkey, ZParams params, String... sets);
+
+    String brpoplpush(String source, String destination, int timeout);
+
+    Long publish(String channel, String message);
+
+    void subscribe(JedisPubSub jedisPubSub, String... channels);
+
+    void psubscribe(JedisPubSub jedisPubSub, String... patterns);
+
+    String randomKey();
+
+    Long bitop(BitOP op, final String destKey, String... srcKeys);
+}
diff --git a/src/main/java/redis/clients/jedis/MultiKeyCommandsPipeline.java b/src/main/java/redis/clients/jedis/MultiKeyCommandsPipeline.java
new file mode 100644
index 0000000..1478e81
--- /dev/null
+++ b/src/main/java/redis/clients/jedis/MultiKeyCommandsPipeline.java
@@ -0,0 +1,67 @@
+package redis.clients.jedis;
+
+
+import java.util.List;
+import java.util.Set;
+
+
+/**
+ * Multikey related commands (these are split out because they are non-shardable)
+ */
+public interface MultiKeyCommandsPipeline {
+    Response<Long> del(String... keys);
+
+    Response<List<String>> blpop(String... args);
+
+    Response<List<String>> brpop(String... args);
+
+    Response<Set<String>> keys(String pattern);
+
+    Response<List<String>> mget(String... keys);
+
+    Response<String> mset(String... keysvalues);
+
+    Response<Long> msetnx(String... keysvalues);
+
+    Response<String> rename(String oldkey, String newkey);
+
+    Response<Long> renamenx(String oldkey, String newkey);
+
+    Response<String> rpoplpush(String srckey, String dstkey);
+
+    Response<Set<String>> sdiff(String... keys);
+
+    Response<Long> sdiffstore(String dstkey, String... keys);
+
+    Response<Set<String>> sinter(String... keys);
+
+    Response<Long> sinterstore(String dstkey, String... keys);
+
+    Response<Long> smove(String srckey, String dstkey, String member);
+
+    Response<List<String>> sort(String key, SortingParams sortingParameters, String dstkey);
+
+    Response<List<String>> sort(String key, String dstkey);
+
+    Response<Set<String>> sunion(String... keys);
+
+    Response<Long> sunionstore(String dstkey, String... keys);
+
+    Response<String> watch(String... keys);
+
+    Response<Long> zinterstore(String dstkey, String... sets);
+
+    Response<Long> zinterstore(String dstkey, ZParams params, String... sets);
+
+    Response<Long> zunionstore(String dstkey, String... sets);
+
+    Response<Long> zunionstore(String dstkey, ZParams params, String... sets);
+
+    Response<String> brpoplpush(String source, String destination, int timeout);
+
+    Response<Long> publish(String channel, String message);
+
+    Response<String> randomKey();
+
+    Response<Long> bitop(BitOP op, final String destKey, String... srcKeys);
+}
diff --git a/src/main/java/redis/clients/jedis/MultiKeyPipelineBase.java b/src/main/java/redis/clients/jedis/MultiKeyPipelineBase.java
new file mode 100644
index 0000000..ccf0dfd
--- /dev/null
+++ b/src/main/java/redis/clients/jedis/MultiKeyPipelineBase.java
@@ -0,0 +1,370 @@
+package redis.clients.jedis;
+
+import java.util.List;
+import java.util.Set;
+
+abstract class MultiKeyPipelineBase extends PipelineBase implements
+        BasicRedisPipeline,
+        MultiKeyBinaryRedisPipeline,
+        MultiKeyCommandsPipeline {
+
+    protected Client client = null;
+
+    public Response<List<String>> brpop(String... args) {
+        client.brpop(args);
+        return getResponse(BuilderFactory.STRING_LIST);
+    }
+
+    public Response<List<String>> blpop(String... args) {
+        client.blpop(args);
+        return getResponse(BuilderFactory.STRING_LIST);
+    }
+
+    public Response<List<byte[]>> brpop(byte[]... args) {
+        client.brpop(args);
+        return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
+    }
+
+    public Response<List<byte[]>> blpop(byte[]... args) {
+        client.blpop(args);
+        return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
+    }
+
+    public Response<Long> del(String... keys) {
+        client.del(keys);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> del(byte[]... keys) {
+        client.del(keys);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Set<String>> keys(String pattern) {
+        getClient(pattern).keys(pattern);
+        return getResponse(BuilderFactory.STRING_SET);
+    }
+
+    public Response<Set<byte[]>> keys(byte[] pattern) {
+        getClient(pattern).keys(pattern);
+        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
+    }
+
+    public Response<List<String>> mget(String... keys) {
+        client.mget(keys);
+        return getResponse(BuilderFactory.STRING_LIST);
+    }
+
+    public Response<List<byte[]>> mget(byte[]... keys) {
+        client.mget(keys);
+        return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
+    }
+
+    public Response<String> mset(String... keysvalues) {
+        client.mset(keysvalues);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> mset(byte[]... keysvalues) {
+        client.mset(keysvalues);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Long> msetnx(String... keysvalues) {
+        client.msetnx(keysvalues);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> msetnx(byte[]... keysvalues) {
+        client.msetnx(keysvalues);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<String> rename(String oldkey, String newkey) {
+        client.rename(oldkey, newkey);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> rename(byte[] oldkey, byte[] newkey) {
+        client.rename(oldkey, newkey);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Long> renamenx(String oldkey, String newkey) {
+        client.renamenx(oldkey, newkey);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> renamenx(byte[] oldkey, byte[] newkey) {
+        client.renamenx(oldkey, newkey);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<String> rpoplpush(String srckey, String dstkey) {
+        client.rpoplpush(srckey, dstkey);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<byte[]> rpoplpush(byte[] srckey, byte[] dstkey) {
+        client.rpoplpush(srckey, dstkey);
+        return getResponse(BuilderFactory.BYTE_ARRAY);
+    }
+
+    public Response<Set<String>> sdiff(String... keys) {
+        client.sdiff(keys);
+        return getResponse(BuilderFactory.STRING_SET);
+    }
+
+    public Response<Set<byte[]>> sdiff(byte[]... keys) {
+        client.sdiff(keys);
+        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
+    }
+
+    public Response<Long> sdiffstore(String dstkey, String... keys) {
+        client.sdiffstore(dstkey, keys);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> sdiffstore(byte[] dstkey, byte[]... keys) {
+        client.sdiffstore(dstkey, keys);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Set<String>> sinter(String... keys) {
+        client.sinter(keys);
+        return getResponse(BuilderFactory.STRING_SET);
+    }
+
+    public Response<Set<byte[]>> sinter(byte[]... keys) {
+        client.sinter(keys);
+        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
+    }
+
+    public Response<Long> sinterstore(String dstkey, String... keys) {
+        client.sinterstore(dstkey, keys);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> sinterstore(byte[] dstkey, byte[]... keys) {
+        client.sinterstore(dstkey, keys);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> smove(String srckey, String dstkey, String member) {
+        client.smove(srckey, dstkey, member);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> smove(byte[] srckey, byte[] dstkey, byte[] member) {
+        client.smove(srckey, dstkey, member);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<List<String>> sort(String key,
+                                       SortingParams sortingParameters, String dstkey) {
+        client.sort(key, sortingParameters, dstkey);
+        return getResponse(BuilderFactory.STRING_LIST);
+    }
+
+    public Response<List<byte[]>> sort(byte[] key,
+                                       SortingParams sortingParameters, byte[] dstkey) {
+        client.sort(key, sortingParameters, dstkey);
+        return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
+    }
+
+    public Response<List<String>> sort(String key, String dstkey) {
+        client.sort(key, dstkey);
+        return getResponse(BuilderFactory.STRING_LIST);
+    }
+
+    public Response<List<byte[]>> sort(byte[] key, byte[] dstkey) {
+        client.sort(key, dstkey);
+        return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
+    }
+
+    public Response<Set<String>> sunion(String... keys) {
+        client.sunion(keys);
+        return getResponse(BuilderFactory.STRING_SET);
+    }
+
+    public Response<Set<byte[]>> sunion(byte[]... keys) {
+        client.sunion(keys);
+        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
+    }
+
+    public Response<Long> sunionstore(String dstkey, String... keys) {
+        client.sunionstore(dstkey, keys);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> sunionstore(byte[] dstkey, byte[]... keys) {
+        client.sunionstore(dstkey, keys);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<String> watch(String... keys) {
+        client.watch(keys);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> watch(byte[]... keys) {
+        client.watch(keys);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Long> zinterstore(String dstkey, String... sets) {
+        client.zinterstore(dstkey, sets);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zinterstore(byte[] dstkey, byte[]... sets) {
+        client.zinterstore(dstkey, sets);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zinterstore(String dstkey, ZParams params,
+                                      String... sets) {
+        client.zinterstore(dstkey, params, sets);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zinterstore(byte[] dstkey, ZParams params,
+                                      byte[]... sets) {
+        client.zinterstore(dstkey, params, sets);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zunionstore(String dstkey, String... sets) {
+        client.zunionstore(dstkey, sets);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zunionstore(byte[] dstkey, byte[]... sets) {
+        client.zunionstore(dstkey, sets);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zunionstore(String dstkey, ZParams params,
+                                      String... sets) {
+        client.zunionstore(dstkey, params, sets);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zunionstore(byte[] dstkey, ZParams params,
+                                      byte[]... sets) {
+        client.zunionstore(dstkey, params, sets);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<String> bgrewriteaof() {
+        client.bgrewriteaof();
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> bgsave() {
+        client.bgsave();
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> configGet(String pattern) {
+        client.configGet(pattern);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> configSet(String parameter, String value) {
+        client.configSet(parameter, value);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> brpoplpush(String source, String destination,
+                                       int timeout) {
+        client.brpoplpush(source, destination, timeout);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<byte[]> brpoplpush(byte[] source, byte[] destination,
+                                       int timeout) {
+        client.brpoplpush(source, destination, timeout);
+        return getResponse(BuilderFactory.BYTE_ARRAY);
+    }
+
+    public Response<String> configResetStat() {
+        client.configResetStat();
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> save() {
+        client.save();
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Long> lastsave() {
+        client.lastsave();
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> publish(String channel, String message) {
+        client.publish(channel, message);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> publish(byte[] channel, byte[] message) {
+        client.publish(channel, message);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<String> randomKey() {
+        client.randomKey();
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<byte[]> randomKeyBinary() {
+        client.randomKey();
+        return getResponse(BuilderFactory.BYTE_ARRAY);
+    }
+
+    public Response<String> flushDB() {
+        client.flushDB();
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> flushAll() {
+        client.flushAll();
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> info() {
+        client.info();
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Long> dbSize() {
+        client.dbSize();
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<String> shutdown() {
+        client.shutdown();
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> ping() {
+        client.ping();
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> select(int index) {
+        client.select(index);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Long> bitop(BitOP op, byte[] destKey, byte[]... srcKeys) {
+        client.bitop(op, destKey, srcKeys);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> bitop(BitOP op, String destKey, String... srcKeys) {
+        client.bitop(op, destKey, srcKeys);
+        return getResponse(BuilderFactory.LONG);
+    }
+}
diff --git a/src/main/java/redis/clients/jedis/Pipeline.java b/src/main/java/redis/clients/jedis/Pipeline.java
old mode 100644
new mode 100755
index cd1ecaa..ee680eb
--- a/src/main/java/redis/clients/jedis/Pipeline.java
+++ b/src/main/java/redis/clients/jedis/Pipeline.java
@@ -1,15 +1,11 @@
 package redis.clients.jedis;
 
-import static redis.clients.jedis.Protocol.toByteArray;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import redis.clients.jedis.BinaryClient.LIST_POSITION;
 import redis.clients.jedis.exceptions.JedisDataException;
 
-public class Pipeline extends Queable {
+import java.util.ArrayList;
+import java.util.List;
+
+public class Pipeline extends MultiKeyPipelineBase {
 	
     private MultiResponseBuilder currentMulti;
     
@@ -52,13 +48,21 @@ public class Pipeline extends Queable {
     		return super.getResponse(builder);
     	}
     }
-	
-    private Client client;
-    
+
     public void setClient(Client client) {
         this.client = client;
     }
 
+    @Override
+    protected Client getClient(byte[] key) {
+        return client;
+    }
+
+    @Override
+    protected Client getClient(String key) {
+        return client;
+    }
+
     /**
      * Syncronize pipeline by reading all responses. This operation close the
      * pipeline. In order to get return values from pipelined commands, capture
@@ -78,7 +82,6 @@ public class Pipeline extends Queable {
      * right response type (usually it is a waste of time).
      * 
      * @return A list of all the responses in the order you executed them.
-     * @see sync
      */
     public List<Object> syncAndReturnAll() {
         List<Object> unformatted = client.getAll();
@@ -94,1184 +97,6 @@ public class Pipeline extends Queable {
         return formatted;
     }
 
-    public Response<Long> append(String key, String value) {
-        client.append(key, value);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> append(byte[] key, byte[] value) {
-        client.append(key, value);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<List<String>> blpop(String... args) {
-        client.blpop(args);
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<List<String>> blpop(byte[]... args) {
-        client.blpop(args);
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<List<String>> brpop(String... args) {
-        client.brpop(args);
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<List<String>> brpop(byte[]... args) {
-        client.brpop(args);
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<Long> decr(String key) {
-        client.decr(key);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> decr(byte[] key) {
-        client.decr(key);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> decrBy(String key, long integer) {
-        client.decrBy(key, integer);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> decrBy(byte[] key, long integer) {
-        client.decrBy(key, integer);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> del(String... keys) {
-        client.del(keys);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> del(byte[]... keys) {
-        client.del(keys);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> echo(String string) {
-        client.echo(string);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> echo(byte[] string) {
-        client.echo(string);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Boolean> exists(String key) {
-        client.exists(key);
-        return getResponse(BuilderFactory.BOOLEAN);
-    }
-
-    public Response<Boolean> exists(byte[] key) {
-        client.exists(key);
-        return getResponse(BuilderFactory.BOOLEAN);
-    }
-
-    public Response<Long> expire(String key, int seconds) {
-        client.expire(key, seconds);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> expire(byte[] key, int seconds) {
-        client.expire(key, seconds);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> expireAt(String key, long unixTime) {
-        client.expireAt(key, unixTime);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> expireAt(byte[] key, long unixTime) {
-        client.expireAt(key, unixTime);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> get(String key) {
-        client.get(key);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<byte[]> get(byte[] key) {
-        client.get(key);
-        return getResponse(BuilderFactory.BYTE_ARRAY);
-    }
-
-    public Response<Boolean> getbit(String key, long offset) {
-        client.getbit(key, offset);
-        return getResponse(BuilderFactory.BOOLEAN);
-    }
-
-    public Response<String> getrange(String key, long startOffset,
-            long endOffset) {
-        client.getrange(key, startOffset, endOffset);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> getSet(String key, String value) {
-        client.getSet(key, value);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<byte[]> getSet(byte[] key, byte[] value) {
-        client.getSet(key, value);
-        return getResponse(BuilderFactory.BYTE_ARRAY);
-    }
-
-    public Response<Long> hdel(String key, String field) {
-        client.hdel(key, field);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> hdel(byte[] key, byte[] field) {
-        client.hdel(key, field);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Boolean> hexists(String key, String field) {
-        client.hexists(key, field);
-        return getResponse(BuilderFactory.BOOLEAN);
-    }
-
-    public Response<Boolean> hexists(byte[] key, byte[] field) {
-        client.hexists(key, field);
-        return getResponse(BuilderFactory.BOOLEAN);
-    }
-
-    public Response<String> hget(String key, String field) {
-        client.hget(key, field);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> hget(byte[] key, byte[] field) {
-        client.hget(key, field);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Map<String, String>> hgetAll(String key) {
-        client.hgetAll(key);
-        return getResponse(BuilderFactory.STRING_MAP);
-    }
-
-    public Response<Map<String, String>> hgetAll(byte[] key) {
-        client.hgetAll(key);
-        return getResponse(BuilderFactory.STRING_MAP);
-    }
-
-    public Response<Long> hincrBy(String key, String field, long value) {
-        client.hincrBy(key, field, value);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> hincrBy(byte[] key, byte[] field, long value) {
-        client.hincrBy(key, field, value);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Double> hincrByFloat(String key, String field, double value) {
-        client.hincrByFloat(key, field, value);
-        return getResponse(BuilderFactory.DOUBLE);
-    }
-
-    public Response<Double> hincrByFloat(byte[] key, byte[] field, double value) {
-        client.hincrByFloat(key, field, value);
-        return getResponse(BuilderFactory.DOUBLE);
-    }
-
-    public Response<Set<String>> hkeys(String key) {
-        client.hkeys(key);
-        return getResponse(BuilderFactory.STRING_SET);
-    }
-
-    public Response<Set<String>> hkeys(byte[] key) {
-        client.hkeys(key);
-        return getResponse(BuilderFactory.STRING_SET);
-    }
-
-    public Response<Long> hlen(String key) {
-        client.hlen(key);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> hlen(byte[] key) {
-        client.hlen(key);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<List<String>> hmget(String key, String... fields) {
-        client.hmget(key, fields);
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<List<String>> hmget(byte[] key, byte[]... fields) {
-        client.hmget(key, fields);
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<String> hmset(String key, Map<String, String> hash) {
-        client.hmset(key, hash);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> hmset(byte[] key, Map<byte[], byte[]> hash) {
-        client.hmset(key, hash);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> hset(String key, String field, String value) {
-        client.hset(key, field, value);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> hset(byte[] key, byte[] field, byte[] value) {
-        client.hset(key, field, value);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> hsetnx(String key, String field, String value) {
-        client.hsetnx(key, field, value);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> hsetnx(byte[] key, byte[] field, byte[] value) {
-        client.hsetnx(key, field, value);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<List<String>> hvals(String key) {
-        client.hvals(key);
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<List<String>> hvals(byte[] key) {
-        client.hvals(key);
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<Long> incr(String key) {
-        client.incr(key);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> incr(byte[] key) {
-        client.incr(key);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> incrBy(String key, long integer) {
-        client.incrBy(key, integer);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> incrBy(byte[] key, long integer) {
-        client.incrBy(key, integer);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Double> incrByFloat(String key, double value) {
-        client.incrByFloat(key, value);
-        return getResponse(BuilderFactory.DOUBLE);
-    }
-
-    public Response<Double> incrByFloat(byte[] key, double value) {
-        client.incrByFloat(key, value);
-        return getResponse(BuilderFactory.DOUBLE);
-    }
-
-    public Response<Set<String>> keys(String pattern) {
-        client.keys(pattern);
-        return getResponse(BuilderFactory.STRING_SET);
-    }
-
-    public Response<Set<String>> keys(byte[] pattern) {
-        client.keys(pattern);
-        return getResponse(BuilderFactory.STRING_SET);
-    }
-
-    public Response<String> lindex(String key, int index) {
-        client.lindex(key, index);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> lindex(byte[] key, int index) {
-        client.lindex(key, index);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> linsert(String key, LIST_POSITION where,
-            String pivot, String value) {
-        client.linsert(key, where, pivot, value);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> linsert(byte[] key, LIST_POSITION where,
-            byte[] pivot, byte[] value) {
-        client.linsert(key, where, pivot, value);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> llen(String key) {
-        client.llen(key);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> llen(byte[] key) {
-        client.llen(key);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> lpop(String key) {
-        client.lpop(key);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> lpop(byte[] key) {
-        client.lpop(key);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> lpush(String key, String string) {
-        client.lpush(key, string);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> lpush(byte[] key, byte[] string) {
-        client.lpush(key, string);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> lpushx(String key, String string) {
-        client.lpushx(key, string);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> lpushx(byte[] key, byte[] bytes) {
-        client.lpushx(key, bytes);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<List<String>> lrange(String key, long start, long end) {
-        client.lrange(key, start, end);
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<List<String>> lrange(byte[] key, long start, long end) {
-        client.lrange(key, start, end);
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<Long> lrem(String key, long count, String value) {
-        client.lrem(key, count, value);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> lrem(byte[] key, long count, byte[] value) {
-        client.lrem(key, count, value);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> lset(String key, long index, String value) {
-        client.lset(key, index, value);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> lset(byte[] key, long index, byte[] value) {
-        client.lset(key, index, value);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> ltrim(String key, long start, long end) {
-        client.ltrim(key, start, end);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> ltrim(byte[] key, long start, long end) {
-        client.ltrim(key, start, end);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<List<String>> mget(String... keys) {
-        client.mget(keys);
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<List<String>> mget(byte[]... keys) {
-        client.mget(keys);
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<Long> move(String key, int dbIndex) {
-        client.move(key, dbIndex);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> move(byte[] key, int dbIndex) {
-        client.move(key, dbIndex);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> mset(String... keysvalues) {
-        client.mset(keysvalues);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> mset(byte[]... keysvalues) {
-        client.mset(keysvalues);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> msetnx(String... keysvalues) {
-        client.msetnx(keysvalues);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> msetnx(byte[]... keysvalues) {
-        client.msetnx(keysvalues);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> persist(String key) {
-        client.persist(key);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> persist(byte[] key) {
-        client.persist(key);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> rename(String oldkey, String newkey) {
-        client.rename(oldkey, newkey);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> rename(byte[] oldkey, byte[] newkey) {
-        client.rename(oldkey, newkey);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> renamenx(String oldkey, String newkey) {
-        client.renamenx(oldkey, newkey);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> renamenx(byte[] oldkey, byte[] newkey) {
-        client.renamenx(oldkey, newkey);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> rpop(String key) {
-        client.rpop(key);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> rpop(byte[] key) {
-        client.rpop(key);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> rpoplpush(String srckey, String dstkey) {
-        client.rpoplpush(srckey, dstkey);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> rpoplpush(byte[] srckey, byte[] dstkey) {
-        client.rpoplpush(srckey, dstkey);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> rpush(String key, String string) {
-        client.rpush(key, string);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> rpush(byte[] key, byte[] string) {
-        client.rpush(key, string);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> rpushx(String key, String string) {
-        client.rpushx(key, string);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> rpushx(byte[] key, byte[] string) {
-        client.rpushx(key, string);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> sadd(String key, String member) {
-        client.sadd(key, member);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> sadd(byte[] key, byte[] member) {
-        client.sadd(key, member);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> scard(String key) {
-        client.scard(key);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> scard(byte[] key) {
-        client.scard(key);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Set<String>> sdiff(String... keys) {
-        client.sdiff(keys);
-        return getResponse(BuilderFactory.STRING_SET);
-    }
-
-    public Response<Set<String>> sdiff(byte[]... keys) {
-        client.sdiff(keys);
-        return getResponse(BuilderFactory.STRING_SET);
-    }
-
-    public Response<Long> sdiffstore(String dstkey, String... keys) {
-        client.sdiffstore(dstkey, keys);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> sdiffstore(byte[] dstkey, byte[]... keys) {
-        client.sdiffstore(dstkey, keys);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> set(String key, String value) {
-        client.set(key, value);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> set(byte[] key, byte[] value) {
-        client.set(key, value);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Boolean> setbit(String key, long offset, boolean value) {
-        client.setbit(key, offset, value);
-        return getResponse(BuilderFactory.BOOLEAN);
-    }
-
-    public Response<String> setex(String key, int seconds, String value) {
-        client.setex(key, seconds, value);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> setex(byte[] key, int seconds, byte[] value) {
-        client.setex(key, seconds, value);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> setnx(String key, String value) {
-        client.setnx(key, value);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> setnx(byte[] key, byte[] value) {
-        client.setnx(key, value);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> setrange(String key, long offset, String value) {
-        client.setrange(key, offset, value);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Set<String>> sinter(String... keys) {
-        client.sinter(keys);
-        return getResponse(BuilderFactory.STRING_SET);
-    }
-
-    public Response<Set<String>> sinter(byte[]... keys) {
-        client.sinter(keys);
-        return getResponse(BuilderFactory.STRING_SET);
-    }
-
-    public Response<Long> sinterstore(String dstkey, String... keys) {
-        client.sinterstore(dstkey, keys);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> sinterstore(byte[] dstkey, byte[]... keys) {
-        client.sinterstore(dstkey, keys);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Boolean> sismember(String key, String member) {
-        client.sismember(key, member);
-        return getResponse(BuilderFactory.BOOLEAN);
-    }
-
-    public Response<Boolean> sismember(byte[] key, byte[] member) {
-        client.sismember(key, member);
-        return getResponse(BuilderFactory.BOOLEAN);
-    }
-
-    public Response<Set<String>> smembers(String key) {
-        client.smembers(key);
-        return getResponse(BuilderFactory.STRING_SET);
-    }
-
-    public Response<Set<String>> smembers(byte[] key) {
-        client.smembers(key);
-        return getResponse(BuilderFactory.STRING_SET);
-    }
-
-    public Response<Long> smove(String srckey, String dstkey, String member) {
-        client.smove(srckey, dstkey, member);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> smove(byte[] srckey, byte[] dstkey, byte[] member) {
-        client.smove(srckey, dstkey, member);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> sort(String key) {
-        client.sort(key);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> sort(byte[] key) {
-        client.sort(key);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<List<String>> sort(String key,
-            SortingParams sortingParameters) {
-        client.sort(key, sortingParameters);
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<List<String>> sort(byte[] key,
-            SortingParams sortingParameters) {
-        client.sort(key, sortingParameters);
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<List<String>> sort(String key,
-            SortingParams sortingParameters, String dstkey) {
-        client.sort(key, sortingParameters, dstkey);
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<List<String>> sort(byte[] key,
-            SortingParams sortingParameters, byte[] dstkey) {
-        client.sort(key, sortingParameters, dstkey);
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<List<String>> sort(String key, String dstkey) {
-        client.sort(key, dstkey);
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<List<String>> sort(byte[] key, byte[] dstkey) {
-        client.sort(key, dstkey);
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<String> spop(String key) {
-        client.spop(key);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> spop(byte[] key) {
-        client.spop(key);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> srandmember(String key) {
-        client.srandmember(key);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> srandmember(byte[] key) {
-        client.srandmember(key);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> srem(String key, String member) {
-        client.srem(key, member);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> srem(byte[] key, byte[] member) {
-        client.srem(key, member);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> strlen(String key) {
-        client.strlen(key);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> strlen(byte[] key) {
-        client.strlen(key);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> substr(String key, int start, int end) {
-        client.substr(key, start, end);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> substr(byte[] key, int start, int end) {
-        client.substr(key, start, end);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Set<String>> sunion(String... keys) {
-        client.sunion(keys);
-        return getResponse(BuilderFactory.STRING_SET);
-    }
-
-    public Response<Set<String>> sunion(byte[]... keys) {
-        client.sunion(keys);
-        return getResponse(BuilderFactory.STRING_SET);
-    }
-
-    public Response<Long> sunionstore(String dstkey, String... keys) {
-        client.sunionstore(dstkey, keys);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> sunionstore(byte[] dstkey, byte[]... keys) {
-        client.sunionstore(dstkey, keys);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> ttl(String key) {
-        client.ttl(key);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> ttl(byte[] key) {
-        client.ttl(key);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> type(String key) {
-        client.type(key);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> type(byte[] key) {
-        client.type(key);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> watch(String... keys) {
-        client.watch(keys);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> watch(byte[]... keys) {
-        client.watch(keys);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> zadd(String key, double score, String member) {
-        client.zadd(key, score, member);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zadd(byte[] key, double score, byte[] member) {
-        client.zadd(key, score, member);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zcard(String key) {
-        client.zcard(key);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zcard(byte[] key) {
-        client.zcard(key);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zcount(String key, double min, double max) {
-        client.zcount(key, min, max);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zcount(byte[] key, double min, double max) {
-        client.zcount(key, toByteArray(min), toByteArray(max));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Double> zincrby(String key, double score, String member) {
-        client.zincrby(key, score, member);
-        return getResponse(BuilderFactory.DOUBLE);
-    }
-
-    public Response<Double> zincrby(byte[] key, double score, byte[] member) {
-        client.zincrby(key, score, member);
-        return getResponse(BuilderFactory.DOUBLE);
-    }
-
-    public Response<Long> zinterstore(String dstkey, String... sets) {
-        client.zinterstore(dstkey, sets);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zinterstore(byte[] dstkey, byte[]... sets) {
-        client.zinterstore(dstkey, sets);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zinterstore(String dstkey, ZParams params,
-            String... sets) {
-        client.zinterstore(dstkey, params, sets);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zinterstore(byte[] dstkey, ZParams params,
-            byte[]... sets) {
-        client.zinterstore(dstkey, params, sets);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Set<String>> zrange(String key, int start, int end) {
-        client.zrange(key, start, end);
-        return getResponse(BuilderFactory.STRING_ZSET);
-    }
-
-    public Response<Set<String>> zrange(byte[] key, int start, int end) {
-        client.zrange(key, start, end);
-        return getResponse(BuilderFactory.STRING_ZSET);
-    }
-
-    public Response<Set<String>> zrangeByScore(String key, double min,
-            double max) {
-        client.zrangeByScore(key, min, max);
-        return getResponse(BuilderFactory.STRING_ZSET);
-    }
-
-    public Response<Set<String>> zrangeByScore(byte[] key, double min,
-            double max) {
-        return zrangeByScore(key, toByteArray(min), toByteArray(max));
-    }
-    
-    public Response<Set<String>> zrangeByScore(String key, String min,
-            String max) {
-        client.zrangeByScore(key, min, max);
-        return getResponse(BuilderFactory.STRING_ZSET);
-    }
-
-    public Response<Set<String>> zrangeByScore(byte[] key, byte[] min,
-            byte[] max) {
-        client.zrangeByScore(key, min, max);
-        return getResponse(BuilderFactory.STRING_ZSET);
-    }
-
-    public Response<Set<String>> zrangeByScore(String key, double min,
-            double max, int offset, int count) {
-        client.zrangeByScore(key, min, max, offset, count);
-        return getResponse(BuilderFactory.STRING_ZSET);
-    }
-
-    public Response<Set<String>> zrangeByScore(byte[] key, double min,
-            double max, int offset, int count) {
-        return zrangeByScore(key, toByteArray(min), toByteArray(max), offset, count);
-    }
-    
-    public Response<Set<String>> zrangeByScore(byte[] key, byte[] min,
-    		byte[] max, int offset, int count) {
-        client.zrangeByScore(key, min, max, offset, count);
-        return getResponse(BuilderFactory.STRING_ZSET);
-    }
-
-    public Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min,
-            double max) {
-        client.zrangeByScoreWithScores(key, min, max);
-        return getResponse(BuilderFactory.TUPLE_ZSET);
-    }
-
-    public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, double min,
-            double max) {
-        return zrangeByScoreWithScores(key, toByteArray(min), toByteArray(max));
-    }
-    
-    public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, byte[] min,
-    		byte[] max) {
-        client.zrangeByScoreWithScores(key, min, max);
-        return getResponse(BuilderFactory.TUPLE_ZSET);
-    }
-
-    public Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min,
-            double max, int offset, int count) {
-        client.zrangeByScoreWithScores(key, min, max, offset, count);
-        return getResponse(BuilderFactory.TUPLE_ZSET);
-    }
-
-    public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, double min,
-            double max, int offset, int count) {
-        client.zrangeByScoreWithScores(key, toByteArray(min), toByteArray(max), offset, count);
-        return getResponse(BuilderFactory.TUPLE_ZSET);
-    }
-    
-    public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, byte[] min,
-    		byte[] max, int offset, int count) {
-        client.zrangeByScoreWithScores(key, min, max, offset, count);
-        return getResponse(BuilderFactory.TUPLE_ZSET);
-    }
-
-    public Response<Set<String>> zrevrangeByScore(String key, double max,
-            double min) {
-        client.zrevrangeByScore(key, max, min);
-        return getResponse(BuilderFactory.STRING_ZSET);
-    }
-
-    public Response<Set<String>> zrevrangeByScore(byte[] key, double max,
-            double min) {
-        client.zrevrangeByScore(key, toByteArray(max), toByteArray(min));
-        return getResponse(BuilderFactory.STRING_ZSET);
-    }
-
-    public Response<Set<String>> zrevrangeByScore(String key, String max,
-            String min) {
-        client.zrevrangeByScore(key, max, min);
-        return getResponse(BuilderFactory.STRING_ZSET);
-    }
-
-    public Response<Set<String>> zrevrangeByScore(byte[] key, byte[] max,
-            byte[] min) {
-        client.zrevrangeByScore(key, max, min);
-        return getResponse(BuilderFactory.STRING_ZSET);
-    }
-
-    public Response<Set<String>> zrevrangeByScore(String key, double max,
-            double min, int offset, int count) {
-        client.zrevrangeByScore(key, max, min, offset, count);
-        return getResponse(BuilderFactory.STRING_ZSET);
-    }
-
-    public Response<Set<String>> zrevrangeByScore(byte[] key, double max,
-            double min, int offset, int count) {
-        client.zrevrangeByScore(key, toByteArray(max), toByteArray(min), offset, count);
-        return getResponse(BuilderFactory.STRING_ZSET);
-    }
-    
-    public Response<Set<String>> zrevrangeByScore(byte[] key, byte[] max,
-    		byte[] min, int offset, int count) {
-        client.zrevrangeByScore(key, max, min, offset, count);
-        return getResponse(BuilderFactory.STRING_ZSET);
-    }
-
-    public Response<Set<Tuple>> zrevrangeByScoreWithScores(String key,
-            double max, double min) {
-        client.zrevrangeByScoreWithScores(key, max, min);
-        return getResponse(BuilderFactory.TUPLE_ZSET);
-    }
-
-    public Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
-            double max, double min) {
-        client.zrevrangeByScoreWithScores(key, toByteArray(max), toByteArray(min));
-        return getResponse(BuilderFactory.TUPLE_ZSET);
-    }
-    
-    public Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
-    		byte[] max, byte[] min) {
-        client.zrevrangeByScoreWithScores(key, max, min);
-        return getResponse(BuilderFactory.TUPLE_ZSET);
-    }
-
-    public Response<Set<Tuple>> zrevrangeByScoreWithScores(String key,
-            double max, double min, int offset, int count) {
-        client.zrevrangeByScoreWithScores(key, max, min, offset, count);
-        return getResponse(BuilderFactory.TUPLE_ZSET);
-    }
-
-    public Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
-            double max, double min, int offset, int count) {
-        client.zrevrangeByScoreWithScores(key, toByteArray(max), toByteArray(min), offset, count);
-        return getResponse(BuilderFactory.TUPLE_ZSET);
-    }
-    
-    public Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
-    		byte[] max, byte[] min, int offset, int count) {
-        client.zrevrangeByScoreWithScores(key, max, min, offset, count);
-        return getResponse(BuilderFactory.TUPLE_ZSET);
-    }
-
-    public Response<Set<Tuple>> zrangeWithScores(String key, int start, int end) {
-        client.zrangeWithScores(key, start, end);
-        return getResponse(BuilderFactory.TUPLE_ZSET);
-    }
-
-    public Response<Set<Tuple>> zrangeWithScores(byte[] key, int start, int end) {
-        client.zrangeWithScores(key, start, end);
-        return getResponse(BuilderFactory.TUPLE_ZSET);
-    }
-
-    public Response<Long> zrank(String key, String member) {
-        client.zrank(key, member);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zrank(byte[] key, byte[] member) {
-        client.zrank(key, member);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zrem(String key, String member) {
-        client.zrem(key, member);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zrem(byte[] key, byte[] member) {
-        client.zrem(key, member);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zremrangeByRank(String key, int start, int end) {
-        client.zremrangeByRank(key, start, end);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zremrangeByRank(byte[] key, int start, int end) {
-        client.zremrangeByRank(key, start, end);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zremrangeByScore(String key, double start, double end) {
-        client.zremrangeByScore(key, start, end);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zremrangeByScore(byte[] key, double start, double end) {
-        client.zremrangeByScore(key, toByteArray(start), toByteArray(end));
-        return getResponse(BuilderFactory.LONG);
-    }
-    
-    public Response<Long> zremrangeByScore(byte[] key, byte[] start, byte[] end) {
-        client.zremrangeByScore(key, start, end);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Set<String>> zrevrange(String key, int start, int end) {
-        client.zrevrange(key, start, end);
-        return getResponse(BuilderFactory.STRING_ZSET);
-    }
-
-    public Response<Set<String>> zrevrange(byte[] key, int start, int end) {
-        client.zrevrange(key, start, end);
-        return getResponse(BuilderFactory.STRING_ZSET);
-    }
-
-    public Response<Set<Tuple>> zrevrangeWithScores(String key, int start,
-            int end) {
-        client.zrevrangeWithScores(key, start, end);
-        return getResponse(BuilderFactory.TUPLE_ZSET);
-    }
-
-    public Response<Set<Tuple>> zrevrangeWithScores(byte[] key, int start,
-            int end) {
-        client.zrevrangeWithScores(key, start, end);
-        return getResponse(BuilderFactory.TUPLE_ZSET);
-    }
-
-    public Response<Long> zrevrank(String key, String member) {
-        client.zrevrank(key, member);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zrevrank(byte[] key, byte[] member) {
-        client.zrevrank(key, member);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Double> zscore(String key, String member) {
-        client.zscore(key, member);
-        return getResponse(BuilderFactory.DOUBLE);
-    }
-
-    public Response<Double> zscore(byte[] key, byte[] member) {
-        client.zscore(key, member);
-        return getResponse(BuilderFactory.DOUBLE);
-    }
-
-    public Response<Long> zunionstore(String dstkey, String... sets) {
-        client.zunionstore(dstkey, sets);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zunionstore(byte[] dstkey, byte[]... sets) {
-        client.zunionstore(dstkey, sets);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zunionstore(String dstkey, ZParams params,
-            String... sets) {
-        client.zunionstore(dstkey, params, sets);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zunionstore(byte[] dstkey, ZParams params,
-            byte[]... sets) {
-        client.zunionstore(dstkey, params, sets);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> bgrewriteaof() {
-        client.bgrewriteaof();
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> bgsave() {
-        client.bgsave();
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> configGet(String pattern) {
-        client.configGet(pattern);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> configSet(String parameter, String value) {
-        client.configSet(parameter, value);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> brpoplpush(String source, String destination,
-            int timeout) {
-        client.brpoplpush(source, destination, timeout);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> brpoplpush(byte[] source, byte[] destination,
-            int timeout) {
-        client.brpoplpush(source, destination, timeout);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> configResetStat() {
-        client.configResetStat();
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> save() {
-        client.save();
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> lastsave() {
-        client.lastsave();
-        return getResponse(BuilderFactory.LONG);
-    }
-
     public Response<String> discard() {
         client.discard();
         return getResponse(BuilderFactory.STRING);
@@ -1284,59 +109,11 @@ public class Pipeline extends Queable {
         return response;
     }
 
-    public void multi() {
+    public Response<String> multi() {
         client.multi();
-        getResponse(BuilderFactory.STRING); //Expecting OK
+        Response<String> response = getResponse(BuilderFactory.STRING); //Expecting OK
         currentMulti = new MultiResponseBuilder();
+        return response;
     }
 
-    public Response<Long> publish(String channel, String message) {
-        client.publish(channel, message);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> publish(byte[] channel, byte[] message) {
-        client.publish(channel, message);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> flushDB() {
-        client.flushDB();
-        return getResponse(BuilderFactory.STRING);
-    }
-    
-    public Response<String> flushAll() {
-        client.flushAll();
-        return getResponse(BuilderFactory.STRING);
-    }
-    
-    public Response<String> info() {
-        client.info();
-        return getResponse(BuilderFactory.STRING);
-    }
-    
-    public Response<Long> dbSize() {
-        client.dbSize();
-        return getResponse(BuilderFactory.LONG);
-    }
-    
-    public Response<String> shutdown() {
-        client.shutdown();
-        return getResponse(BuilderFactory.STRING);
-    }
-    
-    public Response<String> ping() {
-        client.ping();
-        return getResponse(BuilderFactory.STRING);
-    }
-    
-    public Response<String> randomKey() {
-        client.randomKey();
-        return getResponse(BuilderFactory.STRING);
-    }   
-    
-    public Response<String> select(int index){
-    	client.select(index);
-    	return getResponse(BuilderFactory.STRING);
-    }    
-}
\ No newline at end of file
+}
diff --git a/src/main/java/redis/clients/jedis/PipelineBase.java b/src/main/java/redis/clients/jedis/PipelineBase.java
new file mode 100644
index 0000000..fb79a03
--- /dev/null
+++ b/src/main/java/redis/clients/jedis/PipelineBase.java
@@ -0,0 +1,982 @@
+package redis.clients.jedis;
+
+import redis.clients.jedis.BinaryClient.LIST_POSITION;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import static redis.clients.jedis.Protocol.toByteArray;
+
+abstract class PipelineBase extends Queable implements
+        BinaryRedisPipeline,
+        RedisPipeline {
+    
+    protected abstract Client getClient(String key);
+    
+    protected abstract Client getClient(byte[] key);
+
+    public Response<Long> append(String key, String value) {
+        getClient(key).append(key, value);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> append(byte[] key, byte[] value) {
+        getClient(key).append(key, value);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<List<String>> blpop(String key) {
+        String[] temp = new String[1];
+        temp[0] = key;
+        getClient(key).blpop(temp);
+        return getResponse(BuilderFactory.STRING_LIST);
+    }
+
+    public Response<List<String>> brpop(String key) {
+        String[] temp = new String[1];
+        temp[0] = key;
+        getClient(key).brpop(temp);
+        return getResponse(BuilderFactory.STRING_LIST);
+    }
+
+    public Response<List<byte[]>> blpop(byte[] key) {
+        byte[][] temp = new byte[1][];
+        temp[0] = key;
+        getClient(key).blpop(temp);
+        return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
+    }
+
+    public Response<List<byte[]>> brpop(byte[] key) {
+        byte[][] temp = new byte[1][];
+        temp[0] = key;
+        getClient(key).brpop(temp);
+        return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
+    }
+
+    public Response<Long> decr(String key) {
+        getClient(key).decr(key);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> decr(byte[] key) {
+        getClient(key).decr(key);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> decrBy(String key, long integer) {
+        getClient(key).decrBy(key, integer);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> decrBy(byte[] key, long integer) {
+        getClient(key).decrBy(key, integer);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> del(String key) {
+        getClient(key).del(key);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> del(byte[] key) {
+        getClient(key).del(key);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<String> echo(String string) {
+        getClient(string).echo(string);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<byte[]> echo(byte[] string) {
+        getClient(string).echo(string);
+        return getResponse(BuilderFactory.BYTE_ARRAY);
+    }
+
+    public Response<Boolean> exists(String key) {
+        getClient(key).exists(key);
+        return getResponse(BuilderFactory.BOOLEAN);
+    }
+
+    public Response<Boolean> exists(byte[] key) {
+        getClient(key).exists(key);
+        return getResponse(BuilderFactory.BOOLEAN);
+    }
+
+    public Response<Long> expire(String key, int seconds) {
+        getClient(key).expire(key, seconds);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> expire(byte[] key, int seconds) {
+        getClient(key).expire(key, seconds);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> expireAt(String key, long unixTime) {
+        getClient(key).expireAt(key, unixTime);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> expireAt(byte[] key, long unixTime) {
+        getClient(key).expireAt(key, unixTime);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<String> get(String key) {
+        getClient(key).get(key);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<byte[]> get(byte[] key) {
+        getClient(key).get(key);
+        return getResponse(BuilderFactory.BYTE_ARRAY);
+    }
+
+    public Response<Boolean> getbit(String key, long offset) {
+        getClient(key).getbit(key, offset);
+        return getResponse(BuilderFactory.BOOLEAN);
+    }
+
+    public Response<Boolean> getbit(byte[] key, long offset) {
+        getClient(key).getbit(key, offset);
+        return getResponse(BuilderFactory.BOOLEAN);
+    }
+
+    public Response<String> getrange(String key, long startOffset,
+                                     long endOffset) {
+        getClient(key).getrange(key, startOffset, endOffset);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> getSet(String key, String value) {
+        getClient(key).getSet(key, value);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<byte[]> getSet(byte[] key, byte[] value) {
+        getClient(key).getSet(key, value);
+        return getResponse(BuilderFactory.BYTE_ARRAY);
+    }
+
+    public Response<Long> getrange(byte[] key, long startOffset, long endOffset) {
+        getClient(key).getrange(key, startOffset, endOffset);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> hdel(String key, String field) {
+        getClient(key).hdel(key, field);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> hdel(byte[] key, byte[] field) {
+        getClient(key).hdel(key, field);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Boolean> hexists(String key, String field) {
+        getClient(key).hexists(key, field);
+        return getResponse(BuilderFactory.BOOLEAN);
+    }
+
+    public Response<Boolean> hexists(byte[] key, byte[] field) {
+        getClient(key).hexists(key, field);
+        return getResponse(BuilderFactory.BOOLEAN);
+    }
+
+    public Response<String> hget(String key, String field) {
+        getClient(key).hget(key, field);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<byte[]> hget(byte[] key, byte[] field) {
+        getClient(key).hget(key, field);
+        return getResponse(BuilderFactory.BYTE_ARRAY);
+    }
+
+    public Response<Map<String, String>> hgetAll(String key) {
+        getClient(key).hgetAll(key);
+        return getResponse(BuilderFactory.STRING_MAP);
+    }
+
+    public Response<Map<byte[], byte[]>> hgetAll(byte[] key) {
+        getClient(key).hgetAll(key);
+        return getResponse(BuilderFactory.BYTE_ARRAY_MAP);
+    }
+
+    public Response<Long> hincrBy(String key, String field, long value) {
+        getClient(key).hincrBy(key, field, value);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> hincrBy(byte[] key, byte[] field, long value) {
+        getClient(key).hincrBy(key, field, value);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Double> hincrByFloat(String key, String field, double value) {
+        getClient(key).hincrByFloat(key, field, value);
+        return getResponse(BuilderFactory.DOUBLE);
+    }
+
+    public Response<Double> hincrByFloat(byte[] key, byte[] field, double value) {
+        getClient(key).hincrByFloat(key, field, value);
+        return getResponse(BuilderFactory.DOUBLE);
+    }
+
+    public Response<Set<String>> hkeys(String key) {
+        getClient(key).hkeys(key);
+        return getResponse(BuilderFactory.STRING_SET);
+    }
+
+    public Response<Set<byte[]>> hkeys(byte[] key) {
+        getClient(key).hkeys(key);
+        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
+    }
+
+    public Response<Long> hlen(String key) {
+        getClient(key).hlen(key);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> hlen(byte[] key) {
+        getClient(key).hlen(key);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<List<String>> hmget(String key, String... fields) {
+        getClient(key).hmget(key, fields);
+        return getResponse(BuilderFactory.STRING_LIST);
+    }
+
+    public Response<List<byte[]>> hmget(byte[] key, byte[]... fields) {
+        getClient(key).hmget(key, fields);
+        return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
+    }
+
+    public Response<String> hmset(String key, Map<String, String> hash) {
+        getClient(key).hmset(key, hash);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> hmset(byte[] key, Map<byte[], byte[]> hash) {
+        getClient(key).hmset(key, hash);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Long> hset(String key, String field, String value) {
+        getClient(key).hset(key, field, value);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> hset(byte[] key, byte[] field, byte[] value) {
+        getClient(key).hset(key, field, value);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> hsetnx(String key, String field, String value) {
+        getClient(key).hsetnx(key, field, value);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> hsetnx(byte[] key, byte[] field, byte[] value) {
+        getClient(key).hsetnx(key, field, value);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<List<String>> hvals(String key) {
+        getClient(key).hvals(key);
+        return getResponse(BuilderFactory.STRING_LIST);
+    }
+
+    public Response<List<byte[]>> hvals(byte[] key) {
+        getClient(key).hvals(key);
+        return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
+    }
+
+    public Response<Long> incr(String key) {
+        getClient(key).incr(key);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> incr(byte[] key) {
+        getClient(key).incr(key);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> incrBy(String key, long integer) {
+        getClient(key).incrBy(key, integer);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> incrBy(byte[] key, long integer) {
+        getClient(key).incrBy(key, integer);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Double> incrByFloat(String key, double value) {
+        getClient(key).incrByFloat(key, value);
+        return getResponse(BuilderFactory.DOUBLE);
+    }
+
+    public Response<Double> incrByFloat(byte[] key, double value) {
+        getClient(key).incrByFloat(key, value);
+        return getResponse(BuilderFactory.DOUBLE);
+    }
+
+    public Response<String> lindex(String key, int index) {
+        getClient(key).lindex(key, index);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<byte[]> lindex(byte[] key, int index) {
+        getClient(key).lindex(key, index);
+        return getResponse(BuilderFactory.BYTE_ARRAY);
+    }
+
+    public Response<Long> linsert(String key, LIST_POSITION where,
+                                  String pivot, String value) {
+        getClient(key).linsert(key, where, pivot, value);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> linsert(byte[] key, LIST_POSITION where,
+                                  byte[] pivot, byte[] value) {
+        getClient(key).linsert(key, where, pivot, value);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> llen(String key) {
+        getClient(key).llen(key);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> llen(byte[] key) {
+        getClient(key).llen(key);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<String> lpop(String key) {
+        getClient(key).lpop(key);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<byte[]> lpop(byte[] key) {
+        getClient(key).lpop(key);
+        return getResponse(BuilderFactory.BYTE_ARRAY);
+    }
+
+    public Response<Long> lpush(String key, String... string) {
+        getClient(key).lpush(key, string);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> lpush(byte[] key, byte[]... string) {
+        getClient(key).lpush(key, string);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> lpushx(String key, String... string) {
+        getClient(key).lpushx(key, string);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> lpushx(byte[] key, byte[]... bytes) {
+        getClient(key).lpushx(key, bytes);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<List<String>> lrange(String key, long start, long end) {
+        getClient(key).lrange(key, start, end);
+        return getResponse(BuilderFactory.STRING_LIST);
+    }
+
+    public Response<List<byte[]>> lrange(byte[] key, long start, long end) {
+        getClient(key).lrange(key, start, end);
+        return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
+    }
+
+    public Response<Long> lrem(String key, long count, String value) {
+        getClient(key).lrem(key, count, value);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> lrem(byte[] key, long count, byte[] value) {
+        getClient(key).lrem(key, count, value);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<String> lset(String key, long index, String value) {
+        getClient(key).lset(key, index, value);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> lset(byte[] key, long index, byte[] value) {
+        getClient(key).lset(key, index, value);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> ltrim(String key, long start, long end) {
+        getClient(key).ltrim(key, start, end);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> ltrim(byte[] key, long start, long end) {
+        getClient(key).ltrim(key, start, end);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Long> move(String key, int dbIndex) {
+        getClient(key).move(key, dbIndex);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> move(byte[] key, int dbIndex) {
+        getClient(key).move(key, dbIndex);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> persist(String key) {
+        getClient(key).persist(key);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> persist(byte[] key) {
+        getClient(key).persist(key);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<String> rpop(String key) {
+        getClient(key).rpop(key);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<byte[]> rpop(byte[] key) {
+        getClient(key).rpop(key);
+        return getResponse(BuilderFactory.BYTE_ARRAY);
+    }
+
+    public Response<Long> rpush(String key, String... string) {
+        getClient(key).rpush(key, string);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> rpush(byte[] key, byte[]... string) {
+        getClient(key).rpush(key, string);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> rpushx(String key, String... string) {
+        getClient(key).rpushx(key, string);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> rpushx(byte[] key, byte[]... string) {
+        getClient(key).rpushx(key, string);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> sadd(String key, String... member) {
+        getClient(key).sadd(key, member);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> sadd(byte[] key, byte[]... member) {
+        getClient(key).sadd(key, member);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> scard(String key) {
+        getClient(key).scard(key);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> scard(byte[] key) {
+        getClient(key).scard(key);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<String> set(String key, String value) {
+        getClient(key).set(key, value);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> set(byte[] key, byte[] value) {
+        getClient(key).set(key, value);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Boolean> setbit(String key, long offset, boolean value) {
+        getClient(key).setbit(key, offset, value);
+        return getResponse(BuilderFactory.BOOLEAN);
+    }
+
+    public Response<Boolean> setbit(byte[] key, long offset, byte[] value) {
+        getClient(key).setbit(key, offset, value);
+        return getResponse(BuilderFactory.BOOLEAN);
+    }
+
+    public Response<String> setex(String key, int seconds, String value) {
+        getClient(key).setex(key, seconds, value);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> setex(byte[] key, int seconds, byte[] value) {
+        getClient(key).setex(key, seconds, value);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Long> setnx(String key, String value) {
+        getClient(key).setnx(key, value);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> setnx(byte[] key, byte[] value) {
+        getClient(key).setnx(key, value);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> setrange(String key, long offset, String value) {
+        getClient(key).setrange(key, offset, value);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> setrange(byte[] key, long offset, byte[] value) {
+        getClient(key).setrange(key, offset, value);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Boolean> sismember(String key, String member) {
+        getClient(key).sismember(key, member);
+        return getResponse(BuilderFactory.BOOLEAN);
+    }
+
+    public Response<Boolean> sismember(byte[] key, byte[] member) {
+        getClient(key).sismember(key, member);
+        return getResponse(BuilderFactory.BOOLEAN);
+    }
+
+    public Response<Set<String>> smembers(String key) {
+        getClient(key).smembers(key);
+        return getResponse(BuilderFactory.STRING_SET);
+    }
+
+    public Response<Set<byte[]>> smembers(byte[] key) {
+        getClient(key).smembers(key);
+        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
+    }
+
+    public Response<List<String>> sort(String key) {
+        getClient(key).sort(key);
+        return getResponse(BuilderFactory.STRING_LIST);
+    }
+
+    public Response<List<byte[]>> sort(byte[] key) {
+        getClient(key).sort(key);
+        return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
+    }
+
+    public Response<List<String>> sort(String key,
+                                       SortingParams sortingParameters) {
+        getClient(key).sort(key, sortingParameters);
+        return getResponse(BuilderFactory.STRING_LIST);
+    }
+
+    public Response<List<byte[]>> sort(byte[] key,
+                                       SortingParams sortingParameters) {
+        getClient(key).sort(key, sortingParameters);
+        return getResponse(BuilderFactory.BYTE_ARRAY_LIST);
+    }
+
+    public Response<String> spop(String key) {
+        getClient(key).spop(key);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<byte[]> spop(byte[] key) {
+        getClient(key).spop(key);
+        return getResponse(BuilderFactory.BYTE_ARRAY);
+    }
+
+    public Response<String> srandmember(String key) {
+        getClient(key).srandmember(key);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<byte[]> srandmember(byte[] key) {
+        getClient(key).srandmember(key);
+        return getResponse(BuilderFactory.BYTE_ARRAY);
+    }
+
+    public Response<Long> srem(String key, String member) {
+        getClient(key).srem(key, member);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> srem(byte[] key, byte[] member) {
+        getClient(key).srem(key, member);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> strlen(String key) {
+        getClient(key).strlen(key);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> strlen(byte[] key) {
+        getClient(key).strlen(key);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<String> substr(String key, int start, int end) {
+        getClient(key).substr(key, start, end);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> substr(byte[] key, int start, int end) {
+        getClient(key).substr(key, start, end);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Long> ttl(String key) {
+        getClient(key).ttl(key);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> ttl(byte[] key) {
+        getClient(key).ttl(key);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<String> type(String key) {
+        getClient(key).type(key);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> type(byte[] key) {
+        getClient(key).type(key);
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Long> zadd(String key, double score, String member) {
+        getClient(key).zadd(key, score, member);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zadd(byte[] key, double score, byte[] member) {
+        getClient(key).zadd(key, score, member);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zcard(String key) {
+        getClient(key).zcard(key);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zcard(byte[] key) {
+        getClient(key).zcard(key);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zcount(String key, double min, double max) {
+        getClient(key).zcount(key, min, max);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zcount(byte[] key, double min, double max) {
+        getClient(key).zcount(key, toByteArray(min), toByteArray(max));
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Double> zincrby(String key, double score, String member) {
+        getClient(key).zincrby(key, score, member);
+        return getResponse(BuilderFactory.DOUBLE);
+    }
+
+    public Response<Double> zincrby(byte[] key, double score, byte[] member) {
+        getClient(key).zincrby(key, score, member);
+        return getResponse(BuilderFactory.DOUBLE);
+    }
+
+    public Response<Set<String>> zrange(String key, int start, int end) {
+        getClient(key).zrange(key, start, end);
+        return getResponse(BuilderFactory.STRING_ZSET);
+    }
+
+    public Response<Set<byte[]>> zrange(byte[] key, int start, int end) {
+        getClient(key).zrange(key, start, end);
+        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
+    }
+
+    public Response<Set<String>> zrangeByScore(String key, double min,
+                                               double max) {
+        getClient(key).zrangeByScore(key, min, max);
+        return getResponse(BuilderFactory.STRING_ZSET);
+    }
+
+    public Response<Set<byte[]>> zrangeByScore(byte[] key, double min,
+                                               double max) {
+        return zrangeByScore(key, toByteArray(min), toByteArray(max));
+    }
+
+    public Response<Set<String>> zrangeByScore(String key, String min,
+                                               String max) {
+        getClient(key).zrangeByScore(key, min, max);
+        return getResponse(BuilderFactory.STRING_ZSET);
+    }
+
+    public Response<Set<byte[]>> zrangeByScore(byte[] key, byte[] min,
+                                               byte[] max) {
+        getClient(key).zrangeByScore(key, min, max);
+        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
+    }
+
+    public Response<Set<String>> zrangeByScore(String key, double min,
+                                               double max, int offset, int count) {
+        getClient(key).zrangeByScore(key, min, max, offset, count);
+        return getResponse(BuilderFactory.STRING_ZSET);
+    }
+
+    public Response<Set<byte[]>> zrangeByScore(byte[] key, double min,
+                                               double max, int offset, int count) {
+        return zrangeByScore(key, toByteArray(min), toByteArray(max), offset, count);
+    }
+
+    public Response<Set<byte[]>> zrangeByScore(byte[] key, byte[] min,
+                                               byte[] max, int offset, int count) {
+        getClient(key).zrangeByScore(key, min, max, offset, count);
+        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
+    }
+
+    public Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min,
+                                                        double max) {
+        getClient(key).zrangeByScoreWithScores(key, min, max);
+        return getResponse(BuilderFactory.TUPLE_ZSET);
+    }
+
+    public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, double min,
+                                                        double max) {
+        return zrangeByScoreWithScores(key, toByteArray(min), toByteArray(max));
+    }
+
+    public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, byte[] min,
+                                                        byte[] max) {
+        getClient(key).zrangeByScoreWithScores(key, min, max);
+        return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
+    }
+
+    public Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min,
+                                                        double max, int offset, int count) {
+        getClient(key).zrangeByScoreWithScores(key, min, max, offset, count);
+        return getResponse(BuilderFactory.TUPLE_ZSET);
+    }
+
+    public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, double min,
+                                                        double max, int offset, int count) {
+        getClient(key).zrangeByScoreWithScores(key, toByteArray(min), toByteArray(max), offset, count);
+        return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
+    }
+
+    public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, byte[] min,
+                                                        byte[] max, int offset, int count) {
+        getClient(key).zrangeByScoreWithScores(key, min, max, offset, count);
+        return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
+    }
+
+    public Response<Set<String>> zrevrangeByScore(String key, double max,
+                                                  double min) {
+        getClient(key).zrevrangeByScore(key, max, min);
+        return getResponse(BuilderFactory.STRING_ZSET);
+    }
+
+    public Response<Set<byte[]>> zrevrangeByScore(byte[] key, double max,
+                                                  double min) {
+        getClient(key).zrevrangeByScore(key, toByteArray(max), toByteArray(min));
+        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
+    }
+
+    public Response<Set<String>> zrevrangeByScore(String key, String max,
+                                                  String min) {
+        getClient(key).zrevrangeByScore(key, max, min);
+        return getResponse(BuilderFactory.STRING_ZSET);
+    }
+
+    public Response<Set<byte[]>> zrevrangeByScore(byte[] key, byte[] max,
+                                                  byte[] min) {
+        getClient(key).zrevrangeByScore(key, max, min);
+        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
+    }
+
+    public Response<Set<String>> zrevrangeByScore(String key, double max,
+                                                  double min, int offset, int count) {
+        getClient(key).zrevrangeByScore(key, max, min, offset, count);
+        return getResponse(BuilderFactory.STRING_ZSET);
+    }
+
+    public Response<Set<byte[]>> zrevrangeByScore(byte[] key, double max,
+                                                  double min, int offset, int count) {
+        getClient(key).zrevrangeByScore(key, toByteArray(max), toByteArray(min), offset, count);
+        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
+    }
+
+    public Response<Set<byte[]>> zrevrangeByScore(byte[] key, byte[] max,
+                                                  byte[] min, int offset, int count) {
+        getClient(key).zrevrangeByScore(key, max, min, offset, count);
+        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
+    }
+
+    public Response<Set<Tuple>> zrevrangeByScoreWithScores(String key,
+                                                           double max, double min) {
+        getClient(key).zrevrangeByScoreWithScores(key, max, min);
+        return getResponse(BuilderFactory.TUPLE_ZSET);
+    }
+
+    public Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
+                                                           double max, double min) {
+        getClient(key).zrevrangeByScoreWithScores(key, toByteArray(max), toByteArray(min));
+        return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
+    }
+
+    public Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
+                                                           byte[] max, byte[] min) {
+        getClient(key).zrevrangeByScoreWithScores(key, max, min);
+        return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
+    }
+
+    public Response<Set<Tuple>> zrevrangeByScoreWithScores(String key,
+                                                           double max, double min, int offset, int count) {
+        getClient(key).zrevrangeByScoreWithScores(key, max, min, offset, count);
+        return getResponse(BuilderFactory.TUPLE_ZSET);
+    }
+
+    public Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
+                                                           double max, double min, int offset, int count) {
+        getClient(key).zrevrangeByScoreWithScores(key, toByteArray(max), toByteArray(min), offset, count);
+        return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
+    }
+
+    public Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key,
+                                                           byte[] max, byte[] min, int offset, int count) {
+        getClient(key).zrevrangeByScoreWithScores(key, max, min, offset, count);
+        return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
+    }
+
+    public Response<Set<Tuple>> zrangeWithScores(String key, int start, int end) {
+        getClient(key).zrangeWithScores(key, start, end);
+        return getResponse(BuilderFactory.TUPLE_ZSET);
+    }
+
+    public Response<Set<Tuple>> zrangeWithScores(byte[] key, int start, int end) {
+        getClient(key).zrangeWithScores(key, start, end);
+        return getResponse(BuilderFactory.TUPLE_ZSET_BINARY);
+    }
+
+    public Response<Long> zrank(String key, String member) {
+        getClient(key).zrank(key, member);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zrank(byte[] key, byte[] member) {
+        getClient(key).zrank(key, member);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zrem(String key, String member) {
+        getClient(key).zrem(key, member);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zrem(byte[] key, byte[] member) {
+        getClient(key).zrem(key, member);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zremrangeByRank(String key, int start, int end) {
+        getClient(key).zremrangeByRank(key, start, end);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zremrangeByRank(byte[] key, int start, int end) {
+        getClient(key).zremrangeByRank(key, start, end);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zremrangeByScore(String key, double start, double end) {
+        getClient(key).zremrangeByScore(key, start, end);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zremrangeByScore(byte[] key, double start, double end) {
+        getClient(key).zremrangeByScore(key, toByteArray(start), toByteArray(end));
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zremrangeByScore(byte[] key, byte[] start, byte[] end) {
+        getClient(key).zremrangeByScore(key, start, end);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Set<String>> zrevrange(String key, int start, int end) {
+        getClient(key).zrevrange(key, start, end);
+        return getResponse(BuilderFactory.STRING_ZSET);
+    }
+
+    public Response<Set<byte[]>> zrevrange(byte[] key, int start, int end) {
+        getClient(key).zrevrange(key, start, end);
+        return getResponse(BuilderFactory.BYTE_ARRAY_ZSET);
+    }
+
+    public Response<Set<Tuple>> zrevrangeWithScores(String key, int start,
+                                                    int end) {
+        getClient(key).zrevrangeWithScores(key, start, end);
+        return getResponse(BuilderFactory.TUPLE_ZSET);
+    }
+
+    public Response<Set<Tuple>> zrevrangeWithScores(byte[] key, int start,
+                                                    int end) {
+        getClient(key).zrevrangeWithScores(key, start, end);
+        return getResponse(BuilderFactory.TUPLE_ZSET);
+    }
+
+    public Response<Long> zrevrank(String key, String member) {
+        getClient(key).zrevrank(key, member);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zrevrank(byte[] key, byte[] member) {
+        getClient(key).zrevrank(key, member);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Double> zscore(String key, String member) {
+        getClient(key).zscore(key, member);
+        return getResponse(BuilderFactory.DOUBLE);
+    }
+
+    public Response<Double> zscore(byte[] key, byte[] member) {
+        getClient(key).zscore(key, member);
+        return getResponse(BuilderFactory.DOUBLE);
+    }
+
+    public Response<Long> bitcount(String key) {
+        getClient(key).bitcount(key);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> bitcount(String key, long start, long end) {
+        getClient(key).bitcount(key, start, end);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> bitcount(byte[] key) {
+        getClient(key).bitcount(key);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> bitcount(byte[] key, long start, long end) {
+        getClient(key).bitcount(key, start, end);
+        return getResponse(BuilderFactory.LONG);
+    }
+
+}
diff --git a/src/main/java/redis/clients/jedis/Protocol.java b/src/main/java/redis/clients/jedis/Protocol.java
index e061ae5..5dc692f 100644
--- a/src/main/java/redis/clients/jedis/Protocol.java
+++ b/src/main/java/redis/clients/jedis/Protocol.java
@@ -24,6 +24,12 @@ public final class Protocol {
     public static final byte MINUS_BYTE = '-';
     public static final byte COLON_BYTE = ':';
 
+    public static final String SENTINEL_MASTERS = "masters";
+    public static final String SENTINEL_GET_MASTER_ADDR_BY_NAME = "get-master-addr-by-name";
+    public static final String SENTINEL_RESET = "reset";
+    public static final String SENTINEL_SLAVES = "slaves";
+    public static final String SENTINEL_IS_MASTER_DOWN_BY_ADDR = "is-master-down-by-addr";
+
     private Protocol() {
 	// this prevent the class from instantiation
     }
@@ -131,6 +137,10 @@ public final class Protocol {
 	return process(is);
     }
 
+    public static final byte[] toByteArray(final boolean value) {
+    return toByteArray(value ? 1 : 0);
+    }
+
     public static final byte[] toByteArray(final int value) {
 	return SafeEncoder.encode(String.valueOf(value));
     }
@@ -144,7 +154,7 @@ public final class Protocol {
     }
 
     public static enum Command {
-	PING, SET, GET, QUIT, EXISTS, DEL, TYPE, FLUSHDB, KEYS, RANDOMKEY, RENAME, RENAMENX, RENAMEX, DBSIZE, EXPIRE, EXPIREAT, TTL, SELECT, MOVE, FLUSHALL, GETSET, MGET, SETNX, SETEX, MSET, MSETNX, DECRBY, DECR, INCRBY, INCRBYFLOAT, INCR, APPEND, SUBSTR, HSET, HGET, HSETNX, HMSET, HMGET, HINCRBY, HINCRBYFLOAT, HEXISTS, HDEL, HLEN, HKEYS, HVALS, HGETALL, RPUSH, LPUSH, LLEN, LRANGE, LTRIM, LINDEX, LSET, LREM, LPOP, RPOP, RPOPLPUSH, SADD, SMEMBERS, SREM, SPOP, SMOVE, SCARD, SISMEMBER, SINTER, SINTERSTORE, SUNION, SUNIONSTORE, SDIFF, SDIFFSTORE, SRANDMEMBER, ZADD, ZRANGE, ZREM, ZINCRBY, ZRANK, ZREVRANK, ZREVRANGE, ZCARD, ZSCORE, MULTI, DISCARD, EXEC, WATCH, UNWATCH, SORT, BLPOP, BRPOP, AUTH, SUBSCRIBE, PUBLISH, UNSUBSCRIBE, PSUBSCRIBE, PUNSUBSCRIBE, ZCOUNT, ZRANGEBYSCORE, ZREVRANGEBYSCORE, ZREMRANGEBYRANK, ZREMRANGEBYSCORE, ZUNIONSTORE, ZINTERSTORE, SAVE, BGSAVE, BGREWRITEAOF, LASTSAVE, SHUTDOWN, INFO, MONITOR, SLAVEOF, CONFIG, STRLEN, SYNC, LPUSHX, PERSIST, RPUSHX, ECHO, LINSERT, DEBUG, BRPOPLPUSH, SETBIT, GETBIT, SETRANGE, GETRANGE, EVAL, EVALSHA, SCRIPT, SLOWLOG, OBJECT;
+	PING, SET, GET, QUIT, EXISTS, DEL, TYPE, FLUSHDB, KEYS, RANDOMKEY, RENAME, RENAMENX, RENAMEX, DBSIZE, EXPIRE, EXPIREAT, TTL, SELECT, MOVE, FLUSHALL, GETSET, MGET, SETNX, SETEX, MSET, MSETNX, DECRBY, DECR, INCRBY, INCRBYFLOAT, INCR, APPEND, SUBSTR, HSET, HGET, HSETNX, HMSET, HMGET, HINCRBY, HINCRBYFLOAT, HEXISTS, HDEL, HLEN, HKEYS, HVALS, HGETALL, RPUSH, LPUSH, LLEN, LRANGE, LTRIM, LINDEX, LSET, LREM, LPOP, RPOP, RPOPLPUSH, SADD, SMEMBERS, SREM, SPOP, SMOVE, SCARD, SISMEMBER, SINTER, SINTERSTORE, SUNION, SUNIONSTORE, SDIFF, SDIFFSTORE, SRANDMEMBER, ZADD, ZRANGE, ZREM, ZINCRBY, ZRANK, ZREVRANK, ZREVRANGE, ZCARD, ZSCORE, MULTI, DISCARD, EXEC, WATCH, UNWATCH, SORT, BLPOP, BRPOP, AUTH, SUBSCRIBE, PUBLISH, UNSUBSCRIBE, PSUBSCRIBE, PUNSUBSCRIBE, ZCOUNT, ZRANGEBYSCORE, ZREVRANGEBYSCORE, ZREMRANGEBYRANK, ZREMRANGEBYSCORE, ZUNIONSTORE, ZINTERSTORE, SAVE, BGSAVE, BGREWRITEAOF, LASTSAVE, SHUTDOWN, INFO, MONITOR, SLAVEOF, CONFIG, STRLEN, SYNC, LPUSHX, PERSIST, RPUSHX, ECHO, LINSERT, DEBUG, BRPOPLPUSH, SETBIT, GETBIT, SETRANGE, GETRANGE, EVAL, EVALSHA, SCRIPT, SLOWLOG, OBJECT, BITCOUNT, BITOP, SENTINEL;
 
 	public final byte[] raw;
 
@@ -154,7 +164,7 @@ public final class Protocol {
     }
 
     public static enum Keyword {
-	AGGREGATE, ALPHA, ASC, BY, DESC, GET, LIMIT, MESSAGE, NO, NOSORT, PMESSAGE, PSUBSCRIBE, PUNSUBSCRIBE, OK, ONE, QUEUED, SET, STORE, SUBSCRIBE, UNSUBSCRIBE, WEIGHTS, WITHSCORES, RESETSTAT, RESET, FLUSH, EXISTS, LOAD, KILL, LEN, REFCOUNT, ENCODING, IDLETIME;
+	AGGREGATE, ALPHA, ASC, BY, DESC, GET, LIMIT, MESSAGE, NO, NOSORT, PMESSAGE, PSUBSCRIBE, PUNSUBSCRIBE, OK, ONE, QUEUED, SET, STORE, SUBSCRIBE, UNSUBSCRIBE, WEIGHTS, WITHSCORES, RESETSTAT, RESET, FLUSH, EXISTS, LOAD, KILL, LEN, REFCOUNT, ENCODING, IDLETIME, AND, OR, XOR, NOT;
 	public final byte[] raw;
 
 	Keyword() {
diff --git a/src/main/java/redis/clients/jedis/RedisPipeline.java b/src/main/java/redis/clients/jedis/RedisPipeline.java
new file mode 100644
index 0000000..43b7516
--- /dev/null
+++ b/src/main/java/redis/clients/jedis/RedisPipeline.java
@@ -0,0 +1,200 @@
+package redis.clients.jedis;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * @author guy
+ */
+public interface RedisPipeline {
+    Response<Long> append(String key, String value);
+
+    Response<List<String>> blpop(String arg);
+
+    Response<List<String>> brpop(String arg);
+
+    Response<Long> decr(String key);
+
+    Response<Long> decrBy(String key, long integer);
+
+    Response<Long> del(String key);
+
+    Response<String> echo(String string);
+
+    Response<Boolean> exists(String key);
+
+    Response<Long> expire(String key, int seconds);
+
+    Response<Long> expireAt(String key, long unixTime);
+
+    Response<String> get(String key);
+
+    Response<Boolean> getbit(String key, long offset);
+
+
+
+    Response<String> getrange(String key, long startOffset,
+                              long endOffset);
+
+    Response<String> getSet(String key, String value);
+
+    Response<Long> hdel(String key, String field);
+
+    Response<Boolean> hexists(String key, String field);
+
+    Response<String> hget(String key, String field);
+
+    Response<Map<String, String>> hgetAll(String key);
+
+    Response<Long> hincrBy(String key, String field, long value);
+
+    Response<Set<String>> hkeys(String key);
+
+    Response<Long> hlen(String key);
+
+    Response<List<String>> hmget(String key, String... fields);
+
+    Response<String> hmset(String key, Map<String, String> hash);
+
+    Response<Long> hset(String key, String field, String value);
+
+    Response<Long> hsetnx(String key, String field, String value);
+
+    Response<List<String>> hvals(String key);
+
+    Response<Long> incr(String key);
+
+    Response<Long> incrBy(String key, long integer);
+
+    Response<String> lindex(String key, int index);
+
+    Response<Long> linsert(String key, BinaryClient.LIST_POSITION where,
+                           String pivot, String value);
+
+    Response<Long> llen(String key);
+
+    Response<String> lpop(String key);
+
+    Response<Long> lpush(String key, String... string);
+
+    Response<Long> lpushx(String key, String... string);
+
+    Response<List<String>> lrange(String key, long start, long end);
+
+    Response<Long> lrem(String key, long count, String value);
+
+    Response<String> lset(String key, long index, String value);
+
+    Response<String> ltrim(String key, long start, long end);
+
+    Response<Long> move(String key, int dbIndex);
+
+    Response<Long> persist(String key);
+
+    Response<String> rpop(String key);
+
+    Response<Long> rpush(String key, String... string);
+
+    Response<Long> rpushx(String key, String... string);
+
+    Response<Long> sadd(String key, String... member);
+
+    Response<Long> scard(String key);
+
+    Response<Boolean> sismember(String key, String member);
+
+    Response<String> set(String key, String value);
+
+    Response<Boolean> setbit(String key, long offset, boolean value);
+
+    Response<String> setex(String key, int seconds, String value);
+
+    Response<Long> setnx(String key, String value);
+
+    Response<Long> setrange(String key, long offset, String value);
+
+    Response<Set<String>> smembers(String key);
+
+    Response<List<String>> sort(String key);
+
+    Response<List<String>> sort(String key,
+                                SortingParams sortingParameters);
+
+    Response<String> spop(String key);
+
+    Response<String> srandmember(String key);
+
+    Response<Long> srem(String key, String member);
+
+    Response<Long> strlen(String key);
+
+    Response<String> substr(String key, int start, int end);
+
+    Response<Long> ttl(String key);
+
+    Response<String> type(String key);
+
+    Response<Long> zadd(String key, double score, String member);
+
+    Response<Long> zcard(String key);
+
+    Response<Long> zcount(String key, double min, double max);
+
+    Response<Double> zincrby(String key, double score, String member);
+
+    Response<Set<String>> zrange(String key, int start, int end);
+
+    Response<Set<String>> zrangeByScore(String key, double min,
+                                        double max);
+
+    Response<Set<String>> zrangeByScore(String key, String min,
+                                        String max);
+
+    Response<Set<String>> zrangeByScore(String key, double min,
+                                        double max, int offset, int count);
+
+    Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min,
+                                                 double max);
+
+    Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min,
+                                                 double max, int offset, int count);
+
+    Response<Set<String>> zrevrangeByScore(String key, double max,
+                                           double min);
+
+    Response<Set<String>> zrevrangeByScore(String key, String max,
+                                           String min);
+
+    Response<Set<String>> zrevrangeByScore(String key, double max,
+                                           double min, int offset, int count);
+
+    Response<Set<Tuple>> zrevrangeByScoreWithScores(String key,
+                                                    double max, double min);
+
+    Response<Set<Tuple>> zrevrangeByScoreWithScores(String key,
+                                                    double max, double min, int offset, int count);
+
+    Response<Set<Tuple>> zrangeWithScores(String key, int start, int end);
+
+    Response<Long> zrank(String key, String member);
+
+    Response<Long> zrem(String key, String member);
+
+    Response<Long> zremrangeByRank(String key, int start, int end);
+
+    Response<Long> zremrangeByScore(String key, double start, double end);
+
+    Response<Set<String>> zrevrange(String key, int start, int end);
+
+    Response<Set<Tuple>> zrevrangeWithScores(String key, int start,
+                                             int end);
+
+    Response<Long> zrevrank(String key, String member);
+
+    Response<Double> zscore(String key, String member);
+
+    Response<Long> bitcount(String key);
+
+    Response<Long> bitcount(String key, long start, long end);
+}
diff --git a/src/main/java/redis/clients/jedis/ScriptingCommands.java b/src/main/java/redis/clients/jedis/ScriptingCommands.java
new file mode 100644
index 0000000..ba693a4
--- /dev/null
+++ b/src/main/java/redis/clients/jedis/ScriptingCommands.java
@@ -0,0 +1,23 @@
+package redis.clients.jedis;
+
+import java.util.List;
+
+public interface ScriptingCommands {
+    Object eval(String script, int keyCount, String... params);
+
+    Object eval(String script, List<String> keys, List<String> args);
+
+    Object eval(String script);
+
+    Object evalsha(String script);
+
+    Object evalsha(String sha1, List<String> keys, List<String> args);
+
+    Object evalsha(String sha1, int keyCount, String... params);
+
+    Boolean scriptExists(String sha1);
+
+    List<Boolean> scriptExists(String... sha1);
+
+    String scriptLoad(String script);
+}
diff --git a/src/main/java/redis/clients/jedis/ShardedJedis.java b/src/main/java/redis/clients/jedis/ShardedJedis.java
index 6e45e26..1572299 100644
--- a/src/main/java/redis/clients/jedis/ShardedJedis.java
+++ b/src/main/java/redis/clients/jedis/ShardedJedis.java
@@ -1,13 +1,13 @@
 package redis.clients.jedis;
 
+import redis.clients.jedis.BinaryClient.LIST_POSITION;
+import redis.clients.util.Hashing;
+
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.regex.Pattern;
 
-import redis.clients.jedis.BinaryClient.LIST_POSITION;
-import redis.clients.util.Hashing;
-
 public class ShardedJedis extends BinaryShardedJedis implements JedisCommands {
     public ShardedJedis(List<JedisShardInfo> shards) {
 	super(shards);
@@ -26,13 +26,6 @@ public class ShardedJedis extends BinaryShardedJedis implements JedisCommands {
 	super(shards, algo, keyTagPattern);
     }
 
-    public void disconnect() {
-	for (Jedis jedis : getAllShards()) {
-	    jedis.quit();
-	    jedis.disconnect();
-	}
-    }
-
     public String set(String key, String value) {
 	Jedis j = getShard(key);
 	return j.set(key, value);
@@ -43,6 +36,11 @@ public class ShardedJedis extends BinaryShardedJedis implements JedisCommands {
 	return j.get(key);
     }
 
+    public String echo(String string) {
+        Jedis j = getShard(string);
+        return j.echo(string);
+    }
+
     public Boolean exists(String key) {
 	Jedis j = getShard(key);
 	return j.exists(key);
@@ -73,6 +71,11 @@ public class ShardedJedis extends BinaryShardedJedis implements JedisCommands {
 	return j.setbit(key, offset, value);
     }
 
+    public Boolean setbit(String key, long offset, String value) {
+    Jedis j = getShard(key);
+    return j.setbit(key, offset, value);
+    }
+
     public Boolean getbit(String key, long offset) {
 	Jedis j = getShard(key);
 	return j.getbit(key, offset);
@@ -103,6 +106,16 @@ public class ShardedJedis extends BinaryShardedJedis implements JedisCommands {
 	return j.setex(key, seconds, value);
     }
 
+    public List<String> blpop(String arg) {
+        Jedis j = getShard(arg);
+        return j.blpop(arg);
+    }
+
+    public List<String> brpop(String arg) {
+        Jedis j = getShard(arg);
+        return j.brpop(arg);
+    }
+
     public Long decrBy(String key, long integer) {
 	Jedis j = getShard(key);
 	return j.decrBy(key, integer);
@@ -218,16 +231,31 @@ public class ShardedJedis extends BinaryShardedJedis implements JedisCommands {
 	return j.lpush(key, strings);
     }
 
-    public Long lpushx(String key, String string) {
+    public Long lpushx(String key, String... string) {
 	Jedis j = getShard(key);
 	return j.lpushx(key, string);
     }
 
-    public Long rpushx(String key, String string) {
+    public Long strlen(final String key) {
+    Jedis j = getShard(key);
+    return j.strlen(key);
+    }
+
+    public Long move(String key, int dbIndex) {
+        Jedis j = getShard(key);
+        return j.move(key, dbIndex);
+    }
+
+    public Long rpushx(String key, String... string) {
 	Jedis j = getShard(key);
 	return j.rpushx(key, string);
     }
 
+    public Long persist(final String key) {
+    Jedis j = getShard(key);
+    return j.persist(key);
+    }
+
     public Long llen(String key) {
 	Jedis j = getShard(key);
 	return j.llen(key);
@@ -493,4 +521,16 @@ public class ShardedJedis extends BinaryShardedJedis implements JedisCommands {
 	Jedis j = getShard(key);
 	return j.linsert(key, where, pivot, value);
     }
+
+    public Long bitcount(final String key) {
+	Jedis j = getShard(key);
+	return j.bitcount(key);
+    }
+
+    public Long bitcount(final String key, long start, long end) {
+	Jedis j = getShard(key);
+	return j.bitcount(key, start, end);
+    }
+
+
 }
diff --git a/src/main/java/redis/clients/jedis/ShardedJedisPipeline.java b/src/main/java/redis/clients/jedis/ShardedJedisPipeline.java
index e8eeed7..be6db92 100644
--- a/src/main/java/redis/clients/jedis/ShardedJedisPipeline.java
+++ b/src/main/java/redis/clients/jedis/ShardedJedisPipeline.java
@@ -1,10 +1,11 @@
 package redis.clients.jedis;
 
-import redis.clients.jedis.BinaryClient.LIST_POSITION;
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
 
-import java.util.*;
-
-public class ShardedJedisPipeline extends Queable {
+public class ShardedJedisPipeline extends PipelineBase {
     private BinaryShardedJedis jedis;
     private List<FutureResult> results = new ArrayList<FutureResult>();
     private Queue<Client> clients = new LinkedList<Client>();
@@ -25,521 +26,6 @@ public class ShardedJedisPipeline extends Queable {
         this.jedis = jedis;
     }
 
-    public Response<String> set(String key, String value) {
-        Client c = getClient(key);
-        c.set(key, value);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> get(String key) {
-        Client c = getClient(key);
-        c.get(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> del(String key) {
-        Client c = getClient(key);
-        c.del(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Boolean> exists(String key) {
-        Client c = getClient(key);
-        c.exists(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BOOLEAN);
-    }
-
-    public Response<Boolean> type(String key) {
-        Client c = getClient(key);
-        c.type(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BOOLEAN);
-    }
-
-    public Response<Long> expire(String key, int seconds) {
-        Client c = getClient(key);
-        c.expire(key, seconds);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> expireAt(String key, long unixTime) {
-        Client c = getClient(key);
-        c.expireAt(key, unixTime);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> ttl(String key) {
-        Client c = getClient(key);
-        c.ttl(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> getSet(String key, String value) {
-        Client c = getClient(key);
-        c.getSet(key, value);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> setnx(String key, String value) {
-        Client c = getClient(key);
-        c.setnx(key, value);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> setex(String key, int seconds, String value) {
-        Client c = getClient(key);
-        c.setex(key, seconds, value);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);        
-    }
-
-    public Response<Long> decrBy(String key, long integer) {
-        Client c = getClient(key);
-        c.decrBy(key, integer);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> decr(String key) {
-        Client c = getClient(key);
-        c.decr(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> incrBy(String key, int integer) {
-        Client c = getClient(key);
-        c.incrBy(key, integer);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Double> incrByFloat(String key, double value) {
-        Client c = getClient(key);
-        c.incrByFloat(key, value);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.DOUBLE);
-    }
-
-    public Response<Long> incr(String key) {
-        Client c = getClient(key);
-        c.incr(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> append(String key, String value) {
-        Client c = getClient(key);
-        c.append(key, value);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> substr(String key, int start, int end) {
-        Client c = getClient(key);
-        c.substr(key, start, end);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> hset(String key, String field, String value) {
-        Client c = getClient(key);
-        c.hset(key, field, value);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> hget(String key, String field) {
-        Client c = getClient(key);
-        c.hget(key, field);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> hsetnx(String key, String field, String value) {
-        Client c = getClient(key);
-        c.hsetnx(key, field, value);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> hmset(String key, Map<String, String> hash) {
-        Client c = getClient(key);
-        c.hmset(key, hash);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<List<String>> hmget(String key, String... fields) {
-        Client c = getClient(key);
-        c.hmget(key, fields);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<Long> hincrBy(String key, String field, int value) {
-        Client c = getClient(key);
-        c.hincrBy(key, field, value);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Double> hincrByFloat(String key, String field, double value) {
-        Client c = getClient(key);
-        c.hincrByFloat(key, field, value);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.DOUBLE);
-    }
-
-    public Response<Boolean> hexists(String key, String field) {
-        Client c = getClient(key);
-        c.hexists(key, field);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BOOLEAN);
-    }
-
-    public Response<Long> hdel(String key, String field) {
-        Client c = getClient(key);
-        c.hdel(key, field);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> hlen(String key) {
-        Client c = getClient(key);
-        c.hlen(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Set<String>> hkeys(String key) {
-        Client c = getClient(key);
-        c.hkeys(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING_SET);
-    }
-
-    public Response<Set<String>> hvals(String key) {
-        Client c = getClient(key);
-        c.hvals(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING_SET);
-    }
-
-    public Response<Map<String, String>> hgetAll(String key) {
-        Client c = getClient(key);
-        c.hgetAll(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING_MAP);
-    }
-
-    public Response<Long> rpush(String key, String string) {
-        Client c = getClient(key);
-        c.rpush(key, string);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> lpush(String key, String string) {
-        Client c = getClient(key);
-        c.lpush(key, string);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> llen(String key) {
-        Client c = getClient(key);
-        c.llen(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<List<String>> lrange(String key, int start, int end) {
-        Client c = getClient(key);
-        c.lrange(key, start, end);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<String> ltrim(String key, int start, int end) {
-        Client c = getClient(key);
-        c.ltrim(key, start, end);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> lindex(String key, int index) {
-        Client c = getClient(key);
-        c.lindex(key, index);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> lset(String key, int index, String value) {
-        Client c = getClient(key);
-        c.lset(key, index, value);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> lrem(String key, int count, String value) {
-        Client c = getClient(key);
-        c.lrem(key, count, value);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> lpop(String key) {
-        Client c = getClient(key);
-        c.lpop(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> rpop(String key) {
-        Client c = getClient(key);
-        c.rpop(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> sadd(String key, String member) {
-        Client c = getClient(key);
-        c.sadd(key, member);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Set<String>> smembers(String key) {
-        Client c = getClient(key);
-        c.smembers(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING_SET);
-    }
-
-    public Response<Long> srem(String key, String member) {
-        Client c = getClient(key);
-        c.srem(key, member);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> spop(String key) {
-        Client c = getClient(key);
-        c.spop(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> scard(String key) {
-        Client c = getClient(key);
-        c.scard(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Boolean> sismember(String key, String member) {
-        Client c = getClient(key);
-        c.sismember(key, member);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BOOLEAN);
-    }
-
-    public Response<String> srandmember(String key) {
-        Client c = getClient(key);
-        c.srandmember(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> zadd(String key, double score, String member) {
-        Client c = getClient(key);
-        c.zadd(key, score, member);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Set<String>> zrange(String key, int start, int end) {
-        Client c = getClient(key);
-        c.zrange(key, start, end);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING_ZSET);
-    }
-
-    public Response<Long> zrem(String key, String member) {
-        Client c = getClient(key);
-        c.zrem(key, member);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Double> zincrby(String key, double score, String member) {
-        Client c = getClient(key);
-        c.zincrby(key, score, member);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.DOUBLE);
-    }
-
-    public Response<Long> zrank(String key, String member) {
-        Client c = getClient(key);
-        c.zrank(key, member);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zrevrank(String key, String member) {
-        Client c = getClient(key);
-        c.zrevrank(key, member);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Set<String>> zrevrange(String key, int start, int end) {
-        Client c = getClient(key);
-        c.zrevrange(key, start, end);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING_ZSET);
-    }
-
-    public Response<Set<Tuple>> zrangeWithScores(String key, int start, int end) {
-        Client c = getClient(key);
-        c.zrangeWithScores(key, start, end);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.TUPLE_ZSET);
-    }
-
-    public Response<Set<Tuple>> zrevrangeWithScores(String key, int start, int end) {
-        Client c = getClient(key);
-        c.zrevrangeWithScores(key, start, end);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.TUPLE_ZSET);
-    }
-
-    public Response<Long> zcard(String key) {
-        Client c = getClient(key);
-        c.zcard(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Double> zscore(String key, String member) {
-        Client c = getClient(key);
-        c.zscore(key, member);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.DOUBLE);
-    }
-
-    public Response<Double> sort(String key) {
-        Client c = getClient(key);
-        c.sort(key);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.DOUBLE);
-    }
-
-    public Response<List<String>> sort(String key, SortingParams sortingParameters) {
-        Client c = getClient(key);
-        c.sort(key, sortingParameters);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<Long> zcount(String key, double min, double max) {
-        Client c = getClient(key);
-        c.zcount(key, min, max);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Set<String>> zrangeByScore(String key, double min, double max) {
-        Client c = getClient(key);
-        c.zrangeByScore(key, min, max);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING_ZSET);
-    }
-
-    public Response<Set<String>> zrangeByScore(String key, double min, double max,
-                                               int offset, int count) {
-        Client c = getClient(key);
-        c.zrangeByScore(key, min, max, offset, count);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.STRING_ZSET);
-    }
-
-    public Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min, double max) {
-        Client c = getClient(key);
-        c.zrangeByScoreWithScores(key, min, max);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.TUPLE_ZSET);
-    }
-
-    public Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min, double max,
-            int offset, int count) {
-        Client c = getClient(key);
-        c.zrangeByScoreWithScores(key, min, max, offset, count);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.TUPLE_ZSET);
-    }
-
-    public Response<Long> zremrangeByRank(String key, int start, int end) {
-        Client c = getClient(key);
-        c.zremrangeByRank(key, start, end);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zremrangeByScore(String key, double start, double end) {
-        Client c = getClient(key);
-        c.zremrangeByScore(key, start, end);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> linsert(String key, LIST_POSITION where, String pivot,
-                                  String value) {
-        Client c = getClient(key);
-        c.linsert(key, where, pivot, value);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Boolean> getbit(String key, long offset) {
-        Client c = getClient(key);
-        c.getbit(key, offset);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BOOLEAN);
-    }
-
-    public Response<Boolean> setbit(String key, long offset, boolean value) {
-        Client c = getClient(key);
-        c.setbit(key, offset, value);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.BOOLEAN);
-    }
-
-    public Response<Long> setrange(String key, long offset, String value) {
-        Client c = getClient(key);
-        c.setrange(key, offset, value);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-
-    }
-
-    public Response<Long> getrange(String key, long startOffset, long endOffset) {
-        Client c = getClient(key);
-        c.getrange(key, startOffset, endOffset);
-        results.add(new FutureResult(c));
-        return getResponse(BuilderFactory.LONG);
-    }
-
     public List<Object> getResults() {
         List<Object> r = new ArrayList<Object>();
         for (FutureResult fr : results) {
@@ -583,9 +69,19 @@ public class ShardedJedisPipeline extends Queable {
     public void execute() {
     }
 
-    private Client getClient(String key) {
+    @Override
+    protected Client getClient(String key) {
         Client client = jedis.getShard(key).getClient();
         clients.add(client);
+        results.add(new FutureResult(client));
+        return client;
+    }
+
+    @Override
+    protected Client getClient(byte[] key) {
+        Client client = jedis.getShard(key).getClient();
+        clients.add(client);
+        results.add(new FutureResult(client));
         return client;
     }
 }
\ No newline at end of file
diff --git a/src/main/java/redis/clients/jedis/Transaction.java b/src/main/java/redis/clients/jedis/Transaction.java
index 18c5f29..bca7157 100644
--- a/src/main/java/redis/clients/jedis/Transaction.java
+++ b/src/main/java/redis/clients/jedis/Transaction.java
@@ -1,579 +1,75 @@
 package redis.clients.jedis;
 
+import redis.clients.jedis.exceptions.JedisDataException;
+
+import java.util.ArrayList;
 import java.util.List;
-import java.util.Map;
-import java.util.Set;
 
-import redis.clients.jedis.BinaryClient.LIST_POSITION;
+/**
+ * Transaction is nearly identical to Pipeline, only differences are the multi/discard behaviors
+ */
+public class Transaction extends MultiKeyPipelineBase {
 
-public class Transaction extends BinaryTransaction {
-    public Transaction() {
+    protected boolean inTransaction = true;
+
+    protected Transaction(){
+        // client will be set later in transaction block
     }
 
     public Transaction(final Client client) {
-        super(client);
+        this.client = client;
     }
 
-    public Response<Long> append(String key, String value) {
-        client.append(key, value);
-        return getResponse(BuilderFactory.LONG);
+    @Override
+    protected Client getClient(String key) {
+        return client;
     }
 
-    public Response<List<String>> blpop(String... args) {
-        client.blpop(args);
-        return getResponse(BuilderFactory.STRING_LIST);
+    @Override
+    protected Client getClient(byte[] key) {
+        return client;
     }
 
-    public Response<List<String>> brpop(String... args) {
-        client.brpop(args);
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<Long> decr(String key) {
-        client.decr(key);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> decrBy(String key, long integer) {
-        client.decrBy(key, integer);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> del(String... keys) {
-        client.del(keys);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> echo(String string) {
-        client.echo(string);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Boolean> exists(String key) {
-        client.exists(key);
-        return getResponse(BuilderFactory.BOOLEAN);
-    }
-
-    public Response<Long> expire(String key, int seconds) {
-        client.expire(key, seconds);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> expireAt(String key, long unixTime) {
-        client.expireAt(key, unixTime);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> get(String key) {
-        client.get(key);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Boolean> getbit(String key, long offset) {
-        client.getbit(key, offset);
-        return getResponse(BuilderFactory.BOOLEAN);
-    }
-
-    public Response<String> getrange(String key, long startOffset,
-            long endOffset) {
-        client.getrange(key, startOffset, endOffset);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> getSet(String key, String value) {
-        client.getSet(key, value);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> hdel(String key, String field) {
-        client.hdel(key, field);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Boolean> hexists(String key, String field) {
-        client.hexists(key, field);
-        return getResponse(BuilderFactory.BOOLEAN);
-    }
-
-    public Response<String> hget(String key, String field) {
-        client.hget(key, field);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Map<String, String>> hgetAll(String key) {
-        client.hgetAll(key);
-        return getResponse(BuilderFactory.STRING_MAP);
-    }
-
-    public Response<Long> hincrBy(String key, String field, long value) {
-        client.hincrBy(key, field, value);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Set<String>> hkeys(String key) {
-        client.hkeys(key);
-        return getResponse(BuilderFactory.STRING_SET);
-    }
-
-    public Response<Long> hlen(String key) {
-        client.hlen(key);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<List<String>> hmget(String key, String... fields) {
-        client.hmget(key, fields);
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<String> hmset(String key, Map<String, String> hash) {
-        client.hmset(key, hash);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> hset(String key, String field, String value) {
-        client.hset(key, field, value);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> hsetnx(String key, String field, String value) {
-        client.hsetnx(key, field, value);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<List<String>> hvals(String key) {
-        client.hvals(key);
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<Long> incr(String key) {
-        client.incr(key);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> incrBy(String key, long integer) {
-        client.incrBy(key, integer);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Set<String>> keys(String pattern) {
-        client.keys(pattern);
-        return getResponse(BuilderFactory.STRING_SET);
-    }
-
-    public Response<String> lindex(String key, int index) {
-        client.lindex(key, index);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> linsert(String key, LIST_POSITION where,
-            String pivot, String value) {
-        client.linsert(key, where, pivot, value);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> llen(String key) {
-        client.llen(key);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> lpop(String key) {
-        client.lpop(key);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> lpush(String key, String string) {
-        client.lpush(key, string);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> lpushx(String key, String string) {
-        client.lpushx(key, string);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<List<String>> lrange(String key, long start, long end) {
-        client.lrange(key, start, end);
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<Long> lrem(String key, long count, String value) {
-        client.lrem(key, count, value);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> lset(String key, long index, String value) {
-        client.lset(key, index, value);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> ltrim(String key, long start, long end) {
-        client.ltrim(key, start, end);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<List<String>> mget(String... keys) {
-        client.mget(keys);
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<Long> move(String key, int dbIndex) {
-        client.move(key, dbIndex);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> mset(String... keysvalues) {
-        client.mset(keysvalues);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> msetnx(String... keysvalues) {
-        client.msetnx(keysvalues);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> persist(String key) {
-        client.persist(key);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> rename(String oldkey, String newkey) {
-        client.rename(oldkey, newkey);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> renamenx(String oldkey, String newkey) {
-        client.renamenx(oldkey, newkey);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> rpop(String key) {
-        client.rpop(key);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> rpoplpush(String srckey, String dstkey) {
-        client.rpoplpush(srckey, dstkey);
-        return getResponse(BuilderFactory.STRING);
-    }
+    public List<Object> exec() {
+        client.exec();
+        client.getAll(1); // Discard all but the last reply
 
-    public Response<Long> rpush(String key, String string) {
-        client.rpush(key, string);
-        return getResponse(BuilderFactory.LONG);
+        List<Object> unformatted = client.getObjectMultiBulkReply();
+        if (unformatted == null) {
+            return null;
+        }
+        List<Object> formatted = new ArrayList<Object>();
+        for (Object o : unformatted) {
+            try {
+                formatted.add(generateResponse(o).get());
+            } catch (JedisDataException e) {
+                formatted.add(e);
+            }
+        }
+        return formatted;
     }
 
-    public Response<Long> rpushx(String key, String string) {
-        client.rpushx(key, string);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> sadd(String key, String member) {
-        client.sadd(key, member);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> scard(String key) {
-        client.scard(key);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Set<String>> sdiff(String... keys) {
-        client.sdiff(keys);
-        return getResponse(BuilderFactory.STRING_SET);
-    }
-
-    public Response<Long> sdiffstore(String dstkey, String... keys) {
-        client.sdiffstore(dstkey, keys);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> set(String key, String value) {
-        client.set(key, value);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Boolean> setbit(String key, long offset, boolean value) {
-        client.setbit(key, offset, value);
-        return getResponse(BuilderFactory.BOOLEAN);
-    }
+    public List<Response<?>> execGetResponse() {
+        client.exec();
+        client.getAll(1); // Discard all but the last reply
 
-    public Response<String> setex(String key, int seconds, String value) {
-        client.setex(key, seconds, value);
-        return getResponse(BuilderFactory.STRING);
+        List<Object> unformatted = client.getObjectMultiBulkReply();
+        if (unformatted == null) {
+            return null;
+        }
+        List<Response<?>> response = new ArrayList<Response<?>>();
+        for (Object o : unformatted) {
+            response.add(generateResponse(o));
+        }
+        return response;
     }
 
-    public Response<Long> setnx(String key, String value) {
-        client.setnx(key, value);
-        return getResponse(BuilderFactory.LONG);
+    public String discard() {
+        client.discard();
+        client.getAll(1); // Discard all but the last reply
+        inTransaction = false;
+        clean();
+        return client.getStatusCodeReply();
     }
 
-    public Response<Long> setrange(String key, long offset, String value) {
-        client.setrange(key, offset, value);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Set<String>> sinter(String... keys) {
-        client.sinter(keys);
-        return getResponse(BuilderFactory.STRING_SET);
-    }
-
-    public Response<Long> sinterstore(String dstkey, String... keys) {
-        client.sinterstore(dstkey, keys);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Boolean> sismember(String key, String member) {
-        client.sismember(key, member);
-        return getResponse(BuilderFactory.BOOLEAN);
-    }
-
-    public Response<Set<String>> smembers(String key) {
-        client.smembers(key);
-        return getResponse(BuilderFactory.STRING_SET);
-    }
-
-    public Response<Long> smove(String srckey, String dstkey, String member) {
-        client.smove(srckey, dstkey, member);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<List<String>> sort(String key) {
-        client.sort(key);
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<List<String>> sort(String key,
-            SortingParams sortingParameters) {
-        client.sort(key, sortingParameters);
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<List<String>> sort(String key,
-            SortingParams sortingParameters, String dstkey) {
-        client.sort(key, sortingParameters, dstkey);
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<List<String>> sort(String key, String dstkey) {
-        client.sort(key, dstkey);
-        return getResponse(BuilderFactory.STRING_LIST);
-    }
-
-    public Response<String> spop(String key) {
-        client.spop(key);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> srandmember(String key) {
-        client.srandmember(key);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> srem(String key, String member) {
-        client.srem(key, member);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> strlen(String key) {
-        client.strlen(key);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> substr(String key, int start, int end) {
-        client.substr(key, start, end);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Set<String>> sunion(String... keys) {
-        client.sunion(keys);
-        return getResponse(BuilderFactory.STRING_SET);
-    }
-
-    public Response<Long> sunionstore(String dstkey, String... keys) {
-        client.sunionstore(dstkey, keys);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> ttl(String key) {
-        client.ttl(key);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> type(String key) {
-        client.type(key);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> zadd(String key, double score, String member) {
-        client.zadd(key, score, member);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zcard(String key) {
-        client.zcard(key);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zcount(String key, double min, double max) {
-        client.zcount(key, min, max);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Double> zincrby(String key, double score, String member) {
-        client.zincrby(key, score, member);
-        return getResponse(BuilderFactory.DOUBLE);
-    }
-
-    public Response<Long> zinterstore(String dstkey, String... sets) {
-        client.zinterstore(dstkey, sets);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zinterstore(String dstkey, ZParams params,
-            String... sets) {
-        client.zinterstore(dstkey, params, sets);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Set<String>> zrange(String key, int start, int end) {
-        client.zrange(key, start, end);
-        return getResponse(BuilderFactory.STRING_ZSET);
-    }
-
-    public Response<Set<String>> zrangeByScore(String key, double min,
-            double max) {
-        client.zrangeByScore(key, min, max);
-        return getResponse(BuilderFactory.STRING_ZSET);
-    }
-
-    public Response<Set<String>> zrangeByScore(String key, String min,
-            String max) {
-        client.zrangeByScore(key, min, max);
-        return getResponse(BuilderFactory.STRING_ZSET);
-    }
-
-    public Response<Set<String>> zrangeByScore(String key, double min,
-            double max, int offset, int count) {
-        client.zrangeByScore(key, min, max, offset, count);
-        return getResponse(BuilderFactory.STRING_ZSET);
-    }
-
-    public Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min,
-            double max) {
-        client.zrangeByScoreWithScores(key, min, max);
-        return getResponse(BuilderFactory.TUPLE_ZSET);
-    }
-
-    public Response<Set<Tuple>> zrangeByScoreWithScores(String key, double min,
-            double max, int offset, int count) {
-        client.zrangeByScoreWithScores(key, min, max, offset, count);
-        return getResponse(BuilderFactory.TUPLE_ZSET);
-    }
-
-    public Response<Set<Tuple>> zrangeWithScores(String key, int start, int end) {
-        client.zrangeWithScores(key, start, end);
-        return getResponse(BuilderFactory.TUPLE_ZSET);
-    }
-
-    public Response<Long> zrank(String key, String member) {
-        client.zrank(key, member);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zrem(String key, String member) {
-        client.zrem(key, member);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zremrangeByRank(String key, int start, int end) {
-        client.zremrangeByRank(key, start, end);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zremrangeByScore(String key, double start, double end) {
-        client.zremrangeByScore(key, start, end);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Set<String>> zrevrange(String key, int start, int end) {
-        client.zrevrange(key, start, end);
-        return getResponse(BuilderFactory.STRING_ZSET);
-    }
-
-    public Response<Set<Tuple>> zrevrangeWithScores(String key, int start,
-            int end) {
-        client.zrevrangeWithScores(key, start, end);
-        return getResponse(BuilderFactory.TUPLE_ZSET);
-    }
-
-    public Response<Long> zrevrank(String key, String member) {
-        client.zrevrank(key, member);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Double> zscore(String key, String member) {
-        client.zscore(key, member);
-        return getResponse(BuilderFactory.DOUBLE);
-    }
-
-    public Response<Long> zunionstore(String dstkey, String... sets) {
-        client.zunionstore(dstkey, sets);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> zunionstore(String dstkey, ZParams params,
-            String... sets) {
-        client.zunionstore(dstkey, params, sets);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<String> bgrewriteaof() {
-        client.bgrewriteaof();
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> bgsave() {
-        client.bgsave();
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> configGet(String pattern) {
-        client.configGet(pattern);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> configSet(String parameter, String value) {
-        client.configSet(parameter, value);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> brpoplpush(String source, String destination,
-            int timeout) {
-        client.brpoplpush(source, destination, timeout);
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> configResetStat() {
-        client.configResetStat();
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<String> save() {
-        client.save();
-        return getResponse(BuilderFactory.STRING);
-    }
-
-    public Response<Long> lastsave() {
-        client.lastsave();
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> publish(String channel, String message) {
-        client.publish(channel, message);
-        return getResponse(BuilderFactory.LONG);
-    }
-
-    public Response<Long> publish(byte[] channel, byte[] message) {
-        client.publish(channel, message);
-        return getResponse(BuilderFactory.LONG);
-    }
 }
\ No newline at end of file
diff --git a/src/main/java/redis/clients/jedis/TransactionBlock.java b/src/main/java/redis/clients/jedis/TransactionBlock.java
index 87df232..e784e19 100644
--- a/src/main/java/redis/clients/jedis/TransactionBlock.java
+++ b/src/main/java/redis/clients/jedis/TransactionBlock.java
@@ -13,6 +13,6 @@ public abstract class TransactionBlock extends Transaction {
     public abstract void execute() throws JedisException;
 
     public void setClient(Client client) {
-	this.client = client;
+	    this.client = client;
     }
 }
diff --git a/src/test/java/redis/clients/jedis/tests/JedisSentinelTest.java b/src/test/java/redis/clients/jedis/tests/JedisSentinelTest.java
new file mode 100644
index 0000000..7cd8188
--- /dev/null
+++ b/src/test/java/redis/clients/jedis/tests/JedisSentinelTest.java
@@ -0,0 +1,68 @@
+package redis.clients.jedis.tests;
+
+import static junit.framework.Assert.assertEquals;
+import static junit.framework.Assert.assertFalse;
+import static junit.framework.Assert.assertTrue;
+
+import java.util.List;
+import java.util.Map;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import redis.clients.jedis.Jedis;
+
+public class JedisSentinelTest {
+    private static final String MASTER_NAME = "mymaster";
+
+    @Before
+    public void setup() throws InterruptedException {
+	Jedis j = new Jedis("localhost", 6380);
+	j.auth("foobared");
+	j.configSet("masterauth", "foobared");
+	j.slaveof("localhost", 6379);
+	// TODO: The sleep is to give time to the slave to synchronize with the
+	// master and also let know the sentinels about this new topology. We
+	// should find a better way to do this.
+	Thread.sleep(5000);
+    }
+
+    @After
+    public void clear() {
+	Jedis j = new Jedis("localhost", 6380);
+	j.auth("foobared");
+	j.slaveofNoOne();
+    }
+
+    @Test
+    public void sentinel() {
+	Jedis j = new Jedis("localhost", 26379);
+	List<Map<String, String>> masters = j.sentinelMasters();
+	final String masterName = masters.get(0).get("name");
+
+	assertEquals(MASTER_NAME, masterName);
+
+	List<String> masterHostAndPort = j
+		.sentinelGetMasterAddrByName(masterName);
+	assertEquals("127.0.0.1", masterHostAndPort.get(0));
+	assertEquals("6379", masterHostAndPort.get(1));
+
+	List<Map<String, String>> slaves = j.sentinelSlaves(masterName);
+	assertEquals("6379", slaves.get(0).get("master-port"));
+
+	List<? extends Object> isMasterDownByAddr = j
+		.sentinelIsMasterDownByAddr("127.0.0.1", 6379);
+	assertEquals(Long.valueOf(0), (Long) isMasterDownByAddr.get(0));
+	assertFalse("?".equals(isMasterDownByAddr.get(1)));
+
+	isMasterDownByAddr = j.sentinelIsMasterDownByAddr("127.0.0.1", 1);
+	assertEquals(Long.valueOf(0), (Long) isMasterDownByAddr.get(0));
+	assertTrue("?".equals(isMasterDownByAddr.get(1)));
+
+	// DO NOT RE-RUN TEST TOO FAST, RESET TAKES SOME TIME TO... RESET
+	assertEquals(Long.valueOf(1), j.sentinelReset(masterName));
+	assertEquals(Long.valueOf(0), j.sentinelReset("woof" + masterName));
+
+    }
+}
diff --git a/src/test/java/redis/clients/jedis/tests/PipeliningTest.java b/src/test/java/redis/clients/jedis/tests/PipeliningTest.java
old mode 100644
new mode 100755
index 568a2cd..ffe2c9b
--- a/src/test/java/redis/clients/jedis/tests/PipeliningTest.java
+++ b/src/test/java/redis/clients/jedis/tests/PipeliningTest.java
@@ -8,10 +8,7 @@ import redis.clients.jedis.exceptions.JedisDataException;
 import redis.clients.jedis.tests.HostAndPortUtil.HostAndPort;
 
 import java.io.UnsupportedEncodingException;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.UUID;
+import java.util.*;
 
 public class PipeliningTest extends Assert {
     private static HostAndPort hnp = HostAndPortUtil.getRedisServers().get(0);
@@ -100,7 +97,59 @@ public class PipeliningTest extends Assert {
 
         assertNotNull(score.get());    
     }
-    
+
+    @Test
+    public void pipelineBinarySafeHashCommands() {
+        jedis.hset("key".getBytes(), "f1".getBytes(), "v111".getBytes());
+        jedis.hset("key".getBytes(), "f22".getBytes(), "v2222".getBytes());
+
+        Pipeline p = jedis.pipelined();
+        Response<Map<byte[],byte[]>> fmap = p.hgetAll("key".getBytes());
+        Response<Set<byte[]>> fkeys = p.hkeys("key".getBytes());
+        Response<List<byte[]>> fordered = p.hmget("key".getBytes(), "f22".getBytes(), "f1".getBytes());
+        Response<List<byte[]>> fvals = p.hvals("key".getBytes());
+        p.sync();
+
+        assertNotNull(fmap.get());
+        // we have to do these strange contortions because byte[] is not a very good key
+        // for a java Map. It only works with equality (you need the exact key object to retrieve
+        // the value) I recommend we switch to using ByteBuffer or something similar:
+        // http://stackoverflow.com/questions/1058149/using-a-byte-array-as-hashmap-key-java
+        Map<byte[],byte[]> map = fmap.get();
+        Set<byte[]> mapKeys = map.keySet();
+        Iterator<byte[]> iterMap = mapKeys.iterator();
+        byte[] firstMapKey = iterMap.next();
+        byte[] secondMapKey = iterMap.next();
+        assertFalse(iterMap.hasNext());
+        verifyHasBothValues(firstMapKey, secondMapKey, "f1".getBytes(), "f22".getBytes());
+        byte[] firstMapValue = map.get(firstMapKey);
+        byte[] secondMapValue = map.get(secondMapKey);
+        verifyHasBothValues(firstMapValue, secondMapValue, "v111".getBytes(), "v2222".getBytes());
+
+        assertNotNull(fkeys.get());
+        Iterator<byte[]> iter = fkeys.get().iterator();
+        byte[] firstKey = iter.next();
+        byte[] secondKey = iter.next();
+        assertFalse(iter.hasNext());
+        verifyHasBothValues(firstKey, secondKey, "f1".getBytes(), "f22".getBytes());
+
+        assertNotNull(fordered.get());
+        assertArrayEquals("v2222".getBytes(), fordered.get().get(0));
+        assertArrayEquals("v111".getBytes(), fordered.get().get(1));
+
+        assertNotNull(fvals.get());
+        assertEquals(2, fvals.get().size());
+        byte[] firstValue = fvals.get().get(0);
+        byte[] secondValue = fvals.get().get(1);
+        verifyHasBothValues(firstValue, secondValue, "v111".getBytes(), "v2222".getBytes());
+    }
+
+    private void verifyHasBothValues(byte[] firstKey, byte[] secondKey, byte[] value1, byte[] value2) {
+        assertFalse(Arrays.equals(firstKey, secondKey));
+        assertTrue(Arrays.equals(firstKey, value1) || Arrays.equals(firstKey, value2));
+        assertTrue(Arrays.equals(secondKey, value1) || Arrays.equals(secondKey, value2));
+    }
+
     @Test
     public void pipelineSelect() {
         Pipeline p = jedis.pipelined();
diff --git a/src/test/java/redis/clients/jedis/tests/commands/AllKindOfValuesCommandsTest.java b/src/test/java/redis/clients/jedis/tests/commands/AllKindOfValuesCommandsTest.java
index d7df713..855a35d 100644
--- a/src/test/java/redis/clients/jedis/tests/commands/AllKindOfValuesCommandsTest.java
+++ b/src/test/java/redis/clients/jedis/tests/commands/AllKindOfValuesCommandsTest.java
@@ -300,7 +300,7 @@ public class AllKindOfValuesCommandsTest extends JedisCommandTestBase {
     @Test
     public void ttl() {
         long ttl = jedis.ttl("foo");
-        assertEquals(-1, ttl);
+        assertEquals(-2, ttl);
 
         jedis.set("foo", "bar");
         ttl = jedis.ttl("foo");
@@ -312,7 +312,7 @@ public class AllKindOfValuesCommandsTest extends JedisCommandTestBase {
 
         // Binary
         long bttl = jedis.ttl(bfoo);
-        assertEquals(-1, bttl);
+        assertEquals(-2, bttl);
 
         jedis.set(bfoo, bbar);
         bttl = jedis.ttl(bfoo);
diff --git a/src/test/java/redis/clients/jedis/tests/commands/BitCommandsTest.java b/src/test/java/redis/clients/jedis/tests/commands/BitCommandsTest.java
index 047ca20..87b044f 100644
--- a/src/test/java/redis/clients/jedis/tests/commands/BitCommandsTest.java
+++ b/src/test/java/redis/clients/jedis/tests/commands/BitCommandsTest.java
@@ -2,6 +2,8 @@ package redis.clients.jedis.tests.commands;
 
 import org.junit.Test;
 
+import redis.clients.jedis.BitOP;
+
 public class BitCommandsTest extends JedisCommandTestBase {
     @Test
     public void setAndgetbit() {
@@ -29,4 +31,63 @@ public class BitCommandsTest extends JedisCommandTestBase {
         assertEquals("Hello", jedis.getrange("key1", 0, 4));
         assertEquals("Jedis", jedis.getrange("key1", 6, 11));
     }
-}
\ No newline at end of file
+
+    @Test
+    public void bitCount() {
+        jedis.del("foo");
+
+        jedis.setbit("foo", 16, true);
+        jedis.setbit("foo", 24, true);
+        jedis.setbit("foo", 40, true);
+        jedis.setbit("foo", 56, true);
+
+        long c4 = jedis.bitcount("foo");
+        assertEquals(4, c4);
+
+        long c3 = jedis.bitcount("foo", 2L, 5L);
+        assertEquals(3, c3);
+
+        jedis.del("foo");
+    }
+
+    @Test
+    public void bitOp()
+    {
+        jedis.set("key1", "\u0060");
+        jedis.set("key2", "\u0044");
+
+        jedis.bitop(BitOP.AND, "resultAnd", "key1", "key2");
+        String resultAnd = jedis.get("resultAnd");
+        assertEquals("\u0040", resultAnd);
+
+        jedis.bitop(BitOP.OR, "resultOr", "key1", "key2");
+        String resultOr = jedis.get("resultOr");
+        assertEquals("\u0064", resultOr);
+
+        jedis.bitop(BitOP.XOR, "resultXor", "key1", "key2");
+        String resultXor = jedis.get("resultXor");
+        assertEquals("\u0024", resultXor);
+
+        jedis.del("resultAnd");
+        jedis.del("resultOr");
+        jedis.del("resultXor");
+        jedis.del("key1");
+        jedis.del("key2");
+    }
+
+    @Test
+    public void bitOpNot()
+    {
+        jedis.del("key");
+        jedis.setbit("key", 0, true);
+        jedis.setbit("key", 4, true);
+
+        jedis.bitop(BitOP.NOT, "resultNot", "key");
+
+        String resultNot = jedis.get("resultNot");
+        assertEquals("\u0077", resultNot);
+
+        jedis.del("key");
+        jedis.del("resultNot");
+    }
+}
diff --git a/src/test/java/redis/clients/jedis/tests/commands/ControlCommandsTest.java b/src/test/java/redis/clients/jedis/tests/commands/ControlCommandsTest.java
index 7e59335..fbc7d8e 100644
--- a/src/test/java/redis/clients/jedis/tests/commands/ControlCommandsTest.java
+++ b/src/test/java/redis/clients/jedis/tests/commands/ControlCommandsTest.java
@@ -58,6 +58,8 @@ public class ControlCommandsTest extends JedisCommandTestBase {
     public void info() {
         String info = jedis.info();
         assertNotNull(info);
+        info = jedis.info("server");
+        assertNotNull(info);
     }
 
     @Test
diff --git a/src/test/java/redis/clients/jedis/tests/commands/ScriptingCommandsTest.java b/src/test/java/redis/clients/jedis/tests/commands/ScriptingCommandsTest.java
index 0a059cd..a3675d4 100644
--- a/src/test/java/redis/clients/jedis/tests/commands/ScriptingCommandsTest.java
+++ b/src/test/java/redis/clients/jedis/tests/commands/ScriptingCommandsTest.java
@@ -6,133 +6,147 @@ import java.util.List;
 import org.junit.Test;
 
 import redis.clients.jedis.exceptions.JedisDataException;
-import redis.clients.jedis.exceptions.JedisException;
 import redis.clients.util.SafeEncoder;
 
 public class ScriptingCommandsTest extends JedisCommandTestBase {
-    
+
     @SuppressWarnings("unchecked")
-	@Test
+    @Test
     public void evalMultiBulk() {
-    	String script = "return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}";
-    	List<String> keys = new ArrayList<String>();
-    	keys.add("key1");
-    	keys.add("key2");
-    	
-    	List<String> args = new ArrayList<String>();
-    	args.add("first");
-    	args.add("second");
-    	
-        List<String> response = (List<String>)jedis.eval(script, keys, args );
-        
-        assertEquals(4, response.size());
-        assertEquals("key1", response.get(0));
-        assertEquals("key2", response.get(1));
-        assertEquals("first", response.get(2));
-        assertEquals("second", response.get(3));
+	String script = "return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}";
+	List<String> keys = new ArrayList<String>();
+	keys.add("key1");
+	keys.add("key2");
+
+	List<String> args = new ArrayList<String>();
+	args.add("first");
+	args.add("second");
+
+	List<String> response = (List<String>) jedis.eval(script, keys, args);
+
+	assertEquals(4, response.size());
+	assertEquals("key1", response.get(0));
+	assertEquals("key2", response.get(1));
+	assertEquals("first", response.get(2));
+	assertEquals("second", response.get(3));
     }
-    
-	@Test
+
+    @Test
     public void evalBulk() {
-    	String script = "return KEYS[1]";
-    	List<String> keys = new ArrayList<String>();
-    	keys.add("key1");
-    	
-    	List<String> args = new ArrayList<String>();
-    	args.add("first");
-    	
-        String response = (String)jedis.eval(script, keys, args);
-        
-        assertEquals("key1", response);        
+	String script = "return KEYS[1]";
+	List<String> keys = new ArrayList<String>();
+	keys.add("key1");
+
+	List<String> args = new ArrayList<String>();
+	args.add("first");
+
+	String response = (String) jedis.eval(script, keys, args);
+
+	assertEquals("key1", response);
     }
-	
-	@Test
+
+    @Test
     public void evalInt() {
-    	String script = "return 2";
-    	List<String> keys = new ArrayList<String>();
-    	keys.add("key1");
-    	
-    	Long response = (Long)jedis.eval(script, keys, new ArrayList<String>());
-        
-        assertEquals(new Long(2), response);
+	String script = "return 2";
+	List<String> keys = new ArrayList<String>();
+	keys.add("key1");
+
+	Long response = (Long) jedis
+		.eval(script, keys, new ArrayList<String>());
+
+	assertEquals(new Long(2), response);
     }
-	
-	@Test
+
+    @Test
     public void evalNoArgs() {
-    	String script = "return KEYS[1]";
-    	List<String> keys = new ArrayList<String>();
-    	keys.add("key1");
-    	String response = (String)jedis.eval(script, keys, new ArrayList<String>());
-        
-        assertEquals("key1", response);
+	String script = "return KEYS[1]";
+	List<String> keys = new ArrayList<String>();
+	keys.add("key1");
+	String response = (String) jedis.eval(script, keys,
+		new ArrayList<String>());
+
+	assertEquals("key1", response);
     }
-	
-	@SuppressWarnings("unchecked")
-	@Test
+
+    @Test
     public void evalsha() {
-		jedis.set("foo", "bar");
-		jedis.eval("return redis.call('get','foo')");
-		String result = (String)jedis.evalsha("6b1bf486c81ceb7edf3c093f4c48582e38c0e791");
-		
-		assertEquals("bar", result);
+	jedis.set("foo", "bar");
+	jedis.eval("return redis.call('get','foo')");
+	String result = (String) jedis
+		.evalsha("6b1bf486c81ceb7edf3c093f4c48582e38c0e791");
+
+	assertEquals("bar", result);
     }
-	
-	@SuppressWarnings("unchecked")
-	@Test(expected=JedisDataException.class)
+
+    @Test(expected = JedisDataException.class)
     public void evalshaShaNotFound() {
-		jedis.evalsha("ffffffffffffffffffffffffffffffffffffffff");
+	jedis.evalsha("ffffffffffffffffffffffffffffffffffffffff");
     }
-	
-	@SuppressWarnings("unchecked")
-	@Test
+
+    @Test
     public void scriptFlush() {
-		jedis.set("foo", "bar");
-		jedis.eval("return redis.call('get','foo')");
-		jedis.scriptFlush();
-		assertFalse(jedis.scriptExists("6b1bf486c81ceb7edf3c093f4c48582e38c0e791"));
+	jedis.set("foo", "bar");
+	jedis.eval("return redis.call('get','foo')");
+	jedis.scriptFlush();
+	assertFalse(jedis
+		.scriptExists("6b1bf486c81ceb7edf3c093f4c48582e38c0e791"));
     }
-	
-	@SuppressWarnings("unchecked")
-	@Test
+
+    @Test
     public void scriptExists() {
-		jedis.scriptLoad("return redis.call('get','foo')");
-		List<Boolean> exists = jedis.scriptExists("ffffffffffffffffffffffffffffffffffffffff","6b1bf486c81ceb7edf3c093f4c48582e38c0e791"); 
-		assertFalse(exists.get(0));
-		assertTrue(exists.get(1));
+	jedis.scriptLoad("return redis.call('get','foo')");
+	List<Boolean> exists = jedis.scriptExists(
+		"ffffffffffffffffffffffffffffffffffffffff",
+		"6b1bf486c81ceb7edf3c093f4c48582e38c0e791");
+	assertFalse(exists.get(0));
+	assertTrue(exists.get(1));
     }
-	
-	@SuppressWarnings("unchecked")
-	@Test
+
+    @Test
     public void scriptExistsBinary() {
-		jedis.scriptLoad(SafeEncoder.encode("return redis.call('get','foo')"));
-		List<Long> exists = jedis.scriptExists(SafeEncoder.encode("ffffffffffffffffffffffffffffffffffffffff"),SafeEncoder.encode("6b1bf486c81ceb7edf3c093f4c48582e38c0e791")); 
-		assertEquals(new Long(0), exists.get(0));
-		assertEquals(new Long(1), exists.get(1));
+	jedis.scriptLoad(SafeEncoder.encode("return redis.call('get','foo')"));
+	List<Long> exists = jedis.scriptExists(
+		SafeEncoder.encode("ffffffffffffffffffffffffffffffffffffffff"),
+		SafeEncoder.encode("6b1bf486c81ceb7edf3c093f4c48582e38c0e791"));
+	assertEquals(new Long(0), exists.get(0));
+	assertEquals(new Long(1), exists.get(1));
     }
-	
-	@SuppressWarnings("unchecked")
-	@Test
+
+    @Test
     public void scriptLoad() {
-		jedis.scriptLoad("return redis.call('get','foo')");
-		assertTrue(jedis.scriptExists("6b1bf486c81ceb7edf3c093f4c48582e38c0e791"));
+	jedis.scriptLoad("return redis.call('get','foo')");
+	assertTrue(jedis
+		.scriptExists("6b1bf486c81ceb7edf3c093f4c48582e38c0e791"));
     }
-	
-	@SuppressWarnings("unchecked")
-	@Test
+
+    @Test
     public void scriptLoadBinary() {
-		jedis.scriptLoad(SafeEncoder.encode("return redis.call('get','foo')"));
-		List<Long> exists = jedis.scriptExists(SafeEncoder.encode("6b1bf486c81ceb7edf3c093f4c48582e38c0e791")); 
-		assertEquals(new Long(1), exists.get(0));
+	jedis.scriptLoad(SafeEncoder.encode("return redis.call('get','foo')"));
+	List<Long> exists = jedis.scriptExists(SafeEncoder
+		.encode("6b1bf486c81ceb7edf3c093f4c48582e38c0e791"));
+	assertEquals(new Long(1), exists.get(0));
     }
-	
-	@SuppressWarnings("unchecked")
-	@Test
+
+    @Test
     public void scriptKill() {
-		try {
-			jedis.scriptKill();
-		}
-		catch(JedisDataException e) {
-			assertTrue(e.getMessage().contains("No scripts in execution right now."));
-		}
+	try {
+	    jedis.scriptKill();
+	} catch (JedisDataException e) {
+	    assertTrue(e.getMessage().contains(
+		    "No scripts in execution right now."));
 	}
+    }
+
+    @Test
+    public void scriptEvalReturnNullValues() {
+	String script = "return {redis.call('hget',KEYS[1],ARGV[1]),redis.call('hget',KEYS[2],ARGV[2])}";
+	jedis.eval(script, 2, "key1", "key2", "1", "1");
+    }
+
+    @Test
+    public void scriptEvalShaReturnNullValues() {
+	String script = "return {redis.call('hget',KEYS[1],ARGV[1]),redis.call('hget',KEYS[2],ARGV[2])}";
+	String sha = jedis.scriptLoad(script);
+	jedis.evalsha(sha, 2, "key1", "key2", "1", "1");
+    }
 }
\ No newline at end of file
diff --git a/src/test/java/redis/clients/jedis/tests/commands/TransactionCommandsTest.java b/src/test/java/redis/clients/jedis/tests/commands/TransactionCommandsTest.java
index 8167658..5e03270 100644
--- a/src/test/java/redis/clients/jedis/tests/commands/TransactionCommandsTest.java
+++ b/src/test/java/redis/clients/jedis/tests/commands/TransactionCommandsTest.java
@@ -171,7 +171,7 @@ public class TransactionCommandsTest extends JedisCommandTestBase {
         t.set(bmykey, bval);
         resp = t.exec();
         assertEquals(1, resp.size());
-        assertArrayEquals("OK".getBytes(), (byte[]) resp.get(0));
+        assertEquals("OK", resp.get(0));
     }
 
     @Test(expected = JedisDataException.class)