Index: uspace/app/bithenge/print.c
===================================================================
--- uspace/app/bithenge/print.c	(revision 520acaf919bc5eaa42052f07a1276495bf0eada1)
+++ uspace/app/bithenge/print.c	(revision 5f679702eab8b71b539c8b6540d64ad41702c3fb)
@@ -68,5 +68,5 @@
 }
 
-static int print_internal(bithenge_print_type_t type, bithenge_internal_node_t *node)
+static int print_internal(bithenge_print_type_t type, bithenge_node_t *node)
 {
 	int rc;
@@ -80,5 +80,5 @@
 }
 
-static int print_boolean(bithenge_print_type_t type, bithenge_boolean_node_t *node)
+static int print_boolean(bithenge_print_type_t type, bithenge_node_t *node)
 {
 	bool value = bithenge_boolean_node_value(node);
@@ -94,5 +94,5 @@
 }
 
-static int print_integer(bithenge_print_type_t type, bithenge_integer_node_t *node)
+static int print_integer(bithenge_print_type_t type, bithenge_node_t *node)
 {
 	bithenge_int_t value = bithenge_integer_node_value(node);
@@ -101,5 +101,5 @@
 }
 
-static int print_string(bithenge_print_type_t type, bithenge_string_node_t *node)
+static int print_string(bithenge_print_type_t type, bithenge_node_t *node)
 {
 	size_t off = 0;
@@ -126,11 +126,11 @@
 		return EINVAL;
 	case BITHENGE_NODE_INTERNAL:
-		return print_internal(type, bithenge_as_internal_node(tree));
+		return print_internal(type, tree);
 	case BITHENGE_NODE_BOOLEAN:
-		return print_boolean(type, bithenge_as_boolean_node(tree));
+		return print_boolean(type, tree);
 	case BITHENGE_NODE_INTEGER:
-		return print_integer(type, bithenge_as_integer_node(tree));
+		return print_integer(type, tree);
 	case BITHENGE_NODE_STRING:
-		return print_string(type, bithenge_as_string_node(tree));
+		return print_string(type, tree);
 	}
 	return ENOTSUP;
