diff --git a/src/b-tree.c b/src/b-tree.c
index 130a795..255b0d3 100644
--- a/src/b-tree.c
+++ b/src/b-tree.c
@@ -1,5 +1,6 @@
 #include <blue/core/queue.h>
 #include <stdlib.h>
+#include <assert.h>
 #include <string.h>
 
 #include "b-tree.h"
@@ -18,7 +19,7 @@ struct cache_entry {
 };
 
 #define GET_ENTRY(tree, entries, index) \
-	(b_tree_node_entry *)((unsigned char *)(entries) + ((index) * (tree)->tree_ops->entry_size));
+	(b_tree_node_entry *)((unsigned char *)(entries) + ((index) * (tree)->tree_entry_size));
 
 
 static b_tree_node *cache_alloc_node(struct b_tree *tree)
@@ -32,7 +33,7 @@ static b_tree_node *cache_alloc_node(struct b_tree *tree)
 		}
 	}
 
-	struct cache_entry *e = malloc(sizeof *e + tree->tree_ops->node_size);
+	struct cache_entry *e = malloc(sizeof *e + tree->tree_node_size);
 	if (!e) {
 		return NULL;
 	}
@@ -52,10 +53,13 @@ static void cache_free_node(struct b_tree *tree, b_tree_node *node)
 	e->c_allocated = 0;
 }
 
-void b_tree_init(struct b_tree *tree, const struct b_tree_ops *ops, unsigned int order)
+void b_tree_init(struct b_tree *tree, const struct b_tree_ops *ops, unsigned int node_size, unsigned int entry_size, unsigned int order)
 {
 	memset(tree, 0x0, sizeof *tree);
+	assert((order % 2) == 0);
 	tree->tree_ops = ops;
+	tree->tree_node_size = node_size;
+	tree->tree_entry_size = entry_size;
 	tree->tree_order = order;
 }
 
@@ -114,14 +118,14 @@ static void node_set_entry(struct b_tree *tree, b_tree_node *node, unsigned long
 {
 	b_tree_node_entry *entries = tree->tree_ops->node_get_entries(node);
 	b_tree_node_entry *dest = GET_ENTRY(tree, entries, index);
-	memcpy(dest, entry, tree->tree_ops->entry_size);
+	memcpy(dest, entry, tree->tree_entry_size);
 }
 
 static void node_kill_entry(struct b_tree *tree, b_tree_node *node, unsigned long index)
 {
 	b_tree_node_entry *entries = tree->tree_ops->node_get_entries(node);
 	b_tree_node_entry *dest = GET_ENTRY(tree, entries, index);
-	memset(dest, 0x0, tree->tree_ops->entry_size);
+	memset(dest, 0x0, tree->tree_entry_size);
 }
 
 static void node_shift_entries(struct b_tree *tree, b_tree_node *node, unsigned long shift_from, long shift_by)
@@ -137,7 +141,7 @@ static void node_shift_entries(struct b_tree *tree, b_tree_node *node, unsigned
 	b_tree_node_entry *dest = GET_ENTRY(tree, entries, shift_from + shift_by);
 	unsigned int count = nr_entries - shift_from;
 
-	memmove(dest, src, tree->tree_ops->entry_size * count);
+	memmove(dest, src, tree->tree_entry_size * count);
 	if (shift_by < 0) {
 		dest = GET_ENTRY(tree, entries, nr_entries + shift_by);
 		count = abs(shift_by);
@@ -147,8 +151,8 @@ static void node_shift_entries(struct b_tree *tree, b_tree_node *node, unsigned
 		count = shift_by;
 	}
 
-	memset(dest, 0x0, count * tree->tree_ops->entry_size);
-	return 0;
+	memset(dest, 0x0, count * tree->tree_entry_size);
+	return;
 }
 
 static void node_shift_children(struct b_tree *tree, b_tree_node *node, unsigned long shift_from, long shift_by)
@@ -195,9 +199,9 @@ static void node_move_entries(struct b_tree *tree, b_tree_node *from, b_tree_nod
 	b_tree_node_entry *src = GET_ENTRY(tree, from_entries, src_index);
 	b_tree_node_entry *dest = GET_ENTRY(tree, to_entries, dest_index);
 
-	memmove(dest, src, count * tree->tree_ops->entry_size);
+	memmove(dest, src, count * tree->tree_entry_size);
 	if (src_index + count >= from_nr_entries) {
-		memset(src, 0x0, count * tree->tree_ops->entry_size);
+		memset(src, 0x0, count * tree->tree_entry_size);
 	} else {
 		node_shift_entries(tree, from, src_index + count, (int)count * -1);
 	}
@@ -268,7 +272,7 @@ static int node_is_leaf(struct b_tree *tree, b_tree_node *node)
 
 static void node_init(struct b_tree *tree, b_tree_node *out)
 {
-	memset(out, 0x0, tree->tree_ops->node_size);
+	memset(out, 0x0, tree->tree_node_size);
 	for (unsigned int i = 0; i < tree->tree_order; i++) {
 		node_set_child(tree, out, i, B_TREE_INVALID_PTR);
 	}
diff --git a/src/b-tree.h b/src/b-tree.h
index dd9ec8e..fbd4413 100644
--- a/src/b-tree.h
+++ b/src/b-tree.h
@@ -12,9 +12,6 @@ typedef struct { char _x; } b_tree_node;
 typedef struct { char _x; }b_tree_node_entry;
 
 struct b_tree_ops {
-	size_t node_size;
-	size_t entry_size;
-
 	int (*tree_get_node)(struct b_tree *, unsigned long, b_tree_node *);
 	int (*tree_put_node)(struct b_tree *, unsigned long, const b_tree_node *);
 	long (*tree_alloc_node)(struct b_tree *);
@@ -29,12 +26,14 @@ struct b_tree_ops {
 
 struct b_tree {
 	const struct b_tree_ops *tree_ops;
+	unsigned int tree_node_size;
+	unsigned int tree_entry_size;
 	b_queue tree_cache;
 	unsigned int tree_order;
 	long tree_root;
 };
 
-extern void b_tree_init(struct b_tree *tree, const struct b_tree_ops *ops, unsigned int order);
+extern void b_tree_init(struct b_tree *tree, const struct b_tree_ops *ops, unsigned int node_size, unsigned int entry_size, unsigned int order);
 extern int b_tree_put(struct b_tree *tree, const b_tree_node_entry *entry);
 
 #endif
diff --git a/src/create.c b/src/create.c
index 05bfa61..9a52654 100644
--- a/src/create.c
+++ b/src/create.c
@@ -124,9 +124,6 @@ static int entry_compare(const b_tree_node_entry *e0, const b_tree_node_entry *e
 }
 
 static const struct b_tree_ops ops = {
-	.node_size = sizeof(struct node),
-	.entry_size = sizeof(struct entry),
-
 	.tree_get_node = tree_get_node,
 	.tree_put_node = tree_put_node,
 	.tree_alloc_node = tree_alloc_node,
@@ -221,6 +218,8 @@ static int create(
 	const b_arglist *opt,
 	const b_array *args)
 {
+	printf("%zu\n", sizeof(struct ec3_cluster_group));
+	return 0;
 	const char *in_path = NULL, *out_path = NULL;
 
 	b_arglist_get_string(
@@ -241,7 +240,7 @@ static int create(
 	fwrite(&root, sizeof root, 1, fp);
 
 	struct data_tree tree;
-	b_tree_init(&tree.base, &ops, ORDER);
+	b_tree_init(&tree.base, &ops, sizeof(struct node), sizeof(struct entry), ORDER);
 	tree.fp = fp;