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..24b6089
--- /dev/null
+++ b/src/main/java/redis/clients/jedis/BinaryRedisPipeline.java
@@ -0,0 +1,205 @@
+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<Long> decr(byte[] key);
+
+    Response<Long> decrBy(byte[] key, long integer);
+
+    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<String> hget(byte[] key, byte[] field);
+
+    Response<Map<String, String>> hgetAll(byte[] key);
+
+    Response<Long> hincrBy(byte[] key, byte[] field, long value);
+
+    Response<Set<String>> hkeys(byte[] key);
+
+    Response<Long> hlen(byte[] key);
+
+    Response<List<String>> 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<String>> hvals(byte[] key);
+
+    Response<Long> incr(byte[] key);
+
+    Response<Long> incrBy(byte[] key, long integer);
+
+    Response<String> lindex(byte[] key, int index);
+
+    Response<Long> linsert(byte[] key, BinaryClient.LIST_POSITION where,
+                           byte[] pivot, byte[] value);
+
+    Response<Long> llen(byte[] key);
+
+    Response<String> lpop(byte[] key);
+
+    Response<Long> lpush(byte[] key, byte[] string);
+
+    Response<Long> lpushx(byte[] key, byte[] bytes);
+
+    Response<List<String>> 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> persist(byte[] key);
+
+    Response<String> 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<String>> smembers(byte[] key);
+
+    Response<Boolean> sismember(byte[] key, byte[] member);
+
+    Response<Long> sort(byte[] key);
+
+    Response<List<String>> sort(byte[] key,
+                                SortingParams sortingParameters);
+
+    Response<String> spop(byte[] key);
+
+    Response<String> 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<String>> zrange(byte[] key, int start, int end);
+
+    Response<Set<String>> zrangeByScore(byte[] key, double min,
+                                        double max);
+
+    Response<Set<String>> zrangeByScore(byte[] key, byte[] min,
+                                        byte[] max);
+
+    Response<Set<String>> zrangeByScore(byte[] key, double min,
+                                        double max, int offset, int count);
+
+    Response<Set<String>> 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<String>> zrevrangeByScore(byte[] key, double max,
+                                           double min);
+
+    Response<Set<String>> zrevrangeByScore(byte[] key, byte[] max,
+                                           byte[] min);
+
+    Response<Set<String>> zrevrangeByScore(byte[] key, double max,
+                                           double min, int offset, int count);
+
+    Response<Set<String>> 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<String>> 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);
+}
diff --git a/src/main/java/redis/clients/jedis/Pipeline.java b/src/main/java/redis/clients/jedis/Pipeline.java
index d89efea..a85fceb 100644
--- a/src/main/java/redis/clients/jedis/Pipeline.java
+++ b/src/main/java/redis/clients/jedis/Pipeline.java
@@ -9,7 +9,7 @@ import java.util.Set;
 import redis.clients.jedis.BinaryClient.LIST_POSITION;
 import redis.clients.jedis.exceptions.JedisDataException;
 