Index: uspace/app/bithenge/tree.c
===================================================================
--- uspace/app/bithenge/tree.c	(revision 520acaf919bc5eaa42052f07a1276495bf0eada1)
+++ uspace/app/bithenge/tree.c	(revision 5f679702eab8b71b539c8b6540d64ad41702c3fb)
@@ -41,10 +41,8 @@
 int bithenge_node_destroy(bithenge_node_t *node)
 {
-	bithenge_string_node_t *string_node;
 	switch (bithenge_node_type(node)) {
 	case BITHENGE_NODE_STRING:
-		string_node = bithenge_as_string_node(node);
-		if (string_node->needs_free)
-			free(string_node->value);
+		if (node->string_value.needs_free)
+			free(node->string_value.ptr);
 		break;
 	case BITHENGE_NODE_INTERNAL:
@@ -52,5 +50,5 @@
 		break;
 	case BITHENGE_NODE_BOOLEAN:
-		return EOK;
+		return EOK; // the boolean nodes are allocated statically below
 	case BITHENGE_NODE_INTEGER: /* pass-through */
 	case BITHENGE_NODE_NONE:
@@ -63,5 +61,5 @@
 typedef struct
 {
-	bithenge_internal_node_t base;
+	bithenge_node_t base;
 	bithenge_node_t **nodes;
 	bithenge_int_t len;
@@ -69,13 +67,13 @@
 } simple_internal_node_t;
 
-static simple_internal_node_t *internal_as_simple(bithenge_internal_node_t *node)
+static simple_internal_node_t *node_as_simple(bithenge_node_t *node)
 {
 	return (simple_internal_node_t *)node;
 }
 
-static int simple_internal_node_for_each(bithenge_internal_node_t *base, bithenge_for_each_func_t func, void *data)
+static int simple_internal_node_for_each(bithenge_node_t *base, bithenge_for_each_func_t func, void *data)
 {
 	int rc;
-	simple_internal_node_t *node = internal_as_simple(base);
+	simple_internal_node_t *node = node_as_simple(base);
 	for (bithenge_int_t i = 0; i < node->len; i++) {
 		rc = func(node->nodes[2*i+0], node->nodes[2*i+1], data);
@@ -92,5 +90,5 @@
 static bithenge_node_t *simple_internal_as_node(simple_internal_node_t *node)
 {
-	return bithenge_internal_as_node(&node->base);
+	return &node->base;
 }
 
@@ -101,6 +99,6 @@
 	if (!node)
 		return ENOMEM;
-	node->base.base.type = BITHENGE_NODE_INTERNAL;
-	node->base.ops = &simple_internal_node_ops;
+	node->base.type = BITHENGE_NODE_INTERNAL;
+	node->base.internal_ops = &simple_internal_node_ops;
 	node->nodes = nodes;
 	node->len = len;
@@ -110,11 +108,11 @@
 }
 
-static bithenge_boolean_node_t false_node = { {BITHENGE_NODE_BOOLEAN}, false };
-static bithenge_boolean_node_t true_node = { {BITHENGE_NODE_BOOLEAN}, true };
+static bithenge_node_t false_node = { BITHENGE_NODE_BOOLEAN, .boolean_value = false };
+static bithenge_node_t true_node = { BITHENGE_NODE_BOOLEAN, .boolean_value = true };
 
 int bithenge_new_boolean_node(bithenge_node_t **out, bool value)
 {
 	assert(out);
-	*out = bithenge_boolean_as_node(value ? &true_node : &false_node);
+	*out = value ? &true_node : &false_node;
 	return EOK;
 }
@@ -123,10 +121,10 @@
 {
 	assert(out);
-	bithenge_integer_node_t *node = malloc(sizeof(*node));
+	bithenge_node_t *node = malloc(sizeof(*node));
 	if (!node)
 		return ENOMEM;
-	node->base.type = BITHENGE_NODE_INTEGER;
-	node->value = value;
-	*out = bithenge_integer_as_node(node);
+	node->type = BITHENGE_NODE_INTEGER;
+	node->integer_value = value;
+	*out = node;
 	return EOK;
 }
@@ -135,11 +133,11 @@
 {
 	assert(out);
-	bithenge_string_node_t *node = malloc(sizeof(*node));
+	bithenge_node_t *node = malloc(sizeof(*node));
 	if (!node)
 		return ENOMEM;
-	node->base.type = BITHENGE_NODE_STRING;
-	node->value = value;
-	node->needs_free = needs_free;
-	*out = bithenge_string_as_node(node);
+	node->type = BITHENGE_NODE_STRING;
+	node->string_value.ptr = value;
+	node->string_value.needs_free = needs_free;
+	*out = node;
 	return EOK;
 }
Index: uspace/app/bithenge/tree.h
===================================================================
--- uspace/app/bithenge/tree.h	(revision 520acaf919bc5eaa42052f07a1276495bf0eada1)
+++ uspace/app/bithenge/tree.h	(revision 5f679702eab8b71b539c8b6540d64ad41702c3fb)
@@ -62,4 +62,13 @@
 typedef struct bithenge_node_t {
 	bithenge_node_type_t type;
+	union {
+		struct bithenge_internal_node_ops_t *internal_ops;
+		bool boolean_value;
+		bithenge_int_t integer_value;
+		struct {
+			const char *ptr;
+			bool needs_free;
+		} string_value;
+	};
 } bithenge_node_t;
 
@@ -71,91 +80,26 @@
 typedef int (*bithenge_for_each_func_t)(bithenge_node_t *key, bithenge_node_t *value, void *data);
 
-typedef struct {
-	bithenge_node_t base;
-	const struct bithenge_internal_node_ops_t *ops;
-} bithenge_internal_node_t;
-
 typedef struct bithenge_internal_node_ops_t {
-	int (*for_each)(bithenge_internal_node_t *node, bithenge_for_each_func_t func, void *data);
+	int (*for_each)(bithenge_node_t *node, bithenge_for_each_func_t func, void *data);
 } bithenge_internal_node_ops_t;
 
-typedef struct {
-	bithenge_node_t base;
-	bool value;
-} bithenge_boolean_node_t;
-
-typedef struct {
-	bithenge_node_t base;
-	bithenge_int_t value;
-} bithenge_integer_node_t;
-
-typedef struct {
-	bithenge_node_t base;
-	const char *value;
-	bool needs_free;
-} bithenge_string_node_t;
-
-static inline bithenge_node_t *bithenge_internal_as_node(bithenge_internal_node_t *node)
+static inline int bithenge_node_for_each(bithenge_node_t *node, bithenge_for_each_func_t func, void *data)
 {
-	return &node->base;
+	return node->internal_ops->for_each(node, func, data);
 }
 
-static inline bithenge_internal_node_t *bithenge_as_internal_node(bithenge_node_t *node)
+static inline bool bithenge_boolean_node_value(bithenge_node_t *node)
 {
-	assert(node->type == BITHENGE_NODE_INTERNAL);
-	return (bithenge_internal_node_t *)node;
+	return node->boolean_value;
 }
 
-static inline int bithenge_node_for_each(bithenge_internal_node_t *node, bithenge_for_each_func_t func, void *data)
+static inline bithenge_int_t bithenge_integer_node_value(bithenge_node_t *node)
 {
-	return node->ops->for_each(node, func, data);
+	return node->integer_value;
 }
 
-static inline bithenge_node_t *bithenge_boolean_as_node(bithenge_boolean_node_t *node)
+static inline const char *bithenge_string_node_value(bithenge_node_t *node)
 {
-	return &node->base;
-}
-
-static inline bithenge_boolean_node_t *bithenge_as_boolean_node(bithenge_node_t *node)
-{
-	assert(node->type == BITHENGE_NODE_BOOLEAN);
-	return (bithenge_boolean_node_t *)node;
-}
-
-static inline bool bithenge_boolean_node_value(bithenge_boolean_node_t *node)
-{
-	return node->value;
-}
-
-static inline bithenge_node_t *bithenge_integer_as_node(bithenge_integer_node_t *node)
-{
-	return &node->base;
-}
-
-static inline bithenge_integer_node_t *bithenge_as_integer_node(bithenge_node_t *node)
-{
-	assert(node->type == BITHENGE_NODE_INTEGER);
-	return (bithenge_integer_node_t *)node;
-}
-
-static inline bithenge_int_t bithenge_integer_node_value(bithenge_integer_node_t *node)
-{
-	return node->value;
-}
-
-static inline bithenge_node_t *bithenge_string_as_node(bithenge_string_node_t *node)
-{
-	return &node->base;
-}
-
-static inline bithenge_string_node_t *bithenge_as_string_node(bithenge_node_t *node)
-{
-	assert(node->type == BITHENGE_NODE_STRING);
-	return (bithenge_string_node_t *)node;
-}
-
-static inline const char *bithenge_string_node_value(bithenge_string_node_t *node)
-{
-	return node->value;
+	return node->string_value.ptr;
 }