Index: uspace/lib/bithenge/expression.c
===================================================================
--- uspace/lib/bithenge/expression.c	(revision 3a7356dc00f6c8a7d85df4545490283e76be8226)
+++ uspace/lib/bithenge/expression.c	(revision 1c79996e4cd922c6012ceb0b80e17b06cc0ed5e5)
@@ -1066,8 +1066,9 @@
 		if (rc != EOK)
 			return rc;
-		b_size = offset + *size - self->a_size;
+		b_size = *size - a_size;
+		assert(a_size % 8 == 0); /* TODO: don't require this */
 		rc = bithenge_blob_read_bits(self->b,
-		    offset + a_size - self->a_size, buffer + a_size, &b_size,
-		    little_endian);
+		    offset + a_size - self->a_size, buffer + a_size / 8,
+		    &b_size, little_endian);
 		if (rc != EOK)
 			return rc;
Index: uspace/lib/bithenge/sequence.c
===================================================================
--- uspace/lib/bithenge/sequence.c	(revision 3a7356dc00f6c8a7d85df4545490283e76be8226)
+++ uspace/lib/bithenge/sequence.c	(revision 1c79996e4cd922c6012ceb0b80e17b06cc0ed5e5)
@@ -915,5 +915,4 @@
 typedef struct {
 	seq_node_t base;
-	bool prefix;
 	bithenge_expression_t *expr;
 	bithenge_transform_t *xform;
@@ -995,13 +994,4 @@
 	}
 
-	if (!self->prefix) {
-		bool complete;
-		rc = seq_node_complete(do_while_as_seq(self), &complete);
-		if (rc != EOK)
-			return rc;
-		if (!complete)
-			return EINVAL;
-	}
-
 	return rc;
 }
@@ -1035,6 +1025,5 @@
 
 static int do_while_transform_make_node(do_while_transform_t *self,
-    bithenge_node_t **out, bithenge_scope_t *scope, bithenge_blob_t *blob,
-    bool prefix)
+    bithenge_node_t **out, bithenge_scope_t *scope, bithenge_blob_t *blob)
 {
 	do_while_node_t *node = malloc(sizeof(*node));
@@ -1060,18 +1049,7 @@
 	bithenge_expression_inc_ref(self->expr);
 	node->expr = self->expr;
-	node->prefix = prefix;
 	node->count = -1;
 	*out = do_while_as_node(node);
 	return EOK;
-}
-
-static int do_while_transform_apply(bithenge_transform_t *base,
-    bithenge_scope_t *scope, bithenge_node_t *in, bithenge_node_t **out)
-{
-	do_while_transform_t *self = transform_as_do_while(base);
-	if (bithenge_node_type(in) != BITHENGE_NODE_BLOB)
-		return EINVAL;
-	return do_while_transform_make_node(self, out, scope,
-	    bithenge_node_as_blob(in), false);
 }
 
@@ -1089,6 +1067,5 @@
 {
 	do_while_transform_t *self = transform_as_do_while(base);
-	int rc = do_while_transform_make_node(self, out_node, scope, blob,
-	    true);
+	int rc = do_while_transform_make_node(self, out_node, scope, blob);
 	if (rc != EOK)
 		return rc;
@@ -1121,5 +1098,4 @@
 
 static const bithenge_transform_ops_t do_while_transform_ops = {
-	.apply = do_while_transform_apply,
 	.prefix_apply = do_while_transform_prefix_apply,
 	.destroy = do_while_transform_destroy,
Index: uspace/lib/bithenge/transform.c
===================================================================
--- uspace/lib/bithenge/transform.c	(revision 3a7356dc00f6c8a7d85df4545490283e76be8226)
+++ uspace/lib/bithenge/transform.c	(revision 1c79996e4cd922c6012ceb0b80e17b06cc0ed5e5)
@@ -892,6 +892,6 @@
 MAKE_UINT_TRANSFORM(uint32le, uint32_t, uint32_t_le2host, prefix_length_4);
 MAKE_UINT_TRANSFORM(uint32be, uint32_t, uint32_t_be2host, prefix_length_4);
-MAKE_UINT_TRANSFORM(uint64le, uint64_t, uint32_t_le2host, prefix_length_8);
-MAKE_UINT_TRANSFORM(uint64be, uint64_t, uint32_t_be2host, prefix_length_8);
+MAKE_UINT_TRANSFORM(uint64le, uint64_t, uint64_t_le2host, prefix_length_8);
+MAKE_UINT_TRANSFORM(uint64be, uint64_t, uint64_t_be2host, prefix_length_8);
 
 
Index: uspace/lib/bithenge/tree.c
===================================================================
--- uspace/lib/bithenge/tree.c	(revision 3a7356dc00f6c8a7d85df4545490283e76be8226)
+++ uspace/lib/bithenge/tree.c	(revision 1c79996e4cd922c6012ceb0b80e17b06cc0ed5e5)
@@ -102,7 +102,8 @@
 /** Get a child of a node. Takes ownership of the key. If the node does not
  * provide this function, for_each will be used as an alternative, which may be
- * very slow.
- * @memberof bithenge_node_t
- * @param self The internal node to find a child of.
+ * very slow. Also works for blob nodes to find the byte value at a given
+ * index.
+ * @memberof bithenge_node_t
+ * @param self The internal/blob node to find a child of.
  * @param key The key to search for.
  * @param[out] out Holds the found node.
@@ -112,4 +113,23 @@
     bithenge_node_t **out)
 {
+	if (self->type == BITHENGE_NODE_BLOB) {
+		if (bithenge_node_type(key) != BITHENGE_NODE_INTEGER) {
+			bithenge_node_dec_ref(key);
+			return ENOENT;
+		}
+		bithenge_int_t offset = bithenge_integer_node_value(key);
+		bithenge_node_dec_ref(key);
+		uint8_t byte;
+		aoff64_t size = 1;
+		int rc = bithenge_blob_read(bithenge_node_as_blob(self),
+		    offset, (char *)&byte, &size);
+		if (rc != EOK)
+			return rc;
+		if (size != 1)
+			return ENOENT;
+
+		return bithenge_new_integer_node(out, byte);
+	}
+
 	assert(self->type == BITHENGE_NODE_INTERNAL);
 	if (self->internal_ops->get)