-public class Pipeline extends Queable {
+public class Pipeline extends Queable implements BinaryRedisPipeline, RedisPipeline {
 	
     private MultiResponseBuilder currentMulti;
     
@@ -209,8 +209,13 @@ public class Pipeline extends Queable {
         return getResponse(BuilderFactory.BOOLEAN);
     }
 
+    public Response<Boolean> getbit(byte[] key, long offset) {
+        client.getbit(key, offset);
+        return getResponse(BuilderFactory.BOOLEAN);
+    }
+
     public Response<String> getrange(String key, long startOffset,
-            long endOffset) {
+                                     long endOffset) {
         client.getrange(key, startOffset, endOffset);
         return getResponse(BuilderFactory.STRING);
     }
@@ -225,6 +230,11 @@ public class Pipeline extends Queable {
         return getResponse(BuilderFactory.BYTE_ARRAY);
     }
 
+    public Response<Long> getrange(byte[] key, long startOffset, long endOffset) {
+        client.getrange(key, startOffset, endOffset);
+        return getResponse(BuilderFactory.LONG);
+    }
+
     public Response<Long> hdel(String key, String field) {
         client.hdel(key, field);
         return getResponse(BuilderFactory.LONG);
@@ -386,13 +396,13 @@ public class Pipeline extends Queable {
     }
 
     public Response<Long> linsert(String key, LIST_POSITION where,
-            String pivot, String value) {
+                                  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) {
+                                  byte[] pivot, byte[] value) {
         client.linsert(key, where, pivot, value);
         return getResponse(BuilderFactory.LONG);
     }
@@ -642,6 +652,11 @@ public class Pipeline extends Queable {
         return getResponse(BuilderFactory.BOOLEAN);
     }
 
+    public Response<Boolean> setbit(byte[] key, long offset, byte[] 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);
@@ -667,6 +682,11 @@ public class Pipeline extends Queable {
         return getResponse(BuilderFactory.LONG);
     }
 
+    public Response<Long> setrange(byte[] key, long offset, byte[] 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);
@@ -728,25 +748,25 @@ public class Pipeline extends Queable {
     }
 
     public Response<List<String>> sort(String key,
-            SortingParams sortingParameters) {
+                                       SortingParams sortingParameters) {
         client.sort(key, sortingParameters);
         return getResponse(BuilderFactory.STRING_LIST);
     }
 
     public Response<List<String>> sort(byte[] key,
-            SortingParams sortingParameters) {
+                                       SortingParams sortingParameters) {
         client.sort(key, sortingParameters);
         return getResponse(BuilderFactory.STRING_LIST);
     }
 
     public Response<List<String>> sort(String key,
-            SortingParams sortingParameters, String dstkey) {
+                                       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) {
+                                       SortingParams sortingParameters, byte[] dstkey) {
         client.sort(key, sortingParameters, dstkey);
         return getResponse(BuilderFactory.STRING_LIST);
     }
@@ -934,154 +954,154 @@ public class Pipeline extends Queable {
     }
 
     public Response<Set<String>> zrangeByScore(String key, double min,
-            double max) {
+                                               double max) {
         client.zrangeByScore(key, min, max);
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
     public Response<Set<String>> zrangeByScore(byte[] key, double min,
-            double max) {
+                                               double max) {
         return zrangeByScore(key, toByteArray(min), toByteArray(max));
     }
     
     public Response<Set<String>> zrangeByScore(String key, String min,
-            String max) {
+                                               String max) {
         client.zrangeByScore(key, min, max);
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
     public Response<Set<String>> zrangeByScore(byte[] key, byte[] min,
-            byte[] max) {
+                                               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) {
+                                               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) {
+                                               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) {
+                                               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) {
+                                                        double max) {
         client.zrangeByScoreWithScores(key, min, max);
         return getResponse(BuilderFactory.TUPLE_ZSET);
     }
 
     public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, double min,
-            double max) {
+                                                        double max) {
         return zrangeByScoreWithScores(key, toByteArray(min), toByteArray(max));
     }
     
     public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, byte[] min,
-    		byte[] max) {
+                                                        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) {
+                                                        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) {
+                                                        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) {
+                                                        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) {
+                                                  double min) {
         client.zrevrangeByScore(key, max, min);
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
     public Response<Set<String>> zrevrangeByScore(byte[] key, double max,
-            double min) {
+                                                  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) {
+                                                  String min) {
         client.zrevrangeByScore(key, max, min);
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
     public Response<Set<String>> zrevrangeByScore(byte[] key, byte[] max,
-            byte[] min) {
+                                                  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) {
+                                                  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) {
+                                                  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) {
+                                                  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) {
+                                                           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) {
+                                                           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) {
+                                                           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) {
+                                                           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) {
+                                                           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) {
+                                                           byte[] max, byte[] min, int offset, int count) {
         client.zrevrangeByScoreWithScores(key, max, min, offset, count);
         return getResponse(BuilderFactory.TUPLE_ZSET);
     }
@@ -1152,13 +1172,13 @@ public class Pipeline extends Queable {
     }
 
     public Response<Set<Tuple>> zrevrangeWithScores(String key, int start,
-            int end) {
+                                                    int end) {
         client.zrevrangeWithScores(key, start, end);
         return getResponse(BuilderFactory.TUPLE_ZSET);
     }
 
     public Response<Set<Tuple>> zrevrangeWithScores(byte[] key, int start,
-            int end) {
+                                                    int end) {
         client.zrevrangeWithScores(key, start, end);
         return getResponse(BuilderFactory.TUPLE_ZSET);
     }
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..ca3370e
--- /dev/null
+++ b/src/main/java/redis/clients/jedis/RedisPipeline.java
@@ -0,0 +1,184 @@
+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<Long> decr(String key);
+
+    Response<Long> decrBy(String key, long integer);
+
+    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> 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<Set<String>> smembers(String key);
+
+    Response<Long> 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);
+}
diff --git a/src/main/java/redis/clients/jedis/ShardedJedisPipeline.java b/src/main/java/redis/clients/jedis/ShardedJedisPipeline.java
index af416c0..48371ac 100644
--- a/src/main/java/redis/clients/jedis/ShardedJedisPipeline.java
+++ b/src/main/java/redis/clients/jedis/ShardedJedisPipeline.java
@@ -4,7 +4,9 @@ import redis.clients.jedis.BinaryClient.LIST_POSITION;
 
 import java.util.*;
 
-public class ShardedJedisPipeline extends Queable {
+import static redis.clients.jedis.Protocol.toByteArray;
+
+public class ShardedJedisPipeline extends Queable implements BinaryRedisPipeline, RedisPipeline {
     private BinaryShardedJedis jedis;
     private List<FutureResult> results = new ArrayList<FutureResult>();
     private Queue<Client> clients = new LinkedList<Client>();
@@ -32,6 +34,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.STRING);
     }
 
+    public Response<String> set(byte[] key, byte[] 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);
@@ -39,6 +48,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.STRING);
     }
 
+    public Response<byte[]> get(byte[] key) {
+        Client c = getClient(key);
+        c.get(key);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.BYTE_ARRAY);
+    }
+
     public Response<Long> del(String key) {
         Client c = getClient(key);
         c.del(key);
@@ -53,13 +69,27 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.BOOLEAN);
     }
 
