Index: src/0dev.org/ioutil/ioutil.go
==================================================================
--- src/0dev.org/ioutil/ioutil.go
+++ src/0dev.org/ioutil/ioutil.go
@@ -1,10 +1,9 @@
 // Package ioutil contains various constructs for io operations
 package ioutil
 
 import (
-	//"fmt"
 	"io"
 )
 
 // An function alias type that implements io.Writer
 type WriterFunc func([]byte) (int, error)
@@ -22,30 +21,28 @@
 	return r(b)
 }
 
 // Returns a reader that will delegate calls to Read(...) while ensuring
 // that the output buffer will never be smaller than the required size
-func MinReader(reader io.Reader, size int) io.Reader {
+// and will be downsized to a multiple of the required size if larger
+func BlockReader(reader io.Reader, size int) io.Reader {
 	var buffer []byte = make([]byte, 0, size)
 
 	return ReaderFunc(func(output []byte) (int, error) {
 		var (
 			readCount int
 			err       error
 		)
 	start:
-		//fmt.Println("Requesting read with length ", len(output), "buffer's length is ", len(buffer))
-
 		// Reply with the buffered data if there is any
 		if len(buffer) > 0 {
 			readCount = copy(output, buffer)
 
 			// Advance the data in the buffer
 			buffer = buffer[:copy(buffer, buffer[readCount:])]
 
-			//fmt.Println("After buffer read - buffer lenght is", len(buffer))
-
+			// Return count and error if we have read the whole buffer
 			if len(buffer) == 0 {
 				return readCount, err
 			}
 
 			// Do not propagate an error until the buffer is exhausted
@@ -52,23 +49,22 @@
 			return readCount, nil
 		}
 
 		// Delegate if the buffer is empty and the destination buffer is large enough
 		if len(output) >= size {
-			//fmt.Println("Delegating read for output length ", len(output), " and size ", size)
 			return reader.Read(output[:(len(output)/size)*size])
 		}
 
 		// Perform a read into the buffer
 		readCount, err = reader.Read(buffer[:size])
 
-		// Size the buffer down to the read data size and restart
+		// Size the buffer down to the read data size
+		// and restart if we have successfully read some bytes
 		buffer = buffer[:readCount]
-
-		//fmt.Println("Read into buffer: ", len(buffer), "bytes")
-
 		if len(buffer) > 0 {
 			goto start
 		}
+
+		// Returning on err/misbehaving noop reader
 		return 0, err
 	})
 }

Index: src/0dev.org/predictor/predictor.go
==================================================================
--- src/0dev.org/predictor/predictor.go
+++ src/0dev.org/predictor/predictor.go
@@ -119,35 +119,17 @@
 // and decompresses data according to the predictor algorithm
 func Decompressor(reader io.Reader) io.Reader {
 	var ctx context
 	ctx.input = make([]byte, 0, 8)
 
-	return iou.ReaderFunc(func(output []byte) (int, error) {
+	return iou.BlockReader(iou.ReaderFunc(func(output []byte) (int, error) {
 		var (
 			err               error
 			flags, predicted  byte
 			rc, total, copied int
 		)
 
-		// Sanity check for space to read into
-		if len(output) == 0 {
-			return 0, nil
-		}
-
-		// Check whether we have leftover data in the buffer
-		if len(ctx.input) > 0 {
-			rc = copy(output, ctx.input)
-
-			// Check whether we still have leftover data in the buffer :)
-			if rc < len(ctx.input) {
-				// Shift the remaining bytes at the start of the buffer
-				//  and resize the buffer accordingly
-				ctx.input = ctx.input[:copy(ctx.input, ctx.input[rc:])]
-			}
-			return rc, nil
-		}
-
 		// Read the next prediction header
 	readHeader:
 		rc, err = reader.Read(ctx.input[:1])
 		// Fail on error unless it is EOF
 		if err != nil && err != io.EOF {
@@ -194,24 +176,17 @@
 
 		// Copy the decompressed data to the output and accumulate the count
 		copied = copy(output, ctx.input[:rc])
 		total += copied
 
-		// Check for remaining bytes that dont fit in the output buffer
-		if copied < rc {
-			// Shift the remaining bytes at the start of the buffer
-			//  and resize the buffer accordingly
-			ctx.input = ctx.input[:copy(ctx.input, ctx.input[copied:rc])]
-		} else {
-			// Clear the buffer
-			ctx.input = ctx.input[:0]
-
-			// Loop for another pass if there is available space in the output
-			output = output[copied:]
-			if len(output) > 0 && err == nil {
-				goto readHeader
-			}
+		// Clear the buffer
+		ctx.input = ctx.input[:0]
+
+		// Loop for another pass if there is available space in the output
+		output = output[copied:]
+		if len(output) > 0 && err == nil {
+			goto readHeader
 		}
 
 		return total, err
-	})
+	}), 8)
 }