-    public Response<Boolean> type(String key) {
+    public Response<Boolean> exists(byte[] key) {
         Client c = getClient(key);
-        c.type(key);
+        c.exists(key);
         results.add(new FutureResult(c));
         return getResponse(BuilderFactory.BOOLEAN);
     }
 
+    public Response<String> type(String key) {
+        Client c = getClient(key);
+        c.type(key);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> type(byte[] key) {
+        Client c = getClient(key);
+        c.type(key);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.STRING);
+    }
+
     public Response<Long> expire(String key, int seconds) {
         Client c = getClient(key);
         c.expire(key, seconds);
@@ -67,6 +97,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.LONG);
     }
 
+    public Response<Long> expire(byte[] 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);
@@ -74,6 +111,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.LONG);
     }
 
+    public Response<Long> expireAt(byte[] 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);
@@ -81,6 +125,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.LONG);
     }
 
+    public Response<Long> ttl(byte[] 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);
@@ -88,6 +139,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.STRING);
     }
 
+    public Response<byte[]> getSet(byte[] key, byte[] value) {
+        Client c = getClient(key);
+        c.getSet(key, value);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.BYTE_ARRAY);
+    }
+
     public Response<Long> setnx(String key, String value) {
         Client c = getClient(key);
         c.setnx(key, value);
@@ -95,11 +153,25 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.LONG);
     }
 
-    public Response<Long> setex(String key, int seconds, String value) {
+    public Response<Long> setnx(byte[] key, byte[] value) {
+        Client c = getClient(key);
+        c.setnx(key, value);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<String> 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);        
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<String> setex(byte[] key, int seconds, byte[] value) {
+        Client c = getClient(key);
+        c.setex(key, seconds, value);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.STRING);
     }
 
     public Response<Long> decrBy(String key, long integer) {
@@ -109,6 +181,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.LONG);
     }
 
+    public Response<Long> decrBy(byte[] 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);
@@ -116,7 +195,21 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.LONG);
     }
 
-    public Response<Long> incrBy(String key, int integer) {
+    public Response<Long> decr(byte[] key) {
+        Client c = getClient(key);
+        c.decr(key);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> incrBy(String key, long integer) {
+        Client c = getClient(key);
+        c.incrBy(key, integer);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> incrBy(byte[] key, long integer) {
         Client c = getClient(key);
         c.incrBy(key, integer);
         results.add(new FutureResult(c));
@@ -130,6 +223,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.LONG);
     }
 
+    public Response<Long> incr(byte[] 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);
@@ -137,6 +237,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.LONG);
     }
 
+    public Response<Long> append(byte[] key, byte[] 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);
@@ -144,6 +251,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.STRING);
     }
 
+    public Response<String> substr(byte[] 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);
@@ -151,6 +265,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.LONG);
     }
 
+    public Response<Long> hset(byte[] key, byte[] field, byte[] 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);
@@ -158,6 +279,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.STRING);
     }
 
+    public Response<String> hget(byte[] key, byte[] 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);
@@ -165,6 +293,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.LONG);
     }
 
+    public Response<Long> hsetnx(byte[] key, byte[] field, byte[] 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);
@@ -172,6 +307,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.STRING);
     }
 
+    public Response<String> hmset(byte[] key, Map<byte[], byte[]> 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);
@@ -179,7 +321,21 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.STRING_LIST);
     }
 
-    public Response<Long> hincrBy(String key, String field, int value) {
+    public Response<List<String>> hmget(byte[] key, byte[]... 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, long value) {
+        Client c = getClient(key);
+        c.hincrBy(key, field, value);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> hincrBy(byte[] key, byte[] field, long value) {
         Client c = getClient(key);
         c.hincrBy(key, field, value);
         results.add(new FutureResult(c));
@@ -193,6 +349,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.BOOLEAN);
     }
 
+    public Response<Boolean> hexists(byte[] key, byte[] 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);
@@ -200,6 +363,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.LONG);
     }
 
+    public Response<Long> hdel(byte[] key, byte[] 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);
@@ -207,6 +377,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.LONG);
     }
 
+    public Response<Long> hlen(byte[] 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);
@@ -214,13 +391,27 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.STRING_SET);
     }
 
-    public Response<Set<String>> hvals(String key) {
+    public Response<Set<String>> hkeys(byte[] key) {
         Client c = getClient(key);
-        c.hvals(key);
+        c.hkeys(key);
         results.add(new FutureResult(c));
         return getResponse(BuilderFactory.STRING_SET);
     }
 
+    public Response<List<String>> hvals(String key) {
+        Client c = getClient(key);
+        c.hvals(key);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.STRING_LIST);
+    }
+
+    public Response<List<String>> hvals(byte[] key) {
+        Client c = getClient(key);
+        c.hvals(key);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.STRING_LIST);
+    }
+
     public Response<Map<String, String>> hgetAll(String key) {
         Client c = getClient(key);
         c.hgetAll(key);
@@ -228,6 +419,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.STRING_MAP);
     }
 
+    public Response<Map<String, String>> hgetAll(byte[] 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);
@@ -235,6 +433,27 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.LONG);
     }
 
+    public Response<Long> rpush(byte[] key, byte[] string) {
+        Client c = getClient(key);
+        c.rpush(key, string);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> rpushx(String key, String string) {
+        Client c = getClient(key);
+        c.rpushx(key, string);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> rpushx(byte[] key, byte[] string) {
+        Client c = getClient(key);
+        c.rpushx(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);
@@ -242,6 +461,27 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.LONG);
     }
 
+    public Response<Long> lpush(byte[] key, byte[] string) {
+        Client c = getClient(key);
+        c.lpush(key, string);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> lpushx(String key, String string) {
+        Client c = getClient(key);
+        c.lpushx(key, string);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> lpushx(byte[] key, byte[] bytes) {
+        Client c = getClient(key);
+        c.lpushx(key, bytes);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.LONG);
+    }
+
     public Response<Long> llen(String key) {
         Client c = getClient(key);
         c.llen(key);
@@ -249,20 +489,55 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.LONG);
     }
 
-    public Response<List<String>> lrange(String key, int start, int end) {
+    public Response<Long> llen(byte[] key) {
+        Client c = getClient(key);
+        c.llen(key);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<List<String>> lrange(String key, long start, long 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) {
+    public Response<List<String>> lrange(byte[] key, long start, long 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, long start, long end) {
         Client c = getClient(key);
         c.ltrim(key, start, end);
         results.add(new FutureResult(c));
         return getResponse(BuilderFactory.STRING);
     }
 
+    public Response<String> ltrim(byte[] key, long start, long end) {
+        Client c = getClient(key);
+        c.ltrim(key, start, end);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Long> persist(String key) {
+        Client c = getClient(key);
+        c.persist(key);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> persist(byte[] key) {
+        Client c = getClient(key);
+        c.persist(key);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.LONG);
+    }
+
     public Response<String> lindex(String key, int index) {
         Client c = getClient(key);
         c.lindex(key, index);
@@ -270,14 +545,35 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.STRING);
     }
 
-    public Response<String> lset(String key, int index, String value) {
+    public Response<String> lindex(byte[] 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, long 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) {
+    public Response<String> lset(byte[] key, long index, byte[] 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, long count, String value) {
+        Client c = getClient(key);
+        c.lrem(key, count, value);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> lrem(byte[] key, long count, byte[] value) {
         Client c = getClient(key);
         c.lrem(key, count, value);
         results.add(new FutureResult(c));
@@ -291,6 +587,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.STRING);
     }
 
+    public Response<String> lpop(byte[] 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);
@@ -298,6 +601,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.STRING);
     }
 
+    public Response<String> rpop(byte[] 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);
@@ -305,6 +615,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.LONG);
     }
 
+    public Response<Long> sadd(byte[] key, byte[] 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);
@@ -312,6 +629,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.STRING_SET);
     }
 
+    public Response<Set<String>> smembers(byte[] 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);
@@ -319,6 +643,27 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.LONG);
     }
 
+    public Response<Long> srem(byte[] key, byte[] member) {
+        Client c = getClient(key);
+        c.srem(key, member);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> strlen(String key) {
+        Client c = getClient(key);
+        c.strlen(key);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> strlen(byte[] key) {
+        Client c = getClient(key);
+        c.strlen(key);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.LONG);
+    }
+
     public Response<String> spop(String key) {
         Client c = getClient(key);
         c.spop(key);
@@ -326,6 +671,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.STRING);
     }
 
+    public Response<String> spop(byte[] 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);
@@ -333,6 +685,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.LONG);
     }
 
+    public Response<Long> scard(byte[] 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);
@@ -340,6 +699,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.BOOLEAN);
     }
 
+    public Response<Boolean> sismember(byte[] key, byte[] 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);
@@ -347,6 +713,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.STRING);
     }
 
+    public Response<String> srandmember(byte[] 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);
@@ -354,6 +727,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.LONG);
     }
 
+    public Response<Long> zadd(byte[] key, double score, byte[] 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);
@@ -361,6 +741,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
+    public Response<Set<String>> zrange(byte[] 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);
@@ -368,6 +755,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.LONG);
     }
 
+    public Response<Long> zrem(byte[] key, byte[] 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);
@@ -375,6 +769,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.DOUBLE);
     }
 
+    public Response<Double> zincrby(byte[] key, double score, byte[] 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);
@@ -382,6 +783,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.LONG);
     }
 
+    public Response<Long> zrank(byte[] key, byte[] 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);
@@ -389,6 +797,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.LONG);
     }
 
+    public Response<Long> zrevrank(byte[] key, byte[] 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);
@@ -396,6 +811,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
+    public Response<Set<String>> zrevrange(byte[] 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);
@@ -403,6 +825,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.TUPLE_ZSET);
     }
 
+    public Response<Set<Tuple>> zrangeWithScores(byte[] 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);
@@ -410,6 +839,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.TUPLE_ZSET);
     }
 
+    public Response<Set<Tuple>> zrevrangeWithScores(byte[] 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);
@@ -417,6 +853,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.LONG);
     }
 
+    public Response<Long> zcard(byte[] 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);
@@ -424,13 +867,27 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.DOUBLE);
     }
 
-    public Response<Double> sort(String key) {
+    public Response<Double> zscore(byte[] key, byte[] member) {
         Client c = getClient(key);
-        c.sort(key);
+        c.zscore(key, member);
         results.add(new FutureResult(c));
         return getResponse(BuilderFactory.DOUBLE);
     }
 
+    public Response<Long> sort(String key) {
+        Client c = getClient(key);
+        c.sort(key);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> sort(byte[] key) {
+        Client c = getClient(key);
+        c.sort(key);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.LONG);
+    }
+
     public Response<List<String>> sort(String key, SortingParams sortingParameters) {
         Client c = getClient(key);
         c.sort(key, sortingParameters);
@@ -438,6 +895,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.STRING_LIST);
     }
 
+    public Response<List<String>> sort(byte[] 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);
@@ -445,6 +909,69 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.LONG);
     }
 
+    public Response<Long> zcount(byte[] key, double min, double max) {
+        Client c = getClient(key);
+        c.zcount(key, toByteArray(min), toByteArray(max));
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Set<String>> zrevrangeByScore(String key, String max, String min) {
+        Client c = getClient(key);
+        c.zrevrangeByScore(key, min, max);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.STRING_ZSET);
+    }
+
+    public Response<Set<String>> zrevrangeByScore(String key, double max, double min) {
+        Client c = getClient(key);
+        c.zrevrangeByScore(key, min, max);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.STRING_ZSET);
+    }
+
+    public Response<Set<String>> zrevrangeByScore(byte[] key, double max, double min) {
+        Client c = getClient(key);
+        c.zrevrangeByScore(key, toByteArray(min), toByteArray(max));
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.STRING_ZSET);
+    }
+
+    public Response<Set<String>> zrevrangeByScore(byte[] key, byte[] max, byte[] min) {
+        Client c = getClient(key);
+        c.zrevrangeByScore(key, min, max);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.STRING_ZSET);
+    }
+
+    public Response<Set<String>> zrevrangeByScore(String key, double max, double min, int offset, int count) {
+        Client c = getClient(key);
+        c.zrevrangeByScore(key, min, max, offset, count);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.STRING_ZSET);
+    }
+
+    public Response<Set<String>> zrevrangeByScore(byte[] key, double max, double min, int offset, int count) {
+        Client c = getClient(key);
+        c.zrevrangeByScore(key, toByteArray(min), toByteArray(max), offset, count);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.STRING_ZSET);
+    }
+
+    public Response<Set<String>> zrevrangeByScore(byte[] key, byte[] max, byte[] min, int offset, int count) {
+        Client c = getClient(key);
+        c.zrevrangeByScore(key, min, max, offset, count);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.STRING_ZSET);
+    }
+
+    public Response<Set<String>> zrangeByScore(String key, String min, String 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) {
         Client c = getClient(key);
         c.zrangeByScore(key, min, max);
@@ -452,6 +979,20 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
+    public Response<Set<String>> zrangeByScore(byte[] key, double min, double max) {
+        Client c = getClient(key);
+        c.zrangeByScore(key, toByteArray(min), toByteArray(max));
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.STRING_ZSET);
+    }
+
+    public Response<Set<String>> zrangeByScore(byte[] key, byte[] min, byte[] 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);
@@ -460,6 +1001,22 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.STRING_ZSET);
     }
 
+    public Response<Set<String>> zrangeByScore(byte[] key, double min, double max,
+                                               int offset, int count) {
+        Client c = getClient(key);
+        c.zrangeByScore(key, toByteArray(min), toByteArray(max), offset, count);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.STRING_ZSET);
+    }
+
+    public Response<Set<String>> zrangeByScore(byte[] key, byte[] min, byte[] 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);
@@ -467,6 +1024,20 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.TUPLE_ZSET);
     }
 
+    public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, double min, double max) {
+        Client c = getClient(key);
+        c.zrangeByScoreWithScores(key, toByteArray(min), toByteArray(max));
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.TUPLE_ZSET);
+    }
+
+    public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, byte[] min, byte[] 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);
@@ -475,6 +1046,64 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.TUPLE_ZSET);
     }
 
+    public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, double min, double max,
+            int offset, int count) {
+        Client c = getClient(key);
+        c.zrangeByScoreWithScores(key, toByteArray(min), toByteArray(max), offset, count);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.TUPLE_ZSET);
+    }
+
+    public Response<Set<Tuple>> zrangeByScoreWithScores(byte[] key, byte[] min, byte[] 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<Set<Tuple>> zrevrangeByScoreWithScores(String key, double max, double min) {
+        Client c = getClient(key);
+        c.zrevrangeByScoreWithScores(key, min, max);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.TUPLE_ZSET);
+    }
+
+    public Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key, double max, double min) {
+        Client c = getClient(key);
+        c.zrevrangeByScoreWithScores(key, toByteArray(min), toByteArray(max));
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.TUPLE_ZSET);
+    }
+
+    public Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min) {
+        Client c = getClient(key);
+        c.zrevrangeByScoreWithScores(key, min, max);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.TUPLE_ZSET);
+    }
+
+    public Response<Set<Tuple>> zrevrangeByScoreWithScores(String key, double max, double min, int offset, int count) {
+        Client c = getClient(key);
+        c.zrevrangeByScoreWithScores(key, min, max, offset, count);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.TUPLE_ZSET);
+    }
+
+    public Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key, double max, double min, int offset, int count) {
+        Client c = getClient(key);
+        c.zrevrangeByScoreWithScores(key, toByteArray(min), toByteArray(max), offset, count);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.TUPLE_ZSET);
+    }
+
+    public Response<Set<Tuple>> zrevrangeByScoreWithScores(byte[] key, byte[] max, byte[] min, int offset, int count) {
+        Client c = getClient(key);
+        c.zrevrangeByScoreWithScores(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);
@@ -482,6 +1111,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.LONG);
     }
 
+    public Response<Long> zremrangeByRank(byte[] 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);
@@ -489,6 +1125,20 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.LONG);
     }
 
+    public Response<Long> zremrangeByScore(byte[] key, double start, double end) {
+        Client c = getClient(key);
+        c.zremrangeByScore(key, toByteArray(start), toByteArray(end));
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<Long> zremrangeByScore(byte[] key, byte[] start, byte[] 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);
@@ -497,6 +1147,14 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.LONG);
     }
 
+    public Response<Long> linsert(byte[] key, LIST_POSITION where, byte[] pivot,
+                                  byte[] 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);
@@ -504,6 +1162,13 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.BOOLEAN);
     }
 
+    public Response<Boolean> getbit(byte[] 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);
@@ -511,15 +1176,35 @@ public class ShardedJedisPipeline extends Queable {
         return getResponse(BuilderFactory.BOOLEAN);
     }
 
+    public Response<Boolean> setbit(byte[] key, long offset, byte[] 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) {
+    public Response<Long> setrange(byte[] key, long offset, byte[] value) {
+        Client c = getClient(key);
+        c.setrange(key, offset, value);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.LONG);
+    }
+
+    public Response<String> getrange(String key, long startOffset, long endOffset) {
+        Client c = getClient(key);
+        c.getrange(key, startOffset, endOffset);
+        results.add(new FutureResult(c));
+        return getResponse(BuilderFactory.STRING);
+    }
+
+    public Response<Long> getrange(byte[] key, long startOffset, long endOffset) {
         Client c = getClient(key);
         c.getrange(key, startOffset, endOffset);
         results.add(new FutureResult(c));
@@ -574,4 +1259,10 @@ public class ShardedJedisPipeline extends Queable {
         clients.add(client);
         return client;
     }
+
+    private Client getClient(byte[] key) {
+        Client client = jedis.getShard(key).getClient();
+        clients.add(client);
+        return client;
+    }
 }
\ No newline at end of file