diff --git a/Makefile.am b/Makefile.am
index 362573d83..58e33093b 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -132,6 +132,7 @@ noinst_HEADERS += common/funcall.h
 noinst_HEADERS += common/hash.h
 noinst_HEADERS += common/hyperspace.h
 noinst_HEADERS += common/ids.h
+noinst_HEADERS += common/ieee.h
 noinst_HEADERS += common/index.h
 noinst_HEADERS += common/json_path.h
 noinst_HEADERS += common/key_change.h
@@ -393,6 +394,7 @@ noinst_HEADERS += client/keyop_info.h
 noinst_HEADERS += client/pending_aggregation.h
 noinst_HEADERS += client/pending_atomic.h
 noinst_HEADERS += client/pending_count.h
+noinst_HEADERS += client/pending_sum.h
 noinst_HEADERS += client/pending_get.h
 noinst_HEADERS += client/pending_get_partial.h
 noinst_HEADERS += client/pending_group_atomic.h
@@ -444,6 +446,7 @@ libhyperdex_client_la_SOURCES += client/pending_atomic.cc
 libhyperdex_client_la_SOURCES += client/pending_group_atomic.cc
 libhyperdex_client_la_SOURCES += client/pending.cc
 libhyperdex_client_la_SOURCES += client/pending_count.cc
+libhyperdex_client_la_SOURCES += client/pending_sum.cc
 libhyperdex_client_la_SOURCES += client/pending_get.cc
 libhyperdex_client_la_SOURCES += client/pending_get_partial.cc
 libhyperdex_client_la_SOURCES += client/pending_search.cc
diff --git a/admin/admin.cc b/admin/admin.cc
index 6c6bda72e..e64c91142 100644
--- a/admin/admin.cc
+++ b/admin/admin.cc
@@ -53,1008 +53,920 @@
 #include "admin/yieldable.h"
 
 #define ERROR(CODE) \
-    *status = HYPERDEX_ADMIN_ ## CODE; \
-    m_last_error.set_loc(__FILE__, __LINE__); \
-    m_last_error.set_msg()
+	*status = HYPERDEX_ADMIN_ ## CODE; \
+	m_last_error.set_loc(__FILE__, __LINE__); \
+	m_last_error.set_msg()
 
 using hyperdex::admin;
 
-admin :: admin(const char* coordinator, uint16_t port)
-    : m_coord(replicant_client_create(coordinator, port))
-    , m_busybee_mapper(&m_config)
-    , m_busybee(&m_busybee_mapper, 0)
-    , m_config()
-    , m_config_id(-1)
-    , m_config_status()
-    , m_config_state(0)
-    , m_config_data(NULL)
-    , m_config_data_sz(0)
-    , m_next_admin_id(1)
-    , m_next_server_nonce(1)
-    , m_handle_coord_ops(false)
-    , m_coord_ops()
-    , m_server_ops()
-    , m_multi_ops()
-    , m_failed()
-    , m_yieldable()
-    , m_yielding()
-    , m_yielded()
-    , m_pcs()
-    , m_last_error()
+admin :: admin(const char *coordinator, uint16_t port)
+	: m_coord(replicant_client_create(coordinator, port))
+	, m_busybee_mapper(&m_config)
+	, m_busybee(&m_busybee_mapper, 0)
+	, m_config()
+	, m_config_id(-1)
+	, m_config_status()
+	, m_config_state(0)
+	, m_config_data(NULL)
+	, m_config_data_sz(0)
+	, m_next_admin_id(1)
+	, m_next_server_nonce(1)
+	, m_handle_coord_ops(false)
+	, m_coord_ops()
+	, m_server_ops()
+	, m_multi_ops()
+	, m_failed()
+	, m_yieldable()
+	, m_yielding()
+	, m_yielded()
+	, m_pcs()
+	, m_last_error()
 {
-    m_busybee.set_external_fd(replicant_client_poll_fd(m_coord));
+	m_busybee.set_external_fd(replicant_client_poll_fd(m_coord));
 }
 
 admin :: ~admin() throw ()
 {
-    replicant_client_destroy(m_coord);
+	replicant_client_destroy(m_coord);
 }
 
 int64_t
-admin :: dump_config(hyperdex_admin_returncode* status,
-                     const char** config)
+admin :: dump_config(hyperdex_admin_returncode *status,
+                     const char **config)
 {
-    if (!maintain_coord_connection(status))
-    {
-        return -1;
-    }
-
-    int64_t id = m_next_admin_id;
-    ++m_next_admin_id;
-    std::string tmp = m_config.dump();
-    e::intrusive_ptr<pending> op = new pending_string(id, status, HYPERDEX_ADMIN_SUCCESS, tmp, config);
-    m_yieldable.push_back(op.get());
-    return op->admin_visible_id();
+	if (!maintain_coord_connection(status))
+	{
+		return -1;
+	}
+	int64_t id = m_next_admin_id;
+	++m_next_admin_id;
+	std::string tmp = m_config.dump();
+	e::intrusive_ptr<pending> op = new pending_string(id, status, HYPERDEX_ADMIN_SUCCESS, tmp, config);
+	m_yieldable.push_back(op.get());
+	return op->admin_visible_id();
 }
 
 int64_t
-admin :: list_subspaces(const char* space, hyperdex_admin_returncode* status, const char** subspaces)
+admin :: list_subspaces(const char *space, hyperdex_admin_returncode *status, const char **subspaces)
 {
-    if (!maintain_coord_connection(status))
-    {
-        return -1;
-    }
-
-    int64_t id = m_next_admin_id;
-    ++m_next_admin_id;
-    std::string tmp = m_config.list_subspaces(space);
-    e::intrusive_ptr<pending> op = new pending_string(id, status, HYPERDEX_ADMIN_SUCCESS, tmp, subspaces);
-    m_yieldable.push_back(op.get());
-    return op->admin_visible_id();
+	if (!maintain_coord_connection(status))
+	{
+		return -1;
+	}
+	int64_t id = m_next_admin_id;
+	++m_next_admin_id;
+	std::string tmp = m_config.list_subspaces(space);
+	e::intrusive_ptr<pending> op = new pending_string(id, status, HYPERDEX_ADMIN_SUCCESS, tmp, subspaces);
+	m_yieldable.push_back(op.get());
+	return op->admin_visible_id();
 }
 
 int64_t
-admin :: read_only(int ro, hyperdex_admin_returncode* status)
+admin :: read_only(int ro, hyperdex_admin_returncode *status)
 {
-    if (!maintain_coord_connection(status))
-    {
-        return -1;
-    }
-
-    bool set = ro != 0;
-    int64_t id = m_next_admin_id;
-    ++m_next_admin_id;
-    e::intrusive_ptr<coord_rpc> op = new coord_rpc_generic(id, status, (set ? "set read-only" : "set read-write"));
-    char buf[sizeof(uint8_t)];
-    buf[0] = set ? 1 : 0;
-    int64_t cid = rpc("read_only", buf, sizeof(uint8_t),
-                      &op->repl_status, &op->repl_output, &op->repl_output_sz);
-
-    if (cid >= 0)
-    {
-        m_coord_ops[cid] = op;
-        return op->admin_visible_id();
-    }
-    else
-    {
-        interpret_replicant_returncode(op->repl_status, status, &m_last_error);
-        return -1;
-    }
+	if (!maintain_coord_connection(status))
+	{
+		return -1;
+	}
+	bool set = ro != 0;
+	int64_t id = m_next_admin_id;
+	++m_next_admin_id;
+	e::intrusive_ptr<coord_rpc> op = new coord_rpc_generic(id, status, (set ? "set read-only" : "set read-write"));
+	char buf[sizeof(uint8_t)];
+	buf[0] = set ? 1 : 0;
+	int64_t cid = rpc("read_only", buf, sizeof(uint8_t),
+	                  &op->repl_status, &op->repl_output, &op->repl_output_sz);
+	if (cid >= 0)
+	{
+		m_coord_ops[cid] = op;
+		return op->admin_visible_id();
+	}
+	else
+	{
+		interpret_replicant_returncode(op->repl_status, status, &m_last_error);
+		return -1;
+	}
 }
 
 int64_t
-admin :: wait_until_stable(enum hyperdex_admin_returncode* status)
+admin :: wait_until_stable(enum hyperdex_admin_returncode *status)
 {
-    if (!maintain_coord_connection(status))
-    {
-        return -1;
-    }
-
-    int64_t id = m_next_admin_id;
-    ++m_next_admin_id;
-    e::intrusive_ptr<coord_rpc> op = new coord_rpc_generic(id, status, "wait for stability");
-    int64_t cid = replicant_client_cond_wait(m_coord, "hyperdex", "stable", m_config.version(), &op->repl_status, NULL, NULL);
-
-    if (cid >= 0)
-    {
-        m_coord_ops[cid] = op;
-        return op->admin_visible_id();
-    }
-    else
-    {
-        interpret_replicant_returncode(op->repl_status, status, &m_last_error);
-        return -1;
-    }
+	if (!maintain_coord_connection(status))
+	{
+		return -1;
+	}
+	int64_t id = m_next_admin_id;
+	++m_next_admin_id;
+	e::intrusive_ptr<coord_rpc> op = new coord_rpc_generic(id, status, "wait for stability");
+	int64_t cid = replicant_client_cond_wait(m_coord, "hyperdex", "stable", m_config.version(), &op->repl_status, NULL, NULL);
+	if (cid >= 0)
+	{
+		m_coord_ops[cid] = op;
+		return op->admin_visible_id();
+	}
+	else
+	{
+		interpret_replicant_returncode(op->repl_status, status, &m_last_error);
+		return -1;
+	}
 }
 
 int64_t
-admin :: fault_tolerance(const char* space, uint64_t ft,
-                         hyperdex_admin_returncode* status)
+admin :: fault_tolerance(const char *space, uint64_t ft,
+                         hyperdex_admin_returncode *status)
 {
-    if (!maintain_coord_connection(status))
-    {
-        return -1;
-    }
-
-    int64_t id = m_next_admin_id;
-    ++m_next_admin_id;
-    e::intrusive_ptr<coord_rpc> op = new coord_rpc_generic(id, status, "fault tolerance");
-    size_t space_sz = strlen(space);
-    std::vector<char> buf(space_sz + sizeof(uint64_t));
-    memcpy(&buf[0], space, space_sz);
-    e::pack64be(ft, &buf[0] + space_sz);
-
-    int64_t cid = rpc("fault_tolerance", &buf[0], space_sz + sizeof(uint64_t),
-                      &op->repl_status, &op->repl_output, &op->repl_output_sz);
-
-    if (cid >= 0)
-    {
-        m_coord_ops[cid] = op;
-        return op->admin_visible_id();
-    }
-    else
-    {
-        interpret_replicant_returncode(op->repl_status, status, &m_last_error);
-        return -1;
-    }
+	if (!maintain_coord_connection(status))
+	{
+		return -1;
+	}
+	int64_t id = m_next_admin_id;
+	++m_next_admin_id;
+	e::intrusive_ptr<coord_rpc> op = new coord_rpc_generic(id, status, "fault tolerance");
+	size_t space_sz = strlen(space);
+	std::vector<char> buf(space_sz + sizeof(uint64_t));
+	memcpy(&buf[0], space, space_sz);
+	e::pack64be(ft, &buf[0] + space_sz);
+	int64_t cid = rpc("fault_tolerance", &buf[0], space_sz + sizeof(uint64_t),
+	                  &op->repl_status, &op->repl_output, &op->repl_output_sz);
+	if (cid >= 0)
+	{
+		m_coord_ops[cid] = op;
+		return op->admin_visible_id();
+	}
+	else
+	{
+		interpret_replicant_returncode(op->repl_status, status, &m_last_error);
+		return -1;
+	}
 }
 
 int
-admin :: validate_space(const char* description,
-                        hyperdex_admin_returncode* status)
+admin :: validate_space(const char *description,
+                        hyperdex_admin_returncode *status)
 {
-    struct hyperspace* space_builder = hyperspace_parse(description);
-
-    if (!space_builder)
-    {
-        ERROR(NOMEM) << "ran out of memory";
-        return -1;
-    }
-
-    if (hyperspace_error(space_builder))
-    {
-        ERROR(BADSPACE) << "bad space " << hyperspace_error(space_builder);
-        return -1;
-    }
-
-    return 0;
+	struct hyperspace *space_builder = hyperspace_parse(description);
+	if (!space_builder)
+	{
+		ERROR(NOMEM) << "ran out of memory";
+		return -1;
+	}
+	if (hyperspace_error(space_builder))
+	{
+		ERROR(BADSPACE) << "bad space " << hyperspace_error(space_builder);
+		return -1;
+	}
+	return 0;
 }
 
 int64_t
-admin :: add_space(const char* description,
-                   hyperdex_admin_returncode* status)
+admin :: add_space(const char *description,
+                   hyperdex_admin_returncode *status)
 {
-    if (!maintain_coord_connection(status))
-    {
-        return -1;
-    }
-
-    struct hyperspace* space_builder = hyperspace_parse(description);
-
-    if (!space_builder)
-    {
-        ERROR(NOMEM) << "ran out of memory";
-        return -1;
-    }
-
-    if (hyperspace_error(space_builder))
-    {
-        ERROR(BADSPACE) << "bad space " << hyperspace_error(space_builder);
-        return -1;
-    }
-
-    hyperdex::space space;
-
-    if (!space_to_space(space_builder, &space))
-    {
-        ERROR(BADSPACE) << "bad space";
-        return -1;
-    }
-
-    std::auto_ptr<e::buffer> msg(e::buffer::create(pack_size(space)));
-    msg->pack_at(0) << space;
-
-    int64_t id = m_next_admin_id;
-    ++m_next_admin_id;
-    e::intrusive_ptr<coord_rpc> op = new coord_rpc_generic(id, status, "add space");
-    int64_t cid = rpc("space_add", reinterpret_cast<const char*>(msg->data()), msg->size(),
-                      &op->repl_status, &op->repl_output, &op->repl_output_sz);
-
-    if (cid >= 0)
-    {
-        m_coord_ops[cid] = op;
-        return op->admin_visible_id();
-    }
-    else
-    {
-        interpret_replicant_returncode(op->repl_status, status, &m_last_error);
-        return -1;
-    }
+	if (!maintain_coord_connection(status))
+	{
+		return -1;
+	}
+	struct hyperspace *space_builder = hyperspace_parse(description);
+	if (!space_builder)
+	{
+		ERROR(NOMEM) << "ran out of memory";
+		return -1;
+	}
+	if (hyperspace_error(space_builder))
+	{
+		ERROR(BADSPACE) << "bad space " << hyperspace_error(space_builder);
+		return -1;
+	}
+	hyperdex::space space;
+	if (!space_to_space(space_builder, &space))
+	{
+		ERROR(BADSPACE) << "bad space";
+		return -1;
+	}
+	std::auto_ptr<e::buffer> msg(e::buffer::create(pack_size(space)));
+	msg->pack_at(0) << space;
+	int64_t id = m_next_admin_id;
+	++m_next_admin_id;
+	e::intrusive_ptr<coord_rpc> op = new coord_rpc_generic(id, status, "add space");
+	int64_t cid = rpc("space_add", reinterpret_cast<const char *>(msg->data()), msg->size(),
+	                  &op->repl_status, &op->repl_output, &op->repl_output_sz);
+	if (cid >= 0)
+	{
+		m_coord_ops[cid] = op;
+		return op->admin_visible_id();
+	}
+	else
+	{
+		interpret_replicant_returncode(op->repl_status, status, &m_last_error);
+		return -1;
+	}
 }
 
 int64_t
-admin :: rm_space(const char* name,
-                  hyperdex_admin_returncode* status)
+admin :: rm_space(const char *name,
+                  hyperdex_admin_returncode *status)
 {
-    if (!maintain_coord_connection(status))
-    {
-        return -1;
-    }
-
-    int64_t id = m_next_admin_id;
-    ++m_next_admin_id;
-    e::intrusive_ptr<coord_rpc> op = new coord_rpc_generic(id, status, "rm space");
-    int64_t cid = rpc("space_rm", name, strlen(name) + 1,
-                      &op->repl_status, &op->repl_output, &op->repl_output_sz);
-
-    if (cid >= 0)
-    {
-        m_coord_ops[cid] = op;
-        return op->admin_visible_id();
-    }
-    else
-    {
-        interpret_replicant_returncode(op->repl_status, status, &m_last_error);
-        return -1;
-    }
+	if (!maintain_coord_connection(status))
+	{
+		return -1;
+	}
+	int64_t id = m_next_admin_id;
+	++m_next_admin_id;
+	e::intrusive_ptr<coord_rpc> op = new coord_rpc_generic(id, status, "rm space");
+	int64_t cid = rpc("space_rm", name, strlen(name) + 1,
+	                  &op->repl_status, &op->repl_output, &op->repl_output_sz);
+	if (cid >= 0)
+	{
+		m_coord_ops[cid] = op;
+		return op->admin_visible_id();
+	}
+	else
+	{
+		interpret_replicant_returncode(op->repl_status, status, &m_last_error);
+		return -1;
+	}
 }
 
 int64_t
-admin :: mv_space(const char* source, const char* target,
-                  hyperdex_admin_returncode* status)
+admin :: mv_space(const char *source, const char *target,
+                  hyperdex_admin_returncode *status)
 {
-    if (!maintain_coord_connection(status))
-    {
-        return -1;
-    }
-
-    const size_t source_sz = strlen(source);
-    const size_t target_sz = strlen(target);
-    std::vector<char> buf(source_sz + target_sz + 2);
-    memmove(&buf[0], source, source_sz);
-    buf[source_sz] = '\0';
-    memmove(&buf[source_sz + 1], target, target_sz);
-    buf[source_sz + 1 + target_sz] = '\0';
-    int64_t id = m_next_admin_id;
-    ++m_next_admin_id;
-    e::intrusive_ptr<coord_rpc> op = new coord_rpc_generic(id, status, "mv space");
-    int64_t cid = rpc("space_mv", &buf[0], buf.size(),
-                      &op->repl_status, &op->repl_output, &op->repl_output_sz);
-
-    if (cid >= 0)
-    {
-        m_coord_ops[cid] = op;
-        return op->admin_visible_id();
-    }
-    else
-    {
-        interpret_replicant_returncode(op->repl_status, status, &m_last_error);
-        return -1;
-    }
+	if (!maintain_coord_connection(status))
+	{
+		return -1;
+	}
+	const size_t source_sz = strlen(source);
+	const size_t target_sz = strlen(target);
+	std::vector<char> buf(source_sz + target_sz + 2);
+	memmove(&buf[0], source, source_sz);
+	buf[source_sz] = '\0';
+	memmove(&buf[source_sz + 1], target, target_sz);
+	buf[source_sz + 1 + target_sz] = '\0';
+	int64_t id = m_next_admin_id;
+	++m_next_admin_id;
+	e::intrusive_ptr<coord_rpc> op = new coord_rpc_generic(id, status, "mv space");
+	int64_t cid = rpc("space_mv", &buf[0], buf.size(),
+	                  &op->repl_status, &op->repl_output, &op->repl_output_sz);
+	if (cid >= 0)
+	{
+		m_coord_ops[cid] = op;
+		return op->admin_visible_id();
+	}
+	else
+	{
+		interpret_replicant_returncode(op->repl_status, status, &m_last_error);
+		return -1;
+	}
 }
 
 int64_t
-admin :: add_index(const char* space, const char* attr,
-                   hyperdex_admin_returncode* status)
+admin :: add_index(const char *space, const char *attr,
+                   hyperdex_admin_returncode *status)
 {
-    if (!maintain_coord_connection(status))
-    {
-        return -1;
-    }
-
-    size_t space_sz = strlen(space);
-    size_t attr_sz = strlen(attr);
-    std::vector<char> buf(space_sz + attr_sz + 2);
-    memmove(&buf[0], space, space_sz);
-    memmove(&buf[0] + space_sz + 1, attr, attr_sz);
-    buf[space_sz] = '\0';
-    buf[space_sz + 1 + attr_sz] = '\0';
-    int64_t id = m_next_admin_id;
-    ++m_next_admin_id;
-    e::intrusive_ptr<coord_rpc> op = new coord_rpc_generic(id, status, "add_index");
-    int64_t cid = rpc("index_add", &buf[0], buf.size(),
-                      &op->repl_status, &op->repl_output, &op->repl_output_sz);
-
-    if (cid >= 0)
-    {
-        m_coord_ops[cid] = op;
-        return op->admin_visible_id();
-    }
-    else
-    {
-        interpret_replicant_returncode(op->repl_status, status, &m_last_error);
-        return -1;
-    }
+	if (!maintain_coord_connection(status))
+	{
+		return -1;
+	}
+	size_t space_sz = strlen(space);
+	size_t attr_sz = strlen(attr);
+	std::vector<char> buf(space_sz + attr_sz + 2);
+	memmove(&buf[0], space, space_sz);
+	memmove(&buf[0] + space_sz + 1, attr, attr_sz);
+	buf[space_sz] = '\0';
+	buf[space_sz + 1 + attr_sz] = '\0';
+	int64_t id = m_next_admin_id;
+	++m_next_admin_id;
+	e::intrusive_ptr<coord_rpc> op = new coord_rpc_generic(id, status, "add_index");
+	int64_t cid = rpc("index_add", &buf[0], buf.size(),
+	                  &op->repl_status, &op->repl_output, &op->repl_output_sz);
+	if (cid >= 0)
+	{
+		m_coord_ops[cid] = op;
+		return op->admin_visible_id();
+	}
+	else
+	{
+		interpret_replicant_returncode(op->repl_status, status, &m_last_error);
+		return -1;
+	}
 }
 
 int64_t
 admin :: rm_index(uint64_t idxid,
-                  enum hyperdex_admin_returncode* status)
+                  enum hyperdex_admin_returncode *status)
 {
-    if (!maintain_coord_connection(status))
-    {
-        return -1;
-    }
-
-    char buf[sizeof(uint64_t)];
-    e::pack64be(idxid, buf);
-    int64_t id = m_next_admin_id;
-    ++m_next_admin_id;
-    e::intrusive_ptr<coord_rpc> op = new coord_rpc_generic(id, status, "rm_index");
-    int64_t cid = rpc("index_rm", buf, sizeof(uint64_t),
-                      &op->repl_status, &op->repl_output, &op->repl_output_sz);
-
-    if (cid >= 0)
-    {
-        m_coord_ops[cid] = op;
-        return op->admin_visible_id();
-    }
-    else
-    {
-        interpret_replicant_returncode(op->repl_status, status, &m_last_error);
-        return -1;
-    }
+	if (!maintain_coord_connection(status))
+	{
+		return -1;
+	}
+	char buf[sizeof(uint64_t)];
+	e::pack64be(idxid, buf);
+	int64_t id = m_next_admin_id;
+	++m_next_admin_id;
+	e::intrusive_ptr<coord_rpc> op = new coord_rpc_generic(id, status, "rm_index");
+	int64_t cid = rpc("index_rm", buf, sizeof(uint64_t),
+	                  &op->repl_status, &op->repl_output, &op->repl_output_sz);
+	if (cid >= 0)
+	{
+		m_coord_ops[cid] = op;
+		return op->admin_visible_id();
+	}
+	else
+	{
+		interpret_replicant_returncode(op->repl_status, status, &m_last_error);
+		return -1;
+	}
 }
 
 int64_t
-admin :: list_indices(const char* space, enum hyperdex_admin_returncode* status,
-                            const char** indexes)
+admin :: list_indices(const char *space, enum hyperdex_admin_returncode *status,
+                      const char **indexes)
 {
-    if (!maintain_coord_connection(status))
-    {
-        return -1;
-    }
-
-    int64_t id = m_next_admin_id;
-    ++m_next_admin_id;
-    std::string tmp = m_config.list_indices(space);
-    e::intrusive_ptr<pending> op = new pending_string(id, status, HYPERDEX_ADMIN_SUCCESS, tmp, indexes);
-    m_yieldable.push_back(op.get());
-    return op->admin_visible_id();
+	if (!maintain_coord_connection(status))
+	{
+		return -1;
+	}
+	int64_t id = m_next_admin_id;
+	++m_next_admin_id;
+	std::string tmp = m_config.list_indices(space);
+	e::intrusive_ptr<pending> op = new pending_string(id, status, HYPERDEX_ADMIN_SUCCESS, tmp, indexes);
+	m_yieldable.push_back(op.get());
+	return op->admin_visible_id();
 }
 
 int64_t
-admin :: list_spaces(hyperdex_admin_returncode* status,
-                     const char** spaces)
+admin :: list_spaces(hyperdex_admin_returncode *status,
+                     const char **spaces)
 {
-    if (!maintain_coord_connection(status))
-    {
-        return -1;
-    }
-
-    int64_t id = m_next_admin_id;
-    ++m_next_admin_id;
-    std::string tmp = m_config.list_spaces();
-    e::intrusive_ptr<pending> op = new pending_string(id, status, HYPERDEX_ADMIN_SUCCESS, tmp, spaces);
-    m_yieldable.push_back(op.get());
-    return op->admin_visible_id();
+	if (!maintain_coord_connection(status))
+	{
+		return -1;
+	}
+	int64_t id = m_next_admin_id;
+	++m_next_admin_id;
+	std::string tmp = m_config.list_spaces();
+	e::intrusive_ptr<pending> op = new pending_string(id, status, HYPERDEX_ADMIN_SUCCESS, tmp, spaces);
+	m_yieldable.push_back(op.get());
+	return op->admin_visible_id();
 }
 
 int64_t
-admin :: server_register(uint64_t token, const char* address,
-                         enum hyperdex_admin_returncode* status)
+admin :: server_register(uint64_t token, const char *address,
+                         enum hyperdex_admin_returncode *status)
 {
-    if (!maintain_coord_connection(status))
-    {
-        return -1;
-    }
-
-    server_id sid(token);
-    po6::net::location loc;
-    loc = po6::net::location(address);
-
-    int64_t id = m_next_admin_id;
-    ++m_next_admin_id;
-    e::intrusive_ptr<coord_rpc> op = new coord_rpc_generic(id, status, "register server");
-    std::auto_ptr<e::buffer> msg(e::buffer::create(sizeof(uint64_t) + pack_size(loc)));
-    msg->pack() << sid << loc;
-    int64_t cid = rpc("server_register", reinterpret_cast<const char*>(msg->data()), msg->size(),
-                      &op->repl_status, &op->repl_output, &op->repl_output_sz);
-
-    if (cid >= 0)
-    {
-        m_coord_ops[cid] = op;
-        return op->admin_visible_id();
-    }
-    else
-    {
-        interpret_replicant_returncode(op->repl_status, status, &m_last_error);
-        return -1;
-    }
+	if (!maintain_coord_connection(status))
+	{
+		return -1;
+	}
+	server_id sid(token);
+	po6::net::location loc;
+	if (!loc.set(address))
+	{
+		return -1;
+	}
+	int64_t id = m_next_admin_id;
+	++m_next_admin_id;
+	e::intrusive_ptr<coord_rpc> op = new coord_rpc_generic(id, status, "register server");
+	std::auto_ptr<e::buffer> msg(e::buffer::create(sizeof(uint64_t) + pack_size(loc)));
+	msg->pack() << sid << loc;
+	int64_t cid = rpc("server_register", reinterpret_cast<const char *>(msg->data()), msg->size(),
+	                  &op->repl_status, &op->repl_output, &op->repl_output_sz);
+	if (cid >= 0)
+	{
+		m_coord_ops[cid] = op;
+		return op->admin_visible_id();
+	}
+	else
+	{
+		interpret_replicant_returncode(op->repl_status, status, &m_last_error);
+		return -1;
+	}
 }
 
 int64_t
-admin :: server_online(uint64_t token, enum hyperdex_admin_returncode* status)
+admin :: server_online(uint64_t token, enum hyperdex_admin_returncode *status)
 {
-    if (!maintain_coord_connection(status))
-    {
-        return -1;
-    }
-
-    int64_t id = m_next_admin_id;
-    ++m_next_admin_id;
-    e::intrusive_ptr<coord_rpc> op = new coord_rpc_generic(id, status, "bring server online");
-    char buf[sizeof(uint64_t)];
-    e::pack64be(token, buf);
-    int64_t cid = rpc("server_online", buf, sizeof(uint64_t),
-                      &op->repl_status, &op->repl_output, &op->repl_output_sz);
-
-    if (cid >= 0)
-    {
-        m_coord_ops[cid] = op;
-        return op->admin_visible_id();
-    }
-    else
-    {
-        interpret_replicant_returncode(op->repl_status, status, &m_last_error);
-        return -1;
-    }
+	if (!maintain_coord_connection(status))
+	{
+		return -1;
+	}
+	int64_t id = m_next_admin_id;
+	++m_next_admin_id;
+	e::intrusive_ptr<coord_rpc> op = new coord_rpc_generic(id, status, "bring server online");
+	char buf[sizeof(uint64_t)];
+	e::pack64be(token, buf);
+	int64_t cid = rpc("server_online", buf, sizeof(uint64_t),
+	                  &op->repl_status, &op->repl_output, &op->repl_output_sz);
+	if (cid >= 0)
+	{
+		m_coord_ops[cid] = op;
+		return op->admin_visible_id();
+	}
+	else
+	{
+		interpret_replicant_returncode(op->repl_status, status, &m_last_error);
+		return -1;
+	}
 }
 
 int64_t
-admin :: server_offline(uint64_t token, enum hyperdex_admin_returncode* status)
+admin :: server_offline(uint64_t token, enum hyperdex_admin_returncode *status)
 {
-    if (!maintain_coord_connection(status))
-    {
-        return -1;
-    }
-
-    int64_t id = m_next_admin_id;
-    ++m_next_admin_id;
-    e::intrusive_ptr<coord_rpc> op = new coord_rpc_generic(id, status, "bring server offline");
-    char buf[sizeof(uint64_t)];
-    e::pack64be(token, buf);
-    int64_t cid = rpc("server_offline", buf, sizeof(uint64_t),
-                      &op->repl_status, &op->repl_output, &op->repl_output_sz);
-
-    if (cid >= 0)
-    {
-        m_coord_ops[cid] = op;
-        return op->admin_visible_id();
-    }
-    else
-    {
-        interpret_replicant_returncode(op->repl_status, status, &m_last_error);
-        return -1;
-    }
+	if (!maintain_coord_connection(status))
+	{
+		return -1;
+	}
+	int64_t id = m_next_admin_id;
+	++m_next_admin_id;
+	e::intrusive_ptr<coord_rpc> op = new coord_rpc_generic(id, status, "bring server offline");
+	char buf[sizeof(uint64_t)];
+	e::pack64be(token, buf);
+	int64_t cid = rpc("server_offline", buf, sizeof(uint64_t),
+	                  &op->repl_status, &op->repl_output, &op->repl_output_sz);
+	if (cid >= 0)
+	{
+		m_coord_ops[cid] = op;
+		return op->admin_visible_id();
+	}
+	else
+	{
+		interpret_replicant_returncode(op->repl_status, status, &m_last_error);
+		return -1;
+	}
 }
 
 int64_t
-admin :: server_forget(uint64_t token, enum hyperdex_admin_returncode* status)
+admin :: server_forget(uint64_t token, enum hyperdex_admin_returncode *status)
 {
-    if (!maintain_coord_connection(status))
-    {
-        return -1;
-    }
-
-    int64_t id = m_next_admin_id;
-    ++m_next_admin_id;
-    e::intrusive_ptr<coord_rpc> op = new coord_rpc_generic(id, status, "forget server");
-    char buf[sizeof(uint64_t)];
-    e::pack64be(token, buf);
-    int64_t cid = rpc("server_forget", buf, sizeof(uint64_t),
-                      &op->repl_status, &op->repl_output, &op->repl_output_sz);
-
-    if (cid >= 0)
-    {
-        m_coord_ops[cid] = op;
-        return op->admin_visible_id();
-    }
-    else
-    {
-        interpret_replicant_returncode(op->repl_status, status, &m_last_error);
-        return -1;
-    }
+	if (!maintain_coord_connection(status))
+	{
+		return -1;
+	}
+	int64_t id = m_next_admin_id;
+	++m_next_admin_id;
+	e::intrusive_ptr<coord_rpc> op = new coord_rpc_generic(id, status, "forget server");
+	char buf[sizeof(uint64_t)];
+	e::pack64be(token, buf);
+	int64_t cid = rpc("server_forget", buf, sizeof(uint64_t),
+	                  &op->repl_status, &op->repl_output, &op->repl_output_sz);
+	if (cid >= 0)
+	{
+		m_coord_ops[cid] = op;
+		return op->admin_visible_id();
+	}
+	else
+	{
+		interpret_replicant_returncode(op->repl_status, status, &m_last_error);
+		return -1;
+	}
 }
 
 int64_t
-admin :: server_kill(uint64_t token, enum hyperdex_admin_returncode* status)
+admin :: server_kill(uint64_t token, enum hyperdex_admin_returncode *status)
 {
-    if (!maintain_coord_connection(status))
-    {
-        return -1;
-    }
-
-    int64_t id = m_next_admin_id;
-    ++m_next_admin_id;
-    e::intrusive_ptr<coord_rpc> op = new coord_rpc_generic(id, status, "kill server");
-    char buf[sizeof(uint64_t)];
-    e::pack64be(token, buf);
-    int64_t cid = rpc("server_kill", buf, sizeof(uint64_t),
-                      &op->repl_status, &op->repl_output, &op->repl_output_sz);
-
-    if (cid >= 0)
-    {
-        m_coord_ops[cid] = op;
-        return op->admin_visible_id();
-    }
-    else
-    {
-        interpret_replicant_returncode(op->repl_status, status, &m_last_error);
-        return -1;
-    }
+	if (!maintain_coord_connection(status))
+	{
+		return -1;
+	}
+	int64_t id = m_next_admin_id;
+	++m_next_admin_id;
+	e::intrusive_ptr<coord_rpc> op = new coord_rpc_generic(id, status, "kill server");
+	char buf[sizeof(uint64_t)];
+	e::pack64be(token, buf);
+	int64_t cid = rpc("server_kill", buf, sizeof(uint64_t),
+	                  &op->repl_status, &op->repl_output, &op->repl_output_sz);
+	if (cid >= 0)
+	{
+		m_coord_ops[cid] = op;
+		return op->admin_visible_id();
+	}
+	else
+	{
+		interpret_replicant_returncode(op->repl_status, status, &m_last_error);
+		return -1;
+	}
 }
 
 int64_t
-admin :: backup(const char* name, enum hyperdex_admin_returncode* status, const char** backups)
+admin :: backup(const char *name, enum hyperdex_admin_returncode *status, const char **backups)
 {
-    if (!maintain_coord_connection(status))
-    {
-        return -1;
-    }
-
-    int64_t id = m_next_admin_id;
-    ++m_next_admin_id;
-    e::intrusive_ptr<backup_state_machine> op;
-    op = new backup_state_machine(name, id, status, backups);
-
-    if (!op->initialize(this, status))
-    {
-        return -1;
-    }
-
-    return op->admin_visible_id();
+	if (!maintain_coord_connection(status))
+	{
+		return -1;
+	}
+	int64_t id = m_next_admin_id;
+	++m_next_admin_id;
+	e::intrusive_ptr<backup_state_machine> op;
+	op = new backup_state_machine(name, id, status, backups);
+	if (!op->initialize(this, status))
+	{
+		return -1;
+	}
+	return op->admin_visible_id();
 }
 
 int64_t
-admin :: coord_backup(const char* path,
-                      enum hyperdex_admin_returncode* status)
+admin :: coord_backup(const char *path,
+                      enum hyperdex_admin_returncode *status)
 {
-    if (!maintain_coord_connection(status))
-    {
-        return -1;
-    }
-
-    int64_t id = m_next_admin_id;
-    ++m_next_admin_id;
-    e::intrusive_ptr<coord_rpc> op = new coord_rpc_backup(id, status, path);
-    int64_t cid = replicant_client_backup_object(m_coord, "hyperdex", &op->repl_status, &op->repl_output, &op->repl_output_sz);
-
-    if (cid >= 0)
-    {
-        m_coord_ops[cid] = op;
-        return op->admin_visible_id();
-    }
-    else
-    {
-        interpret_replicant_returncode(op->repl_status, status, &m_last_error);
-        return -1;
-    }
+	if (!maintain_coord_connection(status))
+	{
+		return -1;
+	}
+	int64_t id = m_next_admin_id;
+	++m_next_admin_id;
+	e::intrusive_ptr<coord_rpc> op = new coord_rpc_backup(id, status, path);
+	int64_t cid = replicant_client_backup_object(m_coord, "hyperdex", &op->repl_status, &op->repl_output, &op->repl_output_sz);
+	if (cid >= 0)
+	{
+		m_coord_ops[cid] = op;
+		return op->admin_visible_id();
+	}
+	else
+	{
+		interpret_replicant_returncode(op->repl_status, status, &m_last_error);
+		return -1;
+	}
 }
 
 int64_t
-admin :: raw_backup(const server_id& sid, const char* name,
-                    enum hyperdex_admin_returncode* status,
-                    const char** path)
+admin :: raw_backup(const server_id &sid, const char *name,
+                    enum hyperdex_admin_returncode *status,
+                    const char **path)
 {
-    if (!maintain_coord_connection(status))
-    {
-        return -1;
-    }
-
-    e::slice name_s(name, strlen(name) + 1);
-    size_t sz = HYPERDEX_ADMIN_HEADER_SIZE_REQ
-              + pack_size(name_s);
-    std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
-    msg->pack_at(HYPERDEX_ADMIN_HEADER_SIZE_REQ) << name_s;
-    uint64_t id = m_next_admin_id;
-    ++m_next_admin_id;
-    uint64_t nonce = m_next_server_nonce;
-    ++m_next_server_nonce;
-    e::intrusive_ptr<pending> op = new pending_raw_backup(id, status, path);
-
-    if (!send(BACKUP, sid, nonce, msg, op, status))
-    {
-        return -1;
-    }
-
-    return op->admin_visible_id();
+	if (!maintain_coord_connection(status))
+	{
+		return -1;
+	}
+	e::slice name_s(name, strlen(name) + 1);
+	size_t sz = HYPERDEX_ADMIN_HEADER_SIZE_REQ
+	            + pack_size(name_s);
+	std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
+	msg->pack_at(HYPERDEX_ADMIN_HEADER_SIZE_REQ) << name_s;
+	uint64_t id = m_next_admin_id;
+	++m_next_admin_id;
+	uint64_t nonce = m_next_server_nonce;
+	++m_next_server_nonce;
+	e::intrusive_ptr<pending> op = new pending_raw_backup(id, status, path);
+	if (!send(BACKUP, sid, nonce, msg, op, status))
+	{
+		return -1;
+	}
+	return op->admin_visible_id();
 }
 
 int64_t
-admin :: enable_perf_counters(hyperdex_admin_returncode* status,
-                              hyperdex_admin_perf_counter* pc)
+admin :: enable_perf_counters(hyperdex_admin_returncode *status,
+                              hyperdex_admin_perf_counter *pc)
 {
-    if (!maintain_coord_connection(status))
-    {
-        return -1;
-    }
-
-    if (m_pcs)
-    {
-        return m_pcs->admin_visible_id();
-    }
-    else
-    {
-        int64_t id = m_next_admin_id;
-        ++m_next_admin_id;
-        m_pcs = new pending_perf_counters(id, status, pc);
-        m_pcs->send_perf_reqs(this, &m_config, status);
-        return m_pcs->admin_visible_id();
-    }
+	if (!maintain_coord_connection(status))
+	{
+		return -1;
+	}
+	if (m_pcs)
+	{
+		return m_pcs->admin_visible_id();
+	}
+	else
+	{
+		int64_t id = m_next_admin_id;
+		++m_next_admin_id;
+		m_pcs = new pending_perf_counters(id, status, pc);
+		m_pcs->send_perf_reqs(this, &m_config, status);
+		return m_pcs->admin_visible_id();
+	}
 }
 
 void
 admin :: disable_perf_counters()
 {
-    m_pcs = NULL;
+	m_pcs = NULL;
 }
 
 int64_t
-admin :: loop(int timeout, hyperdex_admin_returncode* status)
+admin :: loop(int timeout, hyperdex_admin_returncode *status)
 {
-    *status = HYPERDEX_ADMIN_SUCCESS;
-
-    while (m_pcs ||
-           m_yielding ||
-           !m_failed.empty() ||
-           !m_yieldable.empty() ||
-           !m_coord_ops.empty() ||
-           !m_server_ops.empty())
-    {
-        if (m_yielding)
-        {
-            if (!m_yielding->can_yield())
-            {
-                m_yielding = NULL;
-                continue;
-            }
-
-            if (!m_yielding->yield(status))
-            {
-                return -1;
-            }
-
-            int64_t admin_id = m_yielding->admin_visible_id();
-            m_last_error = m_yielding->error();
-
-            if (!m_yielding->can_yield())
-            {
-                m_yielded = m_yielding;
-                m_yielding = NULL;
-            }
-
-            multi_yieldable_map_t::iterator it = m_multi_ops.find(admin_id);
-
-            if (it != m_multi_ops.end())
-            {
-                e::intrusive_ptr<multi_yieldable> op = it->second;
-                m_multi_ops.erase(it);
-
-                if (!op->callback(this, admin_id, status))
-                {
-                    return -1;
-                }
-
-                m_yielding = op.get();
-                continue;
-            }
-
-            return admin_id;
-        }
-        else if (!m_yieldable.empty())
-        {
-            m_yielding = m_yieldable.front();
-            m_yieldable.pop_front();
-            continue;
-        }
-        else if (!m_failed.empty())
-        {
-            const pending_server_pair& psp(m_failed.front());
-            psp.op->handle_failure(psp.si);
-            m_yielding = psp.op.get();
-            m_failed.pop_front();
-            continue;
-        }
-
-        m_yielded = NULL;
-
-        if (!maintain_coord_connection(status))
-        {
-            return -1;
-        }
-
-        assert(!m_coord_ops.empty() || !m_server_ops.empty() || m_pcs);
-
-        if (m_pcs)
-        {
-            int t = m_pcs->millis_to_next_send();
-
-            if (t <= 0)
-            {
-                m_pcs->send_perf_reqs(this, &m_config, status);
-                t = m_pcs->millis_to_next_send();
-            }
-
-            if (timeout > t)
-            {
-                m_busybee.set_timeout(t);
-                timeout -= t;
-            }
-            else if (timeout < 0)
-            {
-                m_busybee.set_timeout(t);
-            }
-            else
-            {
-                m_busybee.set_timeout(timeout);
-                timeout = 0;
-            }
-        }
-        else
-        {
-            m_busybee.set_timeout(timeout);
-        }
-
-        if (m_handle_coord_ops)
-        {
-            m_handle_coord_ops = false;
-            replicant_returncode lrc = REPLICANT_GARBAGE;
-            int64_t lid = replicant_client_loop(m_coord, 0, &lrc);
-
-            if (lid < 0 && lrc != REPLICANT_TIMEOUT)
-            {
-                interpret_replicant_returncode(lrc, status, &m_last_error);
-                return -1;
-            }
-
-            coord_rpc_map_t::iterator it = m_coord_ops.find(lid);
-
-            if (it == m_coord_ops.end())
-            {
-                continue;
-            }
-
-            e::intrusive_ptr<coord_rpc> op = it->second;
-            m_coord_ops.erase(it);
-
-            if (!op->handle_response(this, status))
-            {
-                return -1;
-            }
-
-            m_yielding = op.get();
-            continue;
-        }
-
-        uint64_t sid_num;
-        std::auto_ptr<e::buffer> msg;
-        busybee_returncode rc = m_busybee.recv(&sid_num, &msg);
-        server_id id(sid_num);
-
-        switch (rc)
-        {
-            case BUSYBEE_SUCCESS:
-                break;
-            case BUSYBEE_POLLFAILED:
-            case BUSYBEE_ADDFDFAIL:
-                ERROR(POLLFAILED) << "poll failed";
-                return -1;
-            case BUSYBEE_DISRUPTED:
-                handle_disruption(id);
-                continue;
-            case BUSYBEE_TIMEOUT:
-                if (m_pcs && timeout != 0)
-                {
-                    continue;
-                }
-
-                ERROR(TIMEOUT) << "operation timed out";
-                return -1;
-            case BUSYBEE_INTERRUPTED:
-                ERROR(INTERRUPTED) << "signal received";
-                return -1;
-            case BUSYBEE_EXTERNAL:
-                m_handle_coord_ops = true;
-                continue;
-            case BUSYBEE_SHUTDOWN:
-            default:
-                abort();
-        }
-
-        e::unpacker up = msg->unpack_from(BUSYBEE_HEADER_SIZE);
-        uint8_t mt;
-        virtual_server_id vfrom;
-        int64_t nonce;
-        up = up >> mt >> vfrom >> nonce;
-
-        if (up.error())
-        {
-            ERROR(SERVERERROR) << "communication error: server "
-                               << sid_num << " sent message="
-                               << msg->as_slice().hex()
-                               << " with invalid header";
-            return -1;
-        }
-
-        network_msgtype msg_type = static_cast<network_msgtype>(mt);
-        pending_map_t::iterator it = m_server_ops.find(nonce);
-
-        if (it == m_server_ops.end())
-        {
-            continue;
-        }
-
-        const pending_server_pair psp(it->second);
-        e::intrusive_ptr<pending> op = psp.op;
-
-        if (msg_type == CONFIGMISMATCH)
-        {
-            m_failed.push_back(psp);
-            continue;
-        }
-
-        if (id == it->second.si)
-        {
-            m_server_ops.erase(it);
-
-            if (!op->handle_message(this, id, msg_type, msg, up, status))
-            {
-                return -1;
-            }
-
-            m_yielding = psp.op.get();
-        }
-        else
-        {
-            ERROR(SERVERERROR) << "server " << sid_num
-                               << " responded for nonce " << nonce
-                               << " which belongs to server " << it->second.si.get();
-            return -1;
-        }
-    }
-
-    ERROR(NONEPENDING) << "no outstanding operations to process";
-    return -1;
+	*status = HYPERDEX_ADMIN_SUCCESS;
+	while (m_pcs ||
+	       m_yielding ||
+	       !m_failed.empty() ||
+	       !m_yieldable.empty() ||
+	       !m_coord_ops.empty() ||
+	       !m_server_ops.empty())
+	{
+		if (m_yielding)
+		{
+			if (!m_yielding->can_yield())
+			{
+				m_yielding = NULL;
+				continue;
+			}
+			if (!m_yielding->yield(status))
+			{
+				return -1;
+			}
+			int64_t admin_id = m_yielding->admin_visible_id();
+			m_last_error = m_yielding->error();
+			if (!m_yielding->can_yield())
+			{
+				m_yielded = m_yielding;
+				m_yielding = NULL;
+			}
+			multi_yieldable_map_t::iterator it = m_multi_ops.find(admin_id);
+			if (it != m_multi_ops.end())
+			{
+				e::intrusive_ptr<multi_yieldable> op = it->second;
+				m_multi_ops.erase(it);
+				if (!op->callback(this, admin_id, status))
+				{
+					return -1;
+				}
+				m_yielding = op.get();
+				continue;
+			}
+			return admin_id;
+		}
+		else if (!m_yieldable.empty())
+		{
+			m_yielding = m_yieldable.front();
+			m_yieldable.pop_front();
+			continue;
+		}
+		else if (!m_failed.empty())
+		{
+			const pending_server_pair &psp(m_failed.front());
+			psp.op->handle_failure(psp.si);
+			m_yielding = psp.op.get();
+			m_failed.pop_front();
+			continue;
+		}
+		m_yielded = NULL;
+		if (!maintain_coord_connection(status))
+		{
+			return -1;
+		}
+		assert(!m_coord_ops.empty() || !m_server_ops.empty() || m_pcs);
+		if (m_pcs)
+		{
+			int t = m_pcs->millis_to_next_send();
+			if (t <= 0)
+			{
+				m_pcs->send_perf_reqs(this, &m_config, status);
+				t = m_pcs->millis_to_next_send();
+			}
+			if (timeout > t)
+			{
+				m_busybee.set_timeout(t);
+				timeout -= t;
+			}
+			else if (timeout < 0)
+			{
+				m_busybee.set_timeout(t);
+			}
+			else
+			{
+				m_busybee.set_timeout(timeout);
+				timeout = 0;
+			}
+		}
+		else
+		{
+			m_busybee.set_timeout(timeout);
+		}
+		if (m_handle_coord_ops)
+		{
+			m_handle_coord_ops = false;
+			replicant_returncode lrc = REPLICANT_GARBAGE;
+			int64_t lid = replicant_client_loop(m_coord, 0, &lrc);
+			if (lid < 0 && lrc != REPLICANT_TIMEOUT)
+			{
+				interpret_replicant_returncode(lrc, status, &m_last_error);
+				return -1;
+			}
+			coord_rpc_map_t::iterator it = m_coord_ops.find(lid);
+			if (it == m_coord_ops.end())
+			{
+				continue;
+			}
+			e::intrusive_ptr<coord_rpc> op = it->second;
+			m_coord_ops.erase(it);
+			if (!op->handle_response(this, status))
+			{
+				return -1;
+			}
+			m_yielding = op.get();
+			continue;
+		}
+		uint64_t sid_num;
+		std::auto_ptr<e::buffer> msg;
+		busybee_returncode rc = m_busybee.recv(&sid_num, &msg);
+		server_id id(sid_num);
+		switch (rc)
+		{
+		case BUSYBEE_SUCCESS:
+			break;
+		case BUSYBEE_POLLFAILED:
+		case BUSYBEE_ADDFDFAIL:
+			ERROR(POLLFAILED) << "poll failed";
+			return -1;
+		case BUSYBEE_DISRUPTED:
+			handle_disruption(id);
+			continue;
+		case BUSYBEE_TIMEOUT:
+			if (m_pcs && timeout != 0)
+			{
+				continue;
+			}
+			ERROR(TIMEOUT) << "operation timed out";
+			return -1;
+		case BUSYBEE_INTERRUPTED:
+			ERROR(INTERRUPTED) << "signal received";
+			return -1;
+		case BUSYBEE_EXTERNAL:
+			m_handle_coord_ops = true;
+			continue;
+		case BUSYBEE_SHUTDOWN:
+		default:
+			abort();
+		}
+		e::unpacker up = msg->unpack_from(BUSYBEE_HEADER_SIZE);
+		uint8_t mt;
+		virtual_server_id vfrom;
+		int64_t nonce;
+		up = up >> mt >> vfrom >> nonce;
+		if (up.error())
+		{
+			ERROR(SERVERERROR) << "communication error: server "
+			                   << sid_num << " sent message="
+			                   << msg->as_slice().hex()
+			                   << " with invalid header";
+			return -1;
+		}
+		network_msgtype msg_type = static_cast<network_msgtype>(mt);
+		pending_map_t::iterator it = m_server_ops.find(nonce);
+		if (it == m_server_ops.end())
+		{
+			continue;
+		}
+		const pending_server_pair psp(it->second);
+		e::intrusive_ptr<pending> op = psp.op;
+		if (msg_type == CONFIGMISMATCH)
+		{
+			m_failed.push_back(psp);
+			continue;
+		}
+		if (id == it->second.si)
+		{
+			m_server_ops.erase(it);
+			if (!op->handle_message(this, id, msg_type, msg, up, status))
+			{
+				return -1;
+			}
+			m_yielding = psp.op.get();
+		}
+		else
+		{
+			ERROR(SERVERERROR) << "server " << sid_num
+			                   << " responded for nonce " << nonce
+			                   << " which belongs to server " << it->second.si.get();
+			return -1;
+		}
+	}
+	ERROR(NONEPENDING) << "no outstanding operations to process";
+	return -1;
 }
 
-const char*
+const char *
 admin :: error_message()
 {
-    return m_last_error.msg();
+	return m_last_error.msg();
 }
 
-const char*
+const char *
 admin :: error_location()
 {
-    return m_last_error.loc();
+	return m_last_error.loc();
 }
 
 void
-admin :: set_error_message(const char* msg)
+admin :: set_error_message(const char *msg)
 {
-    m_last_error = e::error();
-    m_last_error.set_loc(__FILE__, __LINE__);
-    m_last_error.set_msg() << msg;
+	m_last_error = e::error();
+	m_last_error.set_loc(__FILE__, __LINE__);
+	m_last_error.set_msg() << msg;
 }
 
 #define INTERPRET_ERROR(CODE) \
-    *status = HYPERDEX_ADMIN_ ## CODE; \
-    err->set_loc(__FILE__, __LINE__); \
-    err->set_msg()
+	*status = HYPERDEX_ADMIN_ ## CODE; \
+	err->set_loc(__FILE__, __LINE__); \
+	err->set_msg()
 
 void
 admin :: interpret_replicant_returncode(replicant_returncode rstatus,
-                                        hyperdex_admin_returncode* status,
-                                        e::error* err)
+                                        hyperdex_admin_returncode *status,
+                                        e::error *err)
 {
-    switch (rstatus)
-    {
-        case REPLICANT_SUCCESS:
-            *status = HYPERDEX_ADMIN_SUCCESS;
-            break;
-        case REPLICANT_OBJ_NOT_FOUND:
-        case REPLICANT_OBJ_EXIST:
-        case REPLICANT_FUNC_NOT_FOUND:
-        case REPLICANT_COND_NOT_FOUND:
-        case REPLICANT_COND_DESTROYED:
-            INTERPRET_ERROR(COORDFAIL) << "persistent coordinator error: "
-                                       << replicant_client_error_message(m_coord);
-            break;
-        case REPLICANT_MAYBE:
-            INTERPRET_ERROR(COORDFAIL) << "transient coordinator error: "
-                                       << "operation may or may not have completed";
-            break;
-        case REPLICANT_SEE_ERRNO:
-            INTERPRET_ERROR(COORDFAIL) << "transient coordinator error: "
-                                       << po6::strerror(errno);
-            break;
-        case REPLICANT_CLUSTER_JUMP:
-        case REPLICANT_SERVER_ERROR:
-        case REPLICANT_COMM_FAILED:
-            INTERPRET_ERROR(COORDFAIL) << "transient coordinator error: "
-                                       << replicant_client_error_message(m_coord);
-            break;
-        case REPLICANT_TIMEOUT:
-            INTERPRET_ERROR(TIMEOUT) << "operation timed out";
-            break;
-        case REPLICANT_INTERRUPTED:
-            INTERPRET_ERROR(INTERRUPTED) << "signal received";
-            break;
-        case REPLICANT_NONE_PENDING:
-            INTERPRET_ERROR(NONEPENDING) << "no operations pending";
-            break;
-        case REPLICANT_INTERNAL:
-        case REPLICANT_EXCEPTION:
-        case REPLICANT_GARBAGE:
-        default:
-            INTERPRET_ERROR(INTERNAL) << "internal library error: "
-                                      << replicant_client_error_message(m_coord);
-            break;
-    }
+	switch (rstatus)
+	{
+	case REPLICANT_SUCCESS:
+		*status = HYPERDEX_ADMIN_SUCCESS;
+		break;
+	case REPLICANT_OBJ_NOT_FOUND:
+	case REPLICANT_OBJ_EXIST:
+	case REPLICANT_FUNC_NOT_FOUND:
+	case REPLICANT_COND_NOT_FOUND:
+	case REPLICANT_COND_DESTROYED:
+		INTERPRET_ERROR(COORDFAIL) << "persistent coordinator error: "
+		                           << replicant_client_error_message(m_coord);
+		break;
+	case REPLICANT_MAYBE:
+		INTERPRET_ERROR(COORDFAIL) << "transient coordinator error: "
+		                           << "operation may or may not have completed";
+		break;
+	case REPLICANT_SEE_ERRNO:
+		INTERPRET_ERROR(COORDFAIL) << "transient coordinator error: "
+		                           << po6::strerror(errno);
+		break;
+	case REPLICANT_CLUSTER_JUMP:
+	case REPLICANT_SERVER_ERROR:
+	case REPLICANT_COMM_FAILED:
+		INTERPRET_ERROR(COORDFAIL) << "transient coordinator error: "
+		                           << replicant_client_error_message(m_coord);
+		break;
+	case REPLICANT_TIMEOUT:
+		INTERPRET_ERROR(TIMEOUT) << "operation timed out";
+		break;
+	case REPLICANT_INTERRUPTED:
+		INTERPRET_ERROR(INTERRUPTED) << "signal received";
+		break;
+	case REPLICANT_NONE_PENDING:
+		INTERPRET_ERROR(NONEPENDING) << "no operations pending";
+		break;
+	case REPLICANT_INTERNAL:
+	case REPLICANT_EXCEPTION:
+	case REPLICANT_GARBAGE:
+	default:
+		INTERPRET_ERROR(INTERNAL) << "internal library error: "
+		                          << replicant_client_error_message(m_coord);
+		break;
+	}
 }
 
 bool
-admin :: maintain_coord_connection(hyperdex_admin_returncode* status)
+admin :: maintain_coord_connection(hyperdex_admin_returncode *status)
 {
-    if (m_config_status != REPLICANT_SUCCESS)
-    {
-        replicant_client_kill(m_coord, m_config_id);
-        m_config_id = -1;
-    }
-
-    replicant_returncode rc;
-
-    if (m_config_id < 0)
-    {
-        m_config_status = REPLICANT_SUCCESS;
-        m_config_id = replicant_client_cond_follow(m_coord, "hyperdex", "config",
-                                                   &m_config_status, &m_config_state,
-                                                   &m_config_data, &m_config_data_sz);
-        if (replicant_client_wait(m_coord, m_config_id, -1, &rc) < 0)
-        {
-            ERROR(COORDFAIL) << "coordinator failure: " << replicant_client_error_message(m_coord);
-            return false;
-        }
-    }
-
-    if (replicant_client_wait(m_coord, m_config_id, 0, &rc) < 0)
-    {
-        if (rc == REPLICANT_INTERRUPTED)
-        {
-            ERROR(INTERRUPTED) << "interrupted by a signal";
-            return false;
-        }
-        else if (rc != REPLICANT_NONE_PENDING && rc != REPLICANT_TIMEOUT)
-        {
-            ERROR(COORDFAIL) << "coordinator failure: " << replicant_client_error_message(m_coord);
-            return false;
-        }
-    }
-
-    if (m_config.version() < m_config_state)
-    {
-        configuration new_config;
-        e::unpacker up(m_config_data, m_config_data_sz);
-        up = up >> new_config;
-
-        if (!up.error())
-        {
-            m_config = new_config;
-        }
-    }
-
-    return true;
+	if (m_config_status != REPLICANT_SUCCESS)
+	{
+		replicant_client_kill(m_coord, m_config_id);
+		m_config_id = -1;
+	}
+	replicant_returncode rc;
+	if (m_config_id < 0)
+	{
+		m_config_status = REPLICANT_SUCCESS;
+		m_config_id = replicant_client_cond_follow(m_coord, "hyperdex", "config",
+		                                           &m_config_status, &m_config_state,
+		                                           &m_config_data, &m_config_data_sz);
+		if (replicant_client_wait(m_coord, m_config_id, -1, &rc) < 0)
+		{
+			ERROR(COORDFAIL) << "coordinator failure: " << replicant_client_error_message(m_coord);
+			return false;
+		}
+	}
+	if (replicant_client_wait(m_coord, m_config_id, 0, &rc) < 0)
+	{
+		if (rc == REPLICANT_INTERRUPTED)
+		{
+			ERROR(INTERRUPTED) << "interrupted by a signal";
+			return false;
+		}
+		else if (rc != REPLICANT_NONE_PENDING && rc != REPLICANT_TIMEOUT)
+		{
+			ERROR(COORDFAIL) << "coordinator failure: " << replicant_client_error_message(m_coord);
+			return false;
+		}
+	}
+	if (m_config.version() < m_config_state)
+	{
+		configuration new_config;
+		e::unpacker up(m_config_data, m_config_data_sz);
+		up = up >> new_config;
+		if (!up.error())
+		{
+			m_config = new_config;
+		}
+	}
+	return true;
 }
 
 int64_t
-admin :: rpc(const char* func,
-             const char* data, size_t data_sz,
-             replicant_returncode* status,
-             char** output, size_t* output_sz)
+admin :: rpc(const char *func,
+             const char *data, size_t data_sz,
+             replicant_returncode *status,
+             char **output, size_t *output_sz)
 {
-    return replicant_client_call(m_coord, "hyperdex", func, data, data_sz,
-                                 REPLICANT_CALL_ROBUST, status, output, output_sz);
+	return replicant_client_call(m_coord, "hyperdex", func, data, data_sz,
+	                             REPLICANT_CALL_ROBUST, status, output, output_sz);
 }
 
 bool
@@ -1063,84 +975,80 @@ admin :: send(network_msgtype mt,
               uint64_t nonce,
               std::auto_ptr<e::buffer> msg,
               e::intrusive_ptr<pending> op,
-              hyperdex_admin_returncode* status)
+              hyperdex_admin_returncode *status)
 {
-    const uint8_t type = static_cast<uint8_t>(mt);
-    const uint8_t flags = 0;
-    const uint64_t version = m_config.version();
-    msg->pack_at(BUSYBEE_HEADER_SIZE)
-        << type << flags << version << uint64_t(UINT64_MAX) << nonce;
-    m_busybee.set_timeout(-1);
-
-    switch (m_busybee.send(id.get(), msg))
-    {
-        case BUSYBEE_SUCCESS:
-            op->handle_sent_to(id);
-            m_server_ops.insert(std::make_pair(nonce, pending_server_pair(id, op)));
-            return true;
-        case BUSYBEE_DISRUPTED:
-            handle_disruption(id);
-            ERROR(SERVERERROR) << "server " << id.get() << " had a communication disruption";
-            return false;
-        case BUSYBEE_POLLFAILED:
-        case BUSYBEE_ADDFDFAIL:
-            ERROR(POLLFAILED) << "poll failed";
-            return false;
-        case BUSYBEE_SHUTDOWN:
-        case BUSYBEE_TIMEOUT:
-        case BUSYBEE_EXTERNAL:
-        case BUSYBEE_INTERRUPTED:
-        default:
-            abort();
-    }
+	const uint8_t type = static_cast<uint8_t>(mt);
+	const uint8_t flags = 0;
+	const uint64_t version = m_config.version();
+	msg->pack_at(BUSYBEE_HEADER_SIZE)
+	        << type << flags << version << uint64_t(UINT64_MAX) << nonce;
+	m_busybee.set_timeout(-1);
+	switch (m_busybee.send(id.get(), msg))
+	{
+	case BUSYBEE_SUCCESS:
+		op->handle_sent_to(id);
+		m_server_ops.insert(std::make_pair(nonce, pending_server_pair(id, op)));
+		return true;
+	case BUSYBEE_DISRUPTED:
+		handle_disruption(id);
+		ERROR(SERVERERROR) << "server " << id.get() << " had a communication disruption";
+		return false;
+	case BUSYBEE_POLLFAILED:
+	case BUSYBEE_ADDFDFAIL:
+		ERROR(POLLFAILED) << "poll failed";
+		return false;
+	case BUSYBEE_SHUTDOWN:
+	case BUSYBEE_TIMEOUT:
+	case BUSYBEE_EXTERNAL:
+	case BUSYBEE_INTERRUPTED:
+	default:
+		abort();
+	}
 }
 
 void
-admin :: handle_disruption(const server_id& si)
+admin :: handle_disruption(const server_id &si)
 {
-    pending_map_t::iterator it = m_server_ops.begin();
-
-    while (it != m_server_ops.end())
-    {
-        if (it->second.si == si)
-        {
-            m_failed.push_back(it->second);
-            pending_map_t::iterator tmp = it;
-            ++it;
-            m_server_ops.erase(tmp);
-        }
-        else
-        {
-            ++it;
-        }
-    }
-
-    m_busybee.drop(si.get());
+	pending_map_t::iterator it = m_server_ops.begin();
+	while (it != m_server_ops.end())
+	{
+		if (it->second.si == si)
+		{
+			m_failed.push_back(it->second);
+			pending_map_t::iterator tmp = it;
+			++it;
+			m_server_ops.erase(tmp);
+		}
+		else
+		{
+			++it;
+		}
+	}
+	m_busybee.drop(si.get());
 }
 
-HYPERDEX_API std::ostream&
-operator << (std::ostream& lhs, hyperdex_admin_returncode rhs)
+HYPERDEX_API std::ostream &
+operator << (std::ostream &lhs, hyperdex_admin_returncode rhs)
 {
-    switch (rhs)
-    {
-        STRINGIFY(HYPERDEX_ADMIN_SUCCESS);
-        STRINGIFY(HYPERDEX_ADMIN_NOMEM);
-        STRINGIFY(HYPERDEX_ADMIN_NONEPENDING);
-        STRINGIFY(HYPERDEX_ADMIN_POLLFAILED);
-        STRINGIFY(HYPERDEX_ADMIN_TIMEOUT);
-        STRINGIFY(HYPERDEX_ADMIN_INTERRUPTED);
-        STRINGIFY(HYPERDEX_ADMIN_SERVERERROR);
-        STRINGIFY(HYPERDEX_ADMIN_COORDFAIL);
-        STRINGIFY(HYPERDEX_ADMIN_BADSPACE);
-        STRINGIFY(HYPERDEX_ADMIN_DUPLICATE);
-        STRINGIFY(HYPERDEX_ADMIN_NOTFOUND);
-        STRINGIFY(HYPERDEX_ADMIN_LOCALERROR);
-        STRINGIFY(HYPERDEX_ADMIN_INTERNAL);
-        STRINGIFY(HYPERDEX_ADMIN_EXCEPTION);
-        STRINGIFY(HYPERDEX_ADMIN_GARBAGE);
-        default:
-            lhs << "unknown hyperdex_admin_returncode";
-    }
-
-    return lhs;
+	switch (rhs)
+	{
+		STRINGIFY(HYPERDEX_ADMIN_SUCCESS);
+		STRINGIFY(HYPERDEX_ADMIN_NOMEM);
+		STRINGIFY(HYPERDEX_ADMIN_NONEPENDING);
+		STRINGIFY(HYPERDEX_ADMIN_POLLFAILED);
+		STRINGIFY(HYPERDEX_ADMIN_TIMEOUT);
+		STRINGIFY(HYPERDEX_ADMIN_INTERRUPTED);
+		STRINGIFY(HYPERDEX_ADMIN_SERVERERROR);
+		STRINGIFY(HYPERDEX_ADMIN_COORDFAIL);
+		STRINGIFY(HYPERDEX_ADMIN_BADSPACE);
+		STRINGIFY(HYPERDEX_ADMIN_DUPLICATE);
+		STRINGIFY(HYPERDEX_ADMIN_NOTFOUND);
+		STRINGIFY(HYPERDEX_ADMIN_LOCALERROR);
+		STRINGIFY(HYPERDEX_ADMIN_INTERNAL);
+		STRINGIFY(HYPERDEX_ADMIN_EXCEPTION);
+		STRINGIFY(HYPERDEX_ADMIN_GARBAGE);
+	default:
+		lhs << "unknown hyperdex_admin_returncode";
+	}
+	return lhs;
 }
diff --git a/admin/admin.h b/admin/admin.h
index 4b1a2c8b9..64d059138 100644
--- a/admin/admin.h
+++ b/admin/admin.h
@@ -53,131 +53,131 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class admin
 {
-    public:
-        admin(const char* coordinator, uint16_t port);
-        ~admin() throw ();
+public:
+	admin(const char *coordinator, uint16_t port);
+	~admin() throw ();
 
-    public:
-        // introspect the config
-        int64_t dump_config(enum hyperdex_admin_returncode* status,
-                            const char** config);
-        // cluster
-        int64_t read_only(int ro,
-                          enum hyperdex_admin_returncode* status);
-        int64_t wait_until_stable(enum hyperdex_admin_returncode* status);
-        int64_t fault_tolerance(const char* space, uint64_t ft,
-                                enum hyperdex_admin_returncode* status);
-        // manage spaces
-        int validate_space(const char* description,
-                           enum hyperdex_admin_returncode* status);
-        int64_t add_space(const char* description,
-                          enum hyperdex_admin_returncode* status);
-        int64_t rm_space(const char* name,
-                         enum hyperdex_admin_returncode* status);
-        int64_t mv_space(const char* source, const char* target,
-                         enum hyperdex_admin_returncode* status);
-        int64_t add_index(const char* space, const char* attr,
-                          enum hyperdex_admin_returncode* status);
-        int64_t list_indices(const char* space, enum hyperdex_admin_returncode* status,
-                            const char** spaces);
-        int64_t rm_index(uint64_t idxid,
-                         enum hyperdex_admin_returncode* status);
-        int64_t list_spaces(enum hyperdex_admin_returncode* status,
-                            const char** spaces);
-        int64_t list_subspaces(const char* space,
-                            enum hyperdex_admin_returncode* status,
-                            const char** subspaces);
-        // manage servers
-        int64_t server_register(uint64_t token, const char* address,
-                                enum hyperdex_admin_returncode* status);
-        int64_t server_online(uint64_t token, enum hyperdex_admin_returncode* status);
-        int64_t server_offline(uint64_t token, enum hyperdex_admin_returncode* status);
-        int64_t server_forget(uint64_t token, enum hyperdex_admin_returncode* status);
-        int64_t server_kill(uint64_t token, enum hyperdex_admin_returncode* status);
-        // backups
-        int64_t backup(const char* name, enum hyperdex_admin_returncode* status, const char** backups);
-        int64_t coord_backup(const char* path,
-                             enum hyperdex_admin_returncode* status);
-        int64_t raw_backup(const server_id& sid, const char* name,
-                           enum hyperdex_admin_returncode* status,
-                           const char** path);
-        // read performance counters
-        int64_t enable_perf_counters(hyperdex_admin_returncode* status,
-                                     hyperdex_admin_perf_counter* pc);
-        void disable_perf_counters();
-        // looping/polling
-        int64_t loop(int timeout, hyperdex_admin_returncode* status);
-        // error handling
-        const char* error_message();
-        const char* error_location();
-        void set_error_message(const char* msg);
-        void interpret_replicant_returncode(replicant_returncode rstatus,
-                                            hyperdex_admin_returncode* status,
-                                            e::error* err);
+public:
+	// introspect the config
+	int64_t dump_config(enum hyperdex_admin_returncode *status,
+	                    const char **config);
+	// cluster
+	int64_t read_only(int ro,
+	                  enum hyperdex_admin_returncode *status);
+	int64_t wait_until_stable(enum hyperdex_admin_returncode *status);
+	int64_t fault_tolerance(const char *space, uint64_t ft,
+	                        enum hyperdex_admin_returncode *status);
+	// manage spaces
+	int validate_space(const char *description,
+	                   enum hyperdex_admin_returncode *status);
+	int64_t add_space(const char *description,
+	                  enum hyperdex_admin_returncode *status);
+	int64_t rm_space(const char *name,
+	                 enum hyperdex_admin_returncode *status);
+	int64_t mv_space(const char *source, const char *target,
+	                 enum hyperdex_admin_returncode *status);
+	int64_t add_index(const char *space, const char *attr,
+	                  enum hyperdex_admin_returncode *status);
+	int64_t list_indices(const char *space, enum hyperdex_admin_returncode *status,
+	                     const char **spaces);
+	int64_t rm_index(uint64_t idxid,
+	                 enum hyperdex_admin_returncode *status);
+	int64_t list_spaces(enum hyperdex_admin_returncode *status,
+	                    const char **spaces);
+	int64_t list_subspaces(const char *space,
+	                       enum hyperdex_admin_returncode *status,
+	                       const char **subspaces);
+	// manage servers
+	int64_t server_register(uint64_t token, const char *address,
+	                        enum hyperdex_admin_returncode *status);
+	int64_t server_online(uint64_t token, enum hyperdex_admin_returncode *status);
+	int64_t server_offline(uint64_t token, enum hyperdex_admin_returncode *status);
+	int64_t server_forget(uint64_t token, enum hyperdex_admin_returncode *status);
+	int64_t server_kill(uint64_t token, enum hyperdex_admin_returncode *status);
+	// backups
+	int64_t backup(const char *name, enum hyperdex_admin_returncode *status, const char **backups);
+	int64_t coord_backup(const char *path,
+	                     enum hyperdex_admin_returncode *status);
+	int64_t raw_backup(const server_id &sid, const char *name,
+	                   enum hyperdex_admin_returncode *status,
+	                   const char **path);
+	// read performance counters
+	int64_t enable_perf_counters(hyperdex_admin_returncode *status,
+	                             hyperdex_admin_perf_counter *pc);
+	void disable_perf_counters();
+	// looping/polling
+	int64_t loop(int timeout, hyperdex_admin_returncode *status);
+	// error handling
+	const char *error_message();
+	const char *error_location();
+	void set_error_message(const char *msg);
+	void interpret_replicant_returncode(replicant_returncode rstatus,
+	                                    hyperdex_admin_returncode *status,
+	                                    e::error *err);
 
-    private:
-        struct pending_server_pair
-        {
-            pending_server_pair()
-                : si(), op() {}
-            pending_server_pair(const server_id& s,
-                                const e::intrusive_ptr<pending>& o)
-                : si(s), op(o) {}
-            ~pending_server_pair() throw () {}
-            server_id si;
-            e::intrusive_ptr<pending> op;
-        };
-        typedef std::map<uint64_t, pending_server_pair> pending_map_t;
-        typedef std::map<int64_t, e::intrusive_ptr<coord_rpc> > coord_rpc_map_t;
-        typedef std::map<int64_t, e::intrusive_ptr<multi_yieldable> > multi_yieldable_map_t;
-        typedef std::list<pending_server_pair> pending_queue_t;
-        friend class backup_state_machine;
-        friend class pending_perf_counters;
+private:
+	struct pending_server_pair
+	{
+		pending_server_pair()
+			: si(), op() {}
+		pending_server_pair(const server_id &s,
+		                    const e::intrusive_ptr<pending> &o)
+			: si(s), op(o) {}
+		~pending_server_pair() throw () {}
+		server_id si;
+		e::intrusive_ptr<pending> op;
+	};
+	typedef std::map<uint64_t, pending_server_pair> pending_map_t;
+	typedef std::map<int64_t, e::intrusive_ptr<coord_rpc> > coord_rpc_map_t;
+	typedef std::map<int64_t, e::intrusive_ptr<multi_yieldable> > multi_yieldable_map_t;
+	typedef std::list<pending_server_pair> pending_queue_t;
+	friend class backup_state_machine;
+	friend class pending_perf_counters;
 
-    private:
-        bool maintain_coord_connection(hyperdex_admin_returncode* status);
-        int64_t rpc(const char* func,
-                    const char* data, size_t data_sz,
-                    replicant_returncode* status,
-                    char** output, size_t* output_sz);
-        bool send(network_msgtype mt,
-                  server_id id,
-                  uint64_t nonce,
-                  std::auto_ptr<e::buffer> msg,
-                  e::intrusive_ptr<pending> op,
-                  hyperdex_admin_returncode* status);
-        void handle_disruption(const server_id& si);
+private:
+	bool maintain_coord_connection(hyperdex_admin_returncode *status);
+	int64_t rpc(const char *func,
+	            const char *data, size_t data_sz,
+	            replicant_returncode *status,
+	            char **output, size_t *output_sz);
+	bool send(network_msgtype mt,
+	          server_id id,
+	          uint64_t nonce,
+	          std::auto_ptr<e::buffer> msg,
+	          e::intrusive_ptr<pending> op,
+	          hyperdex_admin_returncode *status);
+	void handle_disruption(const server_id &si);
 
-    private:
-        replicant_client* m_coord;
-        mapper m_busybee_mapper;
-        busybee_st m_busybee;
-        // configuration
-        configuration m_config;
-        int64_t m_config_id;
-        replicant_returncode m_config_status;
-        uint64_t m_config_state;
-        char* m_config_data;
-        size_t m_config_data_sz;
-        // nonces
-        int64_t m_next_admin_id;
-        uint64_t m_next_server_nonce;
-        // operations
-        bool m_handle_coord_ops;
-        coord_rpc_map_t m_coord_ops;
-        pending_map_t m_server_ops;
-        multi_yieldable_map_t m_multi_ops;
-        pending_queue_t m_failed;
-        std::list<e::intrusive_ptr<yieldable> > m_yieldable;
-        e::intrusive_ptr<yieldable> m_yielding;
-        e::intrusive_ptr<yieldable> m_yielded;
-        e::intrusive_ptr<pending_perf_counters> m_pcs;
-        // misc
-        e::error m_last_error;
+private:
+	replicant_client *m_coord;
+	mapper m_busybee_mapper;
+	busybee_st m_busybee;
+	// configuration
+	configuration m_config;
+	int64_t m_config_id;
+	replicant_returncode m_config_status;
+	uint64_t m_config_state;
+	char *m_config_data;
+	size_t m_config_data_sz;
+	// nonces
+	int64_t m_next_admin_id;
+	uint64_t m_next_server_nonce;
+	// operations
+	bool m_handle_coord_ops;
+	coord_rpc_map_t m_coord_ops;
+	pending_map_t m_server_ops;
+	multi_yieldable_map_t m_multi_ops;
+	pending_queue_t m_failed;
+	std::list<e::intrusive_ptr<yieldable> > m_yieldable;
+	e::intrusive_ptr<yieldable> m_yielding;
+	e::intrusive_ptr<yieldable> m_yielded;
+	e::intrusive_ptr<pending_perf_counters> m_pcs;
+	// misc
+	e::error m_last_error;
 
-    private:
-        admin(const admin&);
-        admin& operator = (const admin&);
+private:
+	admin(const admin &);
+	admin &operator = (const admin &);
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/admin/backup_state_machine.cc b/admin/backup_state_machine.cc
index f92217686..24d78698e 100644
--- a/admin/backup_state_machine.cc
+++ b/admin/backup_state_machine.cc
@@ -34,21 +34,21 @@
 
 using hyperdex::backup_state_machine;
 
-backup_state_machine :: backup_state_machine(const char* name,
+backup_state_machine :: backup_state_machine(const char *name,
                                              uint64_t id,
-                                             hyperdex_admin_returncode* status,
-                                             const char** backups)
-    : multi_yieldable(id, status)
-    , m_name(name)
-    , m_state(INITIALIZED)
-    , m_nested_id()
-    , m_nested_rc()
-    , m_configuration_version(0)
-    , m_servers()
-    , m_backup(NULL)
-    , m_backups()
-    , m_backups_str()
-    , m_backups_c_str(backups)
+                                             hyperdex_admin_returncode *status,
+                                             const char **backups)
+	: multi_yieldable(id, status)
+	, m_name(name)
+	, m_state(INITIALIZED)
+	, m_nested_id()
+	, m_nested_rc()
+	, m_configuration_version(0)
+	, m_servers()
+	, m_backup(NULL)
+	, m_backups()
+	, m_backups_str()
+	, m_backups_c_str(backups)
 {
 }
 
@@ -59,298 +59,268 @@ backup_state_machine :: ~backup_state_machine() throw ()
 bool
 backup_state_machine :: can_yield()
 {
-    return m_state == DONE || m_state == ERROR;
+	return m_state == DONE || m_state == ERROR;
 }
 
 bool
-backup_state_machine :: yield(hyperdex_admin_returncode* status)
+backup_state_machine :: yield(hyperdex_admin_returncode *status)
 {
-    assert(this->can_yield());
-    *status = HYPERDEX_ADMIN_SUCCESS;
-    m_state = YIELDED;
-    m_backups_str = m_backups.str();
-    *m_backups_c_str = m_backups_str.c_str();
-    return true;
+	assert(this->can_yield());
+	*status = HYPERDEX_ADMIN_SUCCESS;
+	m_state = YIELDED;
+	m_backups_str = m_backups.str();
+	*m_backups_c_str = m_backups_str.c_str();
+	return true;
 }
 
 bool
-backup_state_machine :: initialize(admin* adm, hyperdex_admin_returncode* status)
+backup_state_machine :: initialize(admin *adm, hyperdex_admin_returncode *status)
 {
-    *status = HYPERDEX_ADMIN_SUCCESS;
-    m_nested_id = adm->read_only(1, &m_nested_rc);
-
-    if (!check_nested(adm))
-    {
-        *status = m_nested_rc;
-        return false;
-    }
-
-    adm->m_multi_ops[m_nested_id] = this;
-    m_state = SET_READ_ONLY;
-    return true;
+	*status = HYPERDEX_ADMIN_SUCCESS;
+	m_nested_id = adm->read_only(1, &m_nested_rc);
+	if (!check_nested(adm))
+	{
+		*status = m_nested_rc;
+		return false;
+	}
+	adm->m_multi_ops[m_nested_id] = this;
+	m_state = SET_READ_ONLY;
+	return true;
 }
 
 bool
-backup_state_machine :: callback(admin* adm, int64_t id, hyperdex_admin_returncode* status)
+backup_state_machine :: callback(admin *adm, int64_t id, hyperdex_admin_returncode *status)
 {
-    *status = HYPERDEX_ADMIN_SUCCESS;
-
-    switch (m_state)
-    {
-        case INITIALIZED:
-            callback_unexpected(adm, id);
-            return true;
-        case SET_READ_ONLY:
-            callback_set_read_only(adm, id);
-            return true;
-        case WAIT_TO_QUIESCE:
-            callback_wait_to_quiesce(adm, id);
-            return true;
-        case DAEMON_BACKUP:
-            callback_daemon_backup(adm, id);
-            return true;
-        case COORD_BACKUP:
-            callback_coord_backup(adm, id);
-            return true;
-        case WAIT_TO_QUIESCE_AGAIN:
-            callback_wait_to_quiesce_again(adm, id);
-            return true;
-        case SET_READ_WRITE:
-            callback_set_read_write(adm, id);
-            return true;
-        case DONE:
-            callback_unexpected(adm, id);
-            return true;
-        case BACKOUT:
-            callback_backout(adm, id);
-            return true;
-        case ERROR:
-            callback_unexpected(adm, id);
-            return true;
-        case YIELDED:
-            callback_unexpected(adm, id);
-            return true;
-        default:
-            YIELDING_ERROR(INTERNAL) << "wandered into undefined state";
-            return true;
-    }
+	*status = HYPERDEX_ADMIN_SUCCESS;
+	switch (m_state)
+	{
+	case INITIALIZED:
+		callback_unexpected(adm, id);
+		return true;
+	case SET_READ_ONLY:
+		callback_set_read_only(adm, id);
+		return true;
+	case WAIT_TO_QUIESCE:
+		callback_wait_to_quiesce(adm, id);
+		return true;
+	case DAEMON_BACKUP:
+		callback_daemon_backup(adm, id);
+		return true;
+	case COORD_BACKUP:
+		callback_coord_backup(adm, id);
+		return true;
+	case WAIT_TO_QUIESCE_AGAIN:
+		callback_wait_to_quiesce_again(adm, id);
+		return true;
+	case SET_READ_WRITE:
+		callback_set_read_write(adm, id);
+		return true;
+	case DONE:
+		callback_unexpected(adm, id);
+		return true;
+	case BACKOUT:
+		callback_backout(adm, id);
+		return true;
+	case ERROR:
+		callback_unexpected(adm, id);
+		return true;
+	case YIELDED:
+		callback_unexpected(adm, id);
+		return true;
+	default:
+		YIELDING_ERROR(INTERNAL) << "wandered into undefined state";
+		return true;
+	}
 }
 
 void
-backup_state_machine :: backout(admin* adm)
+backup_state_machine :: backout(admin *adm)
 {
-    m_nested_id = adm->read_only(0, &m_nested_rc);
-
-    if (m_nested_id < 0)
-    {
-        m_state = ERROR;
-    }
-    else
-    {
-        adm->m_multi_ops[m_nested_id] = this;
-    }
+	m_nested_id = adm->read_only(0, &m_nested_rc);
+	if (m_nested_id < 0)
+	{
+		m_state = ERROR;
+	}
+	else
+	{
+		adm->m_multi_ops[m_nested_id] = this;
+	}
 }
 
 bool
-backup_state_machine :: common_callback(admin* adm, int64_t id)
+backup_state_machine :: common_callback(admin *adm, int64_t id)
 {
-    bool ret = true;
-
-    if (m_state == ERROR || m_state == YIELDED)
-    {
-        ret = false;
-    }
-    else if (m_nested_id != id)
-    {
-        YIELDING_ERROR(INTERNAL) << "callback had id=" << id
-                                 << " when it should have id=" << m_nested_id;
-        m_state = m_state > SET_READ_ONLY ? BACKOUT : ERROR;
-        ret = false;
-    }
-    else if (m_nested_rc != HYPERDEX_ADMIN_SUCCESS)
-    {
-        this->set_status(m_nested_rc);
-        this->set_error(adm->m_last_error);
-        m_state = m_state > SET_READ_ONLY ? BACKOUT : ERROR;
-        ret = false;
-    }
-
-    if (!ret && m_state == BACKOUT)
-    {
-        backout(adm);
-    }
-
-    return ret;
+	bool ret = true;
+	if (m_state == ERROR || m_state == YIELDED)
+	{
+		ret = false;
+	}
+	else if (m_nested_id != id)
+	{
+		YIELDING_ERROR(INTERNAL) << "callback had id=" << id
+		                         << " when it should have id=" << m_nested_id;
+		m_state = m_state > SET_READ_ONLY ? BACKOUT : ERROR;
+		ret = false;
+	}
+	else if (m_nested_rc != HYPERDEX_ADMIN_SUCCESS)
+	{
+		this->set_status(m_nested_rc);
+		this->set_error(adm->m_last_error);
+		m_state = m_state > SET_READ_ONLY ? BACKOUT : ERROR;
+		ret = false;
+	}
+	if (!ret && m_state == BACKOUT)
+	{
+		backout(adm);
+	}
+	return ret;
 }
 
 bool
-backup_state_machine :: check_nested(admin* adm)
+backup_state_machine :: check_nested(admin *adm)
 {
-    if (m_nested_id >= 0)
-    {
-        return true;
-    }
-
-    this->set_status(m_nested_rc);
-    this->set_error(adm->m_last_error);
-    m_state = m_state >= SET_READ_ONLY ? BACKOUT : ERROR;
-
-    if (m_state == BACKOUT)
-    {
-        backout(adm);
-    }
-
-    return false;
+	if (m_nested_id >= 0)
+	{
+		return true;
+	}
+	this->set_status(m_nested_rc);
+	this->set_error(adm->m_last_error);
+	m_state = m_state >= SET_READ_ONLY ? BACKOUT : ERROR;
+	if (m_state == BACKOUT)
+	{
+		backout(adm);
+	}
+	return false;
 }
 
 void
-backup_state_machine :: callback_unexpected(admin*, int64_t)
+backup_state_machine :: callback_unexpected(admin *, int64_t)
 {
-    YIELDING_ERROR(INTERNAL) << "wandered into undefined state";
-    m_state = ERROR;
+	YIELDING_ERROR(INTERNAL) << "wandered into undefined state";
+	m_state = ERROR;
 }
 
 void
-backup_state_machine :: callback_set_read_only(admin* adm, int64_t id)
+backup_state_machine :: callback_set_read_only(admin *adm, int64_t id)
 {
-    if (!common_callback(adm, id))
-    {
-        return;
-    }
-
-    m_nested_id = adm->wait_until_stable(&m_nested_rc);
-
-    if (!check_nested(adm))
-    {
-        return;
-    }
-
-    adm->m_multi_ops[m_nested_id] = this;
-    m_state = WAIT_TO_QUIESCE;
+	if (!common_callback(adm, id))
+	{
+		return;
+	}
+	m_nested_id = adm->wait_until_stable(&m_nested_rc);
+	if (!check_nested(adm))
+	{
+		return;
+	}
+	adm->m_multi_ops[m_nested_id] = this;
+	m_state = WAIT_TO_QUIESCE;
 }
 
 void
-backup_state_machine :: callback_wait_to_quiesce(admin* adm, int64_t id)
+backup_state_machine :: callback_wait_to_quiesce(admin *adm, int64_t id)
 {
-    if (!common_callback(adm, id))
-    {
-        return;
-    }
-
-    // at this point we know that:
-    // 1. the cluster is in read-only mode
-    // 2. every write initiated before setting it to read-only mode is complete
-    m_configuration_version = adm->m_config.version();
-
-    // now figure out the servers to take a backup on
-    adm->m_config.get_all_addresses(&m_servers);
-    std::sort(m_servers.rbegin(), m_servers.rend());
-    return callback_daemon_backup(adm, id);
+	if (!common_callback(adm, id))
+	{
+		return;
+	}
+	// at this point we know that:
+	// 1. the cluster is in read-only mode
+	// 2. every write initiated before setting it to read-only mode is complete
+	m_configuration_version = adm->m_config.version();
+	// now figure out the servers to take a backup on
+	adm->m_config.get_all_addresses(&m_servers);
+	std::sort(m_servers.rbegin(), m_servers.rend());
+	return callback_daemon_backup(adm, id);
 }
 
 void
-backup_state_machine :: callback_daemon_backup(admin* adm, int64_t id)
+backup_state_machine :: callback_daemon_backup(admin *adm, int64_t id)
 {
-    if (!common_callback(adm, id))
-    {
-        return;
-    }
-
-    if (m_backup)
-    {
-        m_backups << m_backup << "\n";
-        m_backup = NULL;
-    }
-
-    if (m_servers.empty())
-    {
-        std::string path = m_name + ".coordinator.bin";
-        m_nested_id = adm->coord_backup(path.c_str(), &m_nested_rc);
-
-        if (!check_nested(adm))
-        {
-            return;
-        }
-
-        adm->m_multi_ops[m_nested_id] = this;
-        m_state = COORD_BACKUP;
-        return;
-    }
-
-    server_id sid = m_servers.back().first;
-    po6::net::location loc = m_servers.back().second;
-    m_servers.pop_back();
-    m_nested_id = adm->raw_backup(sid, m_name.c_str(), &m_nested_rc, &m_backup);
-    m_backups << sid.get() << " " << loc.address << " ";
-
-    if (!check_nested(adm))
-    {
-        return;
-    }
-
-    adm->m_multi_ops[m_nested_id] = this;
-    m_state = DAEMON_BACKUP;
+	if (!common_callback(adm, id))
+	{
+		return;
+	}
+	if (m_backup)
+	{
+		m_backups << m_backup << "\n";
+		m_backup = NULL;
+	}
+	if (m_servers.empty())
+	{
+		std::string path = m_name + ".coordinator.bin";
+		m_nested_id = adm->coord_backup(path.c_str(), &m_nested_rc);
+		if (!check_nested(adm))
+		{
+			return;
+		}
+		adm->m_multi_ops[m_nested_id] = this;
+		m_state = COORD_BACKUP;
+		return;
+	}
+	server_id sid = m_servers.back().first;
+	po6::net::location loc = m_servers.back().second;
+	m_servers.pop_back();
+	m_nested_id = adm->raw_backup(sid, m_name.c_str(), &m_nested_rc, &m_backup);
+	m_backups << sid.get() << " " << loc.address << " ";
+	if (!check_nested(adm))
+	{
+		return;
+	}
+	adm->m_multi_ops[m_nested_id] = this;
+	m_state = DAEMON_BACKUP;
 }
 
 void
-backup_state_machine :: callback_coord_backup(admin* adm, int64_t id)
+backup_state_machine :: callback_coord_backup(admin *adm, int64_t id)
 {
-    if (!common_callback(adm, id))
-    {
-        return;
-    }
-
-    m_nested_id = adm->wait_until_stable(&m_nested_rc);
-
-    if (!check_nested(adm))
-    {
-        return;
-    }
-
-    adm->m_multi_ops[m_nested_id] = this;
-    m_state = WAIT_TO_QUIESCE_AGAIN;
+	if (!common_callback(adm, id))
+	{
+		return;
+	}
+	m_nested_id = adm->wait_until_stable(&m_nested_rc);
+	if (!check_nested(adm))
+	{
+		return;
+	}
+	adm->m_multi_ops[m_nested_id] = this;
+	m_state = WAIT_TO_QUIESCE_AGAIN;
 }
 
 void
-backup_state_machine :: callback_wait_to_quiesce_again(admin* adm, int64_t id)
+backup_state_machine :: callback_wait_to_quiesce_again(admin *adm, int64_t id)
 {
-    if (!common_callback(adm, id))
-    {
-        return;
-    }
-
-    if (m_configuration_version != adm->m_config.version())
-    {
-        YIELDING_ERROR(INTERNAL) << "configuration changed while taking backup";
-        backout(adm);
-    }
-
-    m_nested_id = adm->read_only(0, &m_nested_rc);
-
-    if (!check_nested(adm))
-    {
-        return;
-    }
-
-    adm->m_multi_ops[m_nested_id] = this;
-    m_state = SET_READ_WRITE;
+	if (!common_callback(adm, id))
+	{
+		return;
+	}
+	if (m_configuration_version != adm->m_config.version())
+	{
+		YIELDING_ERROR(INTERNAL) << "configuration changed while taking backup";
+		backout(adm);
+	}
+	m_nested_id = adm->read_only(0, &m_nested_rc);
+	if (!check_nested(adm))
+	{
+		return;
+	}
+	adm->m_multi_ops[m_nested_id] = this;
+	m_state = SET_READ_WRITE;
 }
 
 void
-backup_state_machine :: callback_set_read_write(admin* adm, int64_t id)
+backup_state_machine :: callback_set_read_write(admin *adm, int64_t id)
 {
-    if (!common_callback(adm, id))
-    {
-        return;
-    }
-
-    this->set_status(HYPERDEX_ADMIN_SUCCESS);
-    this->set_error(e::error());
-    m_state = DONE;
+	if (!common_callback(adm, id))
+	{
+		return;
+	}
+	this->set_status(HYPERDEX_ADMIN_SUCCESS);
+	this->set_error(e::error());
+	m_state = DONE;
 }
 
 void
-backup_state_machine :: callback_backout(admin*, int64_t)
+backup_state_machine :: callback_backout(admin *, int64_t)
 {
-    m_state = ERROR;
+	m_state = ERROR;
 }
diff --git a/admin/backup_state_machine.h b/admin/backup_state_machine.h
index d70be441c..38dfe55e3 100644
--- a/admin/backup_state_machine.h
+++ b/admin/backup_state_machine.h
@@ -49,58 +49,59 @@ class admin;
 
 class backup_state_machine : public multi_yieldable
 {
-    public:
-        backup_state_machine(const char* name,
-                             uint64_t admin_visible_id,
-                             hyperdex_admin_returncode* status,
-                             const char** backups);
-        ~backup_state_machine() throw ();
+public:
+	backup_state_machine(const char *name,
+	                     uint64_t admin_visible_id,
+	                     hyperdex_admin_returncode *status,
+	                     const char **backups);
+	~backup_state_machine() throw ();
 
-    public:
-        bool can_yield();
-        bool yield(hyperdex_admin_returncode* status);
-        bool initialize(admin* adm, hyperdex_admin_returncode* status);
-        bool callback(admin* adm, int64_t id, hyperdex_admin_returncode* status);
+public:
+	bool can_yield();
+	bool yield(hyperdex_admin_returncode *status);
+	bool initialize(admin *adm, hyperdex_admin_returncode *status);
+	bool callback(admin *adm, int64_t id, hyperdex_admin_returncode *status);
 
-    private:
-        friend class e::intrusive_ptr<backup_state_machine>;
-        backup_state_machine(const backup_state_machine&);
-        backup_state_machine& operator = (const backup_state_machine&);
+private:
+	friend class e::intrusive_ptr<backup_state_machine>;
+	backup_state_machine(const backup_state_machine &);
+	backup_state_machine &operator = (const backup_state_machine &);
 
-    private:
-        void backout(admin* adm);
-        bool common_callback(admin* adm, int64_t id);
-        bool check_nested(admin* adm);
-        void callback_unexpected(admin* adm, int64_t id);
-        void callback_set_read_only(admin* adm, int64_t id);
-        void callback_wait_to_quiesce(admin* adm, int64_t id);
-        void callback_daemon_backup(admin* adm, int64_t id);
-        void callback_coord_backup(admin* adm, int64_t id);
-        void callback_wait_to_quiesce_again(admin* adm, int64_t id);
-        void callback_set_read_write(admin* adm, int64_t id);
-        void callback_backout(admin* adm, int64_t id);
+private:
+	void backout(admin *adm);
+	bool common_callback(admin *adm, int64_t id);
+	bool check_nested(admin *adm);
+	void callback_unexpected(admin *adm, int64_t id);
+	void callback_set_read_only(admin *adm, int64_t id);
+	void callback_wait_to_quiesce(admin *adm, int64_t id);
+	void callback_daemon_backup(admin *adm, int64_t id);
+	void callback_coord_backup(admin *adm, int64_t id);
+	void callback_wait_to_quiesce_again(admin *adm, int64_t id);
+	void callback_set_read_write(admin *adm, int64_t id);
+	void callback_backout(admin *adm, int64_t id);
 
-    private:
-        std::string m_name;
-        enum { INITIALIZED,
-               SET_READ_ONLY,
-               WAIT_TO_QUIESCE,
-               DAEMON_BACKUP,
-               COORD_BACKUP,
-               WAIT_TO_QUIESCE_AGAIN,
-               SET_READ_WRITE,
-               DONE,
-               BACKOUT,
-               ERROR,
-               YIELDED } m_state;
-        int64_t m_nested_id;
-        hyperdex_admin_returncode m_nested_rc;
-        uint64_t m_configuration_version;
-        std::vector<std::pair<server_id, po6::net::location> > m_servers;
-        const char* m_backup;
-        std::ostringstream m_backups;
-        std::string m_backups_str;
-        const char** m_backups_c_str;
+private:
+	std::string m_name;
+	enum { INITIALIZED,
+	       SET_READ_ONLY,
+	       WAIT_TO_QUIESCE,
+	       DAEMON_BACKUP,
+	       COORD_BACKUP,
+	       WAIT_TO_QUIESCE_AGAIN,
+	       SET_READ_WRITE,
+	       DONE,
+	       BACKOUT,
+	       ERROR,
+	       YIELDED
+	     } m_state;
+	int64_t m_nested_id;
+	hyperdex_admin_returncode m_nested_rc;
+	uint64_t m_configuration_version;
+	std::vector<std::pair<server_id, po6::net::location> > m_servers;
+	const char *m_backup;
+	std::ostringstream m_backups;
+	std::string m_backups_str;
+	const char **m_backups_c_str;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/admin/c.cc b/admin/c.cc
index 442eddb02..a6a38327b 100644
--- a/admin/c.cc
+++ b/admin/c.cc
@@ -41,349 +41,349 @@
 #include "admin/admin.h"
 
 #define SIGNAL_PROTECT_ERR(X) \
-    do \
-    { \
-        sigset_t old_sigs; \
-        sigset_t all_sigs; \
-        sigfillset(&all_sigs); \
-        if (pthread_sigmask(SIG_BLOCK, &all_sigs, &old_sigs) < 0) \
-        { \
-            *status = HYPERDEX_ADMIN_INTERNAL; \
-            return (X); \
-        } \
-        e::guard g = e::makeguard(pthread_sigmask, SIG_SETMASK, (sigset_t*)&old_sigs, (sigset_t*)NULL); \
-        g.use_variable(); \
-    } \
-    while (0)
+	do \
+	{ \
+		sigset_t old_sigs; \
+		sigset_t all_sigs; \
+		sigfillset(&all_sigs); \
+		if (pthread_sigmask(SIG_BLOCK, &all_sigs, &old_sigs) < 0) \
+		{ \
+			*status = HYPERDEX_ADMIN_INTERNAL; \
+			return (X); \
+		} \
+		e::guard g = e::makeguard(pthread_sigmask, SIG_SETMASK, (sigset_t*)&old_sigs, (sigset_t*)NULL); \
+		g.use_variable(); \
+	} \
+	while (0)
 
 #define SIGNAL_PROTECT SIGNAL_PROTECT_ERR(-1);
 inline void return_void() {}
 #define SIGNAL_PROTECT_VOID SIGNAL_PROTECT_ERR(return_void());
 
 #define C_WRAP_EXCEPT(X) \
-    SIGNAL_PROTECT; \
-    try \
-    { \
-        X \
-    } \
-    catch (std::bad_alloc& ba) \
-    { \
-        errno = ENOMEM; \
-        *status = HYPERDEX_ADMIN_NOMEM; \
-        return -1; \
-    } \
-    catch (...) \
-    { \
-        *status = HYPERDEX_ADMIN_EXCEPTION; \
-        return -1; \
-    }
+	SIGNAL_PROTECT; \
+	try \
+	{ \
+		X \
+	} \
+	catch (std::bad_alloc& ba) \
+	{ \
+		errno = ENOMEM; \
+		*status = HYPERDEX_ADMIN_NOMEM; \
+		return -1; \
+	} \
+	catch (...) \
+	{ \
+		*status = HYPERDEX_ADMIN_EXCEPTION; \
+		return -1; \
+	}
 
 extern "C"
 {
 
-HYPERDEX_API struct hyperdex_admin*
-hyperdex_admin_create(const char* coordinator, uint16_t port)
-{
-    try
-    {
-        return reinterpret_cast<struct hyperdex_admin*>(new hyperdex::admin(coordinator, port));
-    }
-    catch (std::bad_alloc& ba)
-    {
-        errno = ENOMEM;
-        return NULL;
-    }
-    catch (...)
-    {
-        return NULL;
-    }
-}
-
-HYPERDEX_API void
-hyperdex_admin_destroy(struct hyperdex_admin* admin)
-{
-    delete reinterpret_cast<hyperdex::admin*>(admin);
-}
-
-HYPERDEX_API int64_t
-hyperdex_admin_dump_config(struct hyperdex_admin* _adm,
-                           hyperdex_admin_returncode* status,
-                           const char** config)
-{
-    C_WRAP_EXCEPT(
-    hyperdex::admin* adm = reinterpret_cast<hyperdex::admin*>(_adm);
-    return adm->dump_config(status, config);
-    );
-}
-HYPERDEX_API int64_t
-hyperdex_admin_read_only(struct hyperdex_admin* _adm,
-                         int ro,
-                         enum hyperdex_admin_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    hyperdex::admin* adm = reinterpret_cast<hyperdex::admin*>(_adm);
-    return adm->read_only(ro, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_admin_wait_until_stable(struct hyperdex_admin* _adm,
-                                 enum hyperdex_admin_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    hyperdex::admin* adm = reinterpret_cast<hyperdex::admin*>(_adm);
-    return adm->wait_until_stable(status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_admin_fault_tolerance(struct hyperdex_admin* _adm,
-                               const char* space,
-                               uint64_t ft,
-                               enum hyperdex_admin_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    hyperdex::admin* adm = reinterpret_cast<hyperdex::admin*>(_adm);
-    return adm->fault_tolerance(space, ft, status);
-    );
-}
-
-HYPERDEX_API int
-hyperdex_admin_validate_space(struct hyperdex_admin* _adm,
-                              const char* description,
-                              enum hyperdex_admin_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    hyperdex::admin* adm = reinterpret_cast<hyperdex::admin*>(_adm);
-    return adm->validate_space(description, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_admin_add_space(struct hyperdex_admin* _adm,
-                         const char* description,
-                         enum hyperdex_admin_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    hyperdex::admin* adm = reinterpret_cast<hyperdex::admin*>(_adm);
-    return adm->add_space(description, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_admin_rm_space(struct hyperdex_admin* _adm,
-                        const char* space,
-                        enum hyperdex_admin_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    hyperdex::admin* adm = reinterpret_cast<hyperdex::admin*>(_adm);
-    return adm->rm_space(space, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_admin_mv_space(struct hyperdex_admin* _adm,
-                        const char* source,
-                        const char* target,
-                        enum hyperdex_admin_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    hyperdex::admin* adm = reinterpret_cast<hyperdex::admin*>(_adm);
-    return adm->mv_space(source, target, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_admin_list_spaces(struct hyperdex_admin* _adm,
-                           enum hyperdex_admin_returncode* status,
-                           const char** spaces)
-{
-    C_WRAP_EXCEPT(
-    hyperdex::admin* adm = reinterpret_cast<hyperdex::admin*>(_adm);
-    return adm->list_spaces(status, spaces);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_admin_list_indices(struct hyperdex_admin* _adm,
-                            const char* space,
-                            enum hyperdex_admin_returncode* status,
-                            const char** indexes)
-{
-    C_WRAP_EXCEPT(
-    hyperdex::admin* adm = reinterpret_cast<hyperdex::admin*>(_adm);
-    return adm->list_indices(space, status, indexes);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_admin_list_subspaces(struct hyperdex_admin* _adm,
-                              const char* space,
-                              enum hyperdex_admin_returncode* status,
-                              const char** subspaces)
-{
-    C_WRAP_EXCEPT(
-    hyperdex::admin* adm = reinterpret_cast<hyperdex::admin*>(_adm);
-    return adm->list_subspaces(space, status, subspaces);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_admin_add_index(struct hyperdex_admin* _adm,
-                         const char* space,
-                         const char* attribute,
-                         enum hyperdex_admin_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    hyperdex::admin* adm = reinterpret_cast<hyperdex::admin*>(_adm);
-    return adm->add_index(space, attribute, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_admin_rm_index(struct hyperdex_admin* _adm,
-                        uint64_t idxid,
-                        enum hyperdex_admin_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    hyperdex::admin* adm = reinterpret_cast<hyperdex::admin*>(_adm);
-    return adm->rm_index(idxid, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_admin_server_register(struct hyperdex_admin* _adm,
-                               uint64_t token,
-                               const char* address,
-                               enum hyperdex_admin_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    hyperdex::admin* adm = reinterpret_cast<hyperdex::admin*>(_adm);
-    return adm->server_register(token, address, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_admin_server_online(struct hyperdex_admin* _adm,
-                             uint64_t token,
-                             enum hyperdex_admin_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    hyperdex::admin* adm = reinterpret_cast<hyperdex::admin*>(_adm);
-    return adm->server_online(token, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_admin_server_offline(struct hyperdex_admin* _adm,
-                              uint64_t token,
-                              enum hyperdex_admin_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    hyperdex::admin* adm = reinterpret_cast<hyperdex::admin*>(_adm);
-    return adm->server_offline(token, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_admin_server_forget(struct hyperdex_admin* _adm,
-                             uint64_t token,
-                             enum hyperdex_admin_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    hyperdex::admin* adm = reinterpret_cast<hyperdex::admin*>(_adm);
-    return adm->server_forget(token, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_admin_server_kill(struct hyperdex_admin* _adm,
-                           uint64_t token,
-                           enum hyperdex_admin_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    hyperdex::admin* adm = reinterpret_cast<hyperdex::admin*>(_adm);
-    return adm->server_kill(token, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_admin_backup(struct hyperdex_admin* _adm,
-                      const char* backup,
-                      enum hyperdex_admin_returncode* status,
-                      const char** backups)
-{
-    C_WRAP_EXCEPT(
-    hyperdex::admin* adm = reinterpret_cast<hyperdex::admin*>(_adm);
-    return adm->backup(backup, status, backups);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_admin_enable_perf_counters(struct hyperdex_admin* _adm,
-                                    enum hyperdex_admin_returncode* status,
-                                    struct hyperdex_admin_perf_counter* pc)
-{
-    C_WRAP_EXCEPT(
-    hyperdex::admin* adm = reinterpret_cast<hyperdex::admin*>(_adm);
-    return adm->enable_perf_counters(status, pc);
-    );
-}
-
-HYPERDEX_API void
-hyperdex_admin_disable_perf_counters(struct hyperdex_admin* _adm)
-{
-    hyperdex::admin* adm = reinterpret_cast<hyperdex::admin*>(_adm);
-    return adm->disable_perf_counters();
-}
-
-HYPERDEX_API int64_t
-hyperdex_admin_loop(struct hyperdex_admin* _adm, int timeout,
-                    enum hyperdex_admin_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    hyperdex::admin* adm = reinterpret_cast<hyperdex::admin*>(_adm);
-    return adm->loop(timeout, status);
-    );
-}
-
-HYPERDEX_API const char*
-hyperdex_admin_error_message(struct hyperdex_admin* _adm)
-{
-    hyperdex::admin* adm = reinterpret_cast<hyperdex::admin*>(_adm);
-    return adm->error_message();
-}
-
-HYPERDEX_API const char*
-hyperdex_admin_error_location(struct hyperdex_admin* _adm)
-{
-    hyperdex::admin* adm = reinterpret_cast<hyperdex::admin*>(_adm);
-    return adm->error_location();
-}
-
-HYPERDEX_API const char*
-hyperdex_admin_returncode_to_string(enum hyperdex_admin_returncode status)
-{
-    switch (status)
-    {
-        CSTRINGIFY(HYPERDEX_ADMIN_SUCCESS);
-        CSTRINGIFY(HYPERDEX_ADMIN_NOMEM);
-        CSTRINGIFY(HYPERDEX_ADMIN_NONEPENDING);
-        CSTRINGIFY(HYPERDEX_ADMIN_POLLFAILED);
-        CSTRINGIFY(HYPERDEX_ADMIN_TIMEOUT);
-        CSTRINGIFY(HYPERDEX_ADMIN_INTERRUPTED);
-        CSTRINGIFY(HYPERDEX_ADMIN_SERVERERROR);
-        CSTRINGIFY(HYPERDEX_ADMIN_COORDFAIL);
-        CSTRINGIFY(HYPERDEX_ADMIN_BADSPACE);
-        CSTRINGIFY(HYPERDEX_ADMIN_DUPLICATE);
-        CSTRINGIFY(HYPERDEX_ADMIN_NOTFOUND);
-        CSTRINGIFY(HYPERDEX_ADMIN_LOCALERROR);
-        CSTRINGIFY(HYPERDEX_ADMIN_INTERNAL);
-        CSTRINGIFY(HYPERDEX_ADMIN_EXCEPTION);
-        CSTRINGIFY(HYPERDEX_ADMIN_GARBAGE);
-        default:
-            return "unknown hyperdex_admin_returncode";
-    }
-}
+	HYPERDEX_API struct hyperdex_admin *
+	hyperdex_admin_create(const char *coordinator, uint16_t port)
+	{
+		try
+		{
+			return reinterpret_cast<struct hyperdex_admin *>(new hyperdex::admin(coordinator, port));
+		}
+		catch (std::bad_alloc &ba)
+		{
+			errno = ENOMEM;
+			return NULL;
+		}
+		catch (...)
+		{
+			return NULL;
+		}
+	}
+
+	HYPERDEX_API void
+	hyperdex_admin_destroy(struct hyperdex_admin *admin)
+	{
+		delete reinterpret_cast<hyperdex::admin *>(admin);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_admin_dump_config(struct hyperdex_admin *_adm,
+	                           hyperdex_admin_returncode *status,
+	                           const char **config)
+	{
+		C_WRAP_EXCEPT(
+		    hyperdex::admin *adm = reinterpret_cast<hyperdex::admin *>(_adm);
+		    return adm->dump_config(status, config);
+		);
+	}
+	HYPERDEX_API int64_t
+	hyperdex_admin_read_only(struct hyperdex_admin *_adm,
+	                         int ro,
+	                         enum hyperdex_admin_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    hyperdex::admin *adm = reinterpret_cast<hyperdex::admin *>(_adm);
+		    return adm->read_only(ro, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_admin_wait_until_stable(struct hyperdex_admin *_adm,
+	                                 enum hyperdex_admin_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    hyperdex::admin *adm = reinterpret_cast<hyperdex::admin *>(_adm);
+		    return adm->wait_until_stable(status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_admin_fault_tolerance(struct hyperdex_admin *_adm,
+	                               const char *space,
+	                               uint64_t ft,
+	                               enum hyperdex_admin_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    hyperdex::admin *adm = reinterpret_cast<hyperdex::admin *>(_adm);
+		    return adm->fault_tolerance(space, ft, status);
+		);
+	}
+
+	HYPERDEX_API int
+	hyperdex_admin_validate_space(struct hyperdex_admin *_adm,
+	                              const char *description,
+	                              enum hyperdex_admin_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    hyperdex::admin *adm = reinterpret_cast<hyperdex::admin *>(_adm);
+		    return adm->validate_space(description, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_admin_add_space(struct hyperdex_admin *_adm,
+	                         const char *description,
+	                         enum hyperdex_admin_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    hyperdex::admin *adm = reinterpret_cast<hyperdex::admin *>(_adm);
+		    return adm->add_space(description, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_admin_rm_space(struct hyperdex_admin *_adm,
+	                        const char *space,
+	                        enum hyperdex_admin_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    hyperdex::admin *adm = reinterpret_cast<hyperdex::admin *>(_adm);
+		    return adm->rm_space(space, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_admin_mv_space(struct hyperdex_admin *_adm,
+	                        const char *source,
+	                        const char *target,
+	                        enum hyperdex_admin_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    hyperdex::admin *adm = reinterpret_cast<hyperdex::admin *>(_adm);
+		    return adm->mv_space(source, target, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_admin_list_spaces(struct hyperdex_admin *_adm,
+	                           enum hyperdex_admin_returncode *status,
+	                           const char **spaces)
+	{
+		C_WRAP_EXCEPT(
+		    hyperdex::admin *adm = reinterpret_cast<hyperdex::admin *>(_adm);
+		    return adm->list_spaces(status, spaces);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_admin_list_indices(struct hyperdex_admin *_adm,
+	                            const char *space,
+	                            enum hyperdex_admin_returncode *status,
+	                            const char **indexes)
+	{
+		C_WRAP_EXCEPT(
+		    hyperdex::admin *adm = reinterpret_cast<hyperdex::admin *>(_adm);
+		    return adm->list_indices(space, status, indexes);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_admin_list_subspaces(struct hyperdex_admin *_adm,
+	                              const char *space,
+	                              enum hyperdex_admin_returncode *status,
+	                              const char **subspaces)
+	{
+		C_WRAP_EXCEPT(
+		    hyperdex::admin *adm = reinterpret_cast<hyperdex::admin *>(_adm);
+		    return adm->list_subspaces(space, status, subspaces);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_admin_add_index(struct hyperdex_admin *_adm,
+	                         const char *space,
+	                         const char *attribute,
+	                         enum hyperdex_admin_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    hyperdex::admin *adm = reinterpret_cast<hyperdex::admin *>(_adm);
+		    return adm->add_index(space, attribute, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_admin_rm_index(struct hyperdex_admin *_adm,
+	                        uint64_t idxid,
+	                        enum hyperdex_admin_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    hyperdex::admin *adm = reinterpret_cast<hyperdex::admin *>(_adm);
+		    return adm->rm_index(idxid, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_admin_server_register(struct hyperdex_admin *_adm,
+	                               uint64_t token,
+	                               const char *address,
+	                               enum hyperdex_admin_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    hyperdex::admin *adm = reinterpret_cast<hyperdex::admin *>(_adm);
+		    return adm->server_register(token, address, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_admin_server_online(struct hyperdex_admin *_adm,
+	                             uint64_t token,
+	                             enum hyperdex_admin_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    hyperdex::admin *adm = reinterpret_cast<hyperdex::admin *>(_adm);
+		    return adm->server_online(token, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_admin_server_offline(struct hyperdex_admin *_adm,
+	                              uint64_t token,
+	                              enum hyperdex_admin_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    hyperdex::admin *adm = reinterpret_cast<hyperdex::admin *>(_adm);
+		    return adm->server_offline(token, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_admin_server_forget(struct hyperdex_admin *_adm,
+	                             uint64_t token,
+	                             enum hyperdex_admin_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    hyperdex::admin *adm = reinterpret_cast<hyperdex::admin *>(_adm);
+		    return adm->server_forget(token, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_admin_server_kill(struct hyperdex_admin *_adm,
+	                           uint64_t token,
+	                           enum hyperdex_admin_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    hyperdex::admin *adm = reinterpret_cast<hyperdex::admin *>(_adm);
+		    return adm->server_kill(token, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_admin_backup(struct hyperdex_admin *_adm,
+	                      const char *backup,
+	                      enum hyperdex_admin_returncode *status,
+	                      const char **backups)
+	{
+		C_WRAP_EXCEPT(
+		    hyperdex::admin *adm = reinterpret_cast<hyperdex::admin *>(_adm);
+		    return adm->backup(backup, status, backups);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_admin_enable_perf_counters(struct hyperdex_admin *_adm,
+	                                    enum hyperdex_admin_returncode *status,
+	                                    struct hyperdex_admin_perf_counter *pc)
+	{
+		C_WRAP_EXCEPT(
+		    hyperdex::admin *adm = reinterpret_cast<hyperdex::admin *>(_adm);
+		    return adm->enable_perf_counters(status, pc);
+		);
+	}
+
+	HYPERDEX_API void
+	hyperdex_admin_disable_perf_counters(struct hyperdex_admin *_adm)
+	{
+		hyperdex::admin *adm = reinterpret_cast<hyperdex::admin *>(_adm);
+		return adm->disable_perf_counters();
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_admin_loop(struct hyperdex_admin *_adm, int timeout,
+	                    enum hyperdex_admin_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    hyperdex::admin *adm = reinterpret_cast<hyperdex::admin *>(_adm);
+		    return adm->loop(timeout, status);
+		);
+	}
+
+	HYPERDEX_API const char *
+	hyperdex_admin_error_message(struct hyperdex_admin *_adm)
+	{
+		hyperdex::admin *adm = reinterpret_cast<hyperdex::admin *>(_adm);
+		return adm->error_message();
+	}
+
+	HYPERDEX_API const char *
+	hyperdex_admin_error_location(struct hyperdex_admin *_adm)
+	{
+		hyperdex::admin *adm = reinterpret_cast<hyperdex::admin *>(_adm);
+		return adm->error_location();
+	}
+
+	HYPERDEX_API const char *
+	hyperdex_admin_returncode_to_string(enum hyperdex_admin_returncode status)
+	{
+		switch (status)
+		{
+			CSTRINGIFY(HYPERDEX_ADMIN_SUCCESS);
+			CSTRINGIFY(HYPERDEX_ADMIN_NOMEM);
+			CSTRINGIFY(HYPERDEX_ADMIN_NONEPENDING);
+			CSTRINGIFY(HYPERDEX_ADMIN_POLLFAILED);
+			CSTRINGIFY(HYPERDEX_ADMIN_TIMEOUT);
+			CSTRINGIFY(HYPERDEX_ADMIN_INTERRUPTED);
+			CSTRINGIFY(HYPERDEX_ADMIN_SERVERERROR);
+			CSTRINGIFY(HYPERDEX_ADMIN_COORDFAIL);
+			CSTRINGIFY(HYPERDEX_ADMIN_BADSPACE);
+			CSTRINGIFY(HYPERDEX_ADMIN_DUPLICATE);
+			CSTRINGIFY(HYPERDEX_ADMIN_NOTFOUND);
+			CSTRINGIFY(HYPERDEX_ADMIN_LOCALERROR);
+			CSTRINGIFY(HYPERDEX_ADMIN_INTERNAL);
+			CSTRINGIFY(HYPERDEX_ADMIN_EXCEPTION);
+			CSTRINGIFY(HYPERDEX_ADMIN_GARBAGE);
+		default:
+			return "unknown hyperdex_admin_returncode";
+		}
+	}
 
 } // extern "C"
diff --git a/admin/coord_rpc.cc b/admin/coord_rpc.cc
index 131c2ccc6..a8f76faa3 100644
--- a/admin/coord_rpc.cc
+++ b/admin/coord_rpc.cc
@@ -31,18 +31,18 @@
 using hyperdex::coord_rpc;
 
 coord_rpc :: coord_rpc(uint64_t id,
-                       hyperdex_admin_returncode* s)
-    : yieldable(id, s)
-    , repl_status(REPLICANT_GARBAGE)
-    , repl_output(NULL)
-    , repl_output_sz(0)
+                       hyperdex_admin_returncode *s)
+	: yieldable(id, s)
+	, repl_status(REPLICANT_GARBAGE)
+	, repl_output(NULL)
+	, repl_output_sz(0)
 {
 }
 
 coord_rpc :: ~coord_rpc() throw ()
 {
-    if (repl_output)
-    {
-        free(repl_output);
-    }
+	if (repl_output)
+	{
+		free(repl_output);
+	}
 }
diff --git a/admin/coord_rpc.h b/admin/coord_rpc.h
index f92102250..693b71f53 100644
--- a/admin/coord_rpc.h
+++ b/admin/coord_rpc.h
@@ -52,26 +52,26 @@ class admin;
 
 class coord_rpc : public yieldable
 {
-    public:
-        coord_rpc(uint64_t admin_visible_id,
-                  hyperdex_admin_returncode* status);
-        virtual ~coord_rpc() throw ();
+public:
+	coord_rpc(uint64_t admin_visible_id,
+	          hyperdex_admin_returncode *status);
+	virtual ~coord_rpc() throw ();
 
-    public:
-        virtual bool handle_response(admin* adm,
-                                     hyperdex_admin_returncode* status) = 0;
+public:
+	virtual bool handle_response(admin *adm,
+	                             hyperdex_admin_returncode *status) = 0;
 
-    public:
-        replicant_returncode repl_status;
-        char* repl_output;
-        size_t repl_output_sz;
+public:
+	replicant_returncode repl_status;
+	char *repl_output;
+	size_t repl_output_sz;
 
-    protected:
-        friend class e::intrusive_ptr<coord_rpc>;
+protected:
+	friend class e::intrusive_ptr<coord_rpc>;
 
-    private:
-        coord_rpc(const coord_rpc&);
-        coord_rpc& operator = (const coord_rpc&);
+private:
+	coord_rpc(const coord_rpc &);
+	coord_rpc &operator = (const coord_rpc &);
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/admin/coord_rpc_backup.cc b/admin/coord_rpc_backup.cc
index 7ca7b7215..d85df0cc0 100644
--- a/admin/coord_rpc_backup.cc
+++ b/admin/coord_rpc_backup.cc
@@ -42,11 +42,11 @@
 using hyperdex::coord_rpc_backup;
 
 coord_rpc_backup :: coord_rpc_backup(uint64_t id,
-                                     hyperdex_admin_returncode* status,
-                                     const char* path)
-    : coord_rpc(id, status)
-    , m_path(path)
-    , m_done(false)
+                                     hyperdex_admin_returncode *status,
+                                     const char *path)
+	: coord_rpc(id, status)
+	, m_path(path)
+	, m_done(false)
 {
 }
 
@@ -57,49 +57,44 @@ coord_rpc_backup :: ~coord_rpc_backup() throw ()
 bool
 coord_rpc_backup :: can_yield()
 {
-    return !m_done;
+	return !m_done;
 }
 
 bool
-coord_rpc_backup :: yield(hyperdex_admin_returncode* status)
+coord_rpc_backup :: yield(hyperdex_admin_returncode *status)
 {
-    assert(this->can_yield());
-    m_done = true;
-    *status = HYPERDEX_ADMIN_SUCCESS;
-    return true;
+	assert(this->can_yield());
+	m_done = true;
+	*status = HYPERDEX_ADMIN_SUCCESS;
+	return true;
 }
 
 bool
-coord_rpc_backup :: handle_response(admin* adm,
-                                    hyperdex_admin_returncode* status)
+coord_rpc_backup :: handle_response(admin *adm,
+                                    hyperdex_admin_returncode *status)
 {
-    *status = HYPERDEX_ADMIN_SUCCESS;
-    hyperdex_admin_returncode resp_status;
-    e::error err;
-    adm->interpret_replicant_returncode(repl_status, &resp_status, &err);
-    set_status(resp_status);
-    set_error(err);
-
-    if (resp_status != HYPERDEX_ADMIN_SUCCESS)
-    {
-        return true;
-    }
-
-    po6::io::fd fd(open(m_path.c_str(), O_WRONLY|O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR));
-
-    if (fd.get() < 0)
-    {
-        YIELDING_ERROR(LOCALERROR) << "could not open coordinator backup file \""
-                                   << e::strescape(m_path) << "\": " << strerror(errno);
-        return true;
-    }
-
-    if (fd.xwrite(repl_output, repl_output_sz) != static_cast<ssize_t>(repl_output_sz))
-    {
-        YIELDING_ERROR(LOCALERROR) << "could not write coordinator backup file \""
-                                   << e::strescape(m_path) << "\": " << strerror(errno);
-        return true;
-    }
-
-    return true;
+	*status = HYPERDEX_ADMIN_SUCCESS;
+	hyperdex_admin_returncode resp_status;
+	e::error err;
+	adm->interpret_replicant_returncode(repl_status, &resp_status, &err);
+	set_status(resp_status);
+	set_error(err);
+	if (resp_status != HYPERDEX_ADMIN_SUCCESS)
+	{
+		return true;
+	}
+	po6::io::fd fd(open(m_path.c_str(), O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR));
+	if (fd.get() < 0)
+	{
+		YIELDING_ERROR(LOCALERROR) << "could not open coordinator backup file \""
+		                           << e::strescape(m_path) << "\": " << strerror(errno);
+		return true;
+	}
+	if (fd.xwrite(repl_output, repl_output_sz) != static_cast<ssize_t>(repl_output_sz))
+	{
+		YIELDING_ERROR(LOCALERROR) << "could not write coordinator backup file \""
+		                           << e::strescape(m_path) << "\": " << strerror(errno);
+		return true;
+	}
+	return true;
 }
diff --git a/admin/coord_rpc_backup.h b/admin/coord_rpc_backup.h
index db556a78c..23087e117 100644
--- a/admin/coord_rpc_backup.h
+++ b/admin/coord_rpc_backup.h
@@ -35,27 +35,27 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class coord_rpc_backup : public coord_rpc
 {
-    public:
-        coord_rpc_backup(uint64_t admin_visible_id,
-                         hyperdex_admin_returncode* status,
-                         const char* path);
-        virtual ~coord_rpc_backup() throw ();
-
-    public:
-        virtual bool can_yield();
-        virtual bool yield(hyperdex_admin_returncode* status);
-
-    public:
-        virtual bool handle_response(admin* adm,
-                                     hyperdex_admin_returncode* status);
-
-    private:
-        coord_rpc_backup(const coord_rpc_backup&);
-        coord_rpc_backup& operator = (const coord_rpc_backup&);
-
-    private:
-        std::string m_path;
-        bool m_done;
+public:
+	coord_rpc_backup(uint64_t admin_visible_id,
+	                 hyperdex_admin_returncode *status,
+	                 const char *path);
+	virtual ~coord_rpc_backup() throw ();
+
+public:
+	virtual bool can_yield();
+	virtual bool yield(hyperdex_admin_returncode *status);
+
+public:
+	virtual bool handle_response(admin *adm,
+	                             hyperdex_admin_returncode *status);
+
+private:
+	coord_rpc_backup(const coord_rpc_backup &);
+	coord_rpc_backup &operator = (const coord_rpc_backup &);
+
+private:
+	std::string m_path;
+	bool m_done;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/admin/coord_rpc_generic.cc b/admin/coord_rpc_generic.cc
index 4d7bfc379..d8f759b0b 100644
--- a/admin/coord_rpc_generic.cc
+++ b/admin/coord_rpc_generic.cc
@@ -38,11 +38,11 @@
 using hyperdex::coord_rpc_generic;
 
 coord_rpc_generic :: coord_rpc_generic(uint64_t id,
-                                       hyperdex_admin_returncode* s,
-                                       const char* opname)
-    : coord_rpc(id, s)
-    , m_opname(opname)
-    , m_done(false)
+                                       hyperdex_admin_returncode *s,
+                                       const char *opname)
+	: coord_rpc(id, s)
+	, m_opname(opname)
+	, m_done(false)
 {
 }
 
@@ -53,63 +53,59 @@ coord_rpc_generic :: ~coord_rpc_generic() throw ()
 bool
 coord_rpc_generic :: can_yield()
 {
-    return !m_done;
+	return !m_done;
 }
 
 bool
-coord_rpc_generic :: yield(hyperdex_admin_returncode* status)
+coord_rpc_generic :: yield(hyperdex_admin_returncode *status)
 {
-    assert(this->can_yield());
-    m_done = true;
-    *status = HYPERDEX_ADMIN_SUCCESS;
-    return true;
+	assert(this->can_yield());
+	m_done = true;
+	*status = HYPERDEX_ADMIN_SUCCESS;
+	return true;
 }
 
 bool
-coord_rpc_generic :: handle_response(admin* adm,
-                                     hyperdex_admin_returncode* status)
+coord_rpc_generic :: handle_response(admin *adm,
+                                     hyperdex_admin_returncode *status)
 {
-    *status = HYPERDEX_ADMIN_SUCCESS;
-    hyperdex_admin_returncode resp_status;
-    e::error err;
-    adm->interpret_replicant_returncode(repl_status, &resp_status, &err);
-    set_status(resp_status);
-    set_error(err);
-
-    if (resp_status != HYPERDEX_ADMIN_SUCCESS)
-    {
-        return true;
-    }
-
-    if (repl_output_sz >= 2)
-    {
-        uint16_t x;
-        e::unpack16be(repl_output, &x);
-        coordinator_returncode rc = static_cast<coordinator_returncode>(x);
-
-        switch (rc)
-        {
-            case hyperdex::COORD_SUCCESS:
-                set_status(HYPERDEX_ADMIN_SUCCESS);
-                break;
-            case hyperdex::COORD_NOT_FOUND:
-                YIELDING_ERROR(NOTFOUND) << "cannot " << m_opname << ": does not exist";
-                break;
-            case hyperdex::COORD_DUPLICATE:
-                YIELDING_ERROR(DUPLICATE) << "cannot " << m_opname << ": already exists";
-                break;
-            case hyperdex::COORD_UNINITIALIZED:
-                YIELDING_ERROR(COORDFAIL) << "cannot " << m_opname << ": coordinator is uninitialized";
-                break;
-            case hyperdex::COORD_NO_CAN_DO:
-                YIELDING_ERROR(COORDFAIL) << "cannot " << m_opname << ": see coordinator log for details";
-                break;
-            case hyperdex::COORD_MALFORMED:
-            default:
-                YIELDING_ERROR(INTERNAL) << "internal error interfacing with coordinator";
-                break;
-        }
-    }
-
-    return true;
+	*status = HYPERDEX_ADMIN_SUCCESS;
+	hyperdex_admin_returncode resp_status;
+	e::error err;
+	adm->interpret_replicant_returncode(repl_status, &resp_status, &err);
+	set_status(resp_status);
+	set_error(err);
+	if (resp_status != HYPERDEX_ADMIN_SUCCESS)
+	{
+		return true;
+	}
+	if (repl_output_sz >= 2)
+	{
+		uint16_t x;
+		e::unpack16be(repl_output, &x);
+		coordinator_returncode rc = static_cast<coordinator_returncode>(x);
+		switch (rc)
+		{
+		case hyperdex::COORD_SUCCESS:
+			set_status(HYPERDEX_ADMIN_SUCCESS);
+			break;
+		case hyperdex::COORD_NOT_FOUND:
+			YIELDING_ERROR(NOTFOUND) << "cannot " << m_opname << ": does not exist";
+			break;
+		case hyperdex::COORD_DUPLICATE:
+			YIELDING_ERROR(DUPLICATE) << "cannot " << m_opname << ": already exists";
+			break;
+		case hyperdex::COORD_UNINITIALIZED:
+			YIELDING_ERROR(COORDFAIL) << "cannot " << m_opname << ": coordinator is uninitialized";
+			break;
+		case hyperdex::COORD_NO_CAN_DO:
+			YIELDING_ERROR(COORDFAIL) << "cannot " << m_opname << ": see coordinator log for details";
+			break;
+		case hyperdex::COORD_MALFORMED:
+		default:
+			YIELDING_ERROR(INTERNAL) << "internal error interfacing with coordinator";
+			break;
+		}
+	}
+	return true;
 }
diff --git a/admin/coord_rpc_generic.h b/admin/coord_rpc_generic.h
index 61930efa6..2202a0a8e 100644
--- a/admin/coord_rpc_generic.h
+++ b/admin/coord_rpc_generic.h
@@ -35,30 +35,30 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class coord_rpc_generic : public coord_rpc
 {
-    public:
-        coord_rpc_generic(uint64_t admin_visible_id,
-                          hyperdex_admin_returncode* status,
-                          const char* opname);
-        virtual ~coord_rpc_generic() throw ();
+public:
+	coord_rpc_generic(uint64_t admin_visible_id,
+	                  hyperdex_admin_returncode *status,
+	                  const char *opname);
+	virtual ~coord_rpc_generic() throw ();
 
-    public:
-        virtual bool can_yield();
-        virtual bool yield(hyperdex_admin_returncode* status);
+public:
+	virtual bool can_yield();
+	virtual bool yield(hyperdex_admin_returncode *status);
 
-    public:
-        virtual bool handle_response(admin* adm,
-                                     hyperdex_admin_returncode* status);
+public:
+	virtual bool handle_response(admin *adm,
+	                             hyperdex_admin_returncode *status);
 
-    protected:
-        friend class e::intrusive_ptr<coord_rpc>;
+protected:
+	friend class e::intrusive_ptr<coord_rpc>;
 
-    private:
-        coord_rpc_generic(const coord_rpc_generic&);
-        coord_rpc_generic& operator = (const coord_rpc_generic&);
+private:
+	coord_rpc_generic(const coord_rpc_generic &);
+	coord_rpc_generic &operator = (const coord_rpc_generic &);
 
-    private:
-        const char* m_opname;
-        bool m_done;
+private:
+	const char *m_opname;
+	bool m_done;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/admin/hyperspace_builder.cc b/admin/hyperspace_builder.cc
index fdf5b1b05..7e77d8a98 100644
--- a/admin/hyperspace_builder.cc
+++ b/admin/hyperspace_builder.cc
@@ -56,8 +56,8 @@ extern "C"
 {
 #include "admin/parse_space_y.h"
 
-extern int
-yyparse(struct hyperspace* space, void* scanner);
+	extern int
+	yyparse(struct hyperspace *space, void *scanner);
 }
 
 #pragma GCC diagnostic pop
@@ -69,63 +69,63 @@ namespace
 
 class hypersubspace
 {
-    public:
-        hypersubspace() : attrs() {}
-        ~hypersubspace() throw () {}
+public:
+	hypersubspace() : attrs() {}
+	~hypersubspace() throw () {}
 
-    public:
-        std::vector<const char*> attrs;
+public:
+	std::vector<const char *> attrs;
 };
 
 }
 
 class hyperspace
 {
-    public:
-        hyperspace();
-        ~hyperspace() throw ();
-
-    public:
-        // copy the string and return a pointer to the copy
-        const char* internalize(const char*);
-        bool has_attr(const char* name);
-        hyperdatatype attr_type(const char* name);
-
-    public:
-        void* scanner;
-        const char* error;
-        char buffer[BUFFER_SIZE];
-        std::list<std::string> strings;
-
-        // parsed components
-        const char* name;
-        hyperdex::attribute key;
-        std::vector<hyperdex::attribute> attributes;
-        std::vector<hypersubspace> subspaces;
-        std::vector<const char*> indices;
-        uint64_t fault_tolerance;
-        uint64_t partitions;
-        bool authorization;
-
-    private:
-        hyperspace(const hyperspace&);
-        hyperspace& operator = (const hyperspace&);
+public:
+	hyperspace();
+	~hyperspace() throw ();
+
+public:
+	// copy the string and return a pointer to the copy
+	const char *internalize(const char *);
+	bool has_attr(const char *name);
+	hyperdatatype attr_type(const char *name);
+
+public:
+	void *scanner;
+	const char *error;
+	char buffer[BUFFER_SIZE];
+	std::list<std::string> strings;
+
+	// parsed components
+	const char *name;
+	hyperdex::attribute key;
+	std::vector<hyperdex::attribute> attributes;
+	std::vector<hypersubspace> subspaces;
+	std::vector<const char *> indices;
+	uint64_t fault_tolerance;
+	uint64_t partitions;
+	bool authorization;
+
+private:
+	hyperspace(const hyperspace &);
+	hyperspace &operator = (const hyperspace &);
 };
 
 hyperspace :: hyperspace()
-    : scanner(NULL)
-    , error(NULL)
-    , strings()
-    , name(NULL)
-    , key()
-    , attributes()
-    , subspaces()
-    , indices()
-    , fault_tolerance(1)
-    , partitions(64)
-    , authorization(false)
+	: scanner(NULL)
+	, error(NULL)
+	, strings()
+	, name(NULL)
+	, key()
+	, attributes()
+	, subspaces()
+	, indices()
+	, fault_tolerance(1)
+	, partitions(64)
+	, authorization(false)
 {
-    memset(buffer, 0, 1024);
+	memset(buffer, 0, 1024);
 }
 
 hyperspace :: ~hyperspace() throw ()
@@ -133,473 +133,443 @@ hyperspace :: ~hyperspace() throw ()
 }
 
 bool
-hyperspace :: has_attr(const char* attr)
+hyperspace :: has_attr(const char *attr)
 {
-    for (size_t i = 0; i < attributes.size(); ++i)
-    {
-        if (strcmp(attributes[i].name, attr) == 0)
-        {
-            return true;
-        }
-    }
-
-    return false;
+	for (size_t i = 0; i < attributes.size(); ++i)
+	{
+		if (strcmp(attributes[i].name, attr) == 0)
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 hyperdatatype
-hyperspace :: attr_type(const char* attr)
+hyperspace :: attr_type(const char *attr)
 {
-    for (size_t i = 0; i < attributes.size(); ++i)
-    {
-        if (strcmp(attributes[i].name, attr) == 0)
-        {
-            return attributes[i].type;
-        }
-    }
-
-    abort();
+	for (size_t i = 0; i < attributes.size(); ++i)
+	{
+		if (strcmp(attributes[i].name, attr) == 0)
+		{
+			return attributes[i].type;
+		}
+	}
+	abort();
 }
 
-const char*
-hyperspace :: internalize(const char* str)
+const char *
+hyperspace :: internalize(const char *str)
 {
-    strings.push_back(std::string(str));
-    return strings.back().c_str();
+	strings.push_back(std::string(str));
+	return strings.back().c_str();
 }
 
 static bool
-is_identifier(const char* str)
+is_identifier(const char *str)
 {
-    size_t i = 0;
-
-    for (i = 0; str[i]; ++i)
-    {
-        if (!(i > 0 && isdigit(str[i])) &&
-            !(isalpha(str[i])) &&
-            str[i] != '_')
-        {
-            return false;
-        }
-    }
-
-    if (i >= 2 && strncmp(str, "__", 2) == 0)
-    {
-        return false;
-    }
-
-    return i > 0;
+	size_t i = 0;
+	for (i = 0; str[i]; ++i)
+	{
+		if (!(i > 0 && isdigit(str[i])) &&
+		    !(isalpha(str[i])) &&
+		    str[i] != '_')
+		{
+			return false;
+		}
+	}
+	if (i >= 2 && strncmp(str, "__", 2) == 0)
+	{
+		return false;
+	}
+	return i > 0;
 }
 
 static bool
 is_key_datatype(hyperdatatype type)
 {
-    hyperdex::datatype_info* di = hyperdex::datatype_info::lookup(type);
-    return di && di->hashable();
+	hyperdex::datatype_info *di = hyperdex::datatype_info::lookup(type);
+	return di && di->hashable();
 }
 
 static bool
 is_concrete_datatype(hyperdatatype type)
 {
-    return hyperdex::datatype_info::lookup(type) != NULL;
+	return hyperdex::datatype_info::lookup(type) != NULL;
 }
 
 extern "C"
 {
 
-extern int
-yylex_init(void* scanner);
-
-extern int
-yylex_destroy(void* scanner);
-
-extern struct yy_buffer_state*
-yy_scan_string(const char *bytes, void* scanner);
-
-extern void
-yy_switch_to_buffer(yy_buffer_state* new_buffer, void* scanner);
-
-extern void
-yyset_lineno(int line_number, void* scanner);
-
-HYPERDEX_API hyperspace*
-hyperspace_create()
-{
-    hyperspace* space = new (std::nothrow) hyperspace();
-
-    if (!space)
-    {
-        return NULL;
-    }
-
-    return space;
-}
-
-HYPERDEX_API hyperspace*
-hyperspace_parse(const char* desc)
-{
-    hyperspace* space = hyperspace_create();
-    yy_buffer_state* buf = NULL;
-
-    if (!space)
-    {
-        return NULL;
-    }
-
-    if (yylex_init(&space->scanner) < 0)
-    {
-        space->error = "yylex_init failed";
-        return space;
-    }
-
-    buf = yy_scan_string(desc, space->scanner);
-
-    if (!buf)
-    {
-        space->error = "yy_scan_string failed";
-        yylex_destroy(space->scanner);
-        return space;
-    }
-
-    yy_switch_to_buffer(buf, space->scanner);
-    yyset_lineno(1, space->scanner);
-
-    if (yyparse(space, space->scanner) < 0)
-    {
-        space->error = "yyparse failed";
-        yylex_destroy(space->scanner);
-        return space;
-    }
-
-    if (yylex_destroy(space->scanner) < 0)
-    {
-        space->error = "yylex_destroy failed";
-        return space;
-    }
-
-    space->scanner = NULL;
-    return space;
-}
-
-HYPERDEX_API void
-hyperspace_destroy(hyperspace* space)
-{
-    delete space;
-}
-
-HYPERDEX_API const char*
-hyperspace_error(hyperspace* space)
-{
-    if (!space)
-    {
-        return "failed to allocate memory";
-    }
-
-    return space->error;
-}
-
-HYPERDEX_API enum hyperspace_returncode
-hyperspace_set_name(hyperspace* space, const char* name)
-{
-    if (!is_identifier(name))
-    {
-        snprintf(space->buffer, BUFFER_SIZE, "\"%s\" is not a valid name for a space", name);
-        space->buffer[BUFFER_SIZE - 1] = '\0';
-        space->error = space->buffer;
-        return HYPERSPACE_INVALID_NAME;
-    }
-
-    space->name = space->internalize(name);
-    return HYPERSPACE_SUCCESS;
-}
-
-HYPERDEX_API enum hyperspace_returncode
-hyperspace_set_key(hyperspace* space,
-                   const char* attr,
-                   enum hyperdatatype datatype)
-{
-    if (!is_identifier(attr))
-    {
-        snprintf(space->buffer, BUFFER_SIZE, "\"%s\" is not a valid name for the key", attr);
-        space->buffer[BUFFER_SIZE - 1] = '\0';
-        space->error = space->buffer;
-        return HYPERSPACE_INVALID_NAME;
-    }
-
-    if (!is_key_datatype(datatype))
-    {
-        snprintf(space->buffer, BUFFER_SIZE, "\"%d\" is not a valid type for the key", datatype);
-        space->buffer[BUFFER_SIZE - 1] = '\0';
-        space->error = space->buffer;
-        return HYPERSPACE_INVALID_TYPE;
-    }
-
-    if (space->has_attr(attr))
-    {
-        snprintf(space->buffer, BUFFER_SIZE, "cannot call the key \"%s\" because there is already an attribute by that name", attr);
-        space->buffer[BUFFER_SIZE - 1] = '\0';
-        space->error = space->buffer;
-        return HYPERSPACE_DUPLICATE;
-    }
-
-    space->key = hyperdex::attribute(space->internalize(attr), datatype);
-    return HYPERSPACE_SUCCESS;
-}
-
-HYPERDEX_API enum hyperspace_returncode
-hyperspace_add_attribute(hyperspace* space,
-                         const char* attr,
-                         enum hyperdatatype datatype)
-{
-    if (!is_identifier(attr))
-    {
-        snprintf(space->buffer, BUFFER_SIZE, "\"%s\" is not a valid name for an attribute", attr);
-        space->buffer[BUFFER_SIZE - 1] = '\0';
-        space->error = space->buffer;
-        return HYPERSPACE_INVALID_NAME;
-    }
-
-    if (!is_concrete_datatype(datatype))
-    {
-        snprintf(space->buffer, BUFFER_SIZE, "\"%d\" is not a valid type for an attribute", datatype);
-        space->buffer[BUFFER_SIZE - 1] = '\0';
-        space->error = space->buffer;
-        return HYPERSPACE_INVALID_TYPE;
-    }
-
-    if (space->has_attr(attr))
-    {
-        snprintf(space->buffer, BUFFER_SIZE, "cannot create attribute \"%s\" because there is already an attribute by that name", attr);
-        space->buffer[BUFFER_SIZE - 1] = '\0';
-        space->error = space->buffer;
-        return HYPERSPACE_DUPLICATE;
-    }
-
-    if (strcmp(space->key.name, attr) == 0)
-    {
-        snprintf(space->buffer, BUFFER_SIZE, "cannot create attribute \"%s\" because the key is called \"%s\"", attr, attr);
-        space->buffer[BUFFER_SIZE - 1] = '\0';
-        space->error = space->buffer;
-        return HYPERSPACE_DUPLICATE;
-    }
-
-    space->attributes.push_back(hyperdex::attribute(space->internalize(attr), datatype));
-    return HYPERSPACE_SUCCESS;
-}
-
-HYPERDEX_API enum hyperspace_returncode
-hyperspace_add_subspace(hyperspace* space)
-{
-    space->subspaces.push_back(hypersubspace());
-    return HYPERSPACE_SUCCESS;
-}
-
-HYPERDEX_API enum hyperspace_returncode
-hyperspace_add_subspace_attribute(hyperspace* space, const char* attr)
-{
-    if (space->subspaces.empty())
-    {
-        snprintf(space->buffer, BUFFER_SIZE, "cannot add attribute to subspace, because there is no subspace");
-        space->buffer[BUFFER_SIZE - 1] = '\0';
-        space->error = space->buffer;
-        return HYPERSPACE_NO_SUBSPACE;
-    }
-
-    if (!space->has_attr(attr))
-    {
-        snprintf(space->buffer, BUFFER_SIZE, "cannot add attribute \"%s\" to subspace because there is no attribute by that name", attr);
-        space->buffer[BUFFER_SIZE - 1] = '\0';
-        space->error = space->buffer;
-        return HYPERSPACE_UNKNOWN_ATTR;
-    }
-
-    if (!hyperdex::datatype_info::lookup(space->attr_type(attr))->hashable())
-    {
-        snprintf(space->buffer, BUFFER_SIZE, "cannot add attribute \"%s\" to subspace because the type is not hashable", attr);
-        space->buffer[BUFFER_SIZE - 1] = '\0';
-        space->error = space->buffer;
-        return HYPERSPACE_UNINDEXABLE;
-    }
-
-    for (size_t i = 0; i < space->subspaces.back().attrs.size(); ++i)
-    {
-        if (strcmp(space->subspaces.back().attrs[i], attr) == 0)
-        {
-            snprintf(space->buffer, BUFFER_SIZE, "cannot add attribute \"%s\" to subspace because it is already a subspace attribute", attr);
-            space->buffer[BUFFER_SIZE - 1] = '\0';
-            space->error = space->buffer;
-            return HYPERSPACE_DUPLICATE;
-        }
-    }
-
-    space->subspaces.back().attrs.push_back(space->internalize(attr));
-    return HYPERSPACE_SUCCESS;
-}
-
-HYPERDEX_API enum hyperspace_returncode
-hyperspace_add_index(hyperspace* space, const char* attr)
-{
-    if (strcmp(space->key.name, attr) == 0)
-    {
-        snprintf(space->buffer, BUFFER_SIZE, "cannot create index on \"%s\" because it is the key", attr);
-        space->buffer[BUFFER_SIZE - 1] = '\0';
-        space->error = space->buffer;
-        return HYPERSPACE_IS_KEY;
-    }
-
-    if (!space->has_attr(attr))
-    {
-        snprintf(space->buffer, BUFFER_SIZE, "cannot create index on \"%s\" because there is no attribute by that name", attr);
-        space->buffer[BUFFER_SIZE - 1] = '\0';
-        space->error = space->buffer;
-        return HYPERSPACE_UNKNOWN_ATTR;
-    }
-
-    if (!hyperdex::datatype_info::lookup(space->attr_type(attr))->indexable())
-    {
-        snprintf(space->buffer, BUFFER_SIZE, "cannot create index on \"%s\" because the type is not indexable", attr);
-        space->buffer[BUFFER_SIZE - 1] = '\0';
-        space->error = space->buffer;
-        return HYPERSPACE_UNINDEXABLE;
-    }
-
-    space->indices.push_back(space->internalize(attr));
-    return HYPERSPACE_SUCCESS;
-}
-
-HYPERDEX_API enum hyperspace_returncode
-hyperspace_set_fault_tolerance(hyperspace* space, uint64_t num)
-{
-    space->fault_tolerance = num;
-    return HYPERSPACE_SUCCESS;
-}
-
-HYPERDEX_API enum hyperspace_returncode
-hyperspace_set_number_of_partitions(hyperspace* space, uint64_t num)
-{
-    if (num < 1)
-    {
-        snprintf(space->buffer, BUFFER_SIZE, "the number of partitions must be positive, not 0");
-        space->buffer[BUFFER_SIZE - 1] = '\0';
-        space->error = space->buffer;
-        return HYPERSPACE_NO_SUBSPACE;
-    }
-
-    space->partitions = num;
-    return HYPERSPACE_SUCCESS;
-}
-
-HYPERDEX_API enum hyperspace_returncode
-hyperspace_use_authorization(struct hyperspace* space)
-{
-    space->authorization = true;
-    return HYPERSPACE_SUCCESS;
-}
-
-char*
-hyperspace_buffer(hyperspace* space)
-{
-    return space->buffer;
-}
-
-size_t
-hyperspace_buffer_sz(hyperspace*)
-{
-    return BUFFER_SIZE;
-}
-
-void
-hyperspace_set_error(hyperspace* space, const char* msg)
-{
-    space->error = msg;
-}
+	extern int
+	yylex_init(void *scanner);
+
+	extern int
+	yylex_destroy(void *scanner);
+
+	extern struct yy_buffer_state *
+	yy_scan_string(const char *bytes, void *scanner);
+
+	extern void
+	yy_switch_to_buffer(yy_buffer_state *new_buffer, void *scanner);
+
+	extern void
+	yyset_lineno(int line_number, void *scanner);
+
+	HYPERDEX_API hyperspace *
+	hyperspace_create()
+	{
+		hyperspace *space = new (std::nothrow) hyperspace();
+		if (!space)
+		{
+			return NULL;
+		}
+		return space;
+	}
+
+	HYPERDEX_API hyperspace *
+	hyperspace_parse(const char *desc)
+	{
+		hyperspace *space = hyperspace_create();
+		yy_buffer_state *buf = NULL;
+		if (!space)
+		{
+			return NULL;
+		}
+		if (yylex_init(&space->scanner) < 0)
+		{
+			space->error = "yylex_init failed";
+			return space;
+		}
+		buf = yy_scan_string(desc, space->scanner);
+		if (!buf)
+		{
+			space->error = "yy_scan_string failed";
+			yylex_destroy(space->scanner);
+			return space;
+		}
+		yy_switch_to_buffer(buf, space->scanner);
+		yyset_lineno(1, space->scanner);
+		if (yyparse(space, space->scanner) < 0)
+		{
+			space->error = "yyparse failed";
+			yylex_destroy(space->scanner);
+			return space;
+		}
+		if (yylex_destroy(space->scanner) < 0)
+		{
+			space->error = "yylex_destroy failed";
+			return space;
+		}
+		space->scanner = NULL;
+		return space;
+	}
+
+	HYPERDEX_API void
+	hyperspace_destroy(hyperspace *space)
+	{
+		delete space;
+	}
+
+	HYPERDEX_API const char *
+	hyperspace_error(hyperspace *space)
+	{
+		if (!space)
+		{
+			return "failed to allocate memory";
+		}
+		return space->error;
+	}
+
+	HYPERDEX_API enum hyperspace_returncode
+	hyperspace_set_name(hyperspace *space, const char *name)
+	{
+		if (!is_identifier(name))
+		{
+			snprintf(space->buffer, BUFFER_SIZE, "\"%s\" is not a valid name for a space", name);
+			space->buffer[BUFFER_SIZE - 1] = '\0';
+			space->error = space->buffer;
+			return HYPERSPACE_INVALID_NAME;
+		}
+
+		space->name = space->internalize(name);
+		return HYPERSPACE_SUCCESS;
+	}
+
+	HYPERDEX_API enum hyperspace_returncode
+	hyperspace_set_key(hyperspace *space,
+	                   const char *attr,
+	                   enum hyperdatatype datatype)
+	{
+		if (!is_identifier(attr))
+		{
+			snprintf(space->buffer, BUFFER_SIZE, "\"%s\" is not a valid name for the key", attr);
+			space->buffer[BUFFER_SIZE - 1] = '\0';
+			space->error = space->buffer;
+			return HYPERSPACE_INVALID_NAME;
+		}
+
+		if (!is_key_datatype(datatype))
+		{
+			snprintf(space->buffer, BUFFER_SIZE, "\"%d\" is not a valid type for the key", datatype);
+			space->buffer[BUFFER_SIZE - 1] = '\0';
+			space->error = space->buffer;
+			return HYPERSPACE_INVALID_TYPE;
+		}
+
+		if (space->has_attr(attr))
+		{
+			snprintf(space->buffer, BUFFER_SIZE, "cannot call the key \"%s\" because there is already an attribute by that name", attr);
+			space->buffer[BUFFER_SIZE - 1] = '\0';
+			space->error = space->buffer;
+			return HYPERSPACE_DUPLICATE;
+		}
+
+		space->key = hyperdex::attribute(space->internalize(attr), datatype);
+		return HYPERSPACE_SUCCESS;
+	}
+
+	HYPERDEX_API enum hyperspace_returncode
+	hyperspace_add_attribute(hyperspace *space,
+	                         const char *attr,
+	                         enum hyperdatatype datatype)
+	{
+		if (!is_identifier(attr))
+		{
+			snprintf(space->buffer, BUFFER_SIZE, "\"%s\" is not a valid name for an attribute", attr);
+			space->buffer[BUFFER_SIZE - 1] = '\0';
+			space->error = space->buffer;
+			return HYPERSPACE_INVALID_NAME;
+		}
+
+		if (!is_concrete_datatype(datatype))
+		{
+			snprintf(space->buffer, BUFFER_SIZE, "\"%d\" is not a valid type for an attribute", datatype);
+			space->buffer[BUFFER_SIZE - 1] = '\0';
+			space->error = space->buffer;
+			return HYPERSPACE_INVALID_TYPE;
+		}
+
+		if (space->has_attr(attr))
+		{
+			snprintf(space->buffer, BUFFER_SIZE, "cannot create attribute \"%s\" because there is already an attribute by that name", attr);
+			space->buffer[BUFFER_SIZE - 1] = '\0';
+			space->error = space->buffer;
+			return HYPERSPACE_DUPLICATE;
+		}
+
+		if (strcmp(space->key.name, attr) == 0)
+		{
+			snprintf(space->buffer, BUFFER_SIZE, "cannot create attribute \"%s\" because the key is called \"%s\"", attr, attr);
+			space->buffer[BUFFER_SIZE - 1] = '\0';
+			space->error = space->buffer;
+			return HYPERSPACE_DUPLICATE;
+		}
+
+		space->attributes.push_back(hyperdex::attribute(space->internalize(attr), datatype));
+		return HYPERSPACE_SUCCESS;
+	}
+
+	HYPERDEX_API enum hyperspace_returncode
+	hyperspace_add_subspace(hyperspace *space)
+	{
+		space->subspaces.push_back(hypersubspace());
+		return HYPERSPACE_SUCCESS;
+	}
+
+	HYPERDEX_API enum hyperspace_returncode
+	hyperspace_add_subspace_attribute(hyperspace *space, const char *attr)
+	{
+		if (space->subspaces.empty())
+		{
+			snprintf(space->buffer, BUFFER_SIZE, "cannot add attribute to subspace, because there is no subspace");
+			space->buffer[BUFFER_SIZE - 1] = '\0';
+			space->error = space->buffer;
+			return HYPERSPACE_NO_SUBSPACE;
+		}
+
+		if (!space->has_attr(attr))
+		{
+			snprintf(space->buffer, BUFFER_SIZE, "cannot add attribute \"%s\" to subspace because there is no attribute by that name", attr);
+			space->buffer[BUFFER_SIZE - 1] = '\0';
+			space->error = space->buffer;
+			return HYPERSPACE_UNKNOWN_ATTR;
+		}
+
+		if (!hyperdex::datatype_info::lookup(space->attr_type(attr))->hashable())
+		{
+			snprintf(space->buffer, BUFFER_SIZE, "cannot add attribute \"%s\" to subspace because the type is not hashable", attr);
+			space->buffer[BUFFER_SIZE - 1] = '\0';
+			space->error = space->buffer;
+			return HYPERSPACE_UNINDEXABLE;
+		}
+
+		for (size_t i = 0; i < space->subspaces.back().attrs.size(); ++i)
+		{
+			if (strcmp(space->subspaces.back().attrs[i], attr) == 0)
+			{
+				snprintf(space->buffer, BUFFER_SIZE, "cannot add attribute \"%s\" to subspace because it is already a subspace attribute", attr);
+				space->buffer[BUFFER_SIZE - 1] = '\0';
+				space->error = space->buffer;
+				return HYPERSPACE_DUPLICATE;
+			}
+		}
+
+		space->subspaces.back().attrs.push_back(space->internalize(attr));
+		return HYPERSPACE_SUCCESS;
+	}
+
+	HYPERDEX_API enum hyperspace_returncode
+	hyperspace_add_index(hyperspace *space, const char *attr)
+	{
+		if (strcmp(space->key.name, attr) == 0)
+		{
+			snprintf(space->buffer, BUFFER_SIZE, "cannot create index on \"%s\" because it is the key", attr);
+			space->buffer[BUFFER_SIZE - 1] = '\0';
+			space->error = space->buffer;
+			return HYPERSPACE_IS_KEY;
+		}
+
+		if (!space->has_attr(attr))
+		{
+			snprintf(space->buffer, BUFFER_SIZE, "cannot create index on \"%s\" because there is no attribute by that name", attr);
+			space->buffer[BUFFER_SIZE - 1] = '\0';
+			space->error = space->buffer;
+			return HYPERSPACE_UNKNOWN_ATTR;
+		}
+
+		if (!hyperdex::datatype_info::lookup(space->attr_type(attr))->indexable())
+		{
+			snprintf(space->buffer, BUFFER_SIZE, "cannot create index on \"%s\" because the type is not indexable", attr);
+			space->buffer[BUFFER_SIZE - 1] = '\0';
+			space->error = space->buffer;
+			return HYPERSPACE_UNINDEXABLE;
+		}
+
+		space->indices.push_back(space->internalize(attr));
+		return HYPERSPACE_SUCCESS;
+	}
+
+	HYPERDEX_API enum hyperspace_returncode
+	hyperspace_set_fault_tolerance(hyperspace *space, uint64_t num)
+	{
+		space->fault_tolerance = num;
+		return HYPERSPACE_SUCCESS;
+	}
+
+	HYPERDEX_API enum hyperspace_returncode
+	hyperspace_set_number_of_partitions(hyperspace *space, uint64_t num)
+	{
+		if (num < 1)
+		{
+			snprintf(space->buffer, BUFFER_SIZE, "the number of partitions must be positive, not 0");
+			space->buffer[BUFFER_SIZE - 1] = '\0';
+			space->error = space->buffer;
+			return HYPERSPACE_NO_SUBSPACE;
+		}
+
+		space->partitions = num;
+		return HYPERSPACE_SUCCESS;
+	}
+
+	HYPERDEX_API enum hyperspace_returncode
+	hyperspace_use_authorization(struct hyperspace *space)
+	{
+		space->authorization = true;
+		return HYPERSPACE_SUCCESS;
+	}
+
+	char *
+	hyperspace_buffer(hyperspace *space)
+	{
+		return space->buffer;
+	}
+
+	size_t
+	hyperspace_buffer_sz(hyperspace *)
+	{
+		return BUFFER_SIZE;
+	}
+
+	void
+	hyperspace_set_error(hyperspace *space, const char *msg)
+	{
+		space->error = msg;
+	}
 
 } // extern "C"
 
 bool
-hyperdex :: space_to_space(hyperspace* in, hyperdex::space* out)
+hyperdex :: space_to_space(hyperspace *in, hyperdex::space *out)
 {
-    assert(!hyperspace_error(in));
-    std::vector<hyperdex::attribute> attrs;
-    attrs.push_back(in->key);
-
-    for (size_t i = 0; i < in->attributes.size(); ++i)
-    {
-        attrs.push_back(in->attributes[i]);
-    }
-
-    if (in->authorization)
-    {
-        attrs.push_back(hyperdex::attribute(HYPERDEX_ATTRIBUTE_SECRET, HYPERDATATYPE_MACAROON_SECRET));
-    }
-
-    schema sc;
-    sc.attrs_sz = attrs.size();
-    sc.attrs = &attrs.front();
-    space sp(in->name, sc);
-    sp.subspaces.push_back(subspace());
-    sp.subspaces.back().attrs.push_back(0);
-
-    for (size_t i = 0; i < in->subspaces.size(); ++i)
-    {
-        if (in->subspaces[i].attrs.empty())
-        {
-            continue;
-        }
-
-        sp.subspaces.push_back(subspace());
-
-        for (size_t j = 0; j < in->subspaces[i].attrs.size(); ++j)
-        {
-            uint16_t attr = sc.lookup_attr(in->subspaces[i].attrs[j]);
-            assert(attr < sc.attrs_sz);
-            sp.subspaces.back().attrs.push_back(attr);
-        }
-    }
-
-    sp.fault_tolerance = in->fault_tolerance;
-
-    if (!sp.validate())
-    {
-        return false;
-    }
-
-    for (size_t i = 0; i < sp.subspaces.size(); ++i)
-    {
-        hyperdex::partition(sp.subspaces[i].attrs.size(), in->partitions, &sp.subspaces[i].regions);
-    }
-
-    for (size_t i = 0; i < in->indices.size(); ++i)
-    {
-        uint16_t attr = sc.lookup_attr(in->indices[i]);
-        assert(attr < sc.attrs_sz);
-        index idx(index::NORMAL, index_id(), attr, e::slice());
-        sp.indices.push_back(idx);
-    }
-
-    for (size_t ss_idx = 0; ss_idx < sp.subspaces.size(); ++ ss_idx)
-    {
-        for (size_t a_idx = 0; a_idx < sp.subspaces[ss_idx].attrs.size(); ++a_idx)
-        {
-            uint16_t attr = sp.subspaces[ss_idx].attrs[a_idx];
-            bool found = false;
-
-            for (size_t i_idx = 0; i_idx < sp.indices.size(); ++i_idx)
-            {
-                if (sp.indices[i_idx].type == index::NORMAL &&
-                    sp.indices[i_idx].attr == attr)
-                {
-                    found = true;
-                }
-            }
-
-            if (!found && attr > 0)
-            {
-                index idx(index::NORMAL, index_id(), attr, e::slice());
-                sp.indices.push_back(idx);
-            }
-        }
-    }
-
-    *out = sp;
-    return true;
+	assert(!hyperspace_error(in));
+	std::vector<hyperdex::attribute> attrs;
+	attrs.push_back(in->key);
+	for (size_t i = 0; i < in->attributes.size(); ++i)
+	{
+		attrs.push_back(in->attributes[i]);
+	}
+	if (in->authorization)
+	{
+		attrs.push_back(hyperdex::attribute(HYPERDEX_ATTRIBUTE_SECRET, HYPERDATATYPE_MACAROON_SECRET));
+	}
+	schema sc;
+	sc.attrs_sz = attrs.size();
+	sc.attrs = &attrs.front();
+	space sp(in->name, sc);
+	sp.subspaces.push_back(subspace());
+	sp.subspaces.back().attrs.push_back(0);
+	for (size_t i = 0; i < in->subspaces.size(); ++i)
+	{
+		if (in->subspaces[i].attrs.empty())
+		{
+			continue;
+		}
+		sp.subspaces.push_back(subspace());
+		for (size_t j = 0; j < in->subspaces[i].attrs.size(); ++j)
+		{
+			uint16_t attr = sc.lookup_attr(in->subspaces[i].attrs[j]);
+			assert(attr < sc.attrs_sz);
+			sp.subspaces.back().attrs.push_back(attr);
+		}
+	}
+	sp.fault_tolerance = in->fault_tolerance;
+	if (!sp.validate())
+	{
+		return false;
+	}
+	for (size_t i = 0; i < sp.subspaces.size(); ++i)
+	{
+		hyperdex::partition(sp.subspaces[i].attrs.size(), in->partitions, &sp.subspaces[i].regions);
+	}
+	for (size_t i = 0; i < in->indices.size(); ++i)
+	{
+		uint16_t attr = sc.lookup_attr(in->indices[i]);
+		assert(attr < sc.attrs_sz);
+		index idx(index::NORMAL, index_id(), attr, e::slice());
+		sp.indices.push_back(idx);
+	}
+	for (size_t ss_idx = 0; ss_idx < sp.subspaces.size(); ++ ss_idx)
+	{
+		for (size_t a_idx = 0; a_idx < sp.subspaces[ss_idx].attrs.size(); ++a_idx)
+		{
+			uint16_t attr = sp.subspaces[ss_idx].attrs[a_idx];
+			bool found = false;
+			for (size_t i_idx = 0; i_idx < sp.indices.size(); ++i_idx)
+			{
+				if (sp.indices[i_idx].type == index::NORMAL &&
+				    sp.indices[i_idx].attr == attr)
+				{
+					found = true;
+				}
+			}
+			if (!found && attr > 0)
+			{
+				index idx(index::NORMAL, index_id(), attr, e::slice());
+				sp.indices.push_back(idx);
+			}
+		}
+	}
+	*out = sp;
+	return true;
 }
diff --git a/admin/hyperspace_builder_internal.h b/admin/hyperspace_builder_internal.h
index bec83d0cc..97269a5c2 100644
--- a/admin/hyperspace_builder_internal.h
+++ b/admin/hyperspace_builder_internal.h
@@ -33,14 +33,14 @@ extern "C"
 {
 #endif /* __cplusplus */
 
-char*
-hyperspace_buffer(struct hyperspace* space);
+char *
+hyperspace_buffer(struct hyperspace *space);
 
 size_t
-hyperspace_buffer_sz(struct hyperspace* space);
+hyperspace_buffer_sz(struct hyperspace *space);
 
 void
-hyperspace_set_error(struct hyperspace* space, const char* msg);
+hyperspace_set_error(struct hyperspace *space, const char *msg);
 
 #ifdef __cplusplus
 } /* extern "C" */
@@ -53,7 +53,7 @@ BEGIN_HYPERDEX_NAMESPACE
 class space;
 
 bool
-space_to_space(hyperspace* in, hyperdex::space* out);
+space_to_space(hyperspace *in, hyperdex::space *out);
 
 END_HYPERDEX_NAMESPACE
 
diff --git a/admin/multi_yieldable.cc b/admin/multi_yieldable.cc
index c27ff7539..b8a4d7245 100644
--- a/admin/multi_yieldable.cc
+++ b/admin/multi_yieldable.cc
@@ -31,8 +31,8 @@
 using hyperdex::multi_yieldable;
 
 multi_yieldable :: multi_yieldable(uint64_t id,
-                                   hyperdex_admin_returncode* s)
-    : yieldable(id, s)
+                                   hyperdex_admin_returncode *s)
+	: yieldable(id, s)
 {
 }
 
diff --git a/admin/multi_yieldable.h b/admin/multi_yieldable.h
index dc61f9b77..58ee9e7cc 100644
--- a/admin/multi_yieldable.h
+++ b/admin/multi_yieldable.h
@@ -47,16 +47,16 @@ class admin;
 
 class multi_yieldable : public yieldable
 {
-    public:
-        multi_yieldable(uint64_t admin_visible_id,
-                        hyperdex_admin_returncode* status);
-        virtual ~multi_yieldable() throw ();
+public:
+	multi_yieldable(uint64_t admin_visible_id,
+	                hyperdex_admin_returncode *status);
+	virtual ~multi_yieldable() throw ();
 
-    public:
-        virtual bool callback(admin* adm, int64_t id, hyperdex_admin_returncode* status) = 0;
+public:
+	virtual bool callback(admin *adm, int64_t id, hyperdex_admin_returncode *status) = 0;
 
-    protected:
-        friend class e::intrusive_ptr<multi_yieldable>;
+protected:
+	friend class e::intrusive_ptr<multi_yieldable>;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/admin/partition.cc b/admin/partition.cc
index ccacf00d4..b2464c04d 100644
--- a/admin/partition.cc
+++ b/admin/partition.cc
@@ -35,101 +35,91 @@
 
 static void
 generate_points(uint64_t intervals,
-                std::vector<uint64_t>* lbs,
-                std::vector<uint64_t>* ubs)
+                std::vector<uint64_t> *lbs,
+                std::vector<uint64_t> *ubs)
 {
-    uint64_t interval = (0x8000000000000000ULL / intervals) * 2;
-
-    for (uint64_t i = 0; i < intervals; ++i)
-    {
-        lbs->push_back(i * interval);
-    }
-
-    for (size_t i = 1; i < lbs->size(); ++i)
-    {
-        ubs->push_back((*lbs)[i] - 1);
-    }
-
-    ubs->push_back(UINT64_MAX);
-    assert(lbs->size() == ubs->size());
+	uint64_t interval = (0x8000000000000000ULL / intervals) * 2;
+	for (uint64_t i = 0; i < intervals; ++i)
+	{
+		lbs->push_back(i * interval);
+	}
+	for (size_t i = 1; i < lbs->size(); ++i)
+	{
+		ubs->push_back((*lbs)[i] - 1);
+	}
+	ubs->push_back(UINT64_MAX);
+	assert(lbs->size() == ubs->size());
 }
 
 void
-recursively_generate(size_t idx, const std::vector<uint64_t>& dimensions,
-                     uint64_t bigger, const std::vector<uint64_t>& bigger_lbs, const std::vector<uint64_t>& bigger_ubs,
-                     uint64_t smaller, const std::vector<uint64_t>& smaller_lbs, const std::vector<uint64_t>& smaller_ubs,
-                     std::vector<uint64_t>* lower_coord, std::vector<uint64_t>* upper_coord,
-                     std::vector<hyperdex::region>* regions)
+recursively_generate(size_t idx, const std::vector<uint64_t> &dimensions,
+                     uint64_t bigger, const std::vector<uint64_t> &bigger_lbs, const std::vector<uint64_t> &bigger_ubs,
+                     uint64_t smaller, const std::vector<uint64_t> &smaller_lbs, const std::vector<uint64_t> &smaller_ubs,
+                     std::vector<uint64_t> *lower_coord, std::vector<uint64_t> *upper_coord,
+                     std::vector<hyperdex::region> *regions)
 {
-    assert(dimensions.size() == lower_coord->size());
-    assert(lower_coord->size() == upper_coord->size());
-
-    if (idx >= dimensions.size())
-    {
-        regions->push_back(hyperdex::region());
-        regions->back().lower_coord = *lower_coord;
-        regions->back().upper_coord = *upper_coord;
-    }
-    else
-    {
-        const std::vector<uint64_t>* lbs;
-        const std::vector<uint64_t>* ubs;
-
-        if (dimensions[idx] == bigger)
-        {
-            lbs = &bigger_lbs;
-            ubs = &bigger_ubs;
-        }
-        else
-        {
-            assert(dimensions[idx] == smaller);
-            lbs = &smaller_lbs;
-            ubs = &smaller_ubs;
-        }
-
-        for (size_t i = 0; i < lbs->size(); ++i)
-        {
-            (*lower_coord)[idx] = (*lbs)[i];
-            (*upper_coord)[idx] = (*ubs)[i];
-            recursively_generate(idx + 1, dimensions,
-                                 bigger, bigger_lbs, bigger_ubs,
-                                 smaller, smaller_lbs, smaller_ubs,
-                                 lower_coord, upper_coord, regions);
-        }
-    }
+	assert(dimensions.size() == lower_coord->size());
+	assert(lower_coord->size() == upper_coord->size());
+	if (idx >= dimensions.size())
+	{
+		regions->push_back(hyperdex::region());
+		regions->back().lower_coord = *lower_coord;
+		regions->back().upper_coord = *upper_coord;
+	}
+	else
+	{
+		const std::vector<uint64_t> *lbs;
+		const std::vector<uint64_t> *ubs;
+		if (dimensions[idx] == bigger)
+		{
+			lbs = &bigger_lbs;
+			ubs = &bigger_ubs;
+		}
+		else
+		{
+			assert(dimensions[idx] == smaller);
+			lbs = &smaller_lbs;
+			ubs = &smaller_ubs;
+		}
+		for (size_t i = 0; i < lbs->size(); ++i)
+		{
+			(*lower_coord)[idx] = (*lbs)[i];
+			(*upper_coord)[idx] = (*ubs)[i];
+			recursively_generate(idx + 1, dimensions,
+			                     bigger, bigger_lbs, bigger_ubs,
+			                     smaller, smaller_lbs, smaller_ubs,
+			                     lower_coord, upper_coord, regions);
+		}
+	}
 }
 
 void
-hyperdex :: partition(uint16_t num_attrs, uint32_t num_servers, std::vector<region>* regions)
+hyperdex :: partition(uint16_t num_attrs, uint32_t num_servers, std::vector<region> *regions)
 {
-    assert(num_attrs > 0);
-    double attrs_per_dimension(num_servers);
-    attrs_per_dimension = pow(attrs_per_dimension, 1/double(num_attrs));
-    std::vector<uint64_t> dimensions(num_attrs, uint64_t(attrs_per_dimension));
-    uint64_t partitions = dimensions.size() * dimensions[0];
-
-    for (size_t i = 0; partitions < num_servers && i < num_attrs; ++i)
-    {
-        partitions = partitions / dimensions[i];
-        ++dimensions[i];
-        partitions = partitions * dimensions[i];
-    }
-
-    uint64_t bigger = dimensions[0];
-    std::vector<uint64_t> bigger_lbs;
-    std::vector<uint64_t> bigger_ubs;
-    generate_points(bigger, &bigger_lbs, &bigger_ubs);
-    uint64_t smaller = dimensions[dimensions.size() - 1];
-    std::vector<uint64_t> smaller_lbs;
-    std::vector<uint64_t> smaller_ubs;
-    generate_points(smaller, &smaller_lbs, &smaller_ubs);
-
-    regions->clear();
-    std::vector<uint64_t> lower_coord(num_attrs, 0);
-    std::vector<uint64_t> upper_coord(num_attrs, 0);
-
-    recursively_generate(0, dimensions,
-                         bigger, bigger_lbs, bigger_ubs,
-                         smaller, smaller_lbs, smaller_ubs,
-                         &lower_coord, &upper_coord, regions);
+	assert(num_attrs > 0);
+	double attrs_per_dimension(num_servers);
+	attrs_per_dimension = pow(attrs_per_dimension, 1 / double(num_attrs));
+	std::vector<uint64_t> dimensions(num_attrs, uint64_t(attrs_per_dimension));
+	uint64_t partitions = dimensions.size() * dimensions[0];
+	for (size_t i = 0; partitions < num_servers && i < num_attrs; ++i)
+	{
+		partitions = partitions / dimensions[i];
+		++dimensions[i];
+		partitions = partitions * dimensions[i];
+	}
+	uint64_t bigger = dimensions[0];
+	std::vector<uint64_t> bigger_lbs;
+	std::vector<uint64_t> bigger_ubs;
+	generate_points(bigger, &bigger_lbs, &bigger_ubs);
+	uint64_t smaller = dimensions[dimensions.size() - 1];
+	std::vector<uint64_t> smaller_lbs;
+	std::vector<uint64_t> smaller_ubs;
+	generate_points(smaller, &smaller_lbs, &smaller_ubs);
+	regions->clear();
+	std::vector<uint64_t> lower_coord(num_attrs, 0);
+	std::vector<uint64_t> upper_coord(num_attrs, 0);
+	recursively_generate(0, dimensions,
+	                     bigger, bigger_lbs, bigger_ubs,
+	                     smaller, smaller_lbs, smaller_ubs,
+	                     &lower_coord, &upper_coord, regions);
 }
diff --git a/admin/partition.h b/admin/partition.h
index 817a0142e..a6987c8b9 100644
--- a/admin/partition.h
+++ b/admin/partition.h
@@ -35,7 +35,7 @@
 BEGIN_HYPERDEX_NAMESPACE
 
 void
-partition(uint16_t num_attrs, uint32_t num_servers, std::vector<region>* regions);
+partition(uint16_t num_attrs, uint32_t num_servers, std::vector<region> *regions);
 
 END_HYPERDEX_NAMESPACE
 
diff --git a/admin/pending.cc b/admin/pending.cc
index 58b72d2cb..b7c9e88b4 100644
--- a/admin/pending.cc
+++ b/admin/pending.cc
@@ -31,8 +31,8 @@
 using hyperdex::pending;
 
 pending :: pending(uint64_t id,
-                   hyperdex_admin_returncode* s)
-    : yieldable(id, s)
+                   hyperdex_admin_returncode *s)
+	: yieldable(id, s)
 {
 }
 
diff --git a/admin/pending.h b/admin/pending.h
index 75f056f6f..0626d981f 100644
--- a/admin/pending.h
+++ b/admin/pending.h
@@ -47,23 +47,23 @@ class admin;
 
 class pending : public yieldable
 {
-    public:
-        pending(uint64_t admin_visible_id,
-                hyperdex_admin_returncode* status);
-        virtual ~pending() throw ();
+public:
+	pending(uint64_t admin_visible_id,
+	        hyperdex_admin_returncode *status);
+	virtual ~pending() throw ();
 
-    public:
-        virtual void handle_sent_to(const server_id& si) = 0;
-        virtual void handle_failure(const server_id& si) = 0;
-        virtual bool handle_message(admin* cl,
-                                    const server_id& si,
-                                    network_msgtype mt,
-                                    std::auto_ptr<e::buffer> msg,
-                                    e::unpacker up,
-                                    hyperdex_admin_returncode* status) = 0;
+public:
+	virtual void handle_sent_to(const server_id &si) = 0;
+	virtual void handle_failure(const server_id &si) = 0;
+	virtual bool handle_message(admin *cl,
+	                            const server_id &si,
+	                            network_msgtype mt,
+	                            std::auto_ptr<e::buffer> msg,
+	                            e::unpacker up,
+	                            hyperdex_admin_returncode *status) = 0;
 
-    protected:
-        friend class e::intrusive_ptr<pending>;
+protected:
+	friend class e::intrusive_ptr<pending>;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/admin/pending_perf_counters.cc b/admin/pending_perf_counters.cc
index a99e55552..98a1fdf43 100644
--- a/admin/pending_perf_counters.cc
+++ b/admin/pending_perf_counters.cc
@@ -39,23 +39,23 @@ using hyperdex::pending_perf_counters;
 
 struct pending_perf_counters::perf_counter
 {
-    perf_counter(uint64_t i, uint64_t t, const std::string& p, uint64_t m)
-        : id(i), time(t), property(p), measurement(m) {}
-    uint64_t id;
-    uint64_t time;
-    std::string property;
-    uint64_t measurement;
+	perf_counter(uint64_t i, uint64_t t, const std::string &p, uint64_t m)
+		: id(i), time(t), property(p), measurement(m) {}
+	uint64_t id;
+	uint64_t time;
+	std::string property;
+	uint64_t measurement;
 };
 
 pending_perf_counters :: pending_perf_counters(uint64_t id,
-                                               hyperdex_admin_returncode* s,
-                                               hyperdex_admin_perf_counter* pc)
-    : pending(id, s)
-    , m_pc(pc)
-    , m_next_send(0)
-    , m_pcs()
-    , m_scratch()
-    , m_cutoffs()
+                                               hyperdex_admin_returncode *s,
+                                               hyperdex_admin_perf_counter *pc)
+	: pending(id, s)
+	, m_pc(pc)
+	, m_next_send(0)
+	, m_pcs()
+	, m_scratch()
+	, m_cutoffs()
 {
 }
 
@@ -64,174 +64,154 @@ pending_perf_counters :: ~pending_perf_counters() throw ()
 }
 
 void
-pending_perf_counters :: send_perf_reqs(admin* adm,
-                                        const configuration* config,
-                                        hyperdex_admin_returncode* status)
+pending_perf_counters :: send_perf_reqs(admin *adm,
+                                        const configuration *config,
+                                        hyperdex_admin_returncode *status)
 {
-    std::vector<std::pair<server_id, po6::net::location> > addrs;
-    config->get_all_addresses(&addrs);
-    uint64_t failed = 0;
-
-    for (size_t i = 0; i < addrs.size(); ++i)
-    {
-        uint64_t nonce = adm->m_next_server_nonce;
-        ++adm->m_next_server_nonce;
-        uint64_t when = 0;
-        std::map<server_id, uint64_t>::iterator it = m_cutoffs.find(addrs[i].first);
-
-        if (it == m_cutoffs.end())
-        {
-            m_cutoffs[addrs[i].first] = 0;
-        }
-        else
-        {
-            when = it->second;
-        }
-
-        size_t sz = HYPERDEX_ADMIN_HEADER_SIZE_REQ + sizeof(uint64_t);
-        std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
-        msg->pack_at(HYPERDEX_ADMIN_HEADER_SIZE_REQ) << when;
-
-        if (!adm->send(PERF_COUNTERS, addrs[i].first, nonce, msg, this, status))
-        {
-            ++failed;
-        }
-    }
-
-    std::map<server_id, uint64_t>::iterator it = m_cutoffs.begin();
-
-    while (it != m_cutoffs.end())
-    {
-        bool found = false;
-
-        for (size_t i = 0; i < addrs.size(); ++i)
-        {
-            if (it->first == addrs[i].first)
-            {
-                found = true;
-                break;
-            }
-        }
-
-        if (found)
-        {
-            ++it;
-        }
-        else
-        {
-            m_cutoffs.erase(it);
-            it = m_cutoffs.begin();
-        }
-    }
+	std::vector<std::pair<server_id, po6::net::location> > addrs;
+	config->get_all_addresses(&addrs);
+	uint64_t failed = 0;
+	for (size_t i = 0; i < addrs.size(); ++i)
+	{
+		uint64_t nonce = adm->m_next_server_nonce;
+		++adm->m_next_server_nonce;
+		uint64_t when = 0;
+		std::map<server_id, uint64_t>::iterator it = m_cutoffs.find(addrs[i].first);
+		if (it == m_cutoffs.end())
+		{
+			m_cutoffs[addrs[i].first] = 0;
+		}
+		else
+		{
+			when = it->second;
+		}
+		size_t sz = HYPERDEX_ADMIN_HEADER_SIZE_REQ + sizeof(uint64_t);
+		std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
+		msg->pack_at(HYPERDEX_ADMIN_HEADER_SIZE_REQ) << when;
+		if (!adm->send(PERF_COUNTERS, addrs[i].first, nonce, msg, this, status))
+		{
+			++failed;
+		}
+	}
+	std::map<server_id, uint64_t>::iterator it = m_cutoffs.begin();
+	while (it != m_cutoffs.end())
+	{
+		bool found = false;
+		for (size_t i = 0; i < addrs.size(); ++i)
+		{
+			if (it->first == addrs[i].first)
+			{
+				found = true;
+				break;
+			}
+		}
+		if (found)
+		{
+			++it;
+		}
+		else
+		{
+			m_cutoffs.erase(it);
+			it = m_cutoffs.begin();
+		}
+	}
 }
 
 int
 pending_perf_counters :: millis_to_next_send()
 {
-    const uint64_t one_second = 1000ULL * 1000ULL * 1000ULL;
-    uint64_t now = po6::monotonic_time();
-
-    if (now >= m_next_send)
-    {
-        m_next_send = now + one_second;
-        return 0;
-    }
-
-    return ((m_next_send - now) / one_second) + 1;
+	const uint64_t one_second = 1000ULL * 1000ULL * 1000ULL;
+	uint64_t now = po6::monotonic_time();
+	if (now >= m_next_send)
+	{
+		m_next_send = now + one_second;
+		return 0;
+	}
+	return ((m_next_send - now) / one_second) + 1;
 }
 
 bool
 pending_perf_counters :: can_yield()
 {
-    return !m_pcs.empty();
+	return !m_pcs.empty();
 }
 
 bool
-pending_perf_counters :: yield(hyperdex_admin_returncode* status)
+pending_perf_counters :: yield(hyperdex_admin_returncode *status)
 {
-    assert(can_yield());
-    m_scratch = m_pcs.front().property;
-    m_pc->id = m_pcs.front().id;
-    m_pc->time = m_pcs.front().time;
-    m_pc->property = m_scratch.c_str();
-    m_pc->measurement = m_pcs.front().measurement;
-    m_pcs.pop_front();
-    *status = HYPERDEX_ADMIN_SUCCESS;
-    return true;
+	assert(can_yield());
+	m_scratch = m_pcs.front().property;
+	m_pc->id = m_pcs.front().id;
+	m_pc->time = m_pcs.front().time;
+	m_pc->property = m_scratch.c_str();
+	m_pc->measurement = m_pcs.front().measurement;
+	m_pcs.pop_front();
+	*status = HYPERDEX_ADMIN_SUCCESS;
+	return true;
 }
 
 void
-pending_perf_counters :: handle_sent_to(const server_id&)
+pending_perf_counters :: handle_sent_to(const server_id &)
 {
 }
 
 void
-pending_perf_counters :: handle_failure(const server_id&)
+pending_perf_counters :: handle_failure(const server_id &)
 {
 }
 
 bool
-pending_perf_counters :: handle_message(admin*,
-                                        const server_id& si,
+pending_perf_counters :: handle_message(admin *,
+                                        const server_id &si,
                                         network_msgtype mt,
                                         std::auto_ptr<e::buffer>,
                                         e::unpacker up,
-                                        hyperdex_admin_returncode* status)
+                                        hyperdex_admin_returncode *status)
 {
-    *status = HYPERDEX_ADMIN_SUCCESS;
-    set_status(HYPERDEX_ADMIN_SUCCESS);
-
-    if (mt != PERF_COUNTERS)
-    {
-        YIELDING_ERROR(SERVERERROR) << "server " << si.get() << " responded to PERF_COUNTERS with wrong message type";
-        return true;
-    }
-
-    e::slice rem = up.remainder();
-    char* ptr = const_cast<char*>(reinterpret_cast<const char*>(rem.data()));
-    char* end = ptr + rem.size() - 1;
-    uint64_t max_time = 0;
-
-    // parse one line at a time
-    while (ptr < end)
-    {
-        char* eol = reinterpret_cast<char*>(memchr(ptr, '\n', end - ptr));
-        eol = eol ? eol : end;
-        *eol = '\0';
-        char* tmp = ptr;
-
-        // parse the time
-        tmp = strchr(ptr, ' ');
-        tmp = tmp ? tmp : eol;
-        *tmp = '\0';
-        uint64_t time = strtoull(ptr, NULL, 0);
-        max_time = std::max(time, max_time);
-        ptr = tmp + 1;
-
-        while (ptr < eol)
-        {
-            tmp = strchr(ptr, ' ');
-            tmp = tmp ? tmp : eol;
-            *tmp = '\0';
-
-            char* equals = strchr(ptr, '=');
-            equals = equals ? equals: tmp;
-            *equals = '\0';
-            uint64_t value = 0;
-
-            if (equals < tmp)
-            {
-                ++equals;
-                value = strtoull(equals, NULL, 0);
-            }
-
-            m_pcs.push_back(perf_counter(si.get(), time, ptr, value));
-            ptr = tmp + 1;
-        }
-
-        ptr = eol + 1;
-    }
-
-    m_cutoffs[si] = max_time;
-    return true;
+	*status = HYPERDEX_ADMIN_SUCCESS;
+	set_status(HYPERDEX_ADMIN_SUCCESS);
+	if (mt != PERF_COUNTERS)
+	{
+		YIELDING_ERROR(SERVERERROR) << "server " << si.get() << " responded to PERF_COUNTERS with wrong message type";
+		return true;
+	}
+	e::slice rem = up.remainder();
+	char *ptr = const_cast<char *>(reinterpret_cast<const char *>(rem.data()));
+	char *end = ptr + rem.size() - 1;
+	uint64_t max_time = 0;
+	// parse one line at a time
+	while (ptr < end)
+	{
+		char *eol = reinterpret_cast<char *>(memchr(ptr, '\n', end - ptr));
+		eol = eol ? eol : end;
+		*eol = '\0';
+		char *tmp = ptr;
+		// parse the time
+		tmp = strchr(ptr, ' ');
+		tmp = tmp ? tmp : eol;
+		*tmp = '\0';
+		uint64_t time = strtoull(ptr, NULL, 0);
+		max_time = std::max(time, max_time);
+		ptr = tmp + 1;
+		while (ptr < eol)
+		{
+			tmp = strchr(ptr, ' ');
+			tmp = tmp ? tmp : eol;
+			*tmp = '\0';
+			char *equals = strchr(ptr, '=');
+			equals = equals ? equals : tmp;
+			*equals = '\0';
+			uint64_t value = 0;
+			if (equals < tmp)
+			{
+				++equals;
+				value = strtoull(equals, NULL, 0);
+			}
+			m_pcs.push_back(perf_counter(si.get(), time, ptr, value));
+			ptr = tmp + 1;
+		}
+		ptr = eol + 1;
+	}
+	m_cutoffs[si] = max_time;
+	return true;
 }
diff --git a/admin/pending_perf_counters.h b/admin/pending_perf_counters.h
index ff1354c75..54a3a307f 100644
--- a/admin/pending_perf_counters.h
+++ b/admin/pending_perf_counters.h
@@ -38,51 +38,51 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class pending_perf_counters : public pending
 {
-    public:
-        pending_perf_counters(uint64_t admin_visible_id,
-                              hyperdex_admin_returncode* status,
-                              hyperdex_admin_perf_counter* pc);
-        virtual ~pending_perf_counters() throw ();
+public:
+	pending_perf_counters(uint64_t admin_visible_id,
+	                      hyperdex_admin_returncode *status,
+	                      hyperdex_admin_perf_counter *pc);
+	virtual ~pending_perf_counters() throw ();
 
-    // manipulate perf counters
-    public:
-        void send_perf_reqs(admin* adm,
-                            const configuration* config,
-                            hyperdex_admin_returncode* status);
-        int millis_to_next_send();
+	// manipulate perf counters
+public:
+	void send_perf_reqs(admin *adm,
+	                    const configuration *config,
+	                    hyperdex_admin_returncode *status);
+	int millis_to_next_send();
 
-    // return to admin
-    public:
-        virtual bool can_yield();
-        virtual bool yield(hyperdex_admin_returncode* status);
+	// return to admin
+public:
+	virtual bool can_yield();
+	virtual bool yield(hyperdex_admin_returncode *status);
 
-    // events
-    public:
-        virtual void handle_sent_to(const server_id& si);
-        virtual void handle_failure(const server_id& si);
-        virtual bool handle_message(admin* adm,
-                                    const server_id& si,
-                                    network_msgtype mt,
-                                    std::auto_ptr<e::buffer> msg,
-                                    e::unpacker up,
-                                    hyperdex_admin_returncode* status);
+	// events
+public:
+	virtual void handle_sent_to(const server_id &si);
+	virtual void handle_failure(const server_id &si);
+	virtual bool handle_message(admin *adm,
+	                            const server_id &si,
+	                            network_msgtype mt,
+	                            std::auto_ptr<e::buffer> msg,
+	                            e::unpacker up,
+	                            hyperdex_admin_returncode *status);
 
-    protected:
-        friend class e::intrusive_ptr<pending_perf_counters>;
+protected:
+	friend class e::intrusive_ptr<pending_perf_counters>;
 
-    private:
-        class perf_counter;
+private:
+	class perf_counter;
 
-    private:
-        pending_perf_counters(const pending_perf_counters& other);
-        pending_perf_counters& operator = (const pending_perf_counters& rhs);
+private:
+	pending_perf_counters(const pending_perf_counters &other);
+	pending_perf_counters &operator = (const pending_perf_counters &rhs);
 
-    private:
-        hyperdex_admin_perf_counter* m_pc;
-        uint64_t m_next_send;
-        std::list<perf_counter> m_pcs;
-        std::string m_scratch;
-        std::map<server_id, uint64_t> m_cutoffs;
+private:
+	hyperdex_admin_perf_counter *m_pc;
+	uint64_t m_next_send;
+	std::list<perf_counter> m_pcs;
+	std::string m_scratch;
+	std::map<server_id, uint64_t> m_cutoffs;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/admin/pending_raw_backup.cc b/admin/pending_raw_backup.cc
index f8d8946ce..34e07faf6 100644
--- a/admin/pending_raw_backup.cc
+++ b/admin/pending_raw_backup.cc
@@ -32,12 +32,12 @@
 using hyperdex::pending_raw_backup;
 
 pending_raw_backup :: pending_raw_backup(uint64_t id,
-                                         hyperdex_admin_returncode* status,
-                                         const char** path)
-    : pending(id, status)
-    , m_path()
-    , m_path_c_str(path)
-    , m_done(false)
+                                         hyperdex_admin_returncode *status,
+                                         const char **path)
+	: pending(id, status)
+	, m_path()
+	, m_path_c_str(path)
+	, m_done(false)
 {
 }
 
@@ -48,69 +48,63 @@ pending_raw_backup :: ~pending_raw_backup() throw ()
 bool
 pending_raw_backup :: can_yield()
 {
-    return !m_done;
+	return !m_done;
 }
 
 bool
-pending_raw_backup :: yield(hyperdex_admin_returncode* status)
+pending_raw_backup :: yield(hyperdex_admin_returncode *status)
 {
-    *status = HYPERDEX_ADMIN_SUCCESS;
-    m_done = true;
-    return true;
+	*status = HYPERDEX_ADMIN_SUCCESS;
+	m_done = true;
+	return true;
 }
 
 void
-pending_raw_backup :: handle_sent_to(const server_id&)
+pending_raw_backup :: handle_sent_to(const server_id &)
 {
 }
 
 void
-pending_raw_backup :: handle_failure(const server_id& si)
+pending_raw_backup :: handle_failure(const server_id &si)
 {
-    YIELDING_ERROR(SERVERERROR) << "communication with " << si << "failed";
+	YIELDING_ERROR(SERVERERROR) << "communication with " << si << "failed";
 }
 
 bool
-pending_raw_backup :: handle_message(admin*,
-                                     const server_id& si,
+pending_raw_backup :: handle_message(admin *,
+                                     const server_id &si,
                                      network_msgtype mt,
                                      std::auto_ptr<e::buffer> msg,
                                      e::unpacker up,
-                                     hyperdex_admin_returncode* status)
+                                     hyperdex_admin_returncode *status)
 {
-    *status = HYPERDEX_ADMIN_SUCCESS;
-
-    if (mt != BACKUP)
-    {
-        YIELDING_ERROR(SERVERERROR) << "server " << si << " responded to BACKUP with " << mt;
-        return true;
-    }
-
-    uint16_t rt;
-    e::slice path;
-    up = up >> rt >> path;
-
-    if (up.error())
-    {
-        YIELDING_ERROR(SERVERERROR) << "communication error: server "
-                                    << si << " sent corrupt message="
-                                    << msg->as_slice().hex()
-                                    << " in response to a BACKUP";
-        return true;
-    }
-
-    network_returncode rc = static_cast<network_returncode>(rt);
-
-    if (rc != NET_SUCCESS)
-    {
-        YIELDING_ERROR(SERVERERROR) << "backup of server " << si
-                                    << " failed; see the server's log for details";
-        return true;
-    }
-
-    m_path.assign(reinterpret_cast<const char*>(path.data()), path.size());
-    *m_path_c_str = m_path.c_str();
-    this->set_status(HYPERDEX_ADMIN_SUCCESS);
-    this->set_error(e::error());
-    return true;
+	*status = HYPERDEX_ADMIN_SUCCESS;
+	if (mt != BACKUP)
+	{
+		YIELDING_ERROR(SERVERERROR) << "server " << si << " responded to BACKUP with " << mt;
+		return true;
+	}
+	uint16_t rt;
+	e::slice path;
+	up = up >> rt >> path;
+	if (up.error())
+	{
+		YIELDING_ERROR(SERVERERROR) << "communication error: server "
+		                            << si << " sent corrupt message="
+		                            << msg->as_slice().hex()
+		                            << " in response to a BACKUP";
+		return true;
+	}
+	network_returncode rc = static_cast<network_returncode>(rt);
+	if (rc != NET_SUCCESS)
+	{
+		YIELDING_ERROR(SERVERERROR) << "backup of server " << si
+		                            << " failed; see the server's log for details";
+		return true;
+	}
+	m_path.assign(reinterpret_cast<const char *>(path.data()), path.size());
+	*m_path_c_str = m_path.c_str();
+	this->set_status(HYPERDEX_ADMIN_SUCCESS);
+	this->set_error(e::error());
+	return true;
 }
diff --git a/admin/pending_raw_backup.h b/admin/pending_raw_backup.h
index a4ced95c7..9f437861c 100644
--- a/admin/pending_raw_backup.h
+++ b/admin/pending_raw_backup.h
@@ -38,36 +38,36 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class pending_raw_backup : public pending
 {
-    public:
-        pending_raw_backup(uint64_t admin_visible_id,
-                           hyperdex_admin_returncode* status,
-                           const char** path);
-        virtual ~pending_raw_backup() throw ();
+public:
+	pending_raw_backup(uint64_t admin_visible_id,
+	                   hyperdex_admin_returncode *status,
+	                   const char **path);
+	virtual ~pending_raw_backup() throw ();
 
-    // return to admin
-    public:
-        virtual bool can_yield();
-        virtual bool yield(hyperdex_admin_returncode* status);
+	// return to admin
+public:
+	virtual bool can_yield();
+	virtual bool yield(hyperdex_admin_returncode *status);
 
-    // events
-    public:
-        virtual void handle_sent_to(const server_id& si);
-        virtual void handle_failure(const server_id& si);
-        virtual bool handle_message(admin* adm,
-                                    const server_id& si,
-                                    network_msgtype mt,
-                                    std::auto_ptr<e::buffer> msg,
-                                    e::unpacker up,
-                                    hyperdex_admin_returncode* status);
+	// events
+public:
+	virtual void handle_sent_to(const server_id &si);
+	virtual void handle_failure(const server_id &si);
+	virtual bool handle_message(admin *adm,
+	                            const server_id &si,
+	                            network_msgtype mt,
+	                            std::auto_ptr<e::buffer> msg,
+	                            e::unpacker up,
+	                            hyperdex_admin_returncode *status);
 
-    private:
-        pending_raw_backup(const pending_raw_backup& other);
-        pending_raw_backup& operator = (const pending_raw_backup& rhs);
+private:
+	pending_raw_backup(const pending_raw_backup &other);
+	pending_raw_backup &operator = (const pending_raw_backup &rhs);
 
-    private:
-        std::string m_path;
-        const char** m_path_c_str;
-        bool m_done;
+private:
+	std::string m_path;
+	const char **m_path_c_str;
+	bool m_done;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/admin/pending_string.cc b/admin/pending_string.cc
index 197d05e58..91171e4e1 100644
--- a/admin/pending_string.cc
+++ b/admin/pending_string.cc
@@ -31,15 +31,15 @@
 using hyperdex::pending_string;
 
 pending_string :: pending_string(uint64_t id,
-                                 hyperdex_admin_returncode* status,
+                                 hyperdex_admin_returncode *status,
                                  hyperdex_admin_returncode _status,
-                                 const std::string& string,
-                                 const char** store)
-    : pending(id, status)
-    , m_status(_status)
-    , m_string(string)
-    , m_store(store)
-    , m_done(false)
+                                 const std::string &string,
+                                 const char **store)
+	: pending(id, status)
+	, m_status(_status)
+	, m_string(string)
+	, m_store(store)
+	, m_done(false)
 {
 }
 
@@ -50,39 +50,39 @@ pending_string :: ~pending_string() throw ()
 bool
 pending_string :: can_yield()
 {
-    return !m_done;
+	return !m_done;
 }
 
 bool
-pending_string :: yield(hyperdex_admin_returncode* status)
+pending_string :: yield(hyperdex_admin_returncode *status)
 {
-    assert(this->can_yield());
-    m_done = true;
-    *status = HYPERDEX_ADMIN_SUCCESS;
-    set_status(m_status);
-    *m_store = m_string.c_str();
-    return true;
+	assert(this->can_yield());
+	m_done = true;
+	*status = HYPERDEX_ADMIN_SUCCESS;
+	set_status(m_status);
+	*m_store = m_string.c_str();
+	return true;
 }
 
 void
-pending_string :: handle_sent_to(const server_id&)
+pending_string :: handle_sent_to(const server_id &)
 {
-    abort();
+	abort();
 }
 
 void
-pending_string :: handle_failure(const server_id&)
+pending_string :: handle_failure(const server_id &)
 {
-    abort();
+	abort();
 }
 
 bool
-pending_string :: handle_message(admin*,
-                                 const server_id&,
+pending_string :: handle_message(admin *,
+                                 const server_id &,
                                  network_msgtype,
                                  std::auto_ptr<e::buffer>,
                                  e::unpacker,
-                                 hyperdex_admin_returncode*)
+                                 hyperdex_admin_returncode *)
 {
-    abort();
+	abort();
 }
diff --git a/admin/pending_string.h b/admin/pending_string.h
index 22057b8b4..c68a70c07 100644
--- a/admin/pending_string.h
+++ b/admin/pending_string.h
@@ -36,39 +36,39 @@ class admin;
 
 class pending_string : public pending
 {
-    public:
-        pending_string(uint64_t admin_visible_id,
-                       hyperdex_admin_returncode* status,
-                       hyperdex_admin_returncode set_status,
-                       const std::string& string,
-                       const char** store);
-        virtual ~pending_string() throw ();
+public:
+	pending_string(uint64_t admin_visible_id,
+	               hyperdex_admin_returncode *status,
+	               hyperdex_admin_returncode set_status,
+	               const std::string &string,
+	               const char **store);
+	virtual ~pending_string() throw ();
 
-    // return to admin
-    public:
-        virtual bool can_yield();
-        virtual bool yield(hyperdex_admin_returncode* status);
+	// return to admin
+public:
+	virtual bool can_yield();
+	virtual bool yield(hyperdex_admin_returncode *status);
 
-    // events
-    public:
-        virtual void handle_sent_to(const server_id& si);
-        virtual void handle_failure(const server_id& si);
-        virtual bool handle_message(admin* cl,
-                                    const server_id& si,
-                                    network_msgtype mt,
-                                    std::auto_ptr<e::buffer> msg,
-                                    e::unpacker up,
-                                    hyperdex_admin_returncode* status);
+	// events
+public:
+	virtual void handle_sent_to(const server_id &si);
+	virtual void handle_failure(const server_id &si);
+	virtual bool handle_message(admin *cl,
+	                            const server_id &si,
+	                            network_msgtype mt,
+	                            std::auto_ptr<e::buffer> msg,
+	                            e::unpacker up,
+	                            hyperdex_admin_returncode *status);
 
-    private:
-        pending_string(const pending_string&);
-        pending_string& operator = (const pending_string&);
+private:
+	pending_string(const pending_string &);
+	pending_string &operator = (const pending_string &);
 
-    private:
-        hyperdex_admin_returncode m_status;
-        std::string m_string;
-        const char** m_store;
-        bool m_done;
+private:
+	hyperdex_admin_returncode m_status;
+	std::string m_string;
+	const char **m_store;
+	bool m_done;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/admin/raw_backup.cc b/admin/raw_backup.cc
index 68c3c21fa..b76948d88 100644
--- a/admin/raw_backup.cc
+++ b/admin/raw_backup.cc
@@ -48,113 +48,112 @@
 extern "C"
 {
 
-using namespace hyperdex;
+	using namespace hyperdex;
 
-HYPERDEX_API int
-hyperdex_admin_raw_backup(const char* host, uint16_t port,
-                          const char* name,
-                          enum hyperdex_admin_returncode* status)
-{
-    try
-    {
-        busybee_single bbs(po6::net::location(host, port));
-        const uint8_t type = static_cast<uint8_t>(BACKUP);
-        const uint8_t flags = 0;
-        const uint64_t version = 0;
-        virtual_server_id to(UINT64_MAX);
-        const uint64_t nonce = 0xdeadbeefcafebabe;
-        size_t name_sz = strlen(name) + 1;
-        e::slice name_s(name, name_sz);
-        size_t sz = BUSYBEE_HEADER_SIZE
-                  + sizeof(uint8_t) /*mt*/
-                  + sizeof(uint8_t) /*flags*/
-                  + sizeof(uint64_t) /*version*/
-                  + sizeof(uint64_t) /*vidt*/
-                  + sizeof(uint64_t) /*nonce*/
-                  + pack_size(name_s);
-        std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
-        e::packer pa = msg->pack_at(BUSYBEE_HEADER_SIZE);
-        pa = pa << type << flags << version << to << nonce << name_s;
-        bbs.set_timeout(-1);
-
-        switch (bbs.send(msg))
-        {
-            case BUSYBEE_SUCCESS:
-                break;
-            case BUSYBEE_TIMEOUT:
-                *status = HYPERDEX_ADMIN_TIMEOUT;
-                return -1;
-            case BUSYBEE_INTERRUPTED:
-                *status = HYPERDEX_ADMIN_INTERRUPTED;
-                return -1;
-            case BUSYBEE_SHUTDOWN:
-            case BUSYBEE_POLLFAILED:
-            case BUSYBEE_DISRUPTED:
-            case BUSYBEE_ADDFDFAIL:
-            case BUSYBEE_EXTERNAL:
-                *status = HYPERDEX_ADMIN_SERVERERROR;
-                return -1;
-            default:
-                abort();
-        }
-
-        switch (bbs.recv(&msg))
-        {
-            case BUSYBEE_SUCCESS:
-                break;
-            case BUSYBEE_TIMEOUT:
-                *status = HYPERDEX_ADMIN_TIMEOUT;
-                return -1;
-            case BUSYBEE_INTERRUPTED:
-                *status = HYPERDEX_ADMIN_INTERRUPTED;
-                return -1;
-            case BUSYBEE_SHUTDOWN:
-            case BUSYBEE_POLLFAILED:
-            case BUSYBEE_DISRUPTED:
-            case BUSYBEE_ADDFDFAIL:
-            case BUSYBEE_EXTERNAL:
-                *status = HYPERDEX_ADMIN_SERVERERROR;
-                return -1;
-            default:
-                abort();
-        }
-
-        e::unpacker up = msg->unpack_from(BUSYBEE_HEADER_SIZE
-                                          + sizeof(uint8_t) /*mt*/
-                                          + sizeof(uint64_t) /*vidt*/
-                                          + sizeof(uint64_t) /*nonce*/);
-        uint16_t rt;
-
-        if ((up >> rt).error())
-        {
-            *status = HYPERDEX_ADMIN_SERVERERROR;
-            return -1;
-        }
-
-        network_returncode rc = static_cast<network_returncode>(rt);
-
-        if (rc == NET_SUCCESS)
-        {
-            *status = HYPERDEX_ADMIN_SUCCESS;
-            return 0;
-        }
-        else
-        {
-            *status = HYPERDEX_ADMIN_SERVERERROR;
-            return -1;
-        }
-    }
-    catch (std::bad_alloc& ba)
-    {
-        errno = ENOMEM;
-        *status = HYPERDEX_ADMIN_NOMEM;
-        return -1;
-    }
-    catch (...)
-    {
-        *status = HYPERDEX_ADMIN_EXCEPTION;
-        return -1;
-    }
-}
+	HYPERDEX_API int
+	hyperdex_admin_raw_backup(const char *host, uint16_t port,
+	                          const char *name,
+	                          enum hyperdex_admin_returncode *status)
+	{
+		try
+		{
+			po6::net::location loc;
+			if (!loc.set(host, port))
+			{
+				return -1;
+			}
+			busybee_single bbs(loc);
+			const uint8_t type = static_cast<uint8_t>(BACKUP);
+			const uint8_t flags = 0;
+			const uint64_t version = 0;
+			virtual_server_id to(UINT64_MAX);
+			const uint64_t nonce = 0xdeadbeefcafebabe;
+			size_t name_sz = strlen(name) + 1;
+			e::slice name_s(name, name_sz);
+			size_t sz = BUSYBEE_HEADER_SIZE
+			            + sizeof(uint8_t) /*mt*/
+			            + sizeof(uint8_t) /*flags*/
+			            + sizeof(uint64_t) /*version*/
+			            + sizeof(uint64_t) /*vidt*/
+			            + sizeof(uint64_t) /*nonce*/
+			            + pack_size(name_s);
+			std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
+			e::packer pa = msg->pack_at(BUSYBEE_HEADER_SIZE);
+			pa = pa << type << flags << version << to << nonce << name_s;
+			bbs.set_timeout(-1);
+			switch (bbs.send(msg))
+			{
+			case BUSYBEE_SUCCESS:
+				break;
+			case BUSYBEE_TIMEOUT:
+				*status = HYPERDEX_ADMIN_TIMEOUT;
+				return -1;
+			case BUSYBEE_INTERRUPTED:
+				*status = HYPERDEX_ADMIN_INTERRUPTED;
+				return -1;
+			case BUSYBEE_SHUTDOWN:
+			case BUSYBEE_POLLFAILED:
+			case BUSYBEE_DISRUPTED:
+			case BUSYBEE_ADDFDFAIL:
+			case BUSYBEE_EXTERNAL:
+				*status = HYPERDEX_ADMIN_SERVERERROR;
+				return -1;
+			default:
+				abort();
+			}
+			switch (bbs.recv(&msg))
+			{
+			case BUSYBEE_SUCCESS:
+				break;
+			case BUSYBEE_TIMEOUT:
+				*status = HYPERDEX_ADMIN_TIMEOUT;
+				return -1;
+			case BUSYBEE_INTERRUPTED:
+				*status = HYPERDEX_ADMIN_INTERRUPTED;
+				return -1;
+			case BUSYBEE_SHUTDOWN:
+			case BUSYBEE_POLLFAILED:
+			case BUSYBEE_DISRUPTED:
+			case BUSYBEE_ADDFDFAIL:
+			case BUSYBEE_EXTERNAL:
+				*status = HYPERDEX_ADMIN_SERVERERROR;
+				return -1;
+			default:
+				abort();
+			}
+			e::unpacker up = msg->unpack_from(BUSYBEE_HEADER_SIZE
+			                                  + sizeof(uint8_t) /*mt*/
+			                                  + sizeof(uint64_t) /*vidt*/
+			                                  + sizeof(uint64_t) /*nonce*/);
+			uint16_t rt;
+			if ((up >> rt).error())
+			{
+				*status = HYPERDEX_ADMIN_SERVERERROR;
+				return -1;
+			}
+			network_returncode rc = static_cast<network_returncode>(rt);
+			if (rc == NET_SUCCESS)
+			{
+				*status = HYPERDEX_ADMIN_SUCCESS;
+				return 0;
+			}
+			else
+			{
+				*status = HYPERDEX_ADMIN_SERVERERROR;
+				return -1;
+			}
+		}
+		catch (std::bad_alloc &ba)
+		{
+			errno = ENOMEM;
+			*status = HYPERDEX_ADMIN_NOMEM;
+			return -1;
+		}
+		catch (...)
+		{
+			*status = HYPERDEX_ADMIN_EXCEPTION;
+			return -1;
+		}
+	}
 
 } // extern "C"
diff --git a/admin/yieldable.cc b/admin/yieldable.cc
index b4acd7d29..0123d2d69 100644
--- a/admin/yieldable.cc
+++ b/admin/yieldable.cc
@@ -31,11 +31,11 @@
 using hyperdex::yieldable;
 
 yieldable :: yieldable(uint64_t id,
-                       hyperdex_admin_returncode* s)
-    : m_ref(0)
-    , m_admin_visible_id(id)
-    , m_status(s)
-    , m_error()
+                       hyperdex_admin_returncode *s)
+	: m_ref(0)
+	, m_admin_visible_id(id)
+	, m_status(s)
+	, m_error()
 {
 }
 
@@ -43,15 +43,15 @@ yieldable :: ~yieldable() throw ()
 {
 }
 
-std::ostream&
-yieldable :: error(const char* file, size_t line)
+std::ostream &
+yieldable :: error(const char *file, size_t line)
 {
-    m_error.set_loc(file, line);
-    return m_error.set_msg();
+	m_error.set_loc(file, line);
+	return m_error.set_msg();
 }
 
 void
-yieldable :: set_error(const e::error& err)
+yieldable :: set_error(const e::error &err)
 {
-    m_error = err;
+	m_error = err;
 }
diff --git a/admin/yieldable.h b/admin/yieldable.h
index 4780077de..55dee8020 100644
--- a/admin/yieldable.h
+++ b/admin/yieldable.h
@@ -47,47 +47,47 @@ class admin;
 
 class yieldable
 {
-    public:
-        yieldable(uint64_t admin_visible_id,
-                  hyperdex_admin_returncode* status);
-        virtual ~yieldable() throw ();
+public:
+	yieldable(uint64_t admin_visible_id,
+	          hyperdex_admin_returncode *status);
+	virtual ~yieldable() throw ();
 
-    public:
-        int64_t admin_visible_id() const { return m_admin_visible_id; }
-        void set_status(hyperdex_admin_returncode status) { *m_status = status; }
-        e::error error() const { return m_error; }
+public:
+	int64_t admin_visible_id() const { return m_admin_visible_id; }
+	void set_status(hyperdex_admin_returncode status) { *m_status = status; }
+	e::error error() const { return m_error; }
 
-    // return to admin
-    public:
-        virtual bool can_yield() = 0;
-        virtual bool yield(hyperdex_admin_returncode* status) = 0;
+	// return to admin
+public:
+	virtual bool can_yield() = 0;
+	virtual bool yield(hyperdex_admin_returncode *status) = 0;
 
-    // refcount
-    protected:
-        friend class e::intrusive_ptr<yieldable>;
-        void inc() { ++m_ref; }
-        void dec() { if (--m_ref == 0) delete this; }
-        size_t m_ref;
+	// refcount
+protected:
+	friend class e::intrusive_ptr<yieldable>;
+	void inc() { ++m_ref; }
+	void dec() { if (--m_ref == 0) delete this; }
+	size_t m_ref;
 
-    protected:
-        std::ostream& error(const char* file, size_t line);
-        void set_error(const e::error& err);
+protected:
+	std::ostream &error(const char *file, size_t line);
+	void set_error(const e::error &err);
 
-    // noncopyable
-    private:
-        yieldable(const yieldable& other);
-        yieldable& operator = (const yieldable& rhs);
+	// noncopyable
+private:
+	yieldable(const yieldable &other);
+	yieldable &operator = (const yieldable &rhs);
 
-    // operation state
-    private:
-        int64_t m_admin_visible_id;
-        hyperdex_admin_returncode* m_status;
-        e::error m_error;
+	// operation state
+private:
+	int64_t m_admin_visible_id;
+	hyperdex_admin_returncode *m_status;
+	e::error m_error;
 };
 
 #define YIELDING_ERROR(CODE) \
-    this->set_status(HYPERDEX_ADMIN_ ## CODE); \
-    this->error(__FILE__, __LINE__)
+	this->set_status(HYPERDEX_ADMIN_ ## CODE); \
+	this->error(__FILE__, __LINE__)
 
 END_HYPERDEX_NAMESPACE
 
diff --git a/autogen.sh b/autogen.sh
new file mode 100755
index 000000000..2ab57c41d
--- /dev/null
+++ b/autogen.sh
@@ -0,0 +1,25 @@
+#!/bin/sh
+#
+# $Id: autogen.sh 1091 2008-06-08 06:37:22Z nicodvb $
+#
+# run this to generate all the initial makefiles, etc.
+
+srcdir=`dirname "$0"`
+test -z "$srcdir" && srcdir=.
+
+ORIGDIR=`pwd`
+cd "$srcdir"
+
+AUTORECONF=${AUTORECONF-autoreconf}
+
+if ! type $AUTORECONF >/dev/null 2>&1; then
+  echo "**Error**: Missing \`autoreconf' program." >&2
+  echo "You will need the autoconf and automake packages." >&2
+  echo "You can download them from ftp://ftp.gnu.org/pub/gnu/." >&2
+  exit 1
+fi
+
+test ! -d "$srcdir/m4" &&  mkdir "$srcdir/m4"
+$AUTORECONF -v --install || exit $?
+cd "$ORIGDIR" || exit $?
+
diff --git a/bindings/c/admin-testcompile.c b/bindings/c/admin-testcompile.c
index a64cb4300..2695804cc 100644
--- a/bindings/c/admin-testcompile.c
+++ b/bindings/c/admin-testcompile.c
@@ -33,9 +33,9 @@
 #endif
 
 int
-main(int argc, const char* argv[])
+main(int argc, const char *argv[])
 {
-    argc = argc;
-    argv = argv;
-    return 0;
+	argc = argc;
+	argv = argv;
+	return 0;
 }
diff --git a/bindings/c/client-testcompile.c b/bindings/c/client-testcompile.c
index 686ce94e4..eaf9e41d0 100644
--- a/bindings/c/client-testcompile.c
+++ b/bindings/c/client-testcompile.c
@@ -33,9 +33,9 @@
 #endif
 
 int
-main(int argc, const char* argv[])
+main(int argc, const char *argv[])
 {
-    argc = argc;
-    argv = argv;
-    return 0;
+	argc = argc;
+	argv = argv;
+	return 0;
 }
diff --git a/bindings/cc/admin-testcompile.cc b/bindings/cc/admin-testcompile.cc
index e77fef306..8cd588d05 100644
--- a/bindings/cc/admin-testcompile.cc
+++ b/bindings/cc/admin-testcompile.cc
@@ -32,9 +32,9 @@
 #endif
 
 int
-main(int argc, const char* argv[])
+main(int argc, const char *argv[])
 {
-    argc = argc;
-    argv = argv;
-    return 0;
+	argc = argc;
+	argv = argv;
+	return 0;
 }
diff --git a/bindings/cc/client-testcompile.cc b/bindings/cc/client-testcompile.cc
index d23b23afe..fbb8f8d07 100644
--- a/bindings/cc/client-testcompile.cc
+++ b/bindings/cc/client-testcompile.cc
@@ -32,9 +32,9 @@
 #endif
 
 int
-main(int argc, const char* argv[])
+main(int argc, const char *argv[])
 {
-    argc = argc;
-    argv = argv;
-    return 0;
+	argc = argc;
+	argv = argv;
+	return 0;
 }
diff --git a/bindings/java/client-util.h b/bindings/java/client-util.h
index 51ffbc787..12202d760 100644
--- a/bindings/java/client-util.h
+++ b/bindings/java/client-util.h
@@ -35,54 +35,54 @@
 #include <hyperdex/client.h>
 #include <hyperdex/datastructures.h>
 
-const char*
-hyperdex_java_client_convert_cstring(JNIEnv* env,
-                                     struct hyperdex_ds_arena* arena,
+const char *
+hyperdex_java_client_convert_cstring(JNIEnv *env,
+                                     struct hyperdex_ds_arena *arena,
                                      jobject str);
 
 int
-hyperdex_java_client_convert_attributes(JNIEnv* env, jobject client,
-                                        struct hyperdex_ds_arena* arena,
+hyperdex_java_client_convert_attributes(JNIEnv *env, jobject client,
+                                        struct hyperdex_ds_arena *arena,
                                         jobject x,
-                                        const struct hyperdex_client_attribute** _attrs,
-                                        size_t* _attrs_sz);
+                                        const struct hyperdex_client_attribute **_attrs,
+                                        size_t *_attrs_sz);
 
 int
-hyperdex_java_client_convert_key(JNIEnv* env, jobject client,
-                                 struct hyperdex_ds_arena* arena,
+hyperdex_java_client_convert_key(JNIEnv *env, jobject client,
+                                 struct hyperdex_ds_arena *arena,
                                  jobject x,
-                                 const char** key,
-                                 size_t* key_sz);
+                                 const char **key,
+                                 size_t *key_sz);
 
 int
-hyperdex_java_client_convert_predicates(JNIEnv* env, jobject client,
-                                        struct hyperdex_ds_arena* arena,
+hyperdex_java_client_convert_predicates(JNIEnv *env, jobject client,
+                                        struct hyperdex_ds_arena *arena,
                                         jobject x,
-                                        const struct hyperdex_client_attribute_check** _checks,
-                                        size_t* _checks_sz);
+                                        const struct hyperdex_client_attribute_check **_checks,
+                                        size_t *_checks_sz);
 
 int
-hyperdex_java_client_throw_exception(JNIEnv* env,
+hyperdex_java_client_throw_exception(JNIEnv *env,
                                      enum hyperdex_client_returncode _rc,
-                                     const char* message);
+                                     const char *message);
 
 struct hyperdex_java_client_deferred
 {
-    struct hyperdex_ds_arena* arena;
-    int64_t reqid;
-    enum hyperdex_client_returncode status;
-    const struct hyperdex_client_attribute* attrs;
-    size_t attrs_sz;
-    const char* description;
-    uint64_t count;
-    int finished;
-    jobject (*encode_return)(JNIEnv* env, jobject obj, struct hyperdex_java_client_deferred* d);
+	struct hyperdex_ds_arena *arena;
+	int64_t reqid;
+	enum hyperdex_client_returncode status;
+	const struct hyperdex_client_attribute *attrs;
+	size_t attrs_sz;
+	const char *description;
+	uint64_t count;
+	int finished;
+	jobject (*encode_return)(JNIEnv *env, jobject obj, struct hyperdex_java_client_deferred *d);
 };
 
 jobject
-hyperdex_java_client_deferred_encode_status_count(JNIEnv* env, jobject obj, struct hyperdex_java_client_deferred* d);
+hyperdex_java_client_deferred_encode_status_count(JNIEnv *env, jobject obj, struct hyperdex_java_client_deferred *d);
 
 jobject
-hyperdex_java_client_deferred_encode_status(JNIEnv* env, jobject obj, struct hyperdex_java_client_deferred* d);
+hyperdex_java_client_deferred_encode_status(JNIEnv *env, jobject obj, struct hyperdex_java_client_deferred *d);
 
 #endif
diff --git a/bindings/java/org/hyperdex/client/Client.java b/bindings/java/org/hyperdex/client/Client.java
index 1711bb8be..a73bad634 100644
--- a/bindings/java/org/hyperdex/client/Client.java
+++ b/bindings/java/org/hyperdex/client/Client.java
@@ -831,4 +831,9 @@ public Long count(String spacename, Map<String, Object> predicates) throws Hyper
     {
         return (Long) async_count(spacename, predicates).waitForIt();
     }
+    public native Deferred async_sum(String spacename, Map<String, Object> predicates, String sum_key) throws HyperDexClientException;
+    public Long sum(String spacename, Map<String, Object> predicates, String sum_key) throws HyperDexClientException
+    {
+        return (Long) async_sum(spacename, predicates, sum_key).waitForIt();
+    }
 }
diff --git a/bindings/java/org_hyperdex_client_Client.c b/bindings/java/org_hyperdex_client_Client.c
index 2f60143af..0f69e04dc 100644
--- a/bindings/java/org_hyperdex_client_Client.c
+++ b/bindings/java/org_hyperdex_client_Client.c
@@ -162,2105 +162,1922 @@ static jfieldID _pred_length_greater_equal_x;
 #define ERROR_CHECK_VOID() if ((*env)->ExceptionCheck(env) == JNI_TRUE) return
 
 #define REF(NAME, DEF) \
-    tmp_cls = (DEF); \
-    NAME = (jclass) (*env)->NewGlobalRef(env, tmp_cls); \
-    (*env)->DeleteLocalRef(env, tmp_cls);
+	tmp_cls = (DEF); \
+	NAME = (jclass) (*env)->NewGlobalRef(env, tmp_cls); \
+	(*env)->DeleteLocalRef(env, tmp_cls);
 
 JNIEXPORT HYPERDEX_API void JNICALL
-Java_org_hyperdex_client_Client_initialize(JNIEnv* env, jclass client)
+Java_org_hyperdex_client_Client_initialize(JNIEnv *env, jclass client)
 {
-    jclass tmp_cls;
-
-    /* cache class String */
-    REF(_string, (*env)->FindClass(env, "java/lang/String"));
-    /* cache class Document */
-    REF(_document, (*env)->FindClass(env, "org/hyperdex/client/Document"));
-    _document_init = (*env)->GetMethodID(env, _document, "<init>", "(Lorg/hyperdex/client/ByteString;)V");
-    _document_to_string = (*env)->GetMethodID(env, _document, "toString", "()Ljava/lang/String;");
-    /* cache class ByteString */
-    REF(_byte_string, (*env)->FindClass(env, "org/hyperdex/client/ByteString"));
-    _byte_string_init = (*env)->GetMethodID(env, _byte_string, "<init>", "([B)V");
-    _byte_string_get = (*env)->GetMethodID(env, _byte_string, "getBytes", "()[B");
-    _byte_string_to_string = (*env)->GetMethodID(env, _byte_string, "toString", "()Ljava/lang/String;");
-    /* cache class Boolean */
-    REF(_boolean, (*env)->FindClass(env, "java/lang/Boolean"));
-    _boolean_init = (*env)->GetMethodID(env, _boolean, "<init>", "(Z)V");
-    /* cache class Integer */
-    REF(_long, (*env)->FindClass(env, "java/lang/Long"));
-    _long_init = (*env)->GetMethodID(env, _long, "<init>", "(J)V");
-    _long_longValue = (*env)->GetMethodID(env, _long, "longValue", "()J");
-    /* cache class Integer */
-    REF(_integer, (*env)->FindClass(env, "java/lang/Integer"));
-    _integer_init = (*env)->GetMethodID(env, _integer, "<init>", "(I)V");
-    _integer_intValue = (*env)->GetMethodID(env, _integer, "intValue", "()I");
-    /* cache class Double */
-    REF(_double, (*env)->FindClass(env, "java/lang/Double"));
-    _double_init = (*env)->GetMethodID(env, _double, "<init>", "(D)V");
-    _double_doubleValue = (*env)->GetMethodID(env, _double, "doubleValue", "()D");
-    /* cache class List */
-    REF(_list, (*env)->FindClass(env, "java/util/List"));
-    _list_iterator = (*env)->GetMethodID(env, _list, "iterator", "()Ljava/util/Iterator;");
-    _list_get = (*env)->GetMethodID(env, _list, "get", "(I)Ljava/lang/Object;");
-    _list_size = (*env)->GetMethodID(env, _list, "size", "()I");
-    /* cache class ArrayList */
-    REF(_array_list, (*env)->FindClass(env, "java/util/ArrayList"));
-    _array_list_init = (*env)->GetMethodID(env, _array_list, "<init>", "()V");
-    _array_list_add = (*env)->GetMethodID(env, _array_list, "add", "(Ljava/lang/Object;)Z");
-    /* cache class Set */
-    REF(_set, (*env)->FindClass(env, "java/util/Set"));
-    _set_iterator = (*env)->GetMethodID(env, _set, "iterator", "()Ljava/util/Iterator;");
-    /* cache class HashSet */
-    REF(_hash_set, (*env)->FindClass(env, "java/util/HashSet"));
-    _hash_set_init = (*env)->GetMethodID(env, _hash_set, "<init>", "()V");
-    _hash_set_add = (*env)->GetMethodID(env, _hash_set, "add", "(Ljava/lang/Object;)Z");
-    /* cache class Map */
-    REF(_map, (*env)->FindClass(env, "java/util/Map"));
-    _map_entrySet = (*env)->GetMethodID(env, _map, "entrySet", "()Ljava/util/Set;");
-    _map_size = (*env)->GetMethodID(env, _map, "size", "()I");
-    /* cache class Map$Entry */
-    REF(_map_entry, (*env)->FindClass(env, "java/util/Map$Entry"));
-    _map_entry_getKey = (*env)->GetMethodID(env, _map_entry, "getKey", "()Ljava/lang/Object;");
-    _map_entry_getValue = (*env)->GetMethodID(env, _map_entry, "getValue", "()Ljava/lang/Object;");
-    /* cache class HashMap */
-    REF(_hash_map, (*env)->FindClass(env, "java/util/HashMap"));
-    _hash_map_init = (*env)->GetMethodID(env, _hash_map, "<init>", "()V");
-    _hash_map_put = (*env)->GetMethodID(env, _hash_map, "put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
-    /* cache class Iterator */
-    REF(_java_iterator, (*env)->FindClass(env, "java/util/Iterator"));
-    _java_iterator_hasNext = (*env)->GetMethodID(env, _java_iterator, "hasNext", "()Z");
-    _java_iterator_next = (*env)->GetMethodID(env, _java_iterator, "next", "()Ljava/lang/Object;");
-    /* cache class HyperDexException */
-    REF(_hd_except, (*env)->FindClass(env, "org/hyperdex/client/HyperDexClientException"));
-    _hd_except_init = (*env)->GetMethodID(env, _hd_except, "<init>", "(JLjava/lang/String;Ljava/lang/String;)V");
-    /* cache class Predicate */
-    REF(_predicate, (*env)->FindClass(env, "org/hyperdex/client/Predicate"));
-    _predicate_checksSize = (*env)->GetMethodID(env, _predicate, "checksSize", "()J");
-    _predicate_convertChecks = (*env)->GetMethodID(env, _predicate, "convertChecks", "(JJJ)J");
-    /* cache class Deferred */
-    REF(_deferred, (*env)->FindClass(env, "org/hyperdex/client/Deferred"));
-    _deferred_c = (*env)->GetFieldID(env, _deferred, "c", "Lorg/hyperdex/client/Client;");
-    _deferred_ptr = (*env)->GetFieldID(env, _deferred, "ptr", "J");
-    _deferred_init = (*env)->GetMethodID(env, _deferred, "<init>", "(Lorg/hyperdex/client/Client;)V");
-    _deferred_loop = (*env)->GetMethodID(env, _deferred, "loop", "()V");
-    /* cache class Iterator */
-    REF(_iterator, (*env)->FindClass(env, "org/hyperdex/client/Iterator"));
-    _iterator_c = (*env)->GetFieldID(env, _iterator, "c", "Lorg/hyperdex/client/Client;");
-    _iterator_ptr = (*env)->GetFieldID(env, _iterator, "ptr", "J");
-    _iterator_init = (*env)->GetMethodID(env, _iterator, "<init>", "(Lorg/hyperdex/client/Client;)V");
-    _iterator_appendBacklogged = (*env)->GetMethodID(env, _iterator, "appendBacklogged", "(Ljava/lang/Object;)V");
-    /* cache class Client */
-    REF(_client, (*env)->FindClass(env, "org/hyperdex/client/Client"));
-    _client_ptr = (*env)->GetFieldID(env, _client, "ptr", "J");
-    _client_add_op = (*env)->GetMethodID(env, _client, "add_op", "(JLorg/hyperdex/client/Operation;)V");
-    _client_remove_op = (*env)->GetMethodID(env, _client, "remove_op", "(J)V");
-    /* cache class LessEqual */
-    REF(_pred_less_equal, (*env)->FindClass(env, "org/hyperdex/client/LessEqual"));
-    _pred_less_equal_x = (*env)->GetFieldID(env, _pred_less_equal, "x", "Ljava/lang/Object;");
-    /* cache class GreaterEqual */
-    REF(_pred_greater_equal, (*env)->FindClass(env, "org/hyperdex/client/GreaterEqual"));
-    _pred_greater_equal_x = (*env)->GetFieldID(env, _pred_greater_equal, "x", "Ljava/lang/Object;");
-    /* cache class Range */
-    REF(_pred_range, (*env)->FindClass(env, "org/hyperdex/client/Range"));
-    _pred_range_x = (*env)->GetFieldID(env, _pred_range, "x", "Ljava/lang/Object;");
-    _pred_range_y = (*env)->GetFieldID(env, _pred_range, "y", "Ljava/lang/Object;");
-    /* cache class Regex */
-    REF(_pred_regex, (*env)->FindClass(env, "org/hyperdex/client/Regex"));
-    _pred_regex_x = (*env)->GetFieldID(env, _pred_regex, "x", "Ljava/lang/String;");
-    /* cache class LengthEquals */
-    REF(_pred_length_equals, (*env)->FindClass(env, "org/hyperdex/client/LengthEquals"));
-    _pred_length_equals_x = (*env)->GetFieldID(env, _pred_length_equals, "x", "Ljava/lang/Object;");
-    /* cache class LengthLessEqual */
-    REF(_pred_length_less_equal, (*env)->FindClass(env, "org/hyperdex/client/LengthLessEqual"));
-    _pred_length_less_equal_x = (*env)->GetFieldID(env, _pred_length_less_equal, "x", "Ljava/lang/Object;");
-    /* cache class LengthGreaterEqual */
-    REF(_pred_length_greater_equal, (*env)->FindClass(env, "org/hyperdex/client/LengthGreaterEqual"));
-    _pred_length_greater_equal_x = (*env)->GetFieldID(env, _pred_length_greater_equal, "x", "Ljava/lang/Object;");
-
-    CHECK_CACHE(_string);
-    CHECK_CACHE(_document);
-    CHECK_CACHE(_document_init);
-    CHECK_CACHE(_document_to_string);
-    CHECK_CACHE(_byte_string);
-    CHECK_CACHE(_byte_string_init);
-    CHECK_CACHE(_byte_string_get);
-    CHECK_CACHE(_byte_string_to_string);
-    CHECK_CACHE(_boolean);
-    CHECK_CACHE(_boolean_init);
-    CHECK_CACHE(_long);
-    CHECK_CACHE(_long_init);
-    CHECK_CACHE(_long_longValue);
-    CHECK_CACHE(_integer);
-    CHECK_CACHE(_integer_init);
-    CHECK_CACHE(_integer_intValue);
-    CHECK_CACHE(_double);
-    CHECK_CACHE(_double_init);
-    CHECK_CACHE(_double_doubleValue);
-    CHECK_CACHE(_list);
-    CHECK_CACHE(_list_iterator);
-    CHECK_CACHE(_list_get);
-    CHECK_CACHE(_list_size);
-    CHECK_CACHE(_array_list);
-    CHECK_CACHE(_array_list_init);
-    CHECK_CACHE(_array_list_add);
-    CHECK_CACHE(_set);
-    CHECK_CACHE(_set_iterator);
-    CHECK_CACHE(_hash_set);
-    CHECK_CACHE(_hash_set_init);
-    CHECK_CACHE(_hash_set_add);
-    CHECK_CACHE(_map);
-    CHECK_CACHE(_map_entrySet);
-    CHECK_CACHE(_map_size);
-    CHECK_CACHE(_map_entry);
-    CHECK_CACHE(_map_entry_getKey);
-    CHECK_CACHE(_map_entry_getValue);
-    CHECK_CACHE(_hash_map);
-    CHECK_CACHE(_hash_map_init);
-    CHECK_CACHE(_hash_map_put);
-    CHECK_CACHE(_java_iterator);
-    CHECK_CACHE(_java_iterator_hasNext);
-    CHECK_CACHE(_java_iterator_next);
-    CHECK_CACHE(_hd_except);
-    CHECK_CACHE(_hd_except_init);
-    CHECK_CACHE(_predicate);
-    CHECK_CACHE(_predicate_checksSize);
-    CHECK_CACHE(_predicate_convertChecks);
-    CHECK_CACHE(_deferred);
-    CHECK_CACHE(_deferred_c);
-    CHECK_CACHE(_deferred_ptr);
-    CHECK_CACHE(_deferred_init);
-    CHECK_CACHE(_deferred_loop);
-    CHECK_CACHE(_iterator);
-    CHECK_CACHE(_iterator_c);
-    CHECK_CACHE(_iterator_ptr);
-    CHECK_CACHE(_iterator_init);
-    CHECK_CACHE(_iterator_appendBacklogged);
-    CHECK_CACHE(_client);
-    CHECK_CACHE(_client_ptr);
-    CHECK_CACHE(_client_add_op);
-    CHECK_CACHE(_client_remove_op);
-    CHECK_CACHE(_pred_less_equal);
-    CHECK_CACHE(_pred_less_equal_x);
-    CHECK_CACHE(_pred_greater_equal);
-    CHECK_CACHE(_pred_greater_equal_x);
-    CHECK_CACHE(_pred_range);
-    CHECK_CACHE(_pred_range_x);
-    CHECK_CACHE(_pred_range_y);
-    CHECK_CACHE(_pred_regex);
-    CHECK_CACHE(_pred_regex_x);
-    CHECK_CACHE(_pred_length_equals);
-    CHECK_CACHE(_pred_length_equals_x);
-    CHECK_CACHE(_pred_length_less_equal);
-    CHECK_CACHE(_pred_length_less_equal_x);
-    CHECK_CACHE(_pred_length_greater_equal);
-    CHECK_CACHE(_pred_length_greater_equal_x);
-
-    (void) client;
+	jclass tmp_cls;
+	/* cache class String */
+	REF(_string, (*env)->FindClass(env, "java/lang/String"));
+	/* cache class Document */
+	REF(_document, (*env)->FindClass(env, "org/hyperdex/client/Document"));
+	_document_init = (*env)->GetMethodID(env, _document, "<init>", "(Lorg/hyperdex/client/ByteString;)V");
+	_document_to_string = (*env)->GetMethodID(env, _document, "toString", "()Ljava/lang/String;");
+	/* cache class ByteString */
+	REF(_byte_string, (*env)->FindClass(env, "org/hyperdex/client/ByteString"));
+	_byte_string_init = (*env)->GetMethodID(env, _byte_string, "<init>", "([B)V");
+	_byte_string_get = (*env)->GetMethodID(env, _byte_string, "getBytes", "()[B");
+	_byte_string_to_string = (*env)->GetMethodID(env, _byte_string, "toString", "()Ljava/lang/String;");
+	/* cache class Boolean */
+	REF(_boolean, (*env)->FindClass(env, "java/lang/Boolean"));
+	_boolean_init = (*env)->GetMethodID(env, _boolean, "<init>", "(Z)V");
+	/* cache class Integer */
+	REF(_long, (*env)->FindClass(env, "java/lang/Long"));
+	_long_init = (*env)->GetMethodID(env, _long, "<init>", "(J)V");
+	_long_longValue = (*env)->GetMethodID(env, _long, "longValue", "()J");
+	/* cache class Integer */
+	REF(_integer, (*env)->FindClass(env, "java/lang/Integer"));
+	_integer_init = (*env)->GetMethodID(env, _integer, "<init>", "(I)V");
+	_integer_intValue = (*env)->GetMethodID(env, _integer, "intValue", "()I");
+	/* cache class Double */
+	REF(_double, (*env)->FindClass(env, "java/lang/Double"));
+	_double_init = (*env)->GetMethodID(env, _double, "<init>", "(D)V");
+	_double_doubleValue = (*env)->GetMethodID(env, _double, "doubleValue", "()D");
+	/* cache class List */
+	REF(_list, (*env)->FindClass(env, "java/util/List"));
+	_list_iterator = (*env)->GetMethodID(env, _list, "iterator", "()Ljava/util/Iterator;");
+	_list_get = (*env)->GetMethodID(env, _list, "get", "(I)Ljava/lang/Object;");
+	_list_size = (*env)->GetMethodID(env, _list, "size", "()I");
+	/* cache class ArrayList */
+	REF(_array_list, (*env)->FindClass(env, "java/util/ArrayList"));
+	_array_list_init = (*env)->GetMethodID(env, _array_list, "<init>", "()V");
+	_array_list_add = (*env)->GetMethodID(env, _array_list, "add", "(Ljava/lang/Object;)Z");
+	/* cache class Set */
+	REF(_set, (*env)->FindClass(env, "java/util/Set"));
+	_set_iterator = (*env)->GetMethodID(env, _set, "iterator", "()Ljava/util/Iterator;");
+	/* cache class HashSet */
+	REF(_hash_set, (*env)->FindClass(env, "java/util/HashSet"));
+	_hash_set_init = (*env)->GetMethodID(env, _hash_set, "<init>", "()V");
+	_hash_set_add = (*env)->GetMethodID(env, _hash_set, "add", "(Ljava/lang/Object;)Z");
+	/* cache class Map */
+	REF(_map, (*env)->FindClass(env, "java/util/Map"));
+	_map_entrySet = (*env)->GetMethodID(env, _map, "entrySet", "()Ljava/util/Set;");
+	_map_size = (*env)->GetMethodID(env, _map, "size", "()I");
+	/* cache class Map$Entry */
+	REF(_map_entry, (*env)->FindClass(env, "java/util/Map$Entry"));
+	_map_entry_getKey = (*env)->GetMethodID(env, _map_entry, "getKey", "()Ljava/lang/Object;");
+	_map_entry_getValue = (*env)->GetMethodID(env, _map_entry, "getValue", "()Ljava/lang/Object;");
+	/* cache class HashMap */
+	REF(_hash_map, (*env)->FindClass(env, "java/util/HashMap"));
+	_hash_map_init = (*env)->GetMethodID(env, _hash_map, "<init>", "()V");
+	_hash_map_put = (*env)->GetMethodID(env, _hash_map, "put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
+	/* cache class Iterator */
+	REF(_java_iterator, (*env)->FindClass(env, "java/util/Iterator"));
+	_java_iterator_hasNext = (*env)->GetMethodID(env, _java_iterator, "hasNext", "()Z");
+	_java_iterator_next = (*env)->GetMethodID(env, _java_iterator, "next", "()Ljava/lang/Object;");
+	/* cache class HyperDexException */
+	REF(_hd_except, (*env)->FindClass(env, "org/hyperdex/client/HyperDexClientException"));
+	_hd_except_init = (*env)->GetMethodID(env, _hd_except, "<init>", "(JLjava/lang/String;Ljava/lang/String;)V");
+	/* cache class Predicate */
+	REF(_predicate, (*env)->FindClass(env, "org/hyperdex/client/Predicate"));
+	_predicate_checksSize = (*env)->GetMethodID(env, _predicate, "checksSize", "()J");
+	_predicate_convertChecks = (*env)->GetMethodID(env, _predicate, "convertChecks", "(JJJ)J");
+	/* cache class Deferred */
+	REF(_deferred, (*env)->FindClass(env, "org/hyperdex/client/Deferred"));
+	_deferred_c = (*env)->GetFieldID(env, _deferred, "c", "Lorg/hyperdex/client/Client;");
+	_deferred_ptr = (*env)->GetFieldID(env, _deferred, "ptr", "J");
+	_deferred_init = (*env)->GetMethodID(env, _deferred, "<init>", "(Lorg/hyperdex/client/Client;)V");
+	_deferred_loop = (*env)->GetMethodID(env, _deferred, "loop", "()V");
+	/* cache class Iterator */
+	REF(_iterator, (*env)->FindClass(env, "org/hyperdex/client/Iterator"));
+	_iterator_c = (*env)->GetFieldID(env, _iterator, "c", "Lorg/hyperdex/client/Client;");
+	_iterator_ptr = (*env)->GetFieldID(env, _iterator, "ptr", "J");
+	_iterator_init = (*env)->GetMethodID(env, _iterator, "<init>", "(Lorg/hyperdex/client/Client;)V");
+	_iterator_appendBacklogged = (*env)->GetMethodID(env, _iterator, "appendBacklogged", "(Ljava/lang/Object;)V");
+	/* cache class Client */
+	REF(_client, (*env)->FindClass(env, "org/hyperdex/client/Client"));
+	_client_ptr = (*env)->GetFieldID(env, _client, "ptr", "J");
+	_client_add_op = (*env)->GetMethodID(env, _client, "add_op", "(JLorg/hyperdex/client/Operation;)V");
+	_client_remove_op = (*env)->GetMethodID(env, _client, "remove_op", "(J)V");
+	/* cache class LessEqual */
+	REF(_pred_less_equal, (*env)->FindClass(env, "org/hyperdex/client/LessEqual"));
+	_pred_less_equal_x = (*env)->GetFieldID(env, _pred_less_equal, "x", "Ljava/lang/Object;");
+	/* cache class GreaterEqual */
+	REF(_pred_greater_equal, (*env)->FindClass(env, "org/hyperdex/client/GreaterEqual"));
+	_pred_greater_equal_x = (*env)->GetFieldID(env, _pred_greater_equal, "x", "Ljava/lang/Object;");
+	/* cache class Range */
+	REF(_pred_range, (*env)->FindClass(env, "org/hyperdex/client/Range"));
+	_pred_range_x = (*env)->GetFieldID(env, _pred_range, "x", "Ljava/lang/Object;");
+	_pred_range_y = (*env)->GetFieldID(env, _pred_range, "y", "Ljava/lang/Object;");
+	/* cache class Regex */
+	REF(_pred_regex, (*env)->FindClass(env, "org/hyperdex/client/Regex"));
+	_pred_regex_x = (*env)->GetFieldID(env, _pred_regex, "x", "Ljava/lang/String;");
+	/* cache class LengthEquals */
+	REF(_pred_length_equals, (*env)->FindClass(env, "org/hyperdex/client/LengthEquals"));
+	_pred_length_equals_x = (*env)->GetFieldID(env, _pred_length_equals, "x", "Ljava/lang/Object;");
+	/* cache class LengthLessEqual */
+	REF(_pred_length_less_equal, (*env)->FindClass(env, "org/hyperdex/client/LengthLessEqual"));
+	_pred_length_less_equal_x = (*env)->GetFieldID(env, _pred_length_less_equal, "x", "Ljava/lang/Object;");
+	/* cache class LengthGreaterEqual */
+	REF(_pred_length_greater_equal, (*env)->FindClass(env, "org/hyperdex/client/LengthGreaterEqual"));
+	_pred_length_greater_equal_x = (*env)->GetFieldID(env, _pred_length_greater_equal, "x", "Ljava/lang/Object;");
+	CHECK_CACHE(_string);
+	CHECK_CACHE(_document);
+	CHECK_CACHE(_document_init);
+	CHECK_CACHE(_document_to_string);
+	CHECK_CACHE(_byte_string);
+	CHECK_CACHE(_byte_string_init);
+	CHECK_CACHE(_byte_string_get);
+	CHECK_CACHE(_byte_string_to_string);
+	CHECK_CACHE(_boolean);
+	CHECK_CACHE(_boolean_init);
+	CHECK_CACHE(_long);
+	CHECK_CACHE(_long_init);
+	CHECK_CACHE(_long_longValue);
+	CHECK_CACHE(_integer);
+	CHECK_CACHE(_integer_init);
+	CHECK_CACHE(_integer_intValue);
+	CHECK_CACHE(_double);
+	CHECK_CACHE(_double_init);
+	CHECK_CACHE(_double_doubleValue);
+	CHECK_CACHE(_list);
+	CHECK_CACHE(_list_iterator);
+	CHECK_CACHE(_list_get);
+	CHECK_CACHE(_list_size);
+	CHECK_CACHE(_array_list);
+	CHECK_CACHE(_array_list_init);
+	CHECK_CACHE(_array_list_add);
+	CHECK_CACHE(_set);
+	CHECK_CACHE(_set_iterator);
+	CHECK_CACHE(_hash_set);
+	CHECK_CACHE(_hash_set_init);
+	CHECK_CACHE(_hash_set_add);
+	CHECK_CACHE(_map);
+	CHECK_CACHE(_map_entrySet);
+	CHECK_CACHE(_map_size);
+	CHECK_CACHE(_map_entry);
+	CHECK_CACHE(_map_entry_getKey);
+	CHECK_CACHE(_map_entry_getValue);
+	CHECK_CACHE(_hash_map);
+	CHECK_CACHE(_hash_map_init);
+	CHECK_CACHE(_hash_map_put);
+	CHECK_CACHE(_java_iterator);
+	CHECK_CACHE(_java_iterator_hasNext);
+	CHECK_CACHE(_java_iterator_next);
+	CHECK_CACHE(_hd_except);
+	CHECK_CACHE(_hd_except_init);
+	CHECK_CACHE(_predicate);
+	CHECK_CACHE(_predicate_checksSize);
+	CHECK_CACHE(_predicate_convertChecks);
+	CHECK_CACHE(_deferred);
+	CHECK_CACHE(_deferred_c);
+	CHECK_CACHE(_deferred_ptr);
+	CHECK_CACHE(_deferred_init);
+	CHECK_CACHE(_deferred_loop);
+	CHECK_CACHE(_iterator);
+	CHECK_CACHE(_iterator_c);
+	CHECK_CACHE(_iterator_ptr);
+	CHECK_CACHE(_iterator_init);
+	CHECK_CACHE(_iterator_appendBacklogged);
+	CHECK_CACHE(_client);
+	CHECK_CACHE(_client_ptr);
+	CHECK_CACHE(_client_add_op);
+	CHECK_CACHE(_client_remove_op);
+	CHECK_CACHE(_pred_less_equal);
+	CHECK_CACHE(_pred_less_equal_x);
+	CHECK_CACHE(_pred_greater_equal);
+	CHECK_CACHE(_pred_greater_equal_x);
+	CHECK_CACHE(_pred_range);
+	CHECK_CACHE(_pred_range_x);
+	CHECK_CACHE(_pred_range_y);
+	CHECK_CACHE(_pred_regex);
+	CHECK_CACHE(_pred_regex_x);
+	CHECK_CACHE(_pred_length_equals);
+	CHECK_CACHE(_pred_length_equals_x);
+	CHECK_CACHE(_pred_length_less_equal);
+	CHECK_CACHE(_pred_length_less_equal_x);
+	CHECK_CACHE(_pred_length_greater_equal);
+	CHECK_CACHE(_pred_length_greater_equal_x);
+	(void) client;
 }
 
 JNIEXPORT HYPERDEX_API void JNICALL
-Java_org_hyperdex_client_Client_terminate(JNIEnv* env, jclass client)
+Java_org_hyperdex_client_Client_terminate(JNIEnv *env, jclass client)
 {
-    (*env)->DeleteGlobalRef(env, _document);
-    (*env)->DeleteGlobalRef(env, _string);
-    (*env)->DeleteGlobalRef(env, _byte_string);
-    (*env)->DeleteGlobalRef(env, _boolean);
-    (*env)->DeleteGlobalRef(env, _long);
-    (*env)->DeleteGlobalRef(env, _integer);
-    (*env)->DeleteGlobalRef(env, _double);
-    (*env)->DeleteGlobalRef(env, _list);
-    (*env)->DeleteGlobalRef(env, _array_list);
-    (*env)->DeleteGlobalRef(env, _set);
-    (*env)->DeleteGlobalRef(env, _hash_set);
-    (*env)->DeleteGlobalRef(env, _map);
-    (*env)->DeleteGlobalRef(env, _map_entry);
-    (*env)->DeleteGlobalRef(env, _hash_map);
-    (*env)->DeleteGlobalRef(env, _java_iterator);
-    (*env)->DeleteGlobalRef(env, _hd_except);
-    (*env)->DeleteGlobalRef(env, _predicate);
-    (*env)->DeleteGlobalRef(env, _deferred);
-    (*env)->DeleteGlobalRef(env, _iterator);
-    (*env)->DeleteGlobalRef(env, _client);
-    (*env)->DeleteGlobalRef(env, _pred_less_equal);
-    (*env)->DeleteGlobalRef(env, _pred_greater_equal);
-    (*env)->DeleteGlobalRef(env, _pred_range);
-    (*env)->DeleteGlobalRef(env, _pred_regex);
-    (*env)->DeleteGlobalRef(env, _pred_length_equals);
-    (*env)->DeleteGlobalRef(env, _pred_length_less_equal);
-    (*env)->DeleteGlobalRef(env, _pred_length_greater_equal);
-
-    (void) client;
+	(*env)->DeleteGlobalRef(env, _document);
+	(*env)->DeleteGlobalRef(env, _string);
+	(*env)->DeleteGlobalRef(env, _byte_string);
+	(*env)->DeleteGlobalRef(env, _boolean);
+	(*env)->DeleteGlobalRef(env, _long);
+	(*env)->DeleteGlobalRef(env, _integer);
+	(*env)->DeleteGlobalRef(env, _double);
+	(*env)->DeleteGlobalRef(env, _list);
+	(*env)->DeleteGlobalRef(env, _array_list);
+	(*env)->DeleteGlobalRef(env, _set);
+	(*env)->DeleteGlobalRef(env, _hash_set);
+	(*env)->DeleteGlobalRef(env, _map);
+	(*env)->DeleteGlobalRef(env, _map_entry);
+	(*env)->DeleteGlobalRef(env, _hash_map);
+	(*env)->DeleteGlobalRef(env, _java_iterator);
+	(*env)->DeleteGlobalRef(env, _hd_except);
+	(*env)->DeleteGlobalRef(env, _predicate);
+	(*env)->DeleteGlobalRef(env, _deferred);
+	(*env)->DeleteGlobalRef(env, _iterator);
+	(*env)->DeleteGlobalRef(env, _client);
+	(*env)->DeleteGlobalRef(env, _pred_less_equal);
+	(*env)->DeleteGlobalRef(env, _pred_greater_equal);
+	(*env)->DeleteGlobalRef(env, _pred_range);
+	(*env)->DeleteGlobalRef(env, _pred_regex);
+	(*env)->DeleteGlobalRef(env, _pred_length_equals);
+	(*env)->DeleteGlobalRef(env, _pred_length_less_equal);
+	(*env)->DeleteGlobalRef(env, _pred_length_greater_equal);
+	(void) client;
 }
 
 /******************************* Pointer Unwrap *******************************/
 
-static struct hyperdex_client*
-hyperdex_get_client_ptr(JNIEnv* env, jobject obj)
+static struct hyperdex_client *
+hyperdex_get_client_ptr(JNIEnv *env, jobject obj)
 {
-    struct hyperdex_client* x;
-    x = (struct hyperdex_client*) (*env)->GetLongField(env, obj, _client_ptr);
-    assert(x);
-    return x;
+	struct hyperdex_client *x;
+	x = (struct hyperdex_client *) (*env)->GetLongField(env, obj, _client_ptr);
+	assert(x);
+	return x;
 }
 
-static struct hyperdex_java_client_deferred*
-hyperdex_get_deferred_ptr(JNIEnv* env, jobject obj)
+static struct hyperdex_java_client_deferred *
+hyperdex_get_deferred_ptr(JNIEnv *env, jobject obj)
 {
-    struct hyperdex_java_client_deferred* x;
-    x = (struct hyperdex_java_client_deferred*) (*env)->GetLongField(env, obj, _deferred_ptr);
-    assert(x);
-    return x;
+	struct hyperdex_java_client_deferred *x;
+	x = (struct hyperdex_java_client_deferred *) (*env)->GetLongField(env, obj, _deferred_ptr);
+	assert(x);
+	return x;
 }
 
-static struct hyperdex_java_client_iterator*
-hyperdex_get_iterator_ptr(JNIEnv* env, jobject obj)
+static struct hyperdex_java_client_iterator *
+hyperdex_get_iterator_ptr(JNIEnv *env, jobject obj)
 {
-    struct hyperdex_java_client_iterator* x;
-    x = (struct hyperdex_java_client_iterator*) (*env)->GetLongField(env, obj, _iterator_ptr);
-    assert(x);
-    return x;
+	struct hyperdex_java_client_iterator *x;
+	x = (struct hyperdex_java_client_iterator *) (*env)->GetLongField(env, obj, _iterator_ptr);
+	assert(x);
+	return x;
 }
 
 /******************************* Error Handling *******************************/
 
 static int
-hyperdex_java_out_of_memory(JNIEnv* env)
+hyperdex_java_out_of_memory(JNIEnv *env)
 {
-    jclass oom;
-    jmethodID init;
-    jobject exc;
-
-    oom  = (*env)->FindClass(env, "java/lang/OutOfMemoryError");
-    ERROR_CHECK(-1);
-    init = (*env)->GetMethodID(env, oom, "<init>", "()V");
-    ERROR_CHECK(-1);
-    exc = (*env)->NewObject(env, oom, init);
-    ERROR_CHECK(-1);
-
-    (*env)->ExceptionClear(env);
-    (*env)->Throw(env, exc);
-    return -1;
+	jclass oom;
+	jmethodID init;
+	jobject exc;
+	oom  = (*env)->FindClass(env, "java/lang/OutOfMemoryError");
+	ERROR_CHECK(-1);
+	init = (*env)->GetMethodID(env, oom, "<init>", "()V");
+	ERROR_CHECK(-1);
+	exc = (*env)->NewObject(env, oom, init);
+	ERROR_CHECK(-1);
+	(*env)->ExceptionClear(env);
+	(*env)->Throw(env, exc);
+	return -1;
 }
 
 static jobject
-hyperdex_java_client_create_exception(JNIEnv* env,
+hyperdex_java_client_create_exception(JNIEnv *env,
                                       enum hyperdex_client_returncode _rc,
-                                      const char* message)
+                                      const char *message)
 {
-    jlong rc = _rc;
-    jstring str = (*env)->NewStringUTF(env, hyperdex_client_returncode_to_string(_rc));
-    jstring msg = (*env)->NewStringUTF(env, message);
-    jobject err = (*env)->NewObject(env, _hd_except, _hd_except_init, rc, str, msg);
-    ERROR_CHECK(0);
-    return err;
+	jlong rc = _rc;
+	jstring str = (*env)->NewStringUTF(env, hyperdex_client_returncode_to_string(_rc));
+	jstring msg = (*env)->NewStringUTF(env, message);
+	jobject err = (*env)->NewObject(env, _hd_except, _hd_except_init, rc, str, msg);
+	ERROR_CHECK(0);
+	return err;
 }
 
 int
-hyperdex_java_client_throw_exception(JNIEnv* env,
+hyperdex_java_client_throw_exception(JNIEnv *env,
                                      enum hyperdex_client_returncode _rc,
-                                     const char* message)
+                                     const char *message)
 {
-    jobject err = hyperdex_java_client_create_exception(env, _rc, message);
-    ERROR_CHECK(-1);
-    (*env)->ExceptionClear(env);
-    return (*env)->Throw(env, err);
+	jobject err = hyperdex_java_client_create_exception(env, _rc, message);
+	ERROR_CHECK(-1);
+	(*env)->ExceptionClear(env);
+	return (*env)->Throw(env, err);
 }
 
 /********************************** Java -> C *********************************/
-typedef int (*elem_string_fptr)(void*, const char*, size_t, enum hyperdex_ds_returncode*);
-typedef int (*elem_int_fptr)(void*, int64_t, enum hyperdex_ds_returncode*);
-typedef int (*elem_float_fptr)(void*, double, enum hyperdex_ds_returncode*);
+typedef int (*elem_string_fptr)(void *, const char *, size_t, enum hyperdex_ds_returncode *);
+typedef int (*elem_int_fptr)(void *, int64_t, enum hyperdex_ds_returncode *);
+typedef int (*elem_float_fptr)(void *, double, enum hyperdex_ds_returncode *);
 
 #define HDJAVA_HANDLE_ELEM_ERROR(X, TYPE) \
-    switch (X) \
-    { \
-        case HYPERDEX_DS_NOMEM: \
-            hyperdex_java_out_of_memory(env); \
-            return -1; \
-        case HYPERDEX_DS_MIXED_TYPES: \
-            hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_WRONGTYPE, "Cannot add " TYPE " to a heterogenous container"); \
-            return -1; \
-        case HYPERDEX_DS_SUCCESS: \
-        case HYPERDEX_DS_STRING_TOO_LONG: \
-        case HYPERDEX_DS_WRONG_STATE: \
-        default: \
-            hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_WRONGTYPE, "Cannot convert " TYPE " to a HyperDex type"); \
-            return -1; \
-    }
+	switch (X) \
+	{ \
+	case HYPERDEX_DS_NOMEM: \
+		hyperdex_java_out_of_memory(env); \
+		return -1; \
+	case HYPERDEX_DS_MIXED_TYPES: \
+		hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_WRONGTYPE, "Cannot add " TYPE " to a heterogenous container"); \
+		return -1; \
+	case HYPERDEX_DS_SUCCESS: \
+	case HYPERDEX_DS_STRING_TOO_LONG: \
+	case HYPERDEX_DS_WRONG_STATE: \
+	default: \
+		hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_WRONGTYPE, "Cannot convert " TYPE " to a HyperDex type"); \
+		return -1; \
+	}
 
 /* Convert a single elment of a list, map, or set*/
 static int
-hyperdex_java_client_convert_elem(JNIEnv* env,
+hyperdex_java_client_convert_elem(JNIEnv *env,
                                   jobject obj,
-                                  void* container,
+                                  void *container,
                                   elem_string_fptr f_string,
                                   elem_int_fptr f_int,
                                   elem_float_fptr f_float)
 {
-    enum hyperdex_ds_returncode error;
-    int success;
-    const char* tmp_str;
-    size_t tmp_str_sz;
-    jbyte* tmp_bytes;
-    size_t tmp_bytes_sz;
-    int64_t tmp_l;
-    int32_t tmp_i;
-    double tmp_d;
-
-    if ((*env)->IsInstanceOf(env, obj, _string) == JNI_TRUE)
-    {
-        tmp_str = (*env)->GetStringUTFChars(env, obj, 0);
-        ERROR_CHECK(-1);
-        tmp_str_sz = (*env)->GetStringUTFLength(env, obj);
-        ERROR_CHECK(-1);
-        success = f_string(container, tmp_str, tmp_str_sz, &error);
-        (*env)->ReleaseStringUTFChars(env, obj, tmp_str);
-        ERROR_CHECK(-1);
-
-        if (success < 0)
-        {
-            HDJAVA_HANDLE_ELEM_ERROR(error, "string");
-        }
-
-        return 0;
-    }
-    else if ((*env)->IsInstanceOf(env, obj, _byte_string) == JNI_TRUE)
-    {
-        obj = (*env)->CallObjectMethod(env, obj, _byte_string_get);
-        ERROR_CHECK(-1);
-        tmp_bytes = (*env)->GetByteArrayElements(env, obj, 0);
-        ERROR_CHECK(-1);
-        tmp_bytes_sz = (*env)->GetArrayLength(env, obj);
-        ERROR_CHECK(-1);
-        success = f_string(container, (const char*)tmp_bytes, tmp_bytes_sz, &error);
-        (*env)->ReleaseByteArrayElements(env, obj, tmp_bytes, 0);
-        ERROR_CHECK(-1);
-
-        if (success < 0)
-        {
-            HDJAVA_HANDLE_ELEM_ERROR(error, "bytes");
-        }
-
-        return 0;
-    }
-    else if ((*env)->IsInstanceOf(env, obj, _long) == JNI_TRUE)
-    {
-        tmp_l = (*env)->CallLongMethod(env, obj, _long_longValue);
-        ERROR_CHECK(-1);
-
-        if (f_int(container, tmp_l, &error) < 0)
-        {
-            HDJAVA_HANDLE_ELEM_ERROR(error, "long");
-        }
-
-        return 0;
-    }
-    else if ((*env)->IsInstanceOf(env, obj, _integer) == JNI_TRUE)
-    {
-        tmp_i = (*env)->CallIntMethod(env, obj, _integer_intValue);
-        ERROR_CHECK(-1);
-
-        if (f_int(container, tmp_i, &error) < 0)
-        {
-            HDJAVA_HANDLE_ELEM_ERROR(error, "int");
-        }
-
-        return 0;
-    }
-    else if ((*env)->IsInstanceOf(env, obj, _double) == JNI_TRUE)
-    {
-        tmp_d = (*env)->CallDoubleMethod(env, obj, _double_doubleValue);
-        ERROR_CHECK(-1);
-
-        if (f_float(container, tmp_d, &error) < 0)
-        {
-            HDJAVA_HANDLE_ELEM_ERROR(error, "float");
-        }
-
-        return 0;
-    }
-    else
-    {
-        hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_WRONGTYPE,
-                                             "Cannot convert unknown type to a HyperDex type");
-        return -1;
-    }
+	enum hyperdex_ds_returncode error;
+	int success;
+	const char *tmp_str;
+	size_t tmp_str_sz;
+	jbyte *tmp_bytes;
+	size_t tmp_bytes_sz;
+	int64_t tmp_l;
+	int32_t tmp_i;
+	double tmp_d;
+	if ((*env)->IsInstanceOf(env, obj, _string) == JNI_TRUE)
+	{
+		tmp_str = (*env)->GetStringUTFChars(env, obj, 0);
+		ERROR_CHECK(-1);
+		tmp_str_sz = (*env)->GetStringUTFLength(env, obj);
+		ERROR_CHECK(-1);
+		success = f_string(container, tmp_str, tmp_str_sz, &error);
+		(*env)->ReleaseStringUTFChars(env, obj, tmp_str);
+		ERROR_CHECK(-1);
+		if (success < 0)
+		{
+			HDJAVA_HANDLE_ELEM_ERROR(error, "string");
+		}
+		return 0;
+	}
+	else if ((*env)->IsInstanceOf(env, obj, _byte_string) == JNI_TRUE)
+	{
+		obj = (*env)->CallObjectMethod(env, obj, _byte_string_get);
+		ERROR_CHECK(-1);
+		tmp_bytes = (*env)->GetByteArrayElements(env, obj, 0);
+		ERROR_CHECK(-1);
+		tmp_bytes_sz = (*env)->GetArrayLength(env, obj);
+		ERROR_CHECK(-1);
+		success = f_string(container, (const char *)tmp_bytes, tmp_bytes_sz, &error);
+		(*env)->ReleaseByteArrayElements(env, obj, tmp_bytes, 0);
+		ERROR_CHECK(-1);
+		if (success < 0)
+		{
+			HDJAVA_HANDLE_ELEM_ERROR(error, "bytes");
+		}
+		return 0;
+	}
+	else if ((*env)->IsInstanceOf(env, obj, _long) == JNI_TRUE)
+	{
+		tmp_l = (*env)->CallLongMethod(env, obj, _long_longValue);
+		ERROR_CHECK(-1);
+		if (f_int(container, tmp_l, &error) < 0)
+		{
+			HDJAVA_HANDLE_ELEM_ERROR(error, "long");
+		}
+		return 0;
+	}
+	else if ((*env)->IsInstanceOf(env, obj, _integer) == JNI_TRUE)
+	{
+		tmp_i = (*env)->CallIntMethod(env, obj, _integer_intValue);
+		ERROR_CHECK(-1);
+		if (f_int(container, tmp_i, &error) < 0)
+		{
+			HDJAVA_HANDLE_ELEM_ERROR(error, "int");
+		}
+		return 0;
+	}
+	else if ((*env)->IsInstanceOf(env, obj, _double) == JNI_TRUE)
+	{
+		tmp_d = (*env)->CallDoubleMethod(env, obj, _double_doubleValue);
+		ERROR_CHECK(-1);
+		if (f_float(container, tmp_d, &error) < 0)
+		{
+			HDJAVA_HANDLE_ELEM_ERROR(error, "float");
+		}
+		return 0;
+	}
+	else
+	{
+		hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_WRONGTYPE,
+		                                     "Cannot convert unknown type to a HyperDex type");
+		return -1;
+	}
 }
 
 static int
-hyperdex_java_client_convert_list(JNIEnv* env,
-                                  struct hyperdex_ds_arena* arena,
+hyperdex_java_client_convert_list(JNIEnv *env,
+                                  struct hyperdex_ds_arena *arena,
                                   jobject x,
-                                  const char** value,
-                                  size_t* value_sz,
-                                  enum hyperdatatype* datatype)
+                                  const char **value,
+                                  size_t *value_sz,
+                                  enum hyperdatatype *datatype)
 {
-    struct hyperdex_ds_list* list;
-    enum hyperdex_ds_returncode error;
-    jobject entry;
-    jobject it = (*env)->CallObjectMethod(env, x, _list_iterator);
-    ERROR_CHECK(-1);
-
-    list = hyperdex_ds_allocate_list(arena);
-
-    if (!list)
-    {
-        hyperdex_java_out_of_memory(env);
-        return -1;
-    }
-
-    while ((*env)->CallBooleanMethod(env, it, _java_iterator_hasNext) == JNI_TRUE)
-    {
-        entry = (*env)->CallObjectMethod(env, it, _java_iterator_next);
-        ERROR_CHECK(-1);
-
-        if (hyperdex_java_client_convert_elem(env, entry, list,
-                    (elem_string_fptr) hyperdex_ds_list_append_string,
-                    (elem_int_fptr) hyperdex_ds_list_append_int,
-                    (elem_float_fptr) hyperdex_ds_list_append_float) < 0)
-        {
-            return -1;
-        }
-
-        (*env)->DeleteLocalRef(env, entry);
-    }
-
-    if (hyperdex_ds_list_finalize(list, &error, value, value_sz, datatype) < 0)
-    {
-        hyperdex_java_out_of_memory(env);
-        return -1;
-    }
-
-    (*env)->DeleteLocalRef(env, it);
-    return 0;
+	struct hyperdex_ds_list *list;
+	enum hyperdex_ds_returncode error;
+	jobject entry;
+	jobject it = (*env)->CallObjectMethod(env, x, _list_iterator);
+	ERROR_CHECK(-1);
+	list = hyperdex_ds_allocate_list(arena);
+	if (!list)
+	{
+		hyperdex_java_out_of_memory(env);
+		return -1;
+	}
+	while ((*env)->CallBooleanMethod(env, it, _java_iterator_hasNext) == JNI_TRUE)
+	{
+		entry = (*env)->CallObjectMethod(env, it, _java_iterator_next);
+		ERROR_CHECK(-1);
+		if (hyperdex_java_client_convert_elem(env, entry, list,
+		                                      (elem_string_fptr) hyperdex_ds_list_append_string,
+		                                      (elem_int_fptr) hyperdex_ds_list_append_int,
+		                                      (elem_float_fptr) hyperdex_ds_list_append_float) < 0)
+		{
+			return -1;
+		}
+		(*env)->DeleteLocalRef(env, entry);
+	}
+	if (hyperdex_ds_list_finalize(list, &error, value, value_sz, datatype) < 0)
+	{
+		hyperdex_java_out_of_memory(env);
+		return -1;
+	}
+	(*env)->DeleteLocalRef(env, it);
+	return 0;
 }
 
 static int
-hyperdex_java_client_convert_set(JNIEnv* env,
-                                 struct hyperdex_ds_arena* arena,
+hyperdex_java_client_convert_set(JNIEnv *env,
+                                 struct hyperdex_ds_arena *arena,
                                  jobject x,
-                                 const char** value,
-                                 size_t* value_sz,
-                                 enum hyperdatatype* datatype)
+                                 const char **value,
+                                 size_t *value_sz,
+                                 enum hyperdatatype *datatype)
 {
-    struct hyperdex_ds_set* set;
-    enum hyperdex_ds_returncode error;
-    jobject it = (*env)->CallObjectMethod(env, x, _set_iterator);
-    jobject entry;
-    ERROR_CHECK(-1);
-
-    set = hyperdex_ds_allocate_set(arena);
-
-    if (!set)
-    {
-        hyperdex_java_out_of_memory(env);
-        return -1;
-    }
-
-    while ((*env)->CallBooleanMethod(env, it, _java_iterator_hasNext) == JNI_TRUE)
-    {
-        entry = (*env)->CallObjectMethod(env, it, _java_iterator_next);
-        ERROR_CHECK(-1);
-
-        if (hyperdex_java_client_convert_elem(env, entry, set,
-                    (elem_string_fptr) hyperdex_ds_set_insert_string,
-                    (elem_int_fptr) hyperdex_ds_set_insert_int,
-                    (elem_float_fptr) hyperdex_ds_set_insert_float) < 0)
-        {
-            return -1;
-        }
-
-        (*env)->DeleteLocalRef(env, entry);
-    }
-
-    if (hyperdex_ds_set_finalize(set, &error, value, value_sz, datatype) < 0)
-    {
-        hyperdex_java_out_of_memory(env);
-        return -1;
-    }
-
-    (*env)->DeleteLocalRef(env, it);
-    return 0;
+	struct hyperdex_ds_set *set;
+	enum hyperdex_ds_returncode error;
+	jobject it = (*env)->CallObjectMethod(env, x, _set_iterator);
+	jobject entry;
+	ERROR_CHECK(-1);
+	set = hyperdex_ds_allocate_set(arena);
+	if (!set)
+	{
+		hyperdex_java_out_of_memory(env);
+		return -1;
+	}
+	while ((*env)->CallBooleanMethod(env, it, _java_iterator_hasNext) == JNI_TRUE)
+	{
+		entry = (*env)->CallObjectMethod(env, it, _java_iterator_next);
+		ERROR_CHECK(-1);
+		if (hyperdex_java_client_convert_elem(env, entry, set,
+		                                      (elem_string_fptr) hyperdex_ds_set_insert_string,
+		                                      (elem_int_fptr) hyperdex_ds_set_insert_int,
+		                                      (elem_float_fptr) hyperdex_ds_set_insert_float) < 0)
+		{
+			return -1;
+		}
+		(*env)->DeleteLocalRef(env, entry);
+	}
+	if (hyperdex_ds_set_finalize(set, &error, value, value_sz, datatype) < 0)
+	{
+		hyperdex_java_out_of_memory(env);
+		return -1;
+	}
+	(*env)->DeleteLocalRef(env, it);
+	return 0;
 }
 
 static int
-hyperdex_java_client_convert_map(JNIEnv* env,
-                                 struct hyperdex_ds_arena* arena,
+hyperdex_java_client_convert_map(JNIEnv *env,
+                                 struct hyperdex_ds_arena *arena,
                                  jobject x,
-                                 const char** value,
-                                 size_t* value_sz,
-                                 enum hyperdatatype* datatype)
+                                 const char **value,
+                                 size_t *value_sz,
+                                 enum hyperdatatype *datatype)
 {
-    struct hyperdex_ds_map* map;
-    enum hyperdex_ds_returncode error;
-    jobject set;
-    jobject it;
-    jobject entry;
-    jobject key;
-    jobject val;
-
-    set = (*env)->CallObjectMethod(env, x, _map_entrySet);
-    ERROR_CHECK(-1);
-    it = (*env)->CallObjectMethod(env, set, _set_iterator);
-    ERROR_CHECK(-1);
-
-    map = hyperdex_ds_allocate_map(arena);
-
-    if (!map)
-    {
-        return hyperdex_java_out_of_memory(env);
-    }
-
-    while ((*env)->CallBooleanMethod(env, it, _java_iterator_hasNext) == JNI_TRUE)
-    {
-        entry = (*env)->CallObjectMethod(env, it, _java_iterator_next);
-        ERROR_CHECK(-1);
-        key = (*env)->CallObjectMethod(env, entry, _map_entry_getKey);
-        ERROR_CHECK(-1);
-        val = (*env)->CallObjectMethod(env, entry, _map_entry_getValue);
-        ERROR_CHECK(-1);
-
-        if (hyperdex_java_client_convert_elem(env, key, map,
-                    (elem_string_fptr) hyperdex_ds_map_insert_key_string,
-                    (elem_int_fptr) hyperdex_ds_map_insert_key_int,
-                    (elem_float_fptr) hyperdex_ds_map_insert_key_float) < 0)
-        {
-            return -1;
-        }
-
-        if (hyperdex_java_client_convert_elem(env, val, map,
-                    (elem_string_fptr) hyperdex_ds_map_insert_val_string,
-                    (elem_int_fptr) hyperdex_ds_map_insert_val_int,
-                    (elem_float_fptr) hyperdex_ds_map_insert_val_float) < 0)
-        {
-            return -1;
-        }
-
-        (*env)->DeleteLocalRef(env, entry);
-        (*env)->DeleteLocalRef(env, key);
-        (*env)->DeleteLocalRef(env, val);
-    }
-
-    if (hyperdex_ds_map_finalize(map, &error, value, value_sz, datatype) < 0)
-    {
-        hyperdex_java_out_of_memory(env);
-        return -1;
-    }
-
-    (*env)->DeleteLocalRef(env, it);
-    (*env)->DeleteLocalRef(env, set);
-    return 0;
+	struct hyperdex_ds_map *map;
+	enum hyperdex_ds_returncode error;
+	jobject set;
+	jobject it;
+	jobject entry;
+	jobject key;
+	jobject val;
+	set = (*env)->CallObjectMethod(env, x, _map_entrySet);
+	ERROR_CHECK(-1);
+	it = (*env)->CallObjectMethod(env, set, _set_iterator);
+	ERROR_CHECK(-1);
+	map = hyperdex_ds_allocate_map(arena);
+	if (!map)
+	{
+		return hyperdex_java_out_of_memory(env);
+	}
+	while ((*env)->CallBooleanMethod(env, it, _java_iterator_hasNext) == JNI_TRUE)
+	{
+		entry = (*env)->CallObjectMethod(env, it, _java_iterator_next);
+		ERROR_CHECK(-1);
+		key = (*env)->CallObjectMethod(env, entry, _map_entry_getKey);
+		ERROR_CHECK(-1);
+		val = (*env)->CallObjectMethod(env, entry, _map_entry_getValue);
+		ERROR_CHECK(-1);
+		if (hyperdex_java_client_convert_elem(env, key, map,
+		                                      (elem_string_fptr) hyperdex_ds_map_insert_key_string,
+		                                      (elem_int_fptr) hyperdex_ds_map_insert_key_int,
+		                                      (elem_float_fptr) hyperdex_ds_map_insert_key_float) < 0)
+		{
+			return -1;
+		}
+		if (hyperdex_java_client_convert_elem(env, val, map,
+		                                      (elem_string_fptr) hyperdex_ds_map_insert_val_string,
+		                                      (elem_int_fptr) hyperdex_ds_map_insert_val_int,
+		                                      (elem_float_fptr) hyperdex_ds_map_insert_val_float) < 0)
+		{
+			return -1;
+		}
+		(*env)->DeleteLocalRef(env, entry);
+		(*env)->DeleteLocalRef(env, key);
+		(*env)->DeleteLocalRef(env, val);
+	}
+	if (hyperdex_ds_map_finalize(map, &error, value, value_sz, datatype) < 0)
+	{
+		hyperdex_java_out_of_memory(env);
+		return -1;
+	}
+	(*env)->DeleteLocalRef(env, it);
+	(*env)->DeleteLocalRef(env, set);
+	return 0;
 }
 
 static int
-hyperdex_java_client_convert_type(JNIEnv* env,
-                                  struct hyperdex_ds_arena* arena,
+hyperdex_java_client_convert_type(JNIEnv *env,
+                                  struct hyperdex_ds_arena *arena,
                                   jobject x,
-                                  const char** value,
-                                  size_t* value_sz,
-                                  enum hyperdatatype* datatype)
+                                  const char **value,
+                                  size_t *value_sz,
+                                  enum hyperdatatype *datatype)
 {
-    enum hyperdex_ds_returncode error;
-    int success;
-    const char* tmp_str;
-    size_t tmp_str_sz;
-    jbyte* tmp_bytes;
-    size_t tmp_bytes_sz;
-    int64_t tmp_l;
-    int32_t tmp_i;
-    double tmp_d;
-
-    if (x == NULL)
-    {
-        *value = "";
-        *value_sz = 0;
-        *datatype = HYPERDATATYPE_GENERIC;
-        return 0;
-    }
-    else if ((*env)->IsInstanceOf(env, x, _document) == JNI_TRUE)
-    {
-        x = (*env)->CallObjectMethod(env, x, _document_to_string);
-        tmp_str = (*env)->GetStringUTFChars(env, x, 0);
-        ERROR_CHECK(-1);
-        tmp_str_sz = (*env)->GetStringUTFLength(env, x);
-        ERROR_CHECK(-1);
-        success = hyperdex_ds_copy_string(arena, tmp_str, tmp_str_sz,
-                                          &error, value, value_sz);
-        (*env)->ReleaseStringUTFChars(env, x, tmp_str);
-        ERROR_CHECK(-1);
-        *datatype = HYPERDATATYPE_DOCUMENT;
-
-        if (success < 0)
-        {
-            hyperdex_java_out_of_memory(env);
-            return -1;
-        }
-
-        return 0;
-    }
-    else if ((*env)->IsInstanceOf(env, x, _string) == JNI_TRUE)
-    {
-        tmp_str = (*env)->GetStringUTFChars(env, x, 0);
-        ERROR_CHECK(-1);
-        tmp_str_sz = (*env)->GetStringUTFLength(env, x);
-        ERROR_CHECK(-1);
-        success = hyperdex_ds_copy_string(arena, tmp_str, tmp_str_sz,
-                                          &error, value, value_sz);
-        (*env)->ReleaseStringUTFChars(env, x, tmp_str);
-        ERROR_CHECK(-1);
-        *datatype = HYPERDATATYPE_STRING;
-
-        if (success < 0)
-        {
-            hyperdex_java_out_of_memory(env);
-            return -1;
-        }
-
-        return 0;
-    }
-    else if ((*env)->IsInstanceOf(env, x, _byte_string) == JNI_TRUE)
-    {
-        x = (*env)->CallObjectMethod(env, x, _byte_string_get);
-        tmp_bytes = (*env)->GetByteArrayElements(env, x, 0);
-        ERROR_CHECK(-1);
-        tmp_bytes_sz = (*env)->GetArrayLength(env, x);
-        ERROR_CHECK(-1);
-        success = hyperdex_ds_copy_string(arena, (const char*)tmp_bytes, tmp_bytes_sz,
-                                          &error, value, value_sz);
-        (*env)->ReleaseByteArrayElements(env, x, tmp_bytes, 0);
-        ERROR_CHECK(-1);
-        *datatype = HYPERDATATYPE_STRING;
-
-        if (success < 0)
-        {
-            hyperdex_java_out_of_memory(env);
-            return -1;
-        }
-
-        return 0;
-    }
-    else if ((*env)->IsInstanceOf(env, x, _long) == JNI_TRUE)
-    {
-        tmp_l = (*env)->CallLongMethod(env, x, _long_longValue);
-        ERROR_CHECK(-1);
-
-        if (hyperdex_ds_copy_int(arena, tmp_l, &error, value, value_sz) < 0)
-        {
-            hyperdex_java_out_of_memory(env);
-            return -1;
-        }
-
-        *datatype = HYPERDATATYPE_INT64;
-        return 0;
-    }
-    else if ((*env)->IsInstanceOf(env, x, _integer) == JNI_TRUE)
-    {
-        tmp_i = (*env)->CallIntMethod(env, x, _integer_intValue);
-        ERROR_CHECK(-1);
-
-        if (hyperdex_ds_copy_int(arena, tmp_i, &error, value, value_sz) < 0)
-        {
-            hyperdex_java_out_of_memory(env);
-            return -1;
-        }
-
-        *datatype = HYPERDATATYPE_INT64;
-        return 0;
-    }
-    else if ((*env)->IsInstanceOf(env, x, _double) == JNI_TRUE)
-    {
-        tmp_d = (*env)->CallDoubleMethod(env, x, _double_doubleValue);
-        ERROR_CHECK(-1);
-
-        if (hyperdex_ds_copy_float(arena, tmp_d, &error, value, value_sz) < 0)
-        {
-            hyperdex_java_out_of_memory(env);
-            return -1;
-        }
-
-        *datatype = HYPERDATATYPE_FLOAT;
-        return 0;
-    }
-    else if ((*env)->IsInstanceOf(env, x, _list) == JNI_TRUE)
-    {
-        return hyperdex_java_client_convert_list(env, arena, x,
-                                                 value, value_sz, datatype);
-    }
-    else if ((*env)->IsInstanceOf(env, x, _set) == JNI_TRUE)
-    {
-        return hyperdex_java_client_convert_set(env, arena, x,
-                                                value, value_sz, datatype);
-    }
-    else if ((*env)->IsInstanceOf(env, x, _map) == JNI_TRUE)
-    {
-        return hyperdex_java_client_convert_map(env, arena, x,
-                                                value, value_sz, datatype);
-    }
-    else
-    {
-        hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_WRONGTYPE,
-                                             "Cannot convert unknown type to a HyperDex type");
-        return -1;
-    }
+	enum hyperdex_ds_returncode error;
+	int success;
+	const char *tmp_str;
+	size_t tmp_str_sz;
+	jbyte *tmp_bytes;
+	size_t tmp_bytes_sz;
+	int64_t tmp_l;
+	int32_t tmp_i;
+	double tmp_d;
+	if (x == NULL)
+	{
+		*value = "";
+		*value_sz = 0;
+		*datatype = HYPERDATATYPE_GENERIC;
+		return 0;
+	}
+	else if ((*env)->IsInstanceOf(env, x, _document) == JNI_TRUE)
+	{
+		x = (*env)->CallObjectMethod(env, x, _document_to_string);
+		tmp_str = (*env)->GetStringUTFChars(env, x, 0);
+		ERROR_CHECK(-1);
+		tmp_str_sz = (*env)->GetStringUTFLength(env, x);
+		ERROR_CHECK(-1);
+		success = hyperdex_ds_copy_string(arena, tmp_str, tmp_str_sz,
+		                                  &error, value, value_sz);
+		(*env)->ReleaseStringUTFChars(env, x, tmp_str);
+		ERROR_CHECK(-1);
+		*datatype = HYPERDATATYPE_DOCUMENT;
+		if (success < 0)
+		{
+			hyperdex_java_out_of_memory(env);
+			return -1;
+		}
+		return 0;
+	}
+	else if ((*env)->IsInstanceOf(env, x, _string) == JNI_TRUE)
+	{
+		tmp_str = (*env)->GetStringUTFChars(env, x, 0);
+		ERROR_CHECK(-1);
+		tmp_str_sz = (*env)->GetStringUTFLength(env, x);
+		ERROR_CHECK(-1);
+		success = hyperdex_ds_copy_string(arena, tmp_str, tmp_str_sz,
+		                                  &error, value, value_sz);
+		(*env)->ReleaseStringUTFChars(env, x, tmp_str);
+		ERROR_CHECK(-1);
+		*datatype = HYPERDATATYPE_STRING;
+		if (success < 0)
+		{
+			hyperdex_java_out_of_memory(env);
+			return -1;
+		}
+		return 0;
+	}
+	else if ((*env)->IsInstanceOf(env, x, _byte_string) == JNI_TRUE)
+	{
+		x = (*env)->CallObjectMethod(env, x, _byte_string_get);
+		tmp_bytes = (*env)->GetByteArrayElements(env, x, 0);
+		ERROR_CHECK(-1);
+		tmp_bytes_sz = (*env)->GetArrayLength(env, x);
+		ERROR_CHECK(-1);
+		success = hyperdex_ds_copy_string(arena, (const char *)tmp_bytes, tmp_bytes_sz,
+		                                  &error, value, value_sz);
+		(*env)->ReleaseByteArrayElements(env, x, tmp_bytes, 0);
+		ERROR_CHECK(-1);
+		*datatype = HYPERDATATYPE_STRING;
+		if (success < 0)
+		{
+			hyperdex_java_out_of_memory(env);
+			return -1;
+		}
+		return 0;
+	}
+	else if ((*env)->IsInstanceOf(env, x, _long) == JNI_TRUE)
+	{
+		tmp_l = (*env)->CallLongMethod(env, x, _long_longValue);
+		ERROR_CHECK(-1);
+		if (hyperdex_ds_copy_int(arena, tmp_l, &error, value, value_sz) < 0)
+		{
+			hyperdex_java_out_of_memory(env);
+			return -1;
+		}
+		*datatype = HYPERDATATYPE_INT64;
+		return 0;
+	}
+	else if ((*env)->IsInstanceOf(env, x, _integer) == JNI_TRUE)
+	{
+		tmp_i = (*env)->CallIntMethod(env, x, _integer_intValue);
+		ERROR_CHECK(-1);
+		if (hyperdex_ds_copy_int(arena, tmp_i, &error, value, value_sz) < 0)
+		{
+			hyperdex_java_out_of_memory(env);
+			return -1;
+		}
+		*datatype = HYPERDATATYPE_INT64;
+		return 0;
+	}
+	else if ((*env)->IsInstanceOf(env, x, _double) == JNI_TRUE)
+	{
+		tmp_d = (*env)->CallDoubleMethod(env, x, _double_doubleValue);
+		ERROR_CHECK(-1);
+		if (hyperdex_ds_copy_float(arena, tmp_d, &error, value, value_sz) < 0)
+		{
+			hyperdex_java_out_of_memory(env);
+			return -1;
+		}
+		*datatype = HYPERDATATYPE_FLOAT;
+		return 0;
+	}
+	else if ((*env)->IsInstanceOf(env, x, _list) == JNI_TRUE)
+	{
+		return hyperdex_java_client_convert_list(env, arena, x,
+		                                         value, value_sz, datatype);
+	}
+	else if ((*env)->IsInstanceOf(env, x, _set) == JNI_TRUE)
+	{
+		return hyperdex_java_client_convert_set(env, arena, x,
+		                                        value, value_sz, datatype);
+	}
+	else if ((*env)->IsInstanceOf(env, x, _map) == JNI_TRUE)
+	{
+		return hyperdex_java_client_convert_map(env, arena, x,
+		                                        value, value_sz, datatype);
+	}
+	else
+	{
+		hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_WRONGTYPE,
+		                                     "Cannot convert unknown type to a HyperDex type");
+		return -1;
+	}
 }
 
 int
-hyperdex_java_client_convert_key(JNIEnv* env, jobject client,
-                                 struct hyperdex_ds_arena* arena,
+hyperdex_java_client_convert_key(JNIEnv *env, jobject client,
+                                 struct hyperdex_ds_arena *arena,
                                  jobject x,
-                                 const char** key,
-                                 size_t* key_sz)
+                                 const char **key,
+                                 size_t *key_sz)
 {
-    enum hyperdatatype datatype;
-    (void)client;
-    return hyperdex_java_client_convert_type(env, arena, x, key, key_sz, &datatype);
+	enum hyperdatatype datatype;
+	(void)client;
+	return hyperdex_java_client_convert_type(env, arena, x, key, key_sz, &datatype);
 }
 
 static int
-hyperdex_java_client_convert_limit(JNIEnv* env, jobject client,
-                                   struct hyperdex_ds_arena* arena,
+hyperdex_java_client_convert_limit(JNIEnv *env, jobject client,
+                                   struct hyperdex_ds_arena *arena,
                                    jint x,
-                                   uint64_t* limit)
+                                   uint64_t *limit)
 {
-    *limit = x;
-    (void)env;
-    (void)client;
-    (void)arena;
-    return 0;
+	*limit = x;
+	(void)env;
+	(void)client;
+	(void)arena;
+	return 0;
 }
 
 static int
-hyperdex_java_client_convert_maxmin(JNIEnv* env, jobject client,
-                                    struct hyperdex_ds_arena* arena,
+hyperdex_java_client_convert_maxmin(JNIEnv *env, jobject client,
+                                    struct hyperdex_ds_arena *arena,
                                     jboolean x,
-                                    int* maxmin)
+                                    int *maxmin)
 {
-    *maxmin = x == JNI_TRUE ? 1 : 0;
-    (void)env;
-    (void)client;
-    (void)arena;
-    return 0;
+	*maxmin = x == JNI_TRUE ? 1 : 0;
+	(void)env;
+	(void)client;
+	(void)arena;
+	return 0;
 }
 
 static int
-hyperdex_java_client_convert_mapattributes(JNIEnv* env, jobject client,
-                                           struct hyperdex_ds_arena* arena,
+hyperdex_java_client_convert_mapattributes(JNIEnv *env, jobject client,
+                                           struct hyperdex_ds_arena *arena,
                                            jobject x,
-                                           const struct hyperdex_client_map_attribute** _mapattrs,
-                                           size_t* _mapattrs_sz)
+                                           const struct hyperdex_client_map_attribute **_mapattrs,
+                                           size_t *_mapattrs_sz)
 {
-    jobject outer_set;
-    jobject outer_it;
-    jobject outer_entry;
-    jobject inner_map;
-    jobject inner_set;
-    jobject inner_it;
-    jobject inner_entry;
-    jobject attr;
-    const char* attr_cstr;
-    jobject key;
-    jobject val;
-    struct hyperdex_client_map_attribute* mapattrs = NULL;
-    size_t mapattrs_sz = 0;
-    size_t mapattrs_idx = 0;
-
-    outer_set = (*env)->CallObjectMethod(env, x, _map_entrySet);
-    ERROR_CHECK(-1);
-    outer_it = (*env)->CallObjectMethod(env, outer_set, _set_iterator);
-    ERROR_CHECK(-1);
-
-    while ((*env)->CallBooleanMethod(env, outer_it, _java_iterator_hasNext) == JNI_TRUE)
-    {
-        outer_entry = (*env)->CallObjectMethod(env, outer_it, _java_iterator_next);
-        ERROR_CHECK(-1);
-        inner_map = (*env)->CallObjectMethod(env, outer_entry, _map_entry_getValue);
-        ERROR_CHECK(-1);
-        mapattrs_sz += (*env)->CallIntMethod(env, inner_map, _map_size);
-        ERROR_CHECK(-1);
-        (*env)->DeleteLocalRef(env, outer_entry);
-        ERROR_CHECK(-1);
-        (*env)->DeleteLocalRef(env, inner_map);
-        ERROR_CHECK(-1);
-    }
-
-    mapattrs = hyperdex_ds_allocate_map_attribute(arena, mapattrs_sz);
-
-    if (!mapattrs)
-    {
-        hyperdex_java_out_of_memory(env);
-        return -1;
-    }
-
-    *_mapattrs = mapattrs;
-    *_mapattrs_sz = mapattrs_sz;
-    mapattrs_idx = 0;
-
-    (*env)->DeleteLocalRef(env, outer_it);
-    ERROR_CHECK(-1);
-    outer_it = (*env)->CallObjectMethod(env, outer_set, _set_iterator);
-    ERROR_CHECK(-1);
-
-    while ((*env)->CallBooleanMethod(env, outer_it, _java_iterator_hasNext) == JNI_TRUE)
-    {
-        outer_entry = (*env)->CallObjectMethod(env, outer_it, _java_iterator_next);
-        ERROR_CHECK(-1);
-        attr = (*env)->CallObjectMethod(env, outer_entry, _map_entry_getKey);
-        ERROR_CHECK(-1);
-        inner_map = (*env)->CallObjectMethod(env, outer_entry, _map_entry_getValue);
-        ERROR_CHECK(-1);
-        inner_set = (*env)->CallObjectMethod(env, inner_map, _map_entrySet);
-        ERROR_CHECK(-1);
-        inner_it = (*env)->CallObjectMethod(env, inner_set, _set_iterator);
-        ERROR_CHECK(-1);
-        attr_cstr = hyperdex_java_client_convert_cstring(env, arena, attr);
-
-        if (!attr_cstr)
-        {
-            return -1;
-        }
-
-        while ((*env)->CallBooleanMethod(env, inner_it, _java_iterator_hasNext) == JNI_TRUE)
-        {
-            assert(mapattrs_idx < mapattrs_sz);
-            inner_entry = (*env)->CallObjectMethod(env, inner_it, _java_iterator_next);
-            ERROR_CHECK(-1);
-            key = (*env)->CallObjectMethod(env, inner_entry, _map_entry_getKey);
-            ERROR_CHECK(-1);
-            val = (*env)->CallObjectMethod(env, inner_entry, _map_entry_getValue);
-            ERROR_CHECK(-1);
-            mapattrs[mapattrs_idx].attr = attr_cstr;
-
-            if (hyperdex_java_client_convert_type(env, arena, key,
-                                                  &mapattrs[mapattrs_idx].map_key,
-                                                  &mapattrs[mapattrs_idx].map_key_sz,
-                                                  &mapattrs[mapattrs_idx].map_key_datatype) < 0)
-            {
-                return -1;
-            }
-
-            if (hyperdex_java_client_convert_type(env, arena, val,
-                                                  &mapattrs[mapattrs_idx].value,
-                                                  &mapattrs[mapattrs_idx].value_sz,
-                                                  &mapattrs[mapattrs_idx].value_datatype) < 0)
-            {
-                return -1;
-            }
-
-            ++mapattrs_idx;
-            (*env)->DeleteLocalRef(env, val);
-            ERROR_CHECK(-1);
-            (*env)->DeleteLocalRef(env, key);
-            ERROR_CHECK(-1);
-            (*env)->DeleteLocalRef(env, inner_entry);
-            ERROR_CHECK(-1);
-        }
-
-        (*env)->DeleteLocalRef(env, inner_it);
-        ERROR_CHECK(-1);
-        (*env)->DeleteLocalRef(env, inner_set);
-        ERROR_CHECK(-1);
-        (*env)->DeleteLocalRef(env, inner_map);
-        ERROR_CHECK(-1);
-        (*env)->DeleteLocalRef(env, attr);
-        ERROR_CHECK(-1);
-        (*env)->DeleteLocalRef(env, outer_entry);
-        ERROR_CHECK(-1);
-    }
-
-    (void)client;
-    return 0;
+	jobject outer_set;
+	jobject outer_it;
+	jobject outer_entry;
+	jobject inner_map;
+	jobject inner_set;
+	jobject inner_it;
+	jobject inner_entry;
+	jobject attr;
+	const char *attr_cstr;
+	jobject key;
+	jobject val;
+	struct hyperdex_client_map_attribute *mapattrs = NULL;
+	size_t mapattrs_sz = 0;
+	size_t mapattrs_idx = 0;
+	outer_set = (*env)->CallObjectMethod(env, x, _map_entrySet);
+	ERROR_CHECK(-1);
+	outer_it = (*env)->CallObjectMethod(env, outer_set, _set_iterator);
+	ERROR_CHECK(-1);
+	while ((*env)->CallBooleanMethod(env, outer_it, _java_iterator_hasNext) == JNI_TRUE)
+	{
+		outer_entry = (*env)->CallObjectMethod(env, outer_it, _java_iterator_next);
+		ERROR_CHECK(-1);
+		inner_map = (*env)->CallObjectMethod(env, outer_entry, _map_entry_getValue);
+		ERROR_CHECK(-1);
+		mapattrs_sz += (*env)->CallIntMethod(env, inner_map, _map_size);
+		ERROR_CHECK(-1);
+		(*env)->DeleteLocalRef(env, outer_entry);
+		ERROR_CHECK(-1);
+		(*env)->DeleteLocalRef(env, inner_map);
+		ERROR_CHECK(-1);
+	}
+	mapattrs = hyperdex_ds_allocate_map_attribute(arena, mapattrs_sz);
+	if (!mapattrs)
+	{
+		hyperdex_java_out_of_memory(env);
+		return -1;
+	}
+	*_mapattrs = mapattrs;
+	*_mapattrs_sz = mapattrs_sz;
+	mapattrs_idx = 0;
+	(*env)->DeleteLocalRef(env, outer_it);
+	ERROR_CHECK(-1);
+	outer_it = (*env)->CallObjectMethod(env, outer_set, _set_iterator);
+	ERROR_CHECK(-1);
+	while ((*env)->CallBooleanMethod(env, outer_it, _java_iterator_hasNext) == JNI_TRUE)
+	{
+		outer_entry = (*env)->CallObjectMethod(env, outer_it, _java_iterator_next);
+		ERROR_CHECK(-1);
+		attr = (*env)->CallObjectMethod(env, outer_entry, _map_entry_getKey);
+		ERROR_CHECK(-1);
+		inner_map = (*env)->CallObjectMethod(env, outer_entry, _map_entry_getValue);
+		ERROR_CHECK(-1);
+		inner_set = (*env)->CallObjectMethod(env, inner_map, _map_entrySet);
+		ERROR_CHECK(-1);
+		inner_it = (*env)->CallObjectMethod(env, inner_set, _set_iterator);
+		ERROR_CHECK(-1);
+		attr_cstr = hyperdex_java_client_convert_cstring(env, arena, attr);
+		if (!attr_cstr)
+		{
+			return -1;
+		}
+		while ((*env)->CallBooleanMethod(env, inner_it, _java_iterator_hasNext) == JNI_TRUE)
+		{
+			assert(mapattrs_idx < mapattrs_sz);
+			inner_entry = (*env)->CallObjectMethod(env, inner_it, _java_iterator_next);
+			ERROR_CHECK(-1);
+			key = (*env)->CallObjectMethod(env, inner_entry, _map_entry_getKey);
+			ERROR_CHECK(-1);
+			val = (*env)->CallObjectMethod(env, inner_entry, _map_entry_getValue);
+			ERROR_CHECK(-1);
+			mapattrs[mapattrs_idx].attr = attr_cstr;
+			if (hyperdex_java_client_convert_type(env, arena, key,
+			                                      &mapattrs[mapattrs_idx].map_key,
+			                                      &mapattrs[mapattrs_idx].map_key_sz,
+			                                      &mapattrs[mapattrs_idx].map_key_datatype) < 0)
+			{
+				return -1;
+			}
+			if (hyperdex_java_client_convert_type(env, arena, val,
+			                                      &mapattrs[mapattrs_idx].value,
+			                                      &mapattrs[mapattrs_idx].value_sz,
+			                                      &mapattrs[mapattrs_idx].value_datatype) < 0)
+			{
+				return -1;
+			}
+			++mapattrs_idx;
+			(*env)->DeleteLocalRef(env, val);
+			ERROR_CHECK(-1);
+			(*env)->DeleteLocalRef(env, key);
+			ERROR_CHECK(-1);
+			(*env)->DeleteLocalRef(env, inner_entry);
+			ERROR_CHECK(-1);
+		}
+		(*env)->DeleteLocalRef(env, inner_it);
+		ERROR_CHECK(-1);
+		(*env)->DeleteLocalRef(env, inner_set);
+		ERROR_CHECK(-1);
+		(*env)->DeleteLocalRef(env, inner_map);
+		ERROR_CHECK(-1);
+		(*env)->DeleteLocalRef(env, attr);
+		ERROR_CHECK(-1);
+		(*env)->DeleteLocalRef(env, outer_entry);
+		ERROR_CHECK(-1);
+	}
+	(void)client;
+	return 0;
 }
 
 static ssize_t
-hyperdex_java_client_estimate_predicate_size(JNIEnv* env, jobject x)
+hyperdex_java_client_estimate_predicate_size(JNIEnv *env, jobject x)
 {
-    jobject it;
-    jobject entry;
-    size_t sum = 0;
-
-    if ((*env)->IsInstanceOf(env, x, _predicate) == JNI_TRUE)
-    {
-        sum = (*env)->CallLongMethod(env, x, _predicate_checksSize);
-        ERROR_CHECK(-1);
-        return sum;
-    }
-    else if ((*env)->IsInstanceOf(env, x, _list) == JNI_TRUE &&
-             (*env)->IsInstanceOf(env,
-                 (*env)->CallObjectMethod(env, x, _list_get, 0), _predicate) == JNI_TRUE)
-    {
-        it = (*env)->CallObjectMethod(env, x, _list_iterator);
-        ERROR_CHECK(-1);
-
-        while ((*env)->CallBooleanMethod(env, it, _java_iterator_hasNext) == JNI_TRUE)
-        {
-            entry = (*env)->CallObjectMethod(env, it, _java_iterator_next);
-            ERROR_CHECK(-1);
-
-            if ((*env)->IsInstanceOf(env, entry, _predicate) != JNI_TRUE)
-            {
-                hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_WRONGTYPE,
-                                                     "Cannot convert unknown type to a HyperDex predicate");
-                return -1;
-            }
-
-            ERROR_CHECK(-1);
-            sum += (*env)->CallLongMethod(env, x, _predicate_checksSize);
-            ERROR_CHECK(-1);
-        }
-
-        return sum;
-    }
-    else
-    {
-        ERROR_CHECK(-1);
-        return 1;
-    }
+	jobject it;
+	jobject entry;
+	size_t sum = 0;
+	if ((*env)->IsInstanceOf(env, x, _predicate) == JNI_TRUE)
+	{
+		sum = (*env)->CallLongMethod(env, x, _predicate_checksSize);
+		ERROR_CHECK(-1);
+		return sum;
+	}
+	else if ((*env)->IsInstanceOf(env, x, _list) == JNI_TRUE &&
+	         (*env)->IsInstanceOf(env,
+	                              (*env)->CallObjectMethod(env, x, _list_get, 0), _predicate) == JNI_TRUE)
+	{
+		it = (*env)->CallObjectMethod(env, x, _list_iterator);
+		ERROR_CHECK(-1);
+		while ((*env)->CallBooleanMethod(env, it, _java_iterator_hasNext) == JNI_TRUE)
+		{
+			entry = (*env)->CallObjectMethod(env, it, _java_iterator_next);
+			ERROR_CHECK(-1);
+			if ((*env)->IsInstanceOf(env, entry, _predicate) != JNI_TRUE)
+			{
+				hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_WRONGTYPE,
+				                                     "Cannot convert unknown type to a HyperDex predicate");
+				return -1;
+			}
+			ERROR_CHECK(-1);
+			sum += (*env)->CallLongMethod(env, x, _predicate_checksSize);
+			ERROR_CHECK(-1);
+		}
+		return sum;
+	}
+	else
+	{
+		ERROR_CHECK(-1);
+		return 1;
+	}
 }
 
 static ssize_t
-hyperdex_java_client_convert_predicate(JNIEnv* env,
-                                       struct hyperdex_ds_arena* arena,
-                                       const char* attr,
+hyperdex_java_client_convert_predicate(JNIEnv *env,
+                                       struct hyperdex_ds_arena *arena,
+                                       const char *attr,
                                        jobject x,
-                                       struct hyperdex_client_attribute_check* checks,
+                                       struct hyperdex_client_attribute_check *checks,
                                        size_t checks_idx)
 {
-    jobject it;
-    jobject entry;
-    jlong tmp;
-    ssize_t i;
-
-    if ((*env)->IsInstanceOf(env, x, _predicate) == JNI_TRUE)
-    {
-        tmp = (*env)->CallLongMethod(env, x, _predicate_convertChecks, arena, checks, checks_idx);
-        ERROR_CHECK(-1);
-
-        for (i = checks_idx; i < tmp; ++i)
-        {
-            checks[i].attr = attr;
-        }
-
-        return tmp;
-    }
-    else if ((*env)->IsInstanceOf(env, x, _list) == JNI_TRUE &&
-             (*env)->IsInstanceOf(env,
-                 (*env)->CallObjectMethod(env, x, _list_get, 0), _predicate) == JNI_TRUE)
-    {
-        it = (*env)->CallObjectMethod(env, x, _list_iterator);
-        ERROR_CHECK(-1);
-        tmp = checks_idx;
-
-        while ((*env)->CallBooleanMethod(env, it, _java_iterator_hasNext))
-        {
-            entry = (*env)->CallObjectMethod(env, it, _java_iterator_next);
-            ERROR_CHECK(-1);
-            tmp = (*env)->CallLongMethod(env, entry, _predicate_convertChecks, arena, checks, tmp);
-            ERROR_CHECK(-1);
-        }
-
-        for (i = checks_idx; i < tmp; ++i)
-        {
-            checks[i].attr = attr;
-        }
-
-        return tmp;
-    }
-    else
-    {
-        checks[checks_idx].attr = attr;
-        checks[checks_idx].predicate = HYPERPREDICATE_EQUALS;
-
-        if (hyperdex_java_client_convert_type(env, arena, x,
-                                              &checks[checks_idx].value,
-                                              &checks[checks_idx].value_sz,
-                                              &checks[checks_idx].datatype) < 0)
-        {
-            return -1;
-        }
-
-        return checks_idx + 1;
-    }
+	jobject it;
+	jobject entry;
+	jlong tmp;
+	ssize_t i;
+	if ((*env)->IsInstanceOf(env, x, _predicate) == JNI_TRUE)
+	{
+		tmp = (*env)->CallLongMethod(env, x, _predicate_convertChecks, arena, checks, checks_idx);
+		ERROR_CHECK(-1);
+		for (i = checks_idx; i < tmp; ++i)
+		{
+			checks[i].attr = attr;
+		}
+		return tmp;
+	}
+	else if ((*env)->IsInstanceOf(env, x, _list) == JNI_TRUE &&
+	         (*env)->IsInstanceOf(env,
+	                              (*env)->CallObjectMethod(env, x, _list_get, 0), _predicate) == JNI_TRUE)
+	{
+		it = (*env)->CallObjectMethod(env, x, _list_iterator);
+		ERROR_CHECK(-1);
+		tmp = checks_idx;
+		while ((*env)->CallBooleanMethod(env, it, _java_iterator_hasNext))
+		{
+			entry = (*env)->CallObjectMethod(env, it, _java_iterator_next);
+			ERROR_CHECK(-1);
+			tmp = (*env)->CallLongMethod(env, entry, _predicate_convertChecks, arena, checks, tmp);
+			ERROR_CHECK(-1);
+		}
+		for (i = checks_idx; i < tmp; ++i)
+		{
+			checks[i].attr = attr;
+		}
+		return tmp;
+	}
+	else
+	{
+		checks[checks_idx].attr = attr;
+		checks[checks_idx].predicate = HYPERPREDICATE_EQUALS;
+		if (hyperdex_java_client_convert_type(env, arena, x,
+		                                      &checks[checks_idx].value,
+		                                      &checks[checks_idx].value_sz,
+		                                      &checks[checks_idx].datatype) < 0)
+		{
+			return -1;
+		}
+		return checks_idx + 1;
+	}
 }
 
 int
-hyperdex_java_client_convert_predicates(JNIEnv* env, jobject client,
-                                        struct hyperdex_ds_arena* arena,
+hyperdex_java_client_convert_predicates(JNIEnv *env, jobject client,
+                                        struct hyperdex_ds_arena *arena,
                                         jobject x,
-                                        const struct hyperdex_client_attribute_check** _checks,
-                                        size_t* _checks_sz)
+                                        const struct hyperdex_client_attribute_check **_checks,
+                                        size_t *_checks_sz)
 {
-    jobject set;
-    jobject it;
-    jobject entry;
-    jobject key;
-    jobject val;
-    const char* attr;
-    struct hyperdex_client_attribute_check* checks = NULL;
-    size_t checks_sz = 0;
-    size_t checks_idx = 0;
-    ssize_t these_checks = 0;
-
-    set = (*env)->CallObjectMethod(env, x, _map_entrySet);
-    ERROR_CHECK(-1);
-    it = (*env)->CallObjectMethod(env, set, _set_iterator);
-    ERROR_CHECK(-1);
-
-    while ((*env)->CallBooleanMethod(env, it, _java_iterator_hasNext) == JNI_TRUE)
-    {
-        entry = (*env)->CallObjectMethod(env, it, _java_iterator_next);
-        ERROR_CHECK(-1);
-        val = (*env)->CallObjectMethod(env, entry, _map_entry_getValue);
-        ERROR_CHECK(-1);
-        these_checks = hyperdex_java_client_estimate_predicate_size(env, val);
-
-        if (these_checks < 0)
-        {
-            return -1;
-        }
-
-        checks_sz += these_checks;
-    }
-
-    (*env)->DeleteLocalRef(env, it);
-    ERROR_CHECK(-1);
-    it = (*env)->CallObjectMethod(env, set, _set_iterator);
-    ERROR_CHECK(-1);
-
-    checks = hyperdex_ds_allocate_attribute_check(arena, checks_sz);
-
-    if (!checks)
-    {
-        hyperdex_java_out_of_memory(env);
-        return -1;
-    }
-
-    *_checks = checks;
-    *_checks_sz = checks_sz;
-
-    while ((*env)->CallBooleanMethod(env, it, _java_iterator_hasNext) == JNI_TRUE)
-    {
-        entry = (*env)->CallObjectMethod(env, it, _java_iterator_next);
-        ERROR_CHECK(-1);
-        key = (*env)->CallObjectMethod(env, entry, _map_entry_getKey);
-        ERROR_CHECK(-1);
-        val = (*env)->CallObjectMethod(env, entry, _map_entry_getValue);
-        ERROR_CHECK(-1);
-        attr = hyperdex_java_client_convert_cstring(env, arena, key);
-
-        if (!attr)
-        {
-            return -1;
-        }
-
-        checks_idx = hyperdex_java_client_convert_predicate(env, arena, attr, val, checks, checks_idx);
-    }
-
-    (*env)->DeleteLocalRef(env, it);
-    ERROR_CHECK(-1);
-    (*env)->DeleteLocalRef(env, set);
-    ERROR_CHECK(-1);
-    (void)client;
-    return 0;
+	jobject set;
+	jobject it;
+	jobject entry;
+	jobject key;
+	jobject val;
+	const char *attr;
+	struct hyperdex_client_attribute_check *checks = NULL;
+	size_t checks_sz = 0;
+	size_t checks_idx = 0;
+	ssize_t these_checks = 0;
+	set = (*env)->CallObjectMethod(env, x, _map_entrySet);
+	ERROR_CHECK(-1);
+	it = (*env)->CallObjectMethod(env, set, _set_iterator);
+	ERROR_CHECK(-1);
+	while ((*env)->CallBooleanMethod(env, it, _java_iterator_hasNext) == JNI_TRUE)
+	{
+		entry = (*env)->CallObjectMethod(env, it, _java_iterator_next);
+		ERROR_CHECK(-1);
+		val = (*env)->CallObjectMethod(env, entry, _map_entry_getValue);
+		ERROR_CHECK(-1);
+		these_checks = hyperdex_java_client_estimate_predicate_size(env, val);
+		if (these_checks < 0)
+		{
+			return -1;
+		}
+		checks_sz += these_checks;
+	}
+	(*env)->DeleteLocalRef(env, it);
+	ERROR_CHECK(-1);
+	it = (*env)->CallObjectMethod(env, set, _set_iterator);
+	ERROR_CHECK(-1);
+	checks = hyperdex_ds_allocate_attribute_check(arena, checks_sz);
+	if (!checks)
+	{
+		hyperdex_java_out_of_memory(env);
+		return -1;
+	}
+	*_checks = checks;
+	*_checks_sz = checks_sz;
+	while ((*env)->CallBooleanMethod(env, it, _java_iterator_hasNext) == JNI_TRUE)
+	{
+		entry = (*env)->CallObjectMethod(env, it, _java_iterator_next);
+		ERROR_CHECK(-1);
+		key = (*env)->CallObjectMethod(env, entry, _map_entry_getKey);
+		ERROR_CHECK(-1);
+		val = (*env)->CallObjectMethod(env, entry, _map_entry_getValue);
+		ERROR_CHECK(-1);
+		attr = hyperdex_java_client_convert_cstring(env, arena, key);
+		if (!attr)
+		{
+			return -1;
+		}
+		checks_idx = hyperdex_java_client_convert_predicate(env, arena, attr, val, checks, checks_idx);
+	}
+	(*env)->DeleteLocalRef(env, it);
+	ERROR_CHECK(-1);
+	(*env)->DeleteLocalRef(env, set);
+	ERROR_CHECK(-1);
+	(void)client;
+	return 0;
 }
 
 static int
-hyperdex_java_client_convert_attributenames(JNIEnv* env, jobject client,
-                                            struct hyperdex_ds_arena* arena,
+hyperdex_java_client_convert_attributenames(JNIEnv *env, jobject client,
+                                            struct hyperdex_ds_arena *arena,
                                             jobject attrs,
-                                            const char*** names, size_t* names_sz)
+                                            const char *** names, size_t *names_sz)
 {
-    size_t idx = 0;
-    jobject entry;
-    jobject it = (*env)->CallObjectMethod(env, attrs, _list_iterator);
-    ERROR_CHECK(-1);
-    *names_sz = (*env)->CallIntMethod(env, attrs, _list_size);
-    ERROR_CHECK(-1);
-    *names = hyperdex_ds_malloc(arena, sizeof(char*) * (*names_sz));
-
-    if (!(*names))
-    {
-        hyperdex_java_out_of_memory(env);
-        return -1;
-    }
-
-    idx = 0;
-
-    while ((*env)->CallIntMethod(env, it, _java_iterator_hasNext) == JNI_TRUE)
-    {
-        entry = (*env)->CallObjectMethod(env, it, _java_iterator_next);
-        ERROR_CHECK(-1);
-        (*names)[idx] = hyperdex_java_client_convert_cstring(env, arena, entry);
-
-        if (!(*names)[idx])
-        {
-            return -1;
-        }
-
-        (*env)->DeleteLocalRef(env, entry);
-        ++idx;
-    }
-
-    (*env)->DeleteLocalRef(env, it);
-    (void) client;
-    return 0;
+	size_t idx = 0;
+	jobject entry;
+	jobject it = (*env)->CallObjectMethod(env, attrs, _list_iterator);
+	ERROR_CHECK(-1);
+	*names_sz = (*env)->CallIntMethod(env, attrs, _list_size);
+	ERROR_CHECK(-1);
+	*names = hyperdex_ds_malloc(arena, sizeof(char *) * (*names_sz));
+	if (!(*names))
+	{
+		hyperdex_java_out_of_memory(env);
+		return -1;
+	}
+	idx = 0;
+	while ((*env)->CallIntMethod(env, it, _java_iterator_hasNext) == JNI_TRUE)
+	{
+		entry = (*env)->CallObjectMethod(env, it, _java_iterator_next);
+		ERROR_CHECK(-1);
+		(*names)[idx] = hyperdex_java_client_convert_cstring(env, arena, entry);
+		if (!(*names)[idx])
+		{
+			return -1;
+		}
+		(*env)->DeleteLocalRef(env, entry);
+		++idx;
+	}
+	(*env)->DeleteLocalRef(env, it);
+	(void) client;
+	return 0;
 }
 
 static int
-hyperdex_java_client_convert_sortby(JNIEnv* env, jobject client,
-                                    struct hyperdex_ds_arena* arena,
+hyperdex_java_client_convert_sortby(JNIEnv *env, jobject client,
+                                    struct hyperdex_ds_arena *arena,
                                     jstring str,
-                                    const char** sortby)
+                                    const char **sortby)
 {
-    (void)client;
-    *sortby = hyperdex_java_client_convert_cstring(env, arena, str);
-    return *sortby != NULL ? 0 : -1;
+	(void)client;
+	*sortby = hyperdex_java_client_convert_cstring(env, arena, str);
+	return *sortby != NULL ? 0 : -1;
 }
 
 static int
-hyperdex_java_client_convert_spacename(JNIEnv* env, jobject client,
-                                       struct hyperdex_ds_arena* arena,
+hyperdex_java_client_convert_sum_key(JNIEnv *env, jobject client,
+                                     struct hyperdex_ds_arena *arena,
+                                     jstring str,
+                                     const char **sum_key)
+{
+	(void)client;
+	*sum_key = hyperdex_java_client_convert_cstring(env, arena, str);
+	return *sum_key != NULL ? 0 : -1;
+}
+
+static int
+hyperdex_java_client_convert_spacename(JNIEnv *env, jobject client,
+                                       struct hyperdex_ds_arena *arena,
                                        jstring str,
-                                       const char** spacename)
+                                       const char **spacename)
 {
-    (void)client;
-    *spacename = hyperdex_java_client_convert_cstring(env, arena, str);
-    return *spacename != NULL ? 0 : -1;
+	(void)client;
+	*spacename = hyperdex_java_client_convert_cstring(env, arena, str);
+	return *spacename != NULL ? 0 : -1;
 }
 
 /********************************** C -> Java *********************************/
 
 #define BUILD_STRING(OUT, X, X_SZ) \
-    do { \
-        tmp_array = (*env)->NewByteArray(env, X_SZ); \
-        ERROR_CHECK(0); \
-        (*env)->SetByteArrayRegion(env, tmp_array, 0, X_SZ, (const jbyte*)X); \
-        ERROR_CHECK(0); \
-        OUT = (*env)->NewObject(env, _byte_string, _byte_string_init, tmp_array); \
-        ERROR_CHECK(0); \
-    } while (0)
+	do { \
+		tmp_array = (*env)->NewByteArray(env, X_SZ); \
+		ERROR_CHECK(0); \
+		(*env)->SetByteArrayRegion(env, tmp_array, 0, X_SZ, (const jbyte*)X); \
+		ERROR_CHECK(0); \
+		OUT = (*env)->NewObject(env, _byte_string, _byte_string_init, tmp_array); \
+		ERROR_CHECK(0); \
+	} while (0)
 
 #define BUILD_INT(OUT, X) \
-    do { \
-        OUT = (*env)->NewObject(env, _long, _long_init, X); \
-        ERROR_CHECK(0); \
-    } while (0)
+	do { \
+		OUT = (*env)->NewObject(env, _long, _long_init, X); \
+		ERROR_CHECK(0); \
+	} while (0)
 
 #define BUILD_FLOAT(OUT, X) \
-    do { \
-        OUT = (*env)->NewObject(env, _double, _double_init, X); \
-        ERROR_CHECK(0); \
-    } while (0)
+	do { \
+		OUT = (*env)->NewObject(env, _double, _double_init, X); \
+		ERROR_CHECK(0); \
+	} while (0)
 
 static jobject
-hyperdex_java_client_build_attribute(JNIEnv* env,
-                                     const struct hyperdex_client_attribute* attr)
+hyperdex_java_client_build_attribute(JNIEnv *env,
+                                     const struct hyperdex_client_attribute *attr)
 {
-    struct hyperdex_ds_iterator iter;
-    jbyteArray tmp_array;
-    const char* tmp_str = NULL;
-    size_t tmp_str_sz = 0;
-    const char* tmp_str2 = NULL;
-    size_t tmp_str2_sz = 0;
-    int64_t tmp_i = 0;
-    int64_t tmp_i2 = 0;
-    double tmp_d = 0;
-    double tmp_d2 = 0;
-    int result = 0;
-    jobject ret = NULL;
-    jobject tmp = NULL;
-    jobject tmp2 = NULL;
-
-    switch (attr->datatype)
-    {
-        case HYPERDATATYPE_STRING:
-            BUILD_STRING(tmp, attr->value, attr->value_sz);
-            return tmp;
-        case HYPERDATATYPE_INT64:
-            if (hyperdex_ds_unpack_int(attr->value, attr->value_sz, &tmp_i) < 0)
-            {
-                hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_SERVERERROR, "server sent malformed int");
-                return 0;
-            }
-
-            BUILD_INT(tmp, tmp_i);
-            return tmp;
-        case HYPERDATATYPE_FLOAT:
-            if (hyperdex_ds_unpack_float(attr->value, attr->value_sz, &tmp_d) < 0)
-            {
-                hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_SERVERERROR, "server sent malformed float");
-                return 0;
-            }
-
-            BUILD_FLOAT(tmp, tmp_d);
-            return tmp;
-        case HYPERDATATYPE_DOCUMENT:
-            BUILD_STRING(tmp, attr->value, attr->value_sz);
-            // Build document from string
-            return (*env)->NewObject(env, _document, _document_init, tmp);
-        case HYPERDATATYPE_LIST_STRING:
-            hyperdex_ds_iterator_init(&iter, attr->datatype, attr->value, attr->value_sz);
-            ret = (*env)->NewObject(env, _array_list, _array_list_init);
-            ERROR_CHECK(0);
-
-            while ((result = hyperdex_ds_iterate_list_string_next(&iter, &tmp_str, &tmp_str_sz)) > 0)
-            {
-                BUILD_STRING(tmp, tmp_str, tmp_str_sz);
-                (*env)->CallBooleanMethod(env, ret, _array_list_add, tmp);
-                ERROR_CHECK(0);
-            }
-
-            if (result < 0)
-            {
-                hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_SERVERERROR, "server sent malformed list(string)");
-                return 0;
-            }
-
-            return ret;
-        case HYPERDATATYPE_LIST_INT64:
-            hyperdex_ds_iterator_init(&iter, attr->datatype, attr->value, attr->value_sz);
-            ret = (*env)->NewObject(env, _array_list, _array_list_init);
-            ERROR_CHECK(0);
-
-            while ((result = hyperdex_ds_iterate_list_int_next(&iter, &tmp_i)) > 0)
-            {
-                BUILD_INT(tmp, tmp_i);
-                (*env)->CallBooleanMethod(env, ret, _array_list_add, tmp);
-                ERROR_CHECK(0);
-            }
-
-            if (result < 0)
-            {
-                hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_SERVERERROR, "server sent malformed list(int)");
-                return 0;
-            }
-
-            return ret;
-        case HYPERDATATYPE_LIST_FLOAT:
-            hyperdex_ds_iterator_init(&iter, attr->datatype, attr->value, attr->value_sz);
-            ret = (*env)->NewObject(env, _array_list, _array_list_init);
-            ERROR_CHECK(0);
-
-            while ((result = hyperdex_ds_iterate_list_float_next(&iter, &tmp_d)) > 0)
-            {
-                BUILD_FLOAT(tmp, tmp_d);
-                (*env)->CallBooleanMethod(env, ret, _array_list_add, tmp);
-                ERROR_CHECK(0);
-            }
-
-            if (result < 0)
-            {
-                hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_SERVERERROR, "server sent malformed list(float)");
-                return 0;
-            }
-
-            return ret;
-        case HYPERDATATYPE_SET_STRING:
-            hyperdex_ds_iterator_init(&iter, attr->datatype, attr->value, attr->value_sz);
-            ret = (*env)->NewObject(env, _hash_set, _hash_set_init);
-            ERROR_CHECK(0);
-
-            while ((result = hyperdex_ds_iterate_set_string_next(&iter, &tmp_str, &tmp_str_sz)) > 0)
-            {
-                BUILD_STRING(tmp, tmp_str, tmp_str_sz);
-                (*env)->CallBooleanMethod(env, ret, _hash_set_add, tmp);
-                ERROR_CHECK(0);
-            }
-
-            if (result < 0)
-            {
-                hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_SERVERERROR, "server sent malformed set(string)");
-                return 0;
-            }
-
-            return ret;
-        case HYPERDATATYPE_SET_INT64:
-            hyperdex_ds_iterator_init(&iter, attr->datatype, attr->value, attr->value_sz);
-            ret = (*env)->NewObject(env, _hash_set, _hash_set_init);
-            ERROR_CHECK(0);
-
-            while ((result = hyperdex_ds_iterate_set_int_next(&iter, &tmp_i)) > 0)
-            {
-                BUILD_INT(tmp, tmp_i);
-                (*env)->CallObjectMethod(env, ret, _hash_set_add, tmp);
-                ERROR_CHECK(0);
-            }
-
-            if (result < 0)
-            {
-                hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_SERVERERROR, "server sent malformed set(int)");
-                return 0;
-            }
-
-            return ret;
-        case HYPERDATATYPE_SET_FLOAT:
-            hyperdex_ds_iterator_init(&iter, attr->datatype, attr->value, attr->value_sz);
-            ret = (*env)->NewObject(env, _hash_set, _hash_set_init);
-            ERROR_CHECK(0);
-
-            while ((result = hyperdex_ds_iterate_set_float_next(&iter, &tmp_d)) > 0)
-            {
-                BUILD_FLOAT(tmp, tmp_d);
-                (*env)->CallObjectMethod(env, ret, _hash_set_add, tmp);
-                ERROR_CHECK(0);
-            }
-
-            if (result < 0)
-            {
-                hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_SERVERERROR, "server sent malformed set(float)");
-                return 0;
-            }
-
-            return ret;
-        case HYPERDATATYPE_MAP_STRING_STRING:
-            hyperdex_ds_iterator_init(&iter, attr->datatype, attr->value, attr->value_sz);
-            ret = (*env)->NewObject(env, _hash_map, _hash_map_init);
-            ERROR_CHECK(0);
-
-            while ((result = hyperdex_ds_iterate_map_string_string_next(&iter, &tmp_str, &tmp_str_sz, &tmp_str2, &tmp_str2_sz)) > 0)
-            {
-                BUILD_STRING(tmp, tmp_str, tmp_str_sz);
-                BUILD_STRING(tmp2, tmp_str2, tmp_str2_sz);
-                (*env)->CallObjectMethod(env, ret, _hash_map_put, tmp, tmp2);
-                ERROR_CHECK(0);
-            }
-
-            if (result < 0)
-            {
-                hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_SERVERERROR, "server sent malformed map(string, string)");
-                return 0;
-            }
-
-            return ret;
-        case HYPERDATATYPE_MAP_STRING_INT64:
-            hyperdex_ds_iterator_init(&iter, attr->datatype, attr->value, attr->value_sz);
-            ret = (*env)->NewObject(env, _hash_map, _hash_map_init);
-            ERROR_CHECK(0);
-
-            while ((result = hyperdex_ds_iterate_map_string_int_next(&iter, &tmp_str, &tmp_str_sz, &tmp_i)) > 0)
-            {
-                BUILD_STRING(tmp, tmp_str, tmp_str_sz);
-                BUILD_INT(tmp2, tmp_i);
-                (*env)->CallObjectMethod(env, ret, _hash_map_put, tmp, tmp2);
-                ERROR_CHECK(0);
-            }
-
-            if (result < 0)
-            {
-                hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_SERVERERROR, "server sent malformed map(string, int)");
-                return 0;
-            }
-
-            return ret;
-        case HYPERDATATYPE_MAP_STRING_FLOAT:
-            hyperdex_ds_iterator_init(&iter, attr->datatype, attr->value, attr->value_sz);
-            ret = (*env)->NewObject(env, _hash_map, _hash_map_init);
-            ERROR_CHECK(0);
-
-            while ((result = hyperdex_ds_iterate_map_string_float_next(&iter, &tmp_str, &tmp_str_sz, &tmp_d)) > 0)
-            {
-                BUILD_STRING(tmp, tmp_str, tmp_str_sz);
-                BUILD_FLOAT(tmp2, tmp_d);
-                (*env)->CallObjectMethod(env, ret, _hash_map_put, tmp, tmp2);
-                ERROR_CHECK(0);
-            }
-
-            if (result < 0)
-            {
-                hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_SERVERERROR, "server sent malformed map(string, float)");
-                return 0;
-            }
-
-            return ret;
-        case HYPERDATATYPE_MAP_INT64_STRING:
-            hyperdex_ds_iterator_init(&iter, attr->datatype, attr->value, attr->value_sz);
-            ret = (*env)->NewObject(env, _hash_map, _hash_map_init);
-            ERROR_CHECK(0);
-
-            while ((result = hyperdex_ds_iterate_map_int_string_next(&iter, &tmp_i, &tmp_str, &tmp_str_sz)) > 0)
-            {
-                BUILD_INT(tmp, tmp_i);
-                BUILD_STRING(tmp2, tmp_str, tmp_str_sz);
-                (*env)->CallObjectMethod(env, ret, _hash_map_put, tmp, tmp2);
-                ERROR_CHECK(0);
-            }
-
-            if (result < 0)
-            {
-                hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_SERVERERROR, "server sent malformed map(int, string)");
-                return 0;
-            }
-
-            return ret;
-        case HYPERDATATYPE_MAP_INT64_INT64:
-            hyperdex_ds_iterator_init(&iter, attr->datatype, attr->value, attr->value_sz);
-            ret = (*env)->NewObject(env, _hash_map, _hash_map_init);
-            ERROR_CHECK(0);
-
-            while ((result = hyperdex_ds_iterate_map_int_int_next(&iter, &tmp_i, &tmp_i2)) > 0)
-            {
-                BUILD_INT(tmp, tmp_i);
-                BUILD_INT(tmp2, tmp_i2);
-                (*env)->CallObjectMethod(env, ret, _hash_map_put, tmp, tmp2);
-                ERROR_CHECK(0);
-            }
-
-            if (result < 0)
-            {
-                hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_SERVERERROR, "server sent malformed map(int, int)");
-                return 0;
-            }
-
-            return ret;
-        case HYPERDATATYPE_MAP_INT64_FLOAT:
-            hyperdex_ds_iterator_init(&iter, attr->datatype, attr->value, attr->value_sz);
-            ret = (*env)->NewObject(env, _hash_map, _hash_map_init);
-            ERROR_CHECK(0);
-
-            while ((result = hyperdex_ds_iterate_map_int_float_next(&iter, &tmp_i, &tmp_d)) > 0)
-            {
-                BUILD_INT(tmp, tmp_i);
-                BUILD_FLOAT(tmp2, tmp_d);
-                (*env)->CallObjectMethod(env, ret, _hash_map_put, tmp, tmp2);
-                ERROR_CHECK(0);
-            }
-
-            if (result < 0)
-            {
-                hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_SERVERERROR, "server sent malformed map(int, float)");
-                return 0;
-            }
-
-            return ret;
-        case HYPERDATATYPE_MAP_FLOAT_STRING:
-            hyperdex_ds_iterator_init(&iter, attr->datatype, attr->value, attr->value_sz);
-            ret = (*env)->NewObject(env, _hash_map, _hash_map_init);
-            ERROR_CHECK(0);
-
-            while ((result = hyperdex_ds_iterate_map_float_string_next(&iter, &tmp_d, &tmp_str, &tmp_str_sz)) > 0)
-            {
-                BUILD_FLOAT(tmp, tmp_d);
-                BUILD_STRING(tmp2, tmp_str, tmp_str_sz);
-                (*env)->CallObjectMethod(env, ret, _hash_map_put, tmp, tmp2);
-                ERROR_CHECK(0);
-            }
-
-            if (result < 0)
-            {
-                hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_SERVERERROR, "server sent malformed map(float, string)");
-                return 0;
-            }
-
-            return ret;
-        case HYPERDATATYPE_MAP_FLOAT_INT64:
-            hyperdex_ds_iterator_init(&iter, attr->datatype, attr->value, attr->value_sz);
-            ret = (*env)->NewObject(env, _hash_map, _hash_map_init);
-            ERROR_CHECK(0);
-
-            while ((result = hyperdex_ds_iterate_map_float_int_next(&iter, &tmp_d, &tmp_i)) > 0)
-            {
-                BUILD_FLOAT(tmp, tmp_d);
-                BUILD_INT(tmp2, tmp_i);
-                (*env)->CallObjectMethod(env, ret, _hash_map_put, tmp, tmp2);
-                ERROR_CHECK(0);
-            }
-
-            if (result < 0)
-            {
-                hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_SERVERERROR, "server sent malformed map(float, int)");
-                return 0;
-            }
-
-            return ret;
-        case HYPERDATATYPE_MAP_FLOAT_FLOAT:
-            hyperdex_ds_iterator_init(&iter, attr->datatype, attr->value, attr->value_sz);
-            ret = (*env)->NewObject(env, _hash_map, _hash_map_init);
-            ERROR_CHECK(0);
-
-            while ((result = hyperdex_ds_iterate_map_float_float_next(&iter, &tmp_d, &tmp_d2)) > 0)
-            {
-                BUILD_FLOAT(tmp, tmp_d);
-                BUILD_FLOAT(tmp2, tmp_d2);
-                (*env)->CallObjectMethod(env, ret, _hash_map_put, tmp, tmp2);
-                ERROR_CHECK(0);
-            }
-
-            if (result < 0)
-            {
-                hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_SERVERERROR, "server sent malformed map(float, float)");
-                return 0;
-            }
-
-            return ret;
-        case HYPERDATATYPE_GENERIC:
-        case HYPERDATATYPE_LIST_GENERIC:
-        case HYPERDATATYPE_SET_GENERIC:
-        case HYPERDATATYPE_MAP_GENERIC:
-        case HYPERDATATYPE_MAP_STRING_KEYONLY:
-        case HYPERDATATYPE_MAP_INT64_KEYONLY:
-        case HYPERDATATYPE_MAP_FLOAT_KEYONLY:
-        case HYPERDATATYPE_GARBAGE:
-        default:
-            hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_SERVERERROR, "server sent malformed attributes");
-            return 0;
-    }
+	struct hyperdex_ds_iterator iter;
+	jbyteArray tmp_array;
+	const char *tmp_str = NULL;
+	size_t tmp_str_sz = 0;
+	const char *tmp_str2 = NULL;
+	size_t tmp_str2_sz = 0;
+	int64_t tmp_i = 0;
+	int64_t tmp_i2 = 0;
+	double tmp_d = 0;
+	double tmp_d2 = 0;
+	int result = 0;
+	jobject ret = NULL;
+	jobject tmp = NULL;
+	jobject tmp2 = NULL;
+	switch (attr->datatype)
+	{
+	case HYPERDATATYPE_STRING:
+		BUILD_STRING(tmp, attr->value, attr->value_sz);
+		return tmp;
+	case HYPERDATATYPE_INT64:
+		if (hyperdex_ds_unpack_int(attr->value, attr->value_sz, &tmp_i) < 0)
+		{
+			hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_SERVERERROR, "server sent malformed int");
+			return 0;
+		}
+		BUILD_INT(tmp, tmp_i);
+		return tmp;
+	case HYPERDATATYPE_FLOAT:
+		if (hyperdex_ds_unpack_float(attr->value, attr->value_sz, &tmp_d) < 0)
+		{
+			hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_SERVERERROR, "server sent malformed float");
+			return 0;
+		}
+		BUILD_FLOAT(tmp, tmp_d);
+		return tmp;
+	case HYPERDATATYPE_DOCUMENT:
+		BUILD_STRING(tmp, attr->value, attr->value_sz);
+		// Build document from string
+		return (*env)->NewObject(env, _document, _document_init, tmp);
+	case HYPERDATATYPE_LIST_STRING:
+		hyperdex_ds_iterator_init(&iter, attr->datatype, attr->value, attr->value_sz);
+		ret = (*env)->NewObject(env, _array_list, _array_list_init);
+		ERROR_CHECK(0);
+		while ((result = hyperdex_ds_iterate_list_string_next(&iter, &tmp_str, &tmp_str_sz)) > 0)
+		{
+			BUILD_STRING(tmp, tmp_str, tmp_str_sz);
+			(*env)->CallBooleanMethod(env, ret, _array_list_add, tmp);
+			ERROR_CHECK(0);
+		}
+		if (result < 0)
+		{
+			hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_SERVERERROR, "server sent malformed list(string)");
+			return 0;
+		}
+		return ret;
+	case HYPERDATATYPE_LIST_INT64:
+		hyperdex_ds_iterator_init(&iter, attr->datatype, attr->value, attr->value_sz);
+		ret = (*env)->NewObject(env, _array_list, _array_list_init);
+		ERROR_CHECK(0);
+		while ((result = hyperdex_ds_iterate_list_int_next(&iter, &tmp_i)) > 0)
+		{
+			BUILD_INT(tmp, tmp_i);
+			(*env)->CallBooleanMethod(env, ret, _array_list_add, tmp);
+			ERROR_CHECK(0);
+		}
+		if (result < 0)
+		{
+			hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_SERVERERROR, "server sent malformed list(int)");
+			return 0;
+		}
+		return ret;
+	case HYPERDATATYPE_LIST_FLOAT:
+		hyperdex_ds_iterator_init(&iter, attr->datatype, attr->value, attr->value_sz);
+		ret = (*env)->NewObject(env, _array_list, _array_list_init);
+		ERROR_CHECK(0);
+		while ((result = hyperdex_ds_iterate_list_float_next(&iter, &tmp_d)) > 0)
+		{
+			BUILD_FLOAT(tmp, tmp_d);
+			(*env)->CallBooleanMethod(env, ret, _array_list_add, tmp);
+			ERROR_CHECK(0);
+		}
+		if (result < 0)
+		{
+			hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_SERVERERROR, "server sent malformed list(float)");
+			return 0;
+		}
+		return ret;
+	case HYPERDATATYPE_SET_STRING:
+		hyperdex_ds_iterator_init(&iter, attr->datatype, attr->value, attr->value_sz);
+		ret = (*env)->NewObject(env, _hash_set, _hash_set_init);
+		ERROR_CHECK(0);
+		while ((result = hyperdex_ds_iterate_set_string_next(&iter, &tmp_str, &tmp_str_sz)) > 0)
+		{
+			BUILD_STRING(tmp, tmp_str, tmp_str_sz);
+			(*env)->CallBooleanMethod(env, ret, _hash_set_add, tmp);
+			ERROR_CHECK(0);
+		}
+		if (result < 0)
+		{
+			hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_SERVERERROR, "server sent malformed set(string)");
+			return 0;
+		}
+		return ret;
+	case HYPERDATATYPE_SET_INT64:
+		hyperdex_ds_iterator_init(&iter, attr->datatype, attr->value, attr->value_sz);
+		ret = (*env)->NewObject(env, _hash_set, _hash_set_init);
+		ERROR_CHECK(0);
+		while ((result = hyperdex_ds_iterate_set_int_next(&iter, &tmp_i)) > 0)
+		{
+			BUILD_INT(tmp, tmp_i);
+			(*env)->CallObjectMethod(env, ret, _hash_set_add, tmp);
+			ERROR_CHECK(0);
+		}
+		if (result < 0)
+		{
+			hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_SERVERERROR, "server sent malformed set(int)");
+			return 0;
+		}
+		return ret;
+	case HYPERDATATYPE_SET_FLOAT:
+		hyperdex_ds_iterator_init(&iter, attr->datatype, attr->value, attr->value_sz);
+		ret = (*env)->NewObject(env, _hash_set, _hash_set_init);
+		ERROR_CHECK(0);
+		while ((result = hyperdex_ds_iterate_set_float_next(&iter, &tmp_d)) > 0)
+		{
+			BUILD_FLOAT(tmp, tmp_d);
+			(*env)->CallObjectMethod(env, ret, _hash_set_add, tmp);
+			ERROR_CHECK(0);
+		}
+		if (result < 0)
+		{
+			hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_SERVERERROR, "server sent malformed set(float)");
+			return 0;
+		}
+		return ret;
+	case HYPERDATATYPE_MAP_STRING_STRING:
+		hyperdex_ds_iterator_init(&iter, attr->datatype, attr->value, attr->value_sz);
+		ret = (*env)->NewObject(env, _hash_map, _hash_map_init);
+		ERROR_CHECK(0);
+		while ((result = hyperdex_ds_iterate_map_string_string_next(&iter, &tmp_str, &tmp_str_sz, &tmp_str2, &tmp_str2_sz)) > 0)
+		{
+			BUILD_STRING(tmp, tmp_str, tmp_str_sz);
+			BUILD_STRING(tmp2, tmp_str2, tmp_str2_sz);
+			(*env)->CallObjectMethod(env, ret, _hash_map_put, tmp, tmp2);
+			ERROR_CHECK(0);
+		}
+		if (result < 0)
+		{
+			hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_SERVERERROR, "server sent malformed map(string, string)");
+			return 0;
+		}
+		return ret;
+	case HYPERDATATYPE_MAP_STRING_INT64:
+		hyperdex_ds_iterator_init(&iter, attr->datatype, attr->value, attr->value_sz);
+		ret = (*env)->NewObject(env, _hash_map, _hash_map_init);
+		ERROR_CHECK(0);
+		while ((result = hyperdex_ds_iterate_map_string_int_next(&iter, &tmp_str, &tmp_str_sz, &tmp_i)) > 0)
+		{
+			BUILD_STRING(tmp, tmp_str, tmp_str_sz);
+			BUILD_INT(tmp2, tmp_i);
+			(*env)->CallObjectMethod(env, ret, _hash_map_put, tmp, tmp2);
+			ERROR_CHECK(0);
+		}
+		if (result < 0)
+		{
+			hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_SERVERERROR, "server sent malformed map(string, int)");
+			return 0;
+		}
+		return ret;
+	case HYPERDATATYPE_MAP_STRING_FLOAT:
+		hyperdex_ds_iterator_init(&iter, attr->datatype, attr->value, attr->value_sz);
+		ret = (*env)->NewObject(env, _hash_map, _hash_map_init);
+		ERROR_CHECK(0);
+		while ((result = hyperdex_ds_iterate_map_string_float_next(&iter, &tmp_str, &tmp_str_sz, &tmp_d)) > 0)
+		{
+			BUILD_STRING(tmp, tmp_str, tmp_str_sz);
+			BUILD_FLOAT(tmp2, tmp_d);
+			(*env)->CallObjectMethod(env, ret, _hash_map_put, tmp, tmp2);
+			ERROR_CHECK(0);
+		}
+		if (result < 0)
+		{
+			hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_SERVERERROR, "server sent malformed map(string, float)");
+			return 0;
+		}
+		return ret;
+	case HYPERDATATYPE_MAP_INT64_STRING:
+		hyperdex_ds_iterator_init(&iter, attr->datatype, attr->value, attr->value_sz);
+		ret = (*env)->NewObject(env, _hash_map, _hash_map_init);
+		ERROR_CHECK(0);
+		while ((result = hyperdex_ds_iterate_map_int_string_next(&iter, &tmp_i, &tmp_str, &tmp_str_sz)) > 0)
+		{
+			BUILD_INT(tmp, tmp_i);
+			BUILD_STRING(tmp2, tmp_str, tmp_str_sz);
+			(*env)->CallObjectMethod(env, ret, _hash_map_put, tmp, tmp2);
+			ERROR_CHECK(0);
+		}
+		if (result < 0)
+		{
+			hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_SERVERERROR, "server sent malformed map(int, string)");
+			return 0;
+		}
+		return ret;
+	case HYPERDATATYPE_MAP_INT64_INT64:
+		hyperdex_ds_iterator_init(&iter, attr->datatype, attr->value, attr->value_sz);
+		ret = (*env)->NewObject(env, _hash_map, _hash_map_init);
+		ERROR_CHECK(0);
+		while ((result = hyperdex_ds_iterate_map_int_int_next(&iter, &tmp_i, &tmp_i2)) > 0)
+		{
+			BUILD_INT(tmp, tmp_i);
+			BUILD_INT(tmp2, tmp_i2);
+			(*env)->CallObjectMethod(env, ret, _hash_map_put, tmp, tmp2);
+			ERROR_CHECK(0);
+		}
+		if (result < 0)
+		{
+			hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_SERVERERROR, "server sent malformed map(int, int)");
+			return 0;
+		}
+		return ret;
+	case HYPERDATATYPE_MAP_INT64_FLOAT:
+		hyperdex_ds_iterator_init(&iter, attr->datatype, attr->value, attr->value_sz);
+		ret = (*env)->NewObject(env, _hash_map, _hash_map_init);
+		ERROR_CHECK(0);
+		while ((result = hyperdex_ds_iterate_map_int_float_next(&iter, &tmp_i, &tmp_d)) > 0)
+		{
+			BUILD_INT(tmp, tmp_i);
+			BUILD_FLOAT(tmp2, tmp_d);
+			(*env)->CallObjectMethod(env, ret, _hash_map_put, tmp, tmp2);
+			ERROR_CHECK(0);
+		}
+		if (result < 0)
+		{
+			hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_SERVERERROR, "server sent malformed map(int, float)");
+			return 0;
+		}
+		return ret;
+	case HYPERDATATYPE_MAP_FLOAT_STRING:
+		hyperdex_ds_iterator_init(&iter, attr->datatype, attr->value, attr->value_sz);
+		ret = (*env)->NewObject(env, _hash_map, _hash_map_init);
+		ERROR_CHECK(0);
+		while ((result = hyperdex_ds_iterate_map_float_string_next(&iter, &tmp_d, &tmp_str, &tmp_str_sz)) > 0)
+		{
+			BUILD_FLOAT(tmp, tmp_d);
+			BUILD_STRING(tmp2, tmp_str, tmp_str_sz);
+			(*env)->CallObjectMethod(env, ret, _hash_map_put, tmp, tmp2);
+			ERROR_CHECK(0);
+		}
+		if (result < 0)
+		{
+			hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_SERVERERROR, "server sent malformed map(float, string)");
+			return 0;
+		}
+		return ret;
+	case HYPERDATATYPE_MAP_FLOAT_INT64:
+		hyperdex_ds_iterator_init(&iter, attr->datatype, attr->value, attr->value_sz);
+		ret = (*env)->NewObject(env, _hash_map, _hash_map_init);
+		ERROR_CHECK(0);
+		while ((result = hyperdex_ds_iterate_map_float_int_next(&iter, &tmp_d, &tmp_i)) > 0)
+		{
+			BUILD_FLOAT(tmp, tmp_d);
+			BUILD_INT(tmp2, tmp_i);
+			(*env)->CallObjectMethod(env, ret, _hash_map_put, tmp, tmp2);
+			ERROR_CHECK(0);
+		}
+		if (result < 0)
+		{
+			hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_SERVERERROR, "server sent malformed map(float, int)");
+			return 0;
+		}
+		return ret;
+	case HYPERDATATYPE_MAP_FLOAT_FLOAT:
+		hyperdex_ds_iterator_init(&iter, attr->datatype, attr->value, attr->value_sz);
+		ret = (*env)->NewObject(env, _hash_map, _hash_map_init);
+		ERROR_CHECK(0);
+		while ((result = hyperdex_ds_iterate_map_float_float_next(&iter, &tmp_d, &tmp_d2)) > 0)
+		{
+			BUILD_FLOAT(tmp, tmp_d);
+			BUILD_FLOAT(tmp2, tmp_d2);
+			(*env)->CallObjectMethod(env, ret, _hash_map_put, tmp, tmp2);
+			ERROR_CHECK(0);
+		}
+		if (result < 0)
+		{
+			hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_SERVERERROR, "server sent malformed map(float, float)");
+			return 0;
+		}
+		return ret;
+	case HYPERDATATYPE_GENERIC:
+	case HYPERDATATYPE_LIST_GENERIC:
+	case HYPERDATATYPE_SET_GENERIC:
+	case HYPERDATATYPE_MAP_GENERIC:
+	case HYPERDATATYPE_MAP_STRING_KEYONLY:
+	case HYPERDATATYPE_MAP_INT64_KEYONLY:
+	case HYPERDATATYPE_MAP_FLOAT_KEYONLY:
+	case HYPERDATATYPE_GARBAGE:
+	default:
+		hyperdex_java_client_throw_exception(env, HYPERDEX_CLIENT_SERVERERROR, "server sent malformed attributes");
+		return 0;
+	}
 }
 
 static jobject
-hyperdex_java_client_build_attributes(JNIEnv* env,
-                                      const struct hyperdex_client_attribute* attrs,
+hyperdex_java_client_build_attributes(JNIEnv *env,
+                                      const struct hyperdex_client_attribute *attrs,
                                       size_t attrs_sz)
 {
-    jobject ret;
-    jobject str;
-    jobject val;
-    size_t i = 0;
-
-    ret = (*env)->NewObject(env, _hash_map, _hash_map_init);
-    ERROR_CHECK(0);
-
-    for (i = 0; i < attrs_sz; ++i)
-    {
-        val = hyperdex_java_client_build_attribute(env, attrs + i);
-
-        if (val == 0)
-        {
-            return 0;
-        }
-
-        str = (*env)->NewStringUTF(env, attrs[i].attr);
-        ERROR_CHECK(0);
-        (*env)->CallObjectMethod(env, ret, _hash_map_put, str, val);
-        ERROR_CHECK(0);
-    }
-
-    return ret;
+	jobject ret;
+	jobject str;
+	jobject val;
+	size_t i = 0;
+	ret = (*env)->NewObject(env, _hash_map, _hash_map_init);
+	ERROR_CHECK(0);
+	for (i = 0; i < attrs_sz; ++i)
+	{
+		val = hyperdex_java_client_build_attribute(env, attrs + i);
+		if (val == 0)
+		{
+			return 0;
+		}
+		str = (*env)->NewStringUTF(env, attrs[i].attr);
+		ERROR_CHECK(0);
+		(*env)->CallObjectMethod(env, ret, _hash_map_put, str, val);
+		ERROR_CHECK(0);
+	}
+	return ret;
 }
 
 /******************************* Deferred Class *******************************/
 JNIEXPORT HYPERDEX_API void JNICALL
-Java_org_hyperdex_client_Deferred__1create(JNIEnv* env, jobject deferred)
+Java_org_hyperdex_client_Deferred__1create(JNIEnv *env, jobject deferred)
 {
-    struct hyperdex_java_client_deferred* ptr;
-
-    ERROR_CHECK_VOID();
-    ptr = malloc(sizeof(struct hyperdex_java_client_deferred));
-
-    if (!ptr)
-    {
-        hyperdex_java_out_of_memory(env);
-        return;
-    }
-
-    memset(ptr, 0, sizeof(struct hyperdex_java_client_deferred));
-    (*env)->SetLongField(env, deferred, _deferred_ptr, (long)ptr);
-    ERROR_CHECK_VOID();
-
-    ptr->arena = hyperdex_ds_arena_create();
-
-    if (!ptr->arena)
-    {
-        /* all other resources are caught by the finalizer? */
-        hyperdex_java_out_of_memory(env);
-        return;
-    }
-
-    ptr->reqid = -1;
-    ptr->status = HYPERDEX_CLIENT_GARBAGE;
-    ptr->attrs = NULL;
-    ptr->attrs_sz = 0;
-    ptr->description = NULL;
-    ptr->count = 0;
-    ptr->finished = 0;
-    ptr->encode_return = NULL;
+	struct hyperdex_java_client_deferred *ptr;
+	ERROR_CHECK_VOID();
+	ptr = malloc(sizeof(struct hyperdex_java_client_deferred));
+	if (!ptr)
+	{
+		hyperdex_java_out_of_memory(env);
+		return;
+	}
+	memset(ptr, 0, sizeof(struct hyperdex_java_client_deferred));
+	(*env)->SetLongField(env, deferred, _deferred_ptr, (long)ptr);
+	ERROR_CHECK_VOID();
+	ptr->arena = hyperdex_ds_arena_create();
+	if (!ptr->arena)
+	{
+		/* all other resources are caught by the finalizer? */
+		hyperdex_java_out_of_memory(env);
+		return;
+	}
+	ptr->reqid = -1;
+	ptr->status = HYPERDEX_CLIENT_GARBAGE;
+	ptr->attrs = NULL;
+	ptr->attrs_sz = 0;
+	ptr->description = NULL;
+	ptr->count = 0;
+	ptr->finished = 0;
+	ptr->encode_return = NULL;
 }
 
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wcast-qual"
 JNIEXPORT HYPERDEX_API void JNICALL
-Java_org_hyperdex_client_Deferred__1destroy(JNIEnv* env, jobject dfrd)
+Java_org_hyperdex_client_Deferred__1destroy(JNIEnv *env, jobject dfrd)
 {
-    jlong lptr;
-    struct hyperdex_java_client_deferred* ptr;
-
-    lptr = (*env)->GetLongField(env, dfrd, _deferred_ptr);
-    ERROR_CHECK_VOID();
-    ptr = (struct hyperdex_java_client_deferred*)lptr;
-
-    if (ptr)
-    {
-        if (ptr->arena)
-        {
-            hyperdex_ds_arena_destroy(ptr->arena);
-        }
-
-        if (ptr->attrs)
-        {
-            hyperdex_client_destroy_attrs(ptr->attrs, ptr->attrs_sz);
-        }
-
-        if (ptr->description)
-        {
-            free((void*)ptr->description);
-        }
-
-        free(ptr);
-    }
-
-    (*env)->SetLongField(env, dfrd, _deferred_ptr, 0);
-    ERROR_CHECK_VOID();
+	jlong lptr;
+	struct hyperdex_java_client_deferred *ptr;
+	lptr = (*env)->GetLongField(env, dfrd, _deferred_ptr);
+	ERROR_CHECK_VOID();
+	ptr = (struct hyperdex_java_client_deferred *)lptr;
+	if (ptr)
+	{
+		if (ptr->arena)
+		{
+			hyperdex_ds_arena_destroy(ptr->arena);
+		}
+		if (ptr->attrs)
+		{
+			hyperdex_client_destroy_attrs(ptr->attrs, ptr->attrs_sz);
+		}
+		if (ptr->description)
+		{
+			free((void *)ptr->description);
+		}
+		free(ptr);
+	}
+	(*env)->SetLongField(env, dfrd, _deferred_ptr, 0);
+	ERROR_CHECK_VOID();
 }
 #pragma GCC diagnostic pop
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Deferred_waitForIt(JNIEnv* env, jobject obj)
+Java_org_hyperdex_client_Deferred_waitForIt(JNIEnv *env, jobject obj)
 {
-    struct hyperdex_java_client_deferred* dfrd = NULL;
-    dfrd = hyperdex_get_deferred_ptr(env, obj);
-    ERROR_CHECK(0);
-
-    while (!dfrd->finished && dfrd->reqid >= 0)
-    {
-        (*env)->CallObjectMethod(env, obj, _deferred_loop);
-        ERROR_CHECK(0);
-    }
-
-    assert(dfrd->encode_return);
-    return dfrd->encode_return(env, obj, dfrd);
+	struct hyperdex_java_client_deferred *dfrd = NULL;
+	dfrd = hyperdex_get_deferred_ptr(env, obj);
+	ERROR_CHECK(0);
+	while (!dfrd->finished && dfrd->reqid >= 0)
+	{
+		(*env)->CallObjectMethod(env, obj, _deferred_loop);
+		ERROR_CHECK(0);
+	}
+	assert(dfrd->encode_return);
+	return dfrd->encode_return(env, obj, dfrd);
 }
 
 JNIEXPORT HYPERDEX_API void JNICALL
-Java_org_hyperdex_client_Deferred_callback(JNIEnv* env, jobject obj)
+Java_org_hyperdex_client_Deferred_callback(JNIEnv *env, jobject obj)
 {
-    jobject client_obj;
-    struct hyperdex_java_client_deferred* dfrd = NULL;
-    dfrd = hyperdex_get_deferred_ptr(env, obj);
-    ERROR_CHECK_VOID();
-    dfrd->finished = 1;
-    client_obj = (*env)->GetObjectField(env, obj, _deferred_c);
-    (*env)->CallObjectMethod(env, client_obj, _client_remove_op, dfrd->reqid);
-    ERROR_CHECK_VOID();
+	jobject client_obj;
+	struct hyperdex_java_client_deferred *dfrd = NULL;
+	dfrd = hyperdex_get_deferred_ptr(env, obj);
+	ERROR_CHECK_VOID();
+	dfrd->finished = 1;
+	client_obj = (*env)->GetObjectField(env, obj, _deferred_c);
+	(*env)->CallObjectMethod(env, client_obj, _client_remove_op, dfrd->reqid);
+	ERROR_CHECK_VOID();
 }
 
 jobject
-hyperdex_java_client_deferred_encode_status(JNIEnv* env, jobject obj, struct hyperdex_java_client_deferred* d)
+hyperdex_java_client_deferred_encode_status(JNIEnv *env, jobject obj, struct hyperdex_java_client_deferred *d)
 {
-    jobject ret;
-    jobject client_obj;
-    struct hyperdex_client* client;
-
-    if (d->status == HYPERDEX_CLIENT_SUCCESS)
-    {
-        ret = (*env)->NewObject(env, _boolean, _boolean_init, JNI_TRUE);
-        ERROR_CHECK(0);
-        return ret;
-    }
-    else if (d->status == HYPERDEX_CLIENT_NOTFOUND)
-    {
-        return NULL;
-    }
-    else if (d->status == HYPERDEX_CLIENT_CMPFAIL)
-    {
-        ret = (*env)->NewObject(env, _boolean, _boolean_init, JNI_FALSE);
-        ERROR_CHECK(0);
-        return ret;
-    }
-    else
-    {
-        client_obj = (*env)->GetObjectField(env, obj, _deferred_c);
-        ERROR_CHECK(0);
-        client = hyperdex_get_client_ptr(env, client_obj);
-        hyperdex_java_client_throw_exception(env, d->status, hyperdex_client_error_message(client));
-        return 0;
-    }
+	jobject ret;
+	jobject client_obj;
+	struct hyperdex_client *client;
+	if (d->status == HYPERDEX_CLIENT_SUCCESS)
+	{
+		ret = (*env)->NewObject(env, _boolean, _boolean_init, JNI_TRUE);
+		ERROR_CHECK(0);
+		return ret;
+	}
+	else if (d->status == HYPERDEX_CLIENT_NOTFOUND)
+	{
+		return NULL;
+	}
+	else if (d->status == HYPERDEX_CLIENT_CMPFAIL)
+	{
+		ret = (*env)->NewObject(env, _boolean, _boolean_init, JNI_FALSE);
+		ERROR_CHECK(0);
+		return ret;
+	}
+	else
+	{
+		client_obj = (*env)->GetObjectField(env, obj, _deferred_c);
+		ERROR_CHECK(0);
+		client = hyperdex_get_client_ptr(env, client_obj);
+		hyperdex_java_client_throw_exception(env, d->status, hyperdex_client_error_message(client));
+		return 0;
+	}
 }
 
 static jobject
-hyperdex_java_client_deferred_encode_status_attributes(JNIEnv* env, jobject obj, struct hyperdex_java_client_deferred* d)
+hyperdex_java_client_deferred_encode_status_attributes(JNIEnv *env, jobject obj, struct hyperdex_java_client_deferred *d)
 {
-    jobject ret;
-    jobject client_obj;
-    struct hyperdex_client* client;
-
-    if (d->status == HYPERDEX_CLIENT_SUCCESS)
-    {
-        ret = hyperdex_java_client_build_attributes(env, d->attrs, d->attrs_sz);
-        ERROR_CHECK(0);
-        return ret;
-    }
-    else if (d->status == HYPERDEX_CLIENT_NOTFOUND)
-    {
-        return NULL;
-    }
-    else if (d->status == HYPERDEX_CLIENT_CMPFAIL)
-    {
-        ret = (*env)->NewObject(env, _boolean, _boolean_init, JNI_FALSE);
-        ERROR_CHECK(0);
-        return ret;
-    }
-    else
-    {
-        client_obj = (*env)->GetObjectField(env, obj, _deferred_c);
-        client = hyperdex_get_client_ptr(env, client_obj);
-        hyperdex_java_client_throw_exception(env, d->status, hyperdex_client_error_message(client));
-        return 0;
-    }
+	jobject ret;
+	jobject client_obj;
+	struct hyperdex_client *client;
+	if (d->status == HYPERDEX_CLIENT_SUCCESS)
+	{
+		ret = hyperdex_java_client_build_attributes(env, d->attrs, d->attrs_sz);
+		ERROR_CHECK(0);
+		return ret;
+	}
+	else if (d->status == HYPERDEX_CLIENT_NOTFOUND)
+	{
+		return NULL;
+	}
+	else if (d->status == HYPERDEX_CLIENT_CMPFAIL)
+	{
+		ret = (*env)->NewObject(env, _boolean, _boolean_init, JNI_FALSE);
+		ERROR_CHECK(0);
+		return ret;
+	}
+	else
+	{
+		client_obj = (*env)->GetObjectField(env, obj, _deferred_c);
+		client = hyperdex_get_client_ptr(env, client_obj);
+		hyperdex_java_client_throw_exception(env, d->status, hyperdex_client_error_message(client));
+		return 0;
+	}
 }
 
 jobject
-hyperdex_java_client_deferred_encode_status_count(JNIEnv* env, jobject obj, struct hyperdex_java_client_deferred* d)
+hyperdex_java_client_deferred_encode_status_count(JNIEnv *env, jobject obj, struct hyperdex_java_client_deferred *d)
 {
-    jobject ret;
-    jobject client_obj;
-    struct hyperdex_client* client;
-
-    if (d->status == HYPERDEX_CLIENT_SUCCESS)
-    {
-        ret = (*env)->NewObject(env, _long, _long_init, d->count);
-        ERROR_CHECK(0);
-        return ret;
-    }
-    else if (d->status == HYPERDEX_CLIENT_NOTFOUND)
-    {
-        return NULL;
-    }
-    else if (d->status == HYPERDEX_CLIENT_CMPFAIL)
-    {
-        ret = (*env)->NewObject(env, _boolean, _boolean_init, JNI_FALSE);
-        ERROR_CHECK(0);
-        return ret;
-    }
-    else
-    {
-        client_obj = (*env)->GetObjectField(env, obj, _deferred_c);
-        client = hyperdex_get_client_ptr(env, client_obj);
-        hyperdex_java_client_throw_exception(env, d->status, hyperdex_client_error_message(client));
-        return 0;
-    }
+	jobject ret;
+	jobject client_obj;
+	struct hyperdex_client *client;
+	if (d->status == HYPERDEX_CLIENT_SUCCESS)
+	{
+		ret = (*env)->NewObject(env, _long, _long_init, d->count);
+		ERROR_CHECK(0);
+		return ret;
+	}
+	else if (d->status == HYPERDEX_CLIENT_NOTFOUND)
+	{
+		return NULL;
+	}
+	else if (d->status == HYPERDEX_CLIENT_CMPFAIL)
+	{
+		ret = (*env)->NewObject(env, _boolean, _boolean_init, JNI_FALSE);
+		ERROR_CHECK(0);
+		return ret;
+	}
+	else
+	{
+		client_obj = (*env)->GetObjectField(env, obj, _deferred_c);
+		client = hyperdex_get_client_ptr(env, client_obj);
+		hyperdex_java_client_throw_exception(env, d->status, hyperdex_client_error_message(client));
+		return 0;
+	}
 }
 
 static jobject
-hyperdex_java_client_deferred_encode_status_description(JNIEnv* env, jobject obj, struct hyperdex_java_client_deferred* d)
+hyperdex_java_client_deferred_encode_status_description(JNIEnv *env, jobject obj, struct hyperdex_java_client_deferred *d)
 {
-    jobject ret;
-    jobject client_obj;
-    struct hyperdex_client* client;
-
-    if (d->status == HYPERDEX_CLIENT_SUCCESS)
-    {
-        ret = (*env)->NewStringUTF(env, d->description);
-        ERROR_CHECK(0);
-        return ret;
-    }
-    else if (d->status == HYPERDEX_CLIENT_NOTFOUND)
-    {
-        ret = (*env)->NewObject(env, _boolean, _boolean_init, JNI_TRUE);
-        ERROR_CHECK(0);
-        return ret;
-    }
-    else if (d->status == HYPERDEX_CLIENT_CMPFAIL)
-    {
-        ret = (*env)->NewObject(env, _boolean, _boolean_init, JNI_FALSE);
-        ERROR_CHECK(0);
-        return ret;
-    }
-    else
-    {
-        client_obj = (*env)->GetObjectField(env, obj, _deferred_c);
-        client = hyperdex_get_client_ptr(env, client_obj);
-        hyperdex_java_client_throw_exception(env, d->status, hyperdex_client_error_message(client));
-        return 0;
-    }
+	jobject ret;
+	jobject client_obj;
+	struct hyperdex_client *client;
+	if (d->status == HYPERDEX_CLIENT_SUCCESS)
+	{
+		ret = (*env)->NewStringUTF(env, d->description);
+		ERROR_CHECK(0);
+		return ret;
+	}
+	else if (d->status == HYPERDEX_CLIENT_NOTFOUND)
+	{
+		ret = (*env)->NewObject(env, _boolean, _boolean_init, JNI_TRUE);
+		ERROR_CHECK(0);
+		return ret;
+	}
+	else if (d->status == HYPERDEX_CLIENT_CMPFAIL)
+	{
+		ret = (*env)->NewObject(env, _boolean, _boolean_init, JNI_FALSE);
+		ERROR_CHECK(0);
+		return ret;
+	}
+	else
+	{
+		client_obj = (*env)->GetObjectField(env, obj, _deferred_c);
+		client = hyperdex_get_client_ptr(env, client_obj);
+		hyperdex_java_client_throw_exception(env, d->status, hyperdex_client_error_message(client));
+		return 0;
+	}
 }
 
 /******************************* Iterator Class *******************************/
 
 struct hyperdex_java_client_iterator
 {
-    struct hyperdex_ds_arena* arena;
-    int64_t reqid;
-    enum hyperdex_client_returncode status;
-    const struct hyperdex_client_attribute* attrs;
-    size_t attrs_sz;
-    int finished;
-    jobject (*encode_return)(JNIEnv* env, jobject obj, struct hyperdex_java_client_iterator* d);
+	struct hyperdex_ds_arena *arena;
+	int64_t reqid;
+	enum hyperdex_client_returncode status;
+	const struct hyperdex_client_attribute *attrs;
+	size_t attrs_sz;
+	int finished;
+	jobject (*encode_return)(JNIEnv *env, jobject obj, struct hyperdex_java_client_iterator *d);
 };
 
 JNIEXPORT HYPERDEX_API void JNICALL
-Java_org_hyperdex_client_Iterator__1create(JNIEnv* env, jobject iterator)
+Java_org_hyperdex_client_Iterator__1create(JNIEnv *env, jobject iterator)
 {
-    jlong lptr;
-    struct hyperdex_java_client_iterator* ptr;
-
-    lptr = (*env)->GetLongField(env, iterator, _iterator_ptr);
-    ERROR_CHECK_VOID();
-    ptr = malloc(sizeof(struct hyperdex_java_client_iterator));
-
-    if (!ptr)
-    {
-        hyperdex_java_out_of_memory(env);
-        return;
-    }
-
-    memset(ptr, 0, sizeof(struct hyperdex_java_client_iterator));
-    lptr = (long) ptr;
-    (*env)->SetLongField(env, iterator, _iterator_ptr, lptr);
-    ERROR_CHECK_VOID();
-
-    ptr->arena = hyperdex_ds_arena_create();
-
-    if (!ptr->arena)
-    {
-        /* all other resources are caught by the finalizer? */
-        hyperdex_java_out_of_memory(env);
-        return;
-    }
-
-    ptr->reqid = -1;
-    ptr->status = HYPERDEX_CLIENT_GARBAGE;
-    ptr->attrs = NULL;
-    ptr->attrs_sz = 0;
-    ptr->finished = 0;
-    ptr->encode_return = NULL;
+	jlong lptr;
+	struct hyperdex_java_client_iterator *ptr;
+	lptr = (*env)->GetLongField(env, iterator, _iterator_ptr);
+	ERROR_CHECK_VOID();
+	ptr = malloc(sizeof(struct hyperdex_java_client_iterator));
+	if (!ptr)
+	{
+		hyperdex_java_out_of_memory(env);
+		return;
+	}
+	memset(ptr, 0, sizeof(struct hyperdex_java_client_iterator));
+	lptr = (long) ptr;
+	(*env)->SetLongField(env, iterator, _iterator_ptr, lptr);
+	ERROR_CHECK_VOID();
+	ptr->arena = hyperdex_ds_arena_create();
+	if (!ptr->arena)
+	{
+		/* all other resources are caught by the finalizer? */
+		hyperdex_java_out_of_memory(env);
+		return;
+	}
+	ptr->reqid = -1;
+	ptr->status = HYPERDEX_CLIENT_GARBAGE;
+	ptr->attrs = NULL;
+	ptr->attrs_sz = 0;
+	ptr->finished = 0;
+	ptr->encode_return = NULL;
 }
 
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wcast-qual"
 JNIEXPORT HYPERDEX_API void JNICALL
-Java_org_hyperdex_client_Iterator__1destroy(JNIEnv* env, jobject iter)
+Java_org_hyperdex_client_Iterator__1destroy(JNIEnv *env, jobject iter)
 {
-    jlong lptr;
-    struct hyperdex_java_client_iterator* ptr;
-
-    lptr = (*env)->GetLongField(env, iter, _iterator_ptr);
-    ERROR_CHECK_VOID();
-    ptr = (struct hyperdex_java_client_iterator*)lptr;
-
-    if (ptr)
-    {
-        if (ptr->arena)
-        {
-            hyperdex_ds_arena_destroy(ptr->arena);
-        }
-
-        if (ptr->attrs)
-        {
-            hyperdex_client_destroy_attrs(ptr->attrs, ptr->attrs_sz);
-        }
-
-        free(ptr);
-    }
-
-    (*env)->SetLongField(env, iter, _iterator_ptr, 0);
-    ERROR_CHECK_VOID();
+	jlong lptr;
+	struct hyperdex_java_client_iterator *ptr;
+	lptr = (*env)->GetLongField(env, iter, _iterator_ptr);
+	ERROR_CHECK_VOID();
+	ptr = (struct hyperdex_java_client_iterator *)lptr;
+	if (ptr)
+	{
+		if (ptr->arena)
+		{
+			hyperdex_ds_arena_destroy(ptr->arena);
+		}
+		if (ptr->attrs)
+		{
+			hyperdex_client_destroy_attrs(ptr->attrs, ptr->attrs_sz);
+		}
+		free(ptr);
+	}
+	(*env)->SetLongField(env, iter, _iterator_ptr, 0);
+	ERROR_CHECK_VOID();
 }
 
 JNIEXPORT HYPERDEX_API jboolean JNICALL
-Java_org_hyperdex_client_Iterator_finished(JNIEnv* env, jobject obj)
+Java_org_hyperdex_client_Iterator_finished(JNIEnv *env, jobject obj)
 {
-    struct hyperdex_java_client_iterator* iter = NULL;
-    iter = hyperdex_get_iterator_ptr(env, obj);
-    return iter->finished == 1 ? JNI_TRUE : JNI_FALSE;
+	struct hyperdex_java_client_iterator *iter = NULL;
+	iter = hyperdex_get_iterator_ptr(env, obj);
+	return iter->finished == 1 ? JNI_TRUE : JNI_FALSE;
 }
 
 JNIEXPORT HYPERDEX_API void JNICALL
-Java_org_hyperdex_client_Iterator_callback(JNIEnv* env, jobject obj)
+Java_org_hyperdex_client_Iterator_callback(JNIEnv *env, jobject obj)
 {
-    jobject tmp;
-    jobject client_obj;
-    struct hyperdex_client* client;
-    struct hyperdex_java_client_iterator* iter = NULL;
-    iter = hyperdex_get_iterator_ptr(env, obj);
-    ERROR_CHECK_VOID();
-    client_obj = (*env)->GetObjectField(env, obj, _iterator_c);
-    ERROR_CHECK_VOID();
-
-    if (iter->status == HYPERDEX_CLIENT_SEARCHDONE)
-    {
-        iter->finished = 1;
-        (*env)->CallObjectMethod(env, client_obj, _client_remove_op, iter->reqid);
-        ERROR_CHECK_VOID();
-    }
-    else if (iter->status == HYPERDEX_CLIENT_SUCCESS)
-    {
-        tmp = iter->encode_return(env, obj, iter);
-
-        if (iter->attrs)
-        {
-            hyperdex_client_destroy_attrs(iter->attrs, iter->attrs_sz);
-        }
-
-        iter->attrs = NULL;
-        iter->attrs_sz = 0;
-        (*env)->CallObjectMethod(env, obj, _iterator_appendBacklogged, tmp);
-        ERROR_CHECK_VOID();
-    }
-    else
-    {
-        client_obj = (*env)->GetObjectField(env, obj, _iterator_c);
-        client = hyperdex_get_client_ptr(env, client_obj);
-        tmp = hyperdex_java_client_create_exception(env, iter->status,
-                                                    hyperdex_client_error_message(client));
-        (*env)->CallObjectMethod(env, obj, _iterator_appendBacklogged, tmp);
-        ERROR_CHECK_VOID();
-    }
+	jobject tmp;
+	jobject client_obj;
+	struct hyperdex_client *client;
+	struct hyperdex_java_client_iterator *iter = NULL;
+	iter = hyperdex_get_iterator_ptr(env, obj);
+	ERROR_CHECK_VOID();
+	client_obj = (*env)->GetObjectField(env, obj, _iterator_c);
+	ERROR_CHECK_VOID();
+	if (iter->status == HYPERDEX_CLIENT_SEARCHDONE)
+	{
+		iter->finished = 1;
+		(*env)->CallObjectMethod(env, client_obj, _client_remove_op, iter->reqid);
+		ERROR_CHECK_VOID();
+	}
+	else if (iter->status == HYPERDEX_CLIENT_SUCCESS)
+	{
+		tmp = iter->encode_return(env, obj, iter);
+		if (iter->attrs)
+		{
+			hyperdex_client_destroy_attrs(iter->attrs, iter->attrs_sz);
+		}
+		iter->attrs = NULL;
+		iter->attrs_sz = 0;
+		(*env)->CallObjectMethod(env, obj, _iterator_appendBacklogged, tmp);
+		ERROR_CHECK_VOID();
+	}
+	else
+	{
+		client_obj = (*env)->GetObjectField(env, obj, _iterator_c);
+		client = hyperdex_get_client_ptr(env, client_obj);
+		tmp = hyperdex_java_client_create_exception(env, iter->status,
+		                                            hyperdex_client_error_message(client));
+		(*env)->CallObjectMethod(env, obj, _iterator_appendBacklogged, tmp);
+		ERROR_CHECK_VOID();
+	}
 }
 
 static jobject
-hyperdex_java_client_iterator_encode_status_attributes(JNIEnv* env, jobject obj, struct hyperdex_java_client_iterator* it)
+hyperdex_java_client_iterator_encode_status_attributes(JNIEnv *env, jobject obj, struct hyperdex_java_client_iterator *it)
 {
-    jobject ret;
-    jobject client_obj;
-    struct hyperdex_client* client;
-
-    if (it->status == HYPERDEX_CLIENT_SUCCESS)
-    {
-        ret = hyperdex_java_client_build_attributes(env, it->attrs, it->attrs_sz);
-        ERROR_CHECK(0);
-        return ret;
-    }
-    else if (it->status == HYPERDEX_CLIENT_NOTFOUND)
-    {
-        ret = (*env)->NewObject(env, _boolean, _boolean_init, JNI_TRUE);
-        ERROR_CHECK(0);
-        return ret;
-    }
-    else if (it->status == HYPERDEX_CLIENT_CMPFAIL)
-    {
-        ret = (*env)->NewObject(env, _boolean, _boolean_init, JNI_FALSE);
-        ERROR_CHECK(0);
-        return ret;
-    }
-    else
-    {
-        client_obj = (*env)->GetObjectField(env, obj, _deferred_c);
-        client = hyperdex_get_client_ptr(env, client_obj);
-        hyperdex_java_client_throw_exception(env, it->status, hyperdex_client_error_message(client));
-        return 0;
-    }
+	jobject ret;
+	jobject client_obj;
+	struct hyperdex_client *client;
+	if (it->status == HYPERDEX_CLIENT_SUCCESS)
+	{
+		ret = hyperdex_java_client_build_attributes(env, it->attrs, it->attrs_sz);
+		ERROR_CHECK(0);
+		return ret;
+	}
+	else if (it->status == HYPERDEX_CLIENT_NOTFOUND)
+	{
+		ret = (*env)->NewObject(env, _boolean, _boolean_init, JNI_TRUE);
+		ERROR_CHECK(0);
+		return ret;
+	}
+	else if (it->status == HYPERDEX_CLIENT_CMPFAIL)
+	{
+		ret = (*env)->NewObject(env, _boolean, _boolean_init, JNI_FALSE);
+		ERROR_CHECK(0);
+		return ret;
+	}
+	else
+	{
+		client_obj = (*env)->GetObjectField(env, obj, _deferred_c);
+		client = hyperdex_get_client_ptr(env, client_obj);
+		hyperdex_java_client_throw_exception(env, it->status, hyperdex_client_error_message(client));
+		return 0;
+	}
 }
 
 
-const char*
-hyperdex_java_client_convert_cstring(JNIEnv* env,
-                                     struct hyperdex_ds_arena* arena,
+const char *
+hyperdex_java_client_convert_cstring(JNIEnv *env,
+                                     struct hyperdex_ds_arena *arena,
                                      jobject str)
 {
-    const char* tmp = NULL;
-    const char* ret = NULL;
-    size_t ret_sz = 0;
-    enum hyperdex_ds_returncode rc;
-    int success;
-    tmp = (*env)->GetStringUTFChars(env, str, 0);
-    ERROR_CHECK(NULL);
-    success = hyperdex_ds_copy_string(arena, tmp, strlen(tmp) + 1, &rc, &ret, &ret_sz);
-    (*env)->ReleaseStringUTFChars(env, str, tmp);
-    ERROR_CHECK(NULL);
-
-    if (success < 0)
-    {
-        hyperdex_java_out_of_memory(env);
-        return NULL;
-    }
-
-    return ret;
+	const char *tmp = NULL;
+	const char *ret = NULL;
+	size_t ret_sz = 0;
+	enum hyperdex_ds_returncode rc;
+	int success;
+	tmp = (*env)->GetStringUTFChars(env, str, 0);
+	ERROR_CHECK(NULL);
+	success = hyperdex_ds_copy_string(arena, tmp, strlen(tmp) + 1, &rc, &ret, &ret_sz);
+	(*env)->ReleaseStringUTFChars(env, str, tmp);
+	ERROR_CHECK(NULL);
+	if (success < 0)
+	{
+		hyperdex_java_out_of_memory(env);
+		return NULL;
+	}
+	return ret;
 }
 
 int
-hyperdex_java_client_convert_attributes(JNIEnv* env, jobject client,
-                                        struct hyperdex_ds_arena* arena,
+hyperdex_java_client_convert_attributes(JNIEnv *env, jobject client,
+                                        struct hyperdex_ds_arena *arena,
                                         jobject x,
-                                        const struct hyperdex_client_attribute** _attrs,
-                                        size_t* _attrs_sz)
+                                        const struct hyperdex_client_attribute **_attrs,
+                                        size_t *_attrs_sz)
 {
-    jobject set;
-    jobject it;
-    jobject entry;
-    jobject key;
-    jobject val;
-    struct hyperdex_client_attribute* attrs = NULL;
-    size_t attrs_sz = 0;
-    size_t attrs_idx = 0;
-
-    set = (*env)->CallObjectMethod(env, x, _map_entrySet);
-    ERROR_CHECK(-1);
-    it = (*env)->CallObjectMethod(env, set, _set_iterator);
-    ERROR_CHECK(-1);
-    attrs_sz = (*env)->CallIntMethod(env, x, _map_size);
-    ERROR_CHECK(-1);
-    attrs = hyperdex_ds_allocate_attribute(arena, attrs_sz);
-
-    if (!attrs)
-    {
-        hyperdex_java_out_of_memory(env);
-        return -1;
-    }
-
-    *_attrs = attrs;
-    *_attrs_sz = attrs_sz;
-    attrs_idx = 0;
-
-    while ((*env)->CallBooleanMethod(env, it, _java_iterator_hasNext) == JNI_TRUE)
-    {
-        entry = (*env)->CallObjectMethod(env, it, _java_iterator_next);
-        ERROR_CHECK(-1);
-        key = (*env)->CallObjectMethod(env, entry, _map_entry_getKey);
-        ERROR_CHECK(-1);
-        val = (*env)->CallObjectMethod(env, entry, _map_entry_getValue);
-        ERROR_CHECK(-1);
-        attrs[attrs_idx].attr = hyperdex_java_client_convert_cstring(env, arena, key);
-
-        if (!attrs[attrs_idx].attr)
-        {
-            return -1;
-        }
-
-        if (hyperdex_java_client_convert_type(env, arena, val,
-                                              &attrs[attrs_idx].value,
-                                              &attrs[attrs_idx].value_sz,
-                                              &attrs[attrs_idx].datatype) < 0)
-        {
-            return -1;
-        }
-
-        (*env)->DeleteLocalRef(env, val);
-        (*env)->DeleteLocalRef(env, key);
-        (*env)->DeleteLocalRef(env, entry);
-        ++attrs_idx;
-    }
-
-    (*env)->DeleteLocalRef(env, it);
-    (*env)->DeleteLocalRef(env, set);
-    (void)client;
-    return 0;
+	jobject set;
+	jobject it;
+	jobject entry;
+	jobject key;
+	jobject val;
+	struct hyperdex_client_attribute *attrs = NULL;
+	size_t attrs_sz = 0;
+	size_t attrs_idx = 0;
+	set = (*env)->CallObjectMethod(env, x, _map_entrySet);
+	ERROR_CHECK(-1);
+	it = (*env)->CallObjectMethod(env, set, _set_iterator);
+	ERROR_CHECK(-1);
+	attrs_sz = (*env)->CallIntMethod(env, x, _map_size);
+	ERROR_CHECK(-1);
+	attrs = hyperdex_ds_allocate_attribute(arena, attrs_sz);
+	if (!attrs)
+	{
+		hyperdex_java_out_of_memory(env);
+		return -1;
+	}
+	*_attrs = attrs;
+	*_attrs_sz = attrs_sz;
+	attrs_idx = 0;
+	while ((*env)->CallBooleanMethod(env, it, _java_iterator_hasNext) == JNI_TRUE)
+	{
+		entry = (*env)->CallObjectMethod(env, it, _java_iterator_next);
+		ERROR_CHECK(-1);
+		key = (*env)->CallObjectMethod(env, entry, _map_entry_getKey);
+		ERROR_CHECK(-1);
+		val = (*env)->CallObjectMethod(env, entry, _map_entry_getValue);
+		ERROR_CHECK(-1);
+		attrs[attrs_idx].attr = hyperdex_java_client_convert_cstring(env, arena, key);
+		if (!attrs[attrs_idx].attr)
+		{
+			return -1;
+		}
+		if (hyperdex_java_client_convert_type(env, arena, val,
+		                                      &attrs[attrs_idx].value,
+		                                      &attrs[attrs_idx].value_sz,
+		                                      &attrs[attrs_idx].datatype) < 0)
+		{
+			return -1;
+		}
+		(*env)->DeleteLocalRef(env, val);
+		(*env)->DeleteLocalRef(env, key);
+		(*env)->DeleteLocalRef(env, entry);
+		++attrs_idx;
+	}
+	(*env)->DeleteLocalRef(env, it);
+	(*env)->DeleteLocalRef(env, set);
+	(void)client;
+	return 0;
 }
 
 /********************************* Predicates *********************************/
 
 #define SINGLE_OBJECT_PREDICATE(CamelCase, lower_case, PREDICATE) \
-    JNIEXPORT HYPERDEX_API jlong JNICALL \
-    Java_org_hyperdex_client_ ## CamelCase ## _checksSize(JNIEnv* env, jobject obj) \
-    { \
-        (void) env; \
-        (void) obj; \
-        return 1; \
-    } \
-    JNIEXPORT HYPERDEX_API jlong JNICALL \
-    Java_org_hyperdex_client_ ## CamelCase ## _convertChecks(JNIEnv* env, jobject obj, jlong arena, \
-                                                             jlong _checks, jlong checks_sz) \
-    { \
-        struct hyperdex_client_attribute_check* checks = (struct hyperdex_client_attribute_check*) _checks; \
-        jobject x = (*env)->GetObjectField(env, obj, _pred_ ## lower_case ## _x); \
-        ERROR_CHECK(-1); \
-        checks[checks_sz].predicate = HYPERPREDICATE_ ## PREDICATE; \
-        if (hyperdex_java_client_convert_type(env, (struct hyperdex_ds_arena*)arena, x, \
-                                              &checks[checks_sz].value, \
-                                              &checks[checks_sz].value_sz, \
-                                              &checks[checks_sz].datatype) < 0) \
-        { \
-            return -1; \
-        } \
-        ERROR_CHECK(-1); \
-        return checks_sz + 1; \
-    }
+	JNIEXPORT HYPERDEX_API jlong JNICALL \
+	Java_org_hyperdex_client_ ## CamelCase ## _checksSize(JNIEnv* env, jobject obj) \
+	{ \
+		(void) env; \
+		(void) obj; \
+		return 1; \
+	} \
+	JNIEXPORT HYPERDEX_API jlong JNICALL \
+	Java_org_hyperdex_client_ ## CamelCase ## _convertChecks(JNIEnv* env, jobject obj, jlong arena, \
+	        jlong _checks, jlong checks_sz) \
+	{ \
+		struct hyperdex_client_attribute_check* checks = (struct hyperdex_client_attribute_check*) _checks; \
+		jobject x = (*env)->GetObjectField(env, obj, _pred_ ## lower_case ## _x); \
+		ERROR_CHECK(-1); \
+		checks[checks_sz].predicate = HYPERPREDICATE_ ## PREDICATE; \
+		if (hyperdex_java_client_convert_type(env, (struct hyperdex_ds_arena*)arena, x, \
+		                                      &checks[checks_sz].value, \
+		                                      &checks[checks_sz].value_sz, \
+		                                      &checks[checks_sz].datatype) < 0) \
+		{ \
+			return -1; \
+		} \
+		ERROR_CHECK(-1); \
+		return checks_sz + 1; \
+	}
 
 SINGLE_OBJECT_PREDICATE(LessEqual, less_equal, LESS_EQUAL)
 SINGLE_OBJECT_PREDICATE(GreaterEqual, greater_equal, GREATER_EQUAL)
@@ -2268,44 +2085,41 @@ SINGLE_OBJECT_PREDICATE(LessThan, less_equal, LESS_THAN)
 SINGLE_OBJECT_PREDICATE(GreaterThan, greater_equal, GREATER_THAN)
 
 JNIEXPORT HYPERDEX_API jlong JNICALL
-Java_org_hyperdex_client_Range_checksSize(JNIEnv* env, jobject obj)
+Java_org_hyperdex_client_Range_checksSize(JNIEnv *env, jobject obj)
 {
-    (void) env;
-    (void) obj;
-    return 2;
+	(void) env;
+	(void) obj;
+	return 2;
 }
 
 JNIEXPORT HYPERDEX_API jlong JNICALL
-Java_org_hyperdex_client_Range_convertChecks(JNIEnv* env, jobject obj, jlong arena,
+Java_org_hyperdex_client_Range_convertChecks(JNIEnv *env, jobject obj, jlong arena,
                                              jlong _checks, jlong checks_sz)
 {
-    struct hyperdex_client_attribute_check* checks = (struct hyperdex_client_attribute_check*) _checks;
-    jobject x;
-    jobject y;
-    x = (*env)->GetObjectField(env, obj, _pred_range_x);
-    y = (*env)->GetObjectField(env, obj, _pred_range_y);
-    ERROR_CHECK(-1);
-    checks[checks_sz + 0].predicate = HYPERPREDICATE_GREATER_EQUAL;
-    checks[checks_sz + 1].predicate = HYPERPREDICATE_LESS_EQUAL;
-
-    if (hyperdex_java_client_convert_type(env, (struct hyperdex_ds_arena*)arena, x,
-                                          &checks[checks_sz].value,
-                                          &checks[checks_sz].value_sz,
-                                          &checks[checks_sz].datatype) < 0)
-    {
-        return -1;
-    }
-
-    if (hyperdex_java_client_convert_type(env, (struct hyperdex_ds_arena*)arena, y,
-                                          &checks[checks_sz + 1].value,
-                                          &checks[checks_sz + 1].value_sz,
-                                          &checks[checks_sz + 1].datatype) < 0)
-    {
-        return -1;
-    }
-
-    ERROR_CHECK(-1);
-    return checks_sz + 2;
+	struct hyperdex_client_attribute_check *checks = (struct hyperdex_client_attribute_check *) _checks;
+	jobject x;
+	jobject y;
+	x = (*env)->GetObjectField(env, obj, _pred_range_x);
+	y = (*env)->GetObjectField(env, obj, _pred_range_y);
+	ERROR_CHECK(-1);
+	checks[checks_sz + 0].predicate = HYPERPREDICATE_GREATER_EQUAL;
+	checks[checks_sz + 1].predicate = HYPERPREDICATE_LESS_EQUAL;
+	if (hyperdex_java_client_convert_type(env, (struct hyperdex_ds_arena *)arena, x,
+	                                      &checks[checks_sz].value,
+	                                      &checks[checks_sz].value_sz,
+	                                      &checks[checks_sz].datatype) < 0)
+	{
+		return -1;
+	}
+	if (hyperdex_java_client_convert_type(env, (struct hyperdex_ds_arena *)arena, y,
+	                                      &checks[checks_sz + 1].value,
+	                                      &checks[checks_sz + 1].value_sz,
+	                                      &checks[checks_sz + 1].datatype) < 0)
+	{
+		return -1;
+	}
+	ERROR_CHECK(-1);
+	return checks_sz + 2;
 }
 
 SINGLE_OBJECT_PREDICATE(Regex, regex, REGEX)
@@ -2316,71 +2130,62 @@ SINGLE_OBJECT_PREDICATE(LengthGreaterEqual, length_greater_equal, LENGTH_GREATER
 /******************************** Client Class ********************************/
 
 JNIEXPORT HYPERDEX_API void JNICALL
-Java_org_hyperdex_client_Client__1create(JNIEnv* env, jobject client, jstring _host, jint port)
+Java_org_hyperdex_client_Client__1create(JNIEnv *env, jobject client, jstring _host, jint port)
 {
-    jlong lptr;
-    const char* host;
-    struct hyperdex_client* ptr;
-
-    lptr = (*env)->GetLongField(env, client, _client_ptr);
-    ERROR_CHECK_VOID();
-    host = (*env)->GetStringUTFChars(env, _host, NULL);
-    ERROR_CHECK_VOID();
-    ptr = hyperdex_client_create(host, port);
-    (*env)->ReleaseStringUTFChars(env, _host, host);
-
-    if (!ptr)
-    {
-        hyperdex_java_out_of_memory(env);
-        return;
-    }
-
-    ERROR_CHECK_VOID();
-    lptr = (long) ptr;
-    (*env)->SetLongField(env, client, _client_ptr, lptr);
-    ERROR_CHECK_VOID();
-    assert(sizeof(long) >= sizeof(struct hyperdex_client*));
+	jlong lptr;
+	const char *host;
+	struct hyperdex_client *ptr;
+	lptr = (*env)->GetLongField(env, client, _client_ptr);
+	ERROR_CHECK_VOID();
+	host = (*env)->GetStringUTFChars(env, _host, NULL);
+	ERROR_CHECK_VOID();
+	ptr = hyperdex_client_create(host, port);
+	(*env)->ReleaseStringUTFChars(env, _host, host);
+	if (!ptr)
+	{
+		hyperdex_java_out_of_memory(env);
+		return;
+	}
+	ERROR_CHECK_VOID();
+	lptr = (long) ptr;
+	(*env)->SetLongField(env, client, _client_ptr, lptr);
+	ERROR_CHECK_VOID();
+	assert(sizeof(long) >= sizeof(struct hyperdex_client *));
 }
 
 JNIEXPORT HYPERDEX_API void JNICALL
-Java_org_hyperdex_client_Client__1destroy(JNIEnv* env, jobject client)
+Java_org_hyperdex_client_Client__1destroy(JNIEnv *env, jobject client)
 {
-    jlong lptr;
-    struct hyperdex_client* ptr;
-
-    lptr = (*env)->GetLongField(env, client, _client_ptr);
-    ERROR_CHECK_VOID();
-    ptr = (struct hyperdex_client*)lptr;
-
-    if (ptr)
-    {
-        hyperdex_client_destroy(ptr);
-    }
-
-    (*env)->SetLongField(env, client, _client_ptr, 0);
-    ERROR_CHECK_VOID();
+	jlong lptr;
+	struct hyperdex_client *ptr;
+	lptr = (*env)->GetLongField(env, client, _client_ptr);
+	ERROR_CHECK_VOID();
+	ptr = (struct hyperdex_client *)lptr;
+	if (ptr)
+	{
+		hyperdex_client_destroy(ptr);
+	}
+	(*env)->SetLongField(env, client, _client_ptr, 0);
+	ERROR_CHECK_VOID();
 }
 
 JNIEXPORT HYPERDEX_API jlong JNICALL
-Java_org_hyperdex_client_Client_inner_1loop(JNIEnv* env, jobject client)
+Java_org_hyperdex_client_Client_inner_1loop(JNIEnv *env, jobject client)
 {
-    struct hyperdex_client* ptr;
-    int64_t x;
-    jlong y;
-    enum hyperdex_client_returncode rc;
-
-    ptr = hyperdex_get_client_ptr(env, client);
-    x = hyperdex_client_loop(ptr, -1, &rc);
-
-    if (x < 0)
-    {
-        hyperdex_java_client_throw_exception(env, rc, hyperdex_client_error_message(ptr));
-        return -1;
-    }
-
-    y = (jlong)x;
-    assert(x == y);
-    return y;
+	struct hyperdex_client *ptr;
+	int64_t x;
+	jlong y;
+	enum hyperdex_client_returncode rc;
+	ptr = hyperdex_get_client_ptr(env, client);
+	x = hyperdex_client_loop(ptr, -1, &rc);
+	if (x < 0)
+	{
+		hyperdex_java_client_throw_exception(env, rc, hyperdex_client_error_message(ptr));
+		return -1;
+	}
+	y = (jlong)x;
+	assert(x == y);
+	return y;
 }
 
 #include "bindings/java/org_hyperdex_client_Client.definitions.c"
diff --git a/bindings/java/org_hyperdex_client_Client.definitions.c b/bindings/java/org_hyperdex_client_Client.definitions.c
index 685ddaa93..a9f66639b 100644
--- a/bindings/java/org_hyperdex_client_Client.definitions.c
+++ b/bindings/java/org_hyperdex_client_Client.definitions.c
@@ -30,1257 +30,1271 @@
 #include "visibility.h"
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-hyperdex_java_client_asynccall__spacename_key__status_attributes(JNIEnv* env, jobject obj, int64_t (*f)(struct hyperdex_client* client, const char* space, const char* key, size_t key_sz, enum hyperdex_client_returncode* status, const struct hyperdex_client_attribute** attrs, size_t* attrs_sz), jstring spacename, jobject key);
-
-JNIEXPORT HYPERDEX_API jobject JNICALL
-hyperdex_java_client_asynccall__spacename_key__status_attributes(JNIEnv* env, jobject obj, int64_t (*f)(struct hyperdex_client* client, const char* space, const char* key, size_t key_sz, enum hyperdex_client_returncode* status, const struct hyperdex_client_attribute** attrs, size_t* attrs_sz), jstring spacename, jobject key)
-{
-    const char* in_space;
-    const char* in_key;
-    size_t in_key_sz;
-    int success = 0;
-    struct hyperdex_client* client = hyperdex_get_client_ptr(env, obj);
-    jobject op = (*env)->NewObject(env, _deferred, _deferred_init, obj);
-    struct hyperdex_java_client_deferred* o = NULL;
-    ERROR_CHECK(0);
-    o = hyperdex_get_deferred_ptr(env, op);
-    ERROR_CHECK(0);
-    success = hyperdex_java_client_convert_spacename(env, obj, o->arena, spacename, &in_space);
-    if (success < 0) return 0;
-    success = hyperdex_java_client_convert_key(env, obj, o->arena, key, &in_key, &in_key_sz);
-    if (success < 0) return 0;
-    o->reqid = f(client, in_space, in_key, in_key_sz, &o->status, &o->attrs, &o->attrs_sz);
-
-    if (o->reqid < 0)
-    {
-        hyperdex_java_client_throw_exception(env, o->status, hyperdex_client_error_message(client));
-        return 0;
-    }
-
-    o->encode_return = hyperdex_java_client_deferred_encode_status_attributes;
-    (*env)->CallObjectMethod(env, obj, _client_add_op, o->reqid, op);
-    ERROR_CHECK(0);
-    return op;
-}
-
-JNIEXPORT HYPERDEX_API jobject JNICALL
-hyperdex_java_client_asynccall__spacename_key_attributenames__status_attributes(JNIEnv* env, jobject obj, int64_t (*f)(struct hyperdex_client* client, const char* space, const char* key, size_t key_sz, const char** attrnames, size_t attrnames_sz, enum hyperdex_client_returncode* status, const struct hyperdex_client_attribute** attrs, size_t* attrs_sz), jstring spacename, jobject key, jobject attributenames);
-
-JNIEXPORT HYPERDEX_API jobject JNICALL
-hyperdex_java_client_asynccall__spacename_key_attributenames__status_attributes(JNIEnv* env, jobject obj, int64_t (*f)(struct hyperdex_client* client, const char* space, const char* key, size_t key_sz, const char** attrnames, size_t attrnames_sz, enum hyperdex_client_returncode* status, const struct hyperdex_client_attribute** attrs, size_t* attrs_sz), jstring spacename, jobject key, jobject attributenames)
-{
-    const char* in_space;
-    const char* in_key;
-    size_t in_key_sz;
-    const char** in_attrnames;
-    size_t in_attrnames_sz;
-    int success = 0;
-    struct hyperdex_client* client = hyperdex_get_client_ptr(env, obj);
-    jobject op = (*env)->NewObject(env, _deferred, _deferred_init, obj);
-    struct hyperdex_java_client_deferred* o = NULL;
-    ERROR_CHECK(0);
-    o = hyperdex_get_deferred_ptr(env, op);
-    ERROR_CHECK(0);
-    success = hyperdex_java_client_convert_spacename(env, obj, o->arena, spacename, &in_space);
-    if (success < 0) return 0;
-    success = hyperdex_java_client_convert_key(env, obj, o->arena, key, &in_key, &in_key_sz);
-    if (success < 0) return 0;
-    success = hyperdex_java_client_convert_attributenames(env, obj, o->arena, attributenames, &in_attrnames, &in_attrnames_sz);
-    if (success < 0) return 0;
-    o->reqid = f(client, in_space, in_key, in_key_sz, in_attrnames, in_attrnames_sz, &o->status, &o->attrs, &o->attrs_sz);
-
-    if (o->reqid < 0)
-    {
-        hyperdex_java_client_throw_exception(env, o->status, hyperdex_client_error_message(client));
-        return 0;
-    }
-
-    o->encode_return = hyperdex_java_client_deferred_encode_status_attributes;
-    (*env)->CallObjectMethod(env, obj, _client_add_op, o->reqid, op);
-    ERROR_CHECK(0);
-    return op;
-}
-
-JNIEXPORT HYPERDEX_API jobject JNICALL
-hyperdex_java_client_asynccall__spacename_key_attributes__status(JNIEnv* env, jobject obj, int64_t (*f)(struct hyperdex_client* client, const char* space, const char* key, size_t key_sz, const struct hyperdex_client_attribute* attrs, size_t attrs_sz, enum hyperdex_client_returncode* status), jstring spacename, jobject key, jobject attributes);
-
-JNIEXPORT HYPERDEX_API jobject JNICALL
-hyperdex_java_client_asynccall__spacename_key_attributes__status(JNIEnv* env, jobject obj, int64_t (*f)(struct hyperdex_client* client, const char* space, const char* key, size_t key_sz, const struct hyperdex_client_attribute* attrs, size_t attrs_sz, enum hyperdex_client_returncode* status), jstring spacename, jobject key, jobject attributes)
-{
-    const char* in_space;
-    const char* in_key;
-    size_t in_key_sz;
-    const struct hyperdex_client_attribute* in_attrs;
-    size_t in_attrs_sz;
-    int success = 0;
-    struct hyperdex_client* client = hyperdex_get_client_ptr(env, obj);
-    jobject op = (*env)->NewObject(env, _deferred, _deferred_init, obj);
-    struct hyperdex_java_client_deferred* o = NULL;
-    ERROR_CHECK(0);
-    o = hyperdex_get_deferred_ptr(env, op);
-    ERROR_CHECK(0);
-    success = hyperdex_java_client_convert_spacename(env, obj, o->arena, spacename, &in_space);
-    if (success < 0) return 0;
-    success = hyperdex_java_client_convert_key(env, obj, o->arena, key, &in_key, &in_key_sz);
-    if (success < 0) return 0;
-    success = hyperdex_java_client_convert_attributes(env, obj, o->arena, attributes, &in_attrs, &in_attrs_sz);
-    if (success < 0) return 0;
-    o->reqid = f(client, in_space, in_key, in_key_sz, in_attrs, in_attrs_sz, &o->status);
-
-    if (o->reqid < 0)
-    {
-        hyperdex_java_client_throw_exception(env, o->status, hyperdex_client_error_message(client));
-        return 0;
-    }
-
-    o->encode_return = hyperdex_java_client_deferred_encode_status;
-    (*env)->CallObjectMethod(env, obj, _client_add_op, o->reqid, op);
-    ERROR_CHECK(0);
-    return op;
-}
-
-JNIEXPORT HYPERDEX_API jobject JNICALL
-hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(JNIEnv* env, jobject obj, int64_t (*f)(struct hyperdex_client* client, const char* space, const char* key, size_t key_sz, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, const struct hyperdex_client_attribute* attrs, size_t attrs_sz, enum hyperdex_client_returncode* status), jstring spacename, jobject key, jobject predicates, jobject attributes);
-
-JNIEXPORT HYPERDEX_API jobject JNICALL
-hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(JNIEnv* env, jobject obj, int64_t (*f)(struct hyperdex_client* client, const char* space, const char* key, size_t key_sz, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, const struct hyperdex_client_attribute* attrs, size_t attrs_sz, enum hyperdex_client_returncode* status), jstring spacename, jobject key, jobject predicates, jobject attributes)
-{
-    const char* in_space;
-    const char* in_key;
-    size_t in_key_sz;
-    const struct hyperdex_client_attribute_check* in_checks;
-    size_t in_checks_sz;
-    const struct hyperdex_client_attribute* in_attrs;
-    size_t in_attrs_sz;
-    int success = 0;
-    struct hyperdex_client* client = hyperdex_get_client_ptr(env, obj);
-    jobject op = (*env)->NewObject(env, _deferred, _deferred_init, obj);
-    struct hyperdex_java_client_deferred* o = NULL;
-    ERROR_CHECK(0);
-    o = hyperdex_get_deferred_ptr(env, op);
-    ERROR_CHECK(0);
-    success = hyperdex_java_client_convert_spacename(env, obj, o->arena, spacename, &in_space);
-    if (success < 0) return 0;
-    success = hyperdex_java_client_convert_key(env, obj, o->arena, key, &in_key, &in_key_sz);
-    if (success < 0) return 0;
-    success = hyperdex_java_client_convert_predicates(env, obj, o->arena, predicates, &in_checks, &in_checks_sz);
-    if (success < 0) return 0;
-    success = hyperdex_java_client_convert_attributes(env, obj, o->arena, attributes, &in_attrs, &in_attrs_sz);
-    if (success < 0) return 0;
-    o->reqid = f(client, in_space, in_key, in_key_sz, in_checks, in_checks_sz, in_attrs, in_attrs_sz, &o->status);
-
-    if (o->reqid < 0)
-    {
-        hyperdex_java_client_throw_exception(env, o->status, hyperdex_client_error_message(client));
-        return 0;
-    }
-
-    o->encode_return = hyperdex_java_client_deferred_encode_status;
-    (*env)->CallObjectMethod(env, obj, _client_add_op, o->reqid, op);
-    ERROR_CHECK(0);
-    return op;
-}
-
-JNIEXPORT HYPERDEX_API jobject JNICALL
-hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(JNIEnv* env, jobject obj, int64_t (*f)(struct hyperdex_client* client, const char* space, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, const struct hyperdex_client_attribute* attrs, size_t attrs_sz, enum hyperdex_client_returncode* status, uint64_t* count), jstring spacename, jobject predicates, jobject attributes);
-
-JNIEXPORT HYPERDEX_API jobject JNICALL
-hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(JNIEnv* env, jobject obj, int64_t (*f)(struct hyperdex_client* client, const char* space, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, const struct hyperdex_client_attribute* attrs, size_t attrs_sz, enum hyperdex_client_returncode* status, uint64_t* count), jstring spacename, jobject predicates, jobject attributes)
-{
-    const char* in_space;
-    const struct hyperdex_client_attribute_check* in_checks;
-    size_t in_checks_sz;
-    const struct hyperdex_client_attribute* in_attrs;
-    size_t in_attrs_sz;
-    int success = 0;
-    struct hyperdex_client* client = hyperdex_get_client_ptr(env, obj);
-    jobject op = (*env)->NewObject(env, _deferred, _deferred_init, obj);
-    struct hyperdex_java_client_deferred* o = NULL;
-    ERROR_CHECK(0);
-    o = hyperdex_get_deferred_ptr(env, op);
-    ERROR_CHECK(0);
-    success = hyperdex_java_client_convert_spacename(env, obj, o->arena, spacename, &in_space);
-    if (success < 0) return 0;
-    success = hyperdex_java_client_convert_predicates(env, obj, o->arena, predicates, &in_checks, &in_checks_sz);
-    if (success < 0) return 0;
-    success = hyperdex_java_client_convert_attributes(env, obj, o->arena, attributes, &in_attrs, &in_attrs_sz);
-    if (success < 0) return 0;
-    o->reqid = f(client, in_space, in_checks, in_checks_sz, in_attrs, in_attrs_sz, &o->status, &o->count);
-
-    if (o->reqid < 0)
-    {
-        hyperdex_java_client_throw_exception(env, o->status, hyperdex_client_error_message(client));
-        return 0;
-    }
-
-    o->encode_return = hyperdex_java_client_deferred_encode_status_count;
-    (*env)->CallObjectMethod(env, obj, _client_add_op, o->reqid, op);
-    ERROR_CHECK(0);
-    return op;
-}
-
-JNIEXPORT HYPERDEX_API jobject JNICALL
-hyperdex_java_client_asynccall__spacename_key__status(JNIEnv* env, jobject obj, int64_t (*f)(struct hyperdex_client* client, const char* space, const char* key, size_t key_sz, enum hyperdex_client_returncode* status), jstring spacename, jobject key);
-
-JNIEXPORT HYPERDEX_API jobject JNICALL
-hyperdex_java_client_asynccall__spacename_key__status(JNIEnv* env, jobject obj, int64_t (*f)(struct hyperdex_client* client, const char* space, const char* key, size_t key_sz, enum hyperdex_client_returncode* status), jstring spacename, jobject key)
-{
-    const char* in_space;
-    const char* in_key;
-    size_t in_key_sz;
-    int success = 0;
-    struct hyperdex_client* client = hyperdex_get_client_ptr(env, obj);
-    jobject op = (*env)->NewObject(env, _deferred, _deferred_init, obj);
-    struct hyperdex_java_client_deferred* o = NULL;
-    ERROR_CHECK(0);
-    o = hyperdex_get_deferred_ptr(env, op);
-    ERROR_CHECK(0);
-    success = hyperdex_java_client_convert_spacename(env, obj, o->arena, spacename, &in_space);
-    if (success < 0) return 0;
-    success = hyperdex_java_client_convert_key(env, obj, o->arena, key, &in_key, &in_key_sz);
-    if (success < 0) return 0;
-    o->reqid = f(client, in_space, in_key, in_key_sz, &o->status);
-
-    if (o->reqid < 0)
-    {
-        hyperdex_java_client_throw_exception(env, o->status, hyperdex_client_error_message(client));
-        return 0;
-    }
-
-    o->encode_return = hyperdex_java_client_deferred_encode_status;
-    (*env)->CallObjectMethod(env, obj, _client_add_op, o->reqid, op);
-    ERROR_CHECK(0);
-    return op;
-}
-
-JNIEXPORT HYPERDEX_API jobject JNICALL
-hyperdex_java_client_asynccall__spacename_key_predicates__status(JNIEnv* env, jobject obj, int64_t (*f)(struct hyperdex_client* client, const char* space, const char* key, size_t key_sz, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, enum hyperdex_client_returncode* status), jstring spacename, jobject key, jobject predicates);
-
-JNIEXPORT HYPERDEX_API jobject JNICALL
-hyperdex_java_client_asynccall__spacename_key_predicates__status(JNIEnv* env, jobject obj, int64_t (*f)(struct hyperdex_client* client, const char* space, const char* key, size_t key_sz, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, enum hyperdex_client_returncode* status), jstring spacename, jobject key, jobject predicates)
-{
-    const char* in_space;
-    const char* in_key;
-    size_t in_key_sz;
-    const struct hyperdex_client_attribute_check* in_checks;
-    size_t in_checks_sz;
-    int success = 0;
-    struct hyperdex_client* client = hyperdex_get_client_ptr(env, obj);
-    jobject op = (*env)->NewObject(env, _deferred, _deferred_init, obj);
-    struct hyperdex_java_client_deferred* o = NULL;
-    ERROR_CHECK(0);
-    o = hyperdex_get_deferred_ptr(env, op);
-    ERROR_CHECK(0);
-    success = hyperdex_java_client_convert_spacename(env, obj, o->arena, spacename, &in_space);
-    if (success < 0) return 0;
-    success = hyperdex_java_client_convert_key(env, obj, o->arena, key, &in_key, &in_key_sz);
-    if (success < 0) return 0;
-    success = hyperdex_java_client_convert_predicates(env, obj, o->arena, predicates, &in_checks, &in_checks_sz);
-    if (success < 0) return 0;
-    o->reqid = f(client, in_space, in_key, in_key_sz, in_checks, in_checks_sz, &o->status);
-
-    if (o->reqid < 0)
-    {
-        hyperdex_java_client_throw_exception(env, o->status, hyperdex_client_error_message(client));
-        return 0;
-    }
-
-    o->encode_return = hyperdex_java_client_deferred_encode_status;
-    (*env)->CallObjectMethod(env, obj, _client_add_op, o->reqid, op);
-    ERROR_CHECK(0);
-    return op;
-}
-
-JNIEXPORT HYPERDEX_API jobject JNICALL
-hyperdex_java_client_asynccall__spacename_predicates__status_count(JNIEnv* env, jobject obj, int64_t (*f)(struct hyperdex_client* client, const char* space, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, enum hyperdex_client_returncode* status, uint64_t* count), jstring spacename, jobject predicates);
-
-JNIEXPORT HYPERDEX_API jobject JNICALL
-hyperdex_java_client_asynccall__spacename_predicates__status_count(JNIEnv* env, jobject obj, int64_t (*f)(struct hyperdex_client* client, const char* space, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, enum hyperdex_client_returncode* status, uint64_t* count), jstring spacename, jobject predicates)
-{
-    const char* in_space;
-    const struct hyperdex_client_attribute_check* in_checks;
-    size_t in_checks_sz;
-    int success = 0;
-    struct hyperdex_client* client = hyperdex_get_client_ptr(env, obj);
-    jobject op = (*env)->NewObject(env, _deferred, _deferred_init, obj);
-    struct hyperdex_java_client_deferred* o = NULL;
-    ERROR_CHECK(0);
-    o = hyperdex_get_deferred_ptr(env, op);
-    ERROR_CHECK(0);
-    success = hyperdex_java_client_convert_spacename(env, obj, o->arena, spacename, &in_space);
-    if (success < 0) return 0;
-    success = hyperdex_java_client_convert_predicates(env, obj, o->arena, predicates, &in_checks, &in_checks_sz);
-    if (success < 0) return 0;
-    o->reqid = f(client, in_space, in_checks, in_checks_sz, &o->status, &o->count);
-
-    if (o->reqid < 0)
-    {
-        hyperdex_java_client_throw_exception(env, o->status, hyperdex_client_error_message(client));
-        return 0;
-    }
-
-    o->encode_return = hyperdex_java_client_deferred_encode_status_count;
-    (*env)->CallObjectMethod(env, obj, _client_add_op, o->reqid, op);
-    ERROR_CHECK(0);
-    return op;
-}
-
-JNIEXPORT HYPERDEX_API jobject JNICALL
-hyperdex_java_client_asynccall__spacename_key_mapattributes__status(JNIEnv* env, jobject obj, int64_t (*f)(struct hyperdex_client* client, const char* space, const char* key, size_t key_sz, const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz, enum hyperdex_client_returncode* status), jstring spacename, jobject key, jobject mapattributes);
-
-JNIEXPORT HYPERDEX_API jobject JNICALL
-hyperdex_java_client_asynccall__spacename_key_mapattributes__status(JNIEnv* env, jobject obj, int64_t (*f)(struct hyperdex_client* client, const char* space, const char* key, size_t key_sz, const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz, enum hyperdex_client_returncode* status), jstring spacename, jobject key, jobject mapattributes)
-{
-    const char* in_space;
-    const char* in_key;
-    size_t in_key_sz;
-    const struct hyperdex_client_map_attribute* in_mapattrs;
-    size_t in_mapattrs_sz;
-    int success = 0;
-    struct hyperdex_client* client = hyperdex_get_client_ptr(env, obj);
-    jobject op = (*env)->NewObject(env, _deferred, _deferred_init, obj);
-    struct hyperdex_java_client_deferred* o = NULL;
-    ERROR_CHECK(0);
-    o = hyperdex_get_deferred_ptr(env, op);
-    ERROR_CHECK(0);
-    success = hyperdex_java_client_convert_spacename(env, obj, o->arena, spacename, &in_space);
-    if (success < 0) return 0;
-    success = hyperdex_java_client_convert_key(env, obj, o->arena, key, &in_key, &in_key_sz);
-    if (success < 0) return 0;
-    success = hyperdex_java_client_convert_mapattributes(env, obj, o->arena, mapattributes, &in_mapattrs, &in_mapattrs_sz);
-    if (success < 0) return 0;
-    o->reqid = f(client, in_space, in_key, in_key_sz, in_mapattrs, in_mapattrs_sz, &o->status);
-
-    if (o->reqid < 0)
-    {
-        hyperdex_java_client_throw_exception(env, o->status, hyperdex_client_error_message(client));
-        return 0;
-    }
-
-    o->encode_return = hyperdex_java_client_deferred_encode_status;
-    (*env)->CallObjectMethod(env, obj, _client_add_op, o->reqid, op);
-    ERROR_CHECK(0);
-    return op;
-}
-
-JNIEXPORT HYPERDEX_API jobject JNICALL
-hyperdex_java_client_asynccall__spacename_key_predicates_mapattributes__status(JNIEnv* env, jobject obj, int64_t (*f)(struct hyperdex_client* client, const char* space, const char* key, size_t key_sz, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz, enum hyperdex_client_returncode* status), jstring spacename, jobject key, jobject predicates, jobject mapattributes);
-
-JNIEXPORT HYPERDEX_API jobject JNICALL
-hyperdex_java_client_asynccall__spacename_key_predicates_mapattributes__status(JNIEnv* env, jobject obj, int64_t (*f)(struct hyperdex_client* client, const char* space, const char* key, size_t key_sz, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz, enum hyperdex_client_returncode* status), jstring spacename, jobject key, jobject predicates, jobject mapattributes)
-{
-    const char* in_space;
-    const char* in_key;
-    size_t in_key_sz;
-    const struct hyperdex_client_attribute_check* in_checks;
-    size_t in_checks_sz;
-    const struct hyperdex_client_map_attribute* in_mapattrs;
-    size_t in_mapattrs_sz;
-    int success = 0;
-    struct hyperdex_client* client = hyperdex_get_client_ptr(env, obj);
-    jobject op = (*env)->NewObject(env, _deferred, _deferred_init, obj);
-    struct hyperdex_java_client_deferred* o = NULL;
-    ERROR_CHECK(0);
-    o = hyperdex_get_deferred_ptr(env, op);
-    ERROR_CHECK(0);
-    success = hyperdex_java_client_convert_spacename(env, obj, o->arena, spacename, &in_space);
-    if (success < 0) return 0;
-    success = hyperdex_java_client_convert_key(env, obj, o->arena, key, &in_key, &in_key_sz);
-    if (success < 0) return 0;
-    success = hyperdex_java_client_convert_predicates(env, obj, o->arena, predicates, &in_checks, &in_checks_sz);
-    if (success < 0) return 0;
-    success = hyperdex_java_client_convert_mapattributes(env, obj, o->arena, mapattributes, &in_mapattrs, &in_mapattrs_sz);
-    if (success < 0) return 0;
-    o->reqid = f(client, in_space, in_key, in_key_sz, in_checks, in_checks_sz, in_mapattrs, in_mapattrs_sz, &o->status);
-
-    if (o->reqid < 0)
-    {
-        hyperdex_java_client_throw_exception(env, o->status, hyperdex_client_error_message(client));
-        return 0;
-    }
-
-    o->encode_return = hyperdex_java_client_deferred_encode_status;
-    (*env)->CallObjectMethod(env, obj, _client_add_op, o->reqid, op);
-    ERROR_CHECK(0);
-    return op;
-}
-
-JNIEXPORT HYPERDEX_API jobject JNICALL
-hyperdex_java_client_asynccall__spacename_predicates_mapattributes__status_count(JNIEnv* env, jobject obj, int64_t (*f)(struct hyperdex_client* client, const char* space, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz, enum hyperdex_client_returncode* status, uint64_t* count), jstring spacename, jobject predicates, jobject mapattributes);
-
-JNIEXPORT HYPERDEX_API jobject JNICALL
-hyperdex_java_client_asynccall__spacename_predicates_mapattributes__status_count(JNIEnv* env, jobject obj, int64_t (*f)(struct hyperdex_client* client, const char* space, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz, enum hyperdex_client_returncode* status, uint64_t* count), jstring spacename, jobject predicates, jobject mapattributes)
-{
-    const char* in_space;
-    const struct hyperdex_client_attribute_check* in_checks;
-    size_t in_checks_sz;
-    const struct hyperdex_client_map_attribute* in_mapattrs;
-    size_t in_mapattrs_sz;
-    int success = 0;
-    struct hyperdex_client* client = hyperdex_get_client_ptr(env, obj);
-    jobject op = (*env)->NewObject(env, _deferred, _deferred_init, obj);
-    struct hyperdex_java_client_deferred* o = NULL;
-    ERROR_CHECK(0);
-    o = hyperdex_get_deferred_ptr(env, op);
-    ERROR_CHECK(0);
-    success = hyperdex_java_client_convert_spacename(env, obj, o->arena, spacename, &in_space);
-    if (success < 0) return 0;
-    success = hyperdex_java_client_convert_predicates(env, obj, o->arena, predicates, &in_checks, &in_checks_sz);
-    if (success < 0) return 0;
-    success = hyperdex_java_client_convert_mapattributes(env, obj, o->arena, mapattributes, &in_mapattrs, &in_mapattrs_sz);
-    if (success < 0) return 0;
-    o->reqid = f(client, in_space, in_checks, in_checks_sz, in_mapattrs, in_mapattrs_sz, &o->status, &o->count);
-
-    if (o->reqid < 0)
-    {
-        hyperdex_java_client_throw_exception(env, o->status, hyperdex_client_error_message(client));
-        return 0;
-    }
-
-    o->encode_return = hyperdex_java_client_deferred_encode_status_count;
-    (*env)->CallObjectMethod(env, obj, _client_add_op, o->reqid, op);
-    ERROR_CHECK(0);
-    return op;
-}
-
-JNIEXPORT HYPERDEX_API jobject JNICALL
-hyperdex_java_client_iterator__spacename_predicates__status_attributes(JNIEnv* env, jobject obj, int64_t (*f)(struct hyperdex_client* client, const char* space, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, enum hyperdex_client_returncode* status, const struct hyperdex_client_attribute** attrs, size_t* attrs_sz), jstring spacename, jobject predicates);
-
-JNIEXPORT HYPERDEX_API jobject JNICALL
-hyperdex_java_client_iterator__spacename_predicates__status_attributes(JNIEnv* env, jobject obj, int64_t (*f)(struct hyperdex_client* client, const char* space, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, enum hyperdex_client_returncode* status, const struct hyperdex_client_attribute** attrs, size_t* attrs_sz), jstring spacename, jobject predicates)
-{
-    const char* in_space;
-    const struct hyperdex_client_attribute_check* in_checks;
-    size_t in_checks_sz;
-    int success = 0;
-    struct hyperdex_client* client = hyperdex_get_client_ptr(env, obj);
-    jobject op = (*env)->NewObject(env, _iterator, _iterator_init, obj);
-    struct hyperdex_java_client_iterator* o = NULL;
-    ERROR_CHECK(0);
-    o = hyperdex_get_iterator_ptr(env, op);
-    ERROR_CHECK(0);
-    success = hyperdex_java_client_convert_spacename(env, obj, o->arena, spacename, &in_space);
-    if (success < 0) return 0;
-    success = hyperdex_java_client_convert_predicates(env, obj, o->arena, predicates, &in_checks, &in_checks_sz);
-    if (success < 0) return 0;
-    o->reqid = f(client, in_space, in_checks, in_checks_sz, &o->status, &o->attrs, &o->attrs_sz);
-
-    if (o->reqid < 0)
-    {
-        hyperdex_java_client_throw_exception(env, o->status, hyperdex_client_error_message(client));
-        return 0;
-    }
-
-    o->encode_return = hyperdex_java_client_iterator_encode_status_attributes;
-    (*env)->CallObjectMethod(env, obj, _client_add_op, o->reqid, op);
-    ERROR_CHECK(0);
-    return op;
+hyperdex_java_client_asynccall__spacename_key__status_attributes(JNIEnv *env, jobject obj, int64_t (*f)(struct hyperdex_client *client, const char *space, const char *key, size_t key_sz, enum hyperdex_client_returncode *status, const struct hyperdex_client_attribute **attrs, size_t *attrs_sz), jstring spacename, jobject key);
+
+JNIEXPORT HYPERDEX_API jobject JNICALL
+hyperdex_java_client_asynccall__spacename_key__status_attributes(JNIEnv *env, jobject obj, int64_t (*f)(struct hyperdex_client *client, const char *space, const char *key, size_t key_sz, enum hyperdex_client_returncode *status, const struct hyperdex_client_attribute **attrs, size_t *attrs_sz), jstring spacename, jobject key)
+{
+	const char *in_space;
+	const char *in_key;
+	size_t in_key_sz;
+	int success = 0;
+	struct hyperdex_client *client = hyperdex_get_client_ptr(env, obj);
+	jobject op = (*env)->NewObject(env, _deferred, _deferred_init, obj);
+	struct hyperdex_java_client_deferred *o = NULL;
+	ERROR_CHECK(0);
+	o = hyperdex_get_deferred_ptr(env, op);
+	ERROR_CHECK(0);
+	success = hyperdex_java_client_convert_spacename(env, obj, o->arena, spacename, &in_space);
+	if (success < 0) return 0;
+	success = hyperdex_java_client_convert_key(env, obj, o->arena, key, &in_key, &in_key_sz);
+	if (success < 0) return 0;
+	o->reqid = f(client, in_space, in_key, in_key_sz, &o->status, &o->attrs, &o->attrs_sz);
+	if (o->reqid < 0)
+	{
+		hyperdex_java_client_throw_exception(env, o->status, hyperdex_client_error_message(client));
+		return 0;
+	}
+	o->encode_return = hyperdex_java_client_deferred_encode_status_attributes;
+	(*env)->CallObjectMethod(env, obj, _client_add_op, o->reqid, op);
+	ERROR_CHECK(0);
+	return op;
+}
+
+JNIEXPORT HYPERDEX_API jobject JNICALL
+hyperdex_java_client_asynccall__spacename_key_attributenames__status_attributes(JNIEnv *env, jobject obj, int64_t (*f)(struct hyperdex_client *client, const char *space, const char *key, size_t key_sz, const char **attrnames, size_t attrnames_sz, enum hyperdex_client_returncode *status, const struct hyperdex_client_attribute **attrs, size_t *attrs_sz), jstring spacename, jobject key, jobject attributenames);
+
+JNIEXPORT HYPERDEX_API jobject JNICALL
+hyperdex_java_client_asynccall__spacename_key_attributenames__status_attributes(JNIEnv *env, jobject obj, int64_t (*f)(struct hyperdex_client *client, const char *space, const char *key, size_t key_sz, const char **attrnames, size_t attrnames_sz, enum hyperdex_client_returncode *status, const struct hyperdex_client_attribute **attrs, size_t *attrs_sz), jstring spacename, jobject key, jobject attributenames)
+{
+	const char *in_space;
+	const char *in_key;
+	size_t in_key_sz;
+	const char **in_attrnames;
+	size_t in_attrnames_sz;
+	int success = 0;
+	struct hyperdex_client *client = hyperdex_get_client_ptr(env, obj);
+	jobject op = (*env)->NewObject(env, _deferred, _deferred_init, obj);
+	struct hyperdex_java_client_deferred *o = NULL;
+	ERROR_CHECK(0);
+	o = hyperdex_get_deferred_ptr(env, op);
+	ERROR_CHECK(0);
+	success = hyperdex_java_client_convert_spacename(env, obj, o->arena, spacename, &in_space);
+	if (success < 0) return 0;
+	success = hyperdex_java_client_convert_key(env, obj, o->arena, key, &in_key, &in_key_sz);
+	if (success < 0) return 0;
+	success = hyperdex_java_client_convert_attributenames(env, obj, o->arena, attributenames, &in_attrnames, &in_attrnames_sz);
+	if (success < 0) return 0;
+	o->reqid = f(client, in_space, in_key, in_key_sz, in_attrnames, in_attrnames_sz, &o->status, &o->attrs, &o->attrs_sz);
+	if (o->reqid < 0)
+	{
+		hyperdex_java_client_throw_exception(env, o->status, hyperdex_client_error_message(client));
+		return 0;
+	}
+	o->encode_return = hyperdex_java_client_deferred_encode_status_attributes;
+	(*env)->CallObjectMethod(env, obj, _client_add_op, o->reqid, op);
+	ERROR_CHECK(0);
+	return op;
+}
+
+JNIEXPORT HYPERDEX_API jobject JNICALL
+hyperdex_java_client_asynccall__spacename_key_attributes__status(JNIEnv *env, jobject obj, int64_t (*f)(struct hyperdex_client *client, const char *space, const char *key, size_t key_sz, const struct hyperdex_client_attribute *attrs, size_t attrs_sz, enum hyperdex_client_returncode *status), jstring spacename, jobject key, jobject attributes);
+
+JNIEXPORT HYPERDEX_API jobject JNICALL
+hyperdex_java_client_asynccall__spacename_key_attributes__status(JNIEnv *env, jobject obj, int64_t (*f)(struct hyperdex_client *client, const char *space, const char *key, size_t key_sz, const struct hyperdex_client_attribute *attrs, size_t attrs_sz, enum hyperdex_client_returncode *status), jstring spacename, jobject key, jobject attributes)
+{
+	const char *in_space;
+	const char *in_key;
+	size_t in_key_sz;
+	const struct hyperdex_client_attribute *in_attrs;
+	size_t in_attrs_sz;
+	int success = 0;
+	struct hyperdex_client *client = hyperdex_get_client_ptr(env, obj);
+	jobject op = (*env)->NewObject(env, _deferred, _deferred_init, obj);
+	struct hyperdex_java_client_deferred *o = NULL;
+	ERROR_CHECK(0);
+	o = hyperdex_get_deferred_ptr(env, op);
+	ERROR_CHECK(0);
+	success = hyperdex_java_client_convert_spacename(env, obj, o->arena, spacename, &in_space);
+	if (success < 0) return 0;
+	success = hyperdex_java_client_convert_key(env, obj, o->arena, key, &in_key, &in_key_sz);
+	if (success < 0) return 0;
+	success = hyperdex_java_client_convert_attributes(env, obj, o->arena, attributes, &in_attrs, &in_attrs_sz);
+	if (success < 0) return 0;
+	o->reqid = f(client, in_space, in_key, in_key_sz, in_attrs, in_attrs_sz, &o->status);
+	if (o->reqid < 0)
+	{
+		hyperdex_java_client_throw_exception(env, o->status, hyperdex_client_error_message(client));
+		return 0;
+	}
+	o->encode_return = hyperdex_java_client_deferred_encode_status;
+	(*env)->CallObjectMethod(env, obj, _client_add_op, o->reqid, op);
+	ERROR_CHECK(0);
+	return op;
+}
+
+JNIEXPORT HYPERDEX_API jobject JNICALL
+hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(JNIEnv *env, jobject obj, int64_t (*f)(struct hyperdex_client *client, const char *space, const char *key, size_t key_sz, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, const struct hyperdex_client_attribute *attrs, size_t attrs_sz, enum hyperdex_client_returncode *status), jstring spacename, jobject key, jobject predicates, jobject attributes);
+
+JNIEXPORT HYPERDEX_API jobject JNICALL
+hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(JNIEnv *env, jobject obj, int64_t (*f)(struct hyperdex_client *client, const char *space, const char *key, size_t key_sz, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, const struct hyperdex_client_attribute *attrs, size_t attrs_sz, enum hyperdex_client_returncode *status), jstring spacename, jobject key, jobject predicates, jobject attributes)
+{
+	const char *in_space;
+	const char *in_key;
+	size_t in_key_sz;
+	const struct hyperdex_client_attribute_check *in_checks;
+	size_t in_checks_sz;
+	const struct hyperdex_client_attribute *in_attrs;
+	size_t in_attrs_sz;
+	int success = 0;
+	struct hyperdex_client *client = hyperdex_get_client_ptr(env, obj);
+	jobject op = (*env)->NewObject(env, _deferred, _deferred_init, obj);
+	struct hyperdex_java_client_deferred *o = NULL;
+	ERROR_CHECK(0);
+	o = hyperdex_get_deferred_ptr(env, op);
+	ERROR_CHECK(0);
+	success = hyperdex_java_client_convert_spacename(env, obj, o->arena, spacename, &in_space);
+	if (success < 0) return 0;
+	success = hyperdex_java_client_convert_key(env, obj, o->arena, key, &in_key, &in_key_sz);
+	if (success < 0) return 0;
+	success = hyperdex_java_client_convert_predicates(env, obj, o->arena, predicates, &in_checks, &in_checks_sz);
+	if (success < 0) return 0;
+	success = hyperdex_java_client_convert_attributes(env, obj, o->arena, attributes, &in_attrs, &in_attrs_sz);
+	if (success < 0) return 0;
+	o->reqid = f(client, in_space, in_key, in_key_sz, in_checks, in_checks_sz, in_attrs, in_attrs_sz, &o->status);
+	if (o->reqid < 0)
+	{
+		hyperdex_java_client_throw_exception(env, o->status, hyperdex_client_error_message(client));
+		return 0;
+	}
+	o->encode_return = hyperdex_java_client_deferred_encode_status;
+	(*env)->CallObjectMethod(env, obj, _client_add_op, o->reqid, op);
+	ERROR_CHECK(0);
+	return op;
+}
+
+JNIEXPORT HYPERDEX_API jobject JNICALL
+hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(JNIEnv *env, jobject obj, int64_t (*f)(struct hyperdex_client *client, const char *space, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, const struct hyperdex_client_attribute *attrs, size_t attrs_sz, enum hyperdex_client_returncode *status, uint64_t *count), jstring spacename, jobject predicates, jobject attributes);
+
+JNIEXPORT HYPERDEX_API jobject JNICALL
+hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(JNIEnv *env, jobject obj, int64_t (*f)(struct hyperdex_client *client, const char *space, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, const struct hyperdex_client_attribute *attrs, size_t attrs_sz, enum hyperdex_client_returncode *status, uint64_t *count), jstring spacename, jobject predicates, jobject attributes)
+{
+	const char *in_space;
+	const struct hyperdex_client_attribute_check *in_checks;
+	size_t in_checks_sz;
+	const struct hyperdex_client_attribute *in_attrs;
+	size_t in_attrs_sz;
+	int success = 0;
+	struct hyperdex_client *client = hyperdex_get_client_ptr(env, obj);
+	jobject op = (*env)->NewObject(env, _deferred, _deferred_init, obj);
+	struct hyperdex_java_client_deferred *o = NULL;
+	ERROR_CHECK(0);
+	o = hyperdex_get_deferred_ptr(env, op);
+	ERROR_CHECK(0);
+	success = hyperdex_java_client_convert_spacename(env, obj, o->arena, spacename, &in_space);
+	if (success < 0) return 0;
+	success = hyperdex_java_client_convert_predicates(env, obj, o->arena, predicates, &in_checks, &in_checks_sz);
+	if (success < 0) return 0;
+	success = hyperdex_java_client_convert_attributes(env, obj, o->arena, attributes, &in_attrs, &in_attrs_sz);
+	if (success < 0) return 0;
+	o->reqid = f(client, in_space, in_checks, in_checks_sz, in_attrs, in_attrs_sz, &o->status, &o->count);
+	if (o->reqid < 0)
+	{
+		hyperdex_java_client_throw_exception(env, o->status, hyperdex_client_error_message(client));
+		return 0;
+	}
+	o->encode_return = hyperdex_java_client_deferred_encode_status_count;
+	(*env)->CallObjectMethod(env, obj, _client_add_op, o->reqid, op);
+	ERROR_CHECK(0);
+	return op;
+}
+
+JNIEXPORT HYPERDEX_API jobject JNICALL
+hyperdex_java_client_asynccall__spacename_key__status(JNIEnv *env, jobject obj, int64_t (*f)(struct hyperdex_client *client, const char *space, const char *key, size_t key_sz, enum hyperdex_client_returncode *status), jstring spacename, jobject key);
+
+JNIEXPORT HYPERDEX_API jobject JNICALL
+hyperdex_java_client_asynccall__spacename_key__status(JNIEnv *env, jobject obj, int64_t (*f)(struct hyperdex_client *client, const char *space, const char *key, size_t key_sz, enum hyperdex_client_returncode *status), jstring spacename, jobject key)
+{
+	const char *in_space;
+	const char *in_key;
+	size_t in_key_sz;
+	int success = 0;
+	struct hyperdex_client *client = hyperdex_get_client_ptr(env, obj);
+	jobject op = (*env)->NewObject(env, _deferred, _deferred_init, obj);
+	struct hyperdex_java_client_deferred *o = NULL;
+	ERROR_CHECK(0);
+	o = hyperdex_get_deferred_ptr(env, op);
+	ERROR_CHECK(0);
+	success = hyperdex_java_client_convert_spacename(env, obj, o->arena, spacename, &in_space);
+	if (success < 0) return 0;
+	success = hyperdex_java_client_convert_key(env, obj, o->arena, key, &in_key, &in_key_sz);
+	if (success < 0) return 0;
+	o->reqid = f(client, in_space, in_key, in_key_sz, &o->status);
+	if (o->reqid < 0)
+	{
+		hyperdex_java_client_throw_exception(env, o->status, hyperdex_client_error_message(client));
+		return 0;
+	}
+	o->encode_return = hyperdex_java_client_deferred_encode_status;
+	(*env)->CallObjectMethod(env, obj, _client_add_op, o->reqid, op);
+	ERROR_CHECK(0);
+	return op;
+}
+
+JNIEXPORT HYPERDEX_API jobject JNICALL
+hyperdex_java_client_asynccall__spacename_key_predicates__status(JNIEnv *env, jobject obj, int64_t (*f)(struct hyperdex_client *client, const char *space, const char *key, size_t key_sz, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, enum hyperdex_client_returncode *status), jstring spacename, jobject key, jobject predicates);
+
+JNIEXPORT HYPERDEX_API jobject JNICALL
+hyperdex_java_client_asynccall__spacename_key_predicates__status(JNIEnv *env, jobject obj, int64_t (*f)(struct hyperdex_client *client, const char *space, const char *key, size_t key_sz, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, enum hyperdex_client_returncode *status), jstring spacename, jobject key, jobject predicates)
+{
+	const char *in_space;
+	const char *in_key;
+	size_t in_key_sz;
+	const struct hyperdex_client_attribute_check *in_checks;
+	size_t in_checks_sz;
+	int success = 0;
+	struct hyperdex_client *client = hyperdex_get_client_ptr(env, obj);
+	jobject op = (*env)->NewObject(env, _deferred, _deferred_init, obj);
+	struct hyperdex_java_client_deferred *o = NULL;
+	ERROR_CHECK(0);
+	o = hyperdex_get_deferred_ptr(env, op);
+	ERROR_CHECK(0);
+	success = hyperdex_java_client_convert_spacename(env, obj, o->arena, spacename, &in_space);
+	if (success < 0) return 0;
+	success = hyperdex_java_client_convert_key(env, obj, o->arena, key, &in_key, &in_key_sz);
+	if (success < 0) return 0;
+	success = hyperdex_java_client_convert_predicates(env, obj, o->arena, predicates, &in_checks, &in_checks_sz);
+	if (success < 0) return 0;
+	o->reqid = f(client, in_space, in_key, in_key_sz, in_checks, in_checks_sz, &o->status);
+	if (o->reqid < 0)
+	{
+		hyperdex_java_client_throw_exception(env, o->status, hyperdex_client_error_message(client));
+		return 0;
+	}
+	o->encode_return = hyperdex_java_client_deferred_encode_status;
+	(*env)->CallObjectMethod(env, obj, _client_add_op, o->reqid, op);
+	ERROR_CHECK(0);
+	return op;
+}
+
+JNIEXPORT HYPERDEX_API jobject JNICALL
+hyperdex_java_client_asynccall__spacename_predicates__status_count(JNIEnv *env, jobject obj, int64_t (*f)(struct hyperdex_client *client, const char *space, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, enum hyperdex_client_returncode *status, uint64_t *count), jstring spacename, jobject predicates);
+
+JNIEXPORT HYPERDEX_API jobject JNICALL
+hyperdex_java_client_asynccall__spacename_predicates__status_count(JNIEnv *env, jobject obj, int64_t (*f)(struct hyperdex_client *client, const char *space, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, enum hyperdex_client_returncode *status, uint64_t *count), jstring spacename, jobject predicates)
+{
+	const char *in_space;
+	const struct hyperdex_client_attribute_check *in_checks;
+	size_t in_checks_sz;
+	int success = 0;
+	struct hyperdex_client *client = hyperdex_get_client_ptr(env, obj);
+	jobject op = (*env)->NewObject(env, _deferred, _deferred_init, obj);
+	struct hyperdex_java_client_deferred *o = NULL;
+	ERROR_CHECK(0);
+	o = hyperdex_get_deferred_ptr(env, op);
+	ERROR_CHECK(0);
+	success = hyperdex_java_client_convert_spacename(env, obj, o->arena, spacename, &in_space);
+	if (success < 0) return 0;
+	success = hyperdex_java_client_convert_predicates(env, obj, o->arena, predicates, &in_checks, &in_checks_sz);
+	if (success < 0) return 0;
+	o->reqid = f(client, in_space, in_checks, in_checks_sz, &o->status, &o->count);
+	if (o->reqid < 0)
+	{
+		hyperdex_java_client_throw_exception(env, o->status, hyperdex_client_error_message(client));
+		return 0;
+	}
+	o->encode_return = hyperdex_java_client_deferred_encode_status_count;
+	(*env)->CallObjectMethod(env, obj, _client_add_op, o->reqid, op);
+	ERROR_CHECK(0);
+	return op;
+}
+
+JNIEXPORT HYPERDEX_API jobject JNICALL
+hyperdex_java_client_asynccall__spacename_predicates__status_sum(JNIEnv *env, jobject obj, int64_t (*f)(struct hyperdex_client *client, const char *space, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, const char *sum_key, enum hyperdex_client_returncode *status, uint64_t *count), jstring spacename, jobject predicates, jstring key);
+
+JNIEXPORT HYPERDEX_API jobject JNICALL
+hyperdex_java_client_asynccall__spacename_predicates__status_sum(JNIEnv *env, jobject obj, int64_t (*f)(struct hyperdex_client *client, const char *space, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, const char *sum_key, enum hyperdex_client_returncode *status, uint64_t *count), jstring spacename, jobject predicates, jstring key)
+{
+	const char *in_space;
+	const struct hyperdex_client_attribute_check *in_checks;
+	size_t in_checks_sz;
+	const char *in_sum_key;
+	int success = 0;
+	struct hyperdex_client *client = hyperdex_get_client_ptr(env, obj);
+	jobject op = (*env)->NewObject(env, _deferred, _deferred_init, obj);
+	struct hyperdex_java_client_deferred *o = NULL;
+	ERROR_CHECK(0);
+	o = hyperdex_get_deferred_ptr(env, op);
+	ERROR_CHECK(0);
+	success = hyperdex_java_client_convert_spacename(env, obj, o->arena, spacename, &in_space);
+	if (success < 0) return 0;
+	success = hyperdex_java_client_convert_predicates(env, obj, o->arena, predicates, &in_checks, &in_checks_sz);
+	if (success < 0) return 0;
+	success = hyperdex_java_client_convert_sum_key(env, obj, o->arena, key, &in_sum_key);
+	if (success < 0) return 0;
+	o->reqid = f(client, in_space, in_checks, in_checks_sz, in_sum_key, &o->status, &o->count);
+	if (o->reqid < 0)
+	{
+		hyperdex_java_client_throw_exception(env, o->status, hyperdex_client_error_message(client));
+		return 0;
+	}
+	o->encode_return = hyperdex_java_client_deferred_encode_status_count;
+	(*env)->CallObjectMethod(env, obj, _client_add_op, o->reqid, op);
+	ERROR_CHECK(0);
+	return op;
+}
+
+
+JNIEXPORT HYPERDEX_API jobject JNICALL
+hyperdex_java_client_asynccall__spacename_key_mapattributes__status(JNIEnv *env, jobject obj, int64_t (*f)(struct hyperdex_client *client, const char *space, const char *key, size_t key_sz, const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz, enum hyperdex_client_returncode *status), jstring spacename, jobject key, jobject mapattributes);
+
+JNIEXPORT HYPERDEX_API jobject JNICALL
+hyperdex_java_client_asynccall__spacename_key_mapattributes__status(JNIEnv *env, jobject obj, int64_t (*f)(struct hyperdex_client *client, const char *space, const char *key, size_t key_sz, const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz, enum hyperdex_client_returncode *status), jstring spacename, jobject key, jobject mapattributes)
+{
+	const char *in_space;
+	const char *in_key;
+	size_t in_key_sz;
+	const struct hyperdex_client_map_attribute *in_mapattrs;
+	size_t in_mapattrs_sz;
+	int success = 0;
+	struct hyperdex_client *client = hyperdex_get_client_ptr(env, obj);
+	jobject op = (*env)->NewObject(env, _deferred, _deferred_init, obj);
+	struct hyperdex_java_client_deferred *o = NULL;
+	ERROR_CHECK(0);
+	o = hyperdex_get_deferred_ptr(env, op);
+	ERROR_CHECK(0);
+	success = hyperdex_java_client_convert_spacename(env, obj, o->arena, spacename, &in_space);
+	if (success < 0) return 0;
+	success = hyperdex_java_client_convert_key(env, obj, o->arena, key, &in_key, &in_key_sz);
+	if (success < 0) return 0;
+	success = hyperdex_java_client_convert_mapattributes(env, obj, o->arena, mapattributes, &in_mapattrs, &in_mapattrs_sz);
+	if (success < 0) return 0;
+	o->reqid = f(client, in_space, in_key, in_key_sz, in_mapattrs, in_mapattrs_sz, &o->status);
+	if (o->reqid < 0)
+	{
+		hyperdex_java_client_throw_exception(env, o->status, hyperdex_client_error_message(client));
+		return 0;
+	}
+	o->encode_return = hyperdex_java_client_deferred_encode_status;
+	(*env)->CallObjectMethod(env, obj, _client_add_op, o->reqid, op);
+	ERROR_CHECK(0);
+	return op;
+}
+
+JNIEXPORT HYPERDEX_API jobject JNICALL
+hyperdex_java_client_asynccall__spacename_key_predicates_mapattributes__status(JNIEnv *env, jobject obj, int64_t (*f)(struct hyperdex_client *client, const char *space, const char *key, size_t key_sz, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz, enum hyperdex_client_returncode *status), jstring spacename, jobject key, jobject predicates, jobject mapattributes);
+
+JNIEXPORT HYPERDEX_API jobject JNICALL
+hyperdex_java_client_asynccall__spacename_key_predicates_mapattributes__status(JNIEnv *env, jobject obj, int64_t (*f)(struct hyperdex_client *client, const char *space, const char *key, size_t key_sz, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz, enum hyperdex_client_returncode *status), jstring spacename, jobject key, jobject predicates, jobject mapattributes)
+{
+	const char *in_space;
+	const char *in_key;
+	size_t in_key_sz;
+	const struct hyperdex_client_attribute_check *in_checks;
+	size_t in_checks_sz;
+	const struct hyperdex_client_map_attribute *in_mapattrs;
+	size_t in_mapattrs_sz;
+	int success = 0;
+	struct hyperdex_client *client = hyperdex_get_client_ptr(env, obj);
+	jobject op = (*env)->NewObject(env, _deferred, _deferred_init, obj);
+	struct hyperdex_java_client_deferred *o = NULL;
+	ERROR_CHECK(0);
+	o = hyperdex_get_deferred_ptr(env, op);
+	ERROR_CHECK(0);
+	success = hyperdex_java_client_convert_spacename(env, obj, o->arena, spacename, &in_space);
+	if (success < 0) return 0;
+	success = hyperdex_java_client_convert_key(env, obj, o->arena, key, &in_key, &in_key_sz);
+	if (success < 0) return 0;
+	success = hyperdex_java_client_convert_predicates(env, obj, o->arena, predicates, &in_checks, &in_checks_sz);
+	if (success < 0) return 0;
+	success = hyperdex_java_client_convert_mapattributes(env, obj, o->arena, mapattributes, &in_mapattrs, &in_mapattrs_sz);
+	if (success < 0) return 0;
+	o->reqid = f(client, in_space, in_key, in_key_sz, in_checks, in_checks_sz, in_mapattrs, in_mapattrs_sz, &o->status);
+	if (o->reqid < 0)
+	{
+		hyperdex_java_client_throw_exception(env, o->status, hyperdex_client_error_message(client));
+		return 0;
+	}
+	o->encode_return = hyperdex_java_client_deferred_encode_status;
+	(*env)->CallObjectMethod(env, obj, _client_add_op, o->reqid, op);
+	ERROR_CHECK(0);
+	return op;
+}
+
+JNIEXPORT HYPERDEX_API jobject JNICALL
+hyperdex_java_client_asynccall__spacename_predicates_mapattributes__status_count(JNIEnv *env, jobject obj, int64_t (*f)(struct hyperdex_client *client, const char *space, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz, enum hyperdex_client_returncode *status, uint64_t *count), jstring spacename, jobject predicates, jobject mapattributes);
+
+JNIEXPORT HYPERDEX_API jobject JNICALL
+hyperdex_java_client_asynccall__spacename_predicates_mapattributes__status_count(JNIEnv *env, jobject obj, int64_t (*f)(struct hyperdex_client *client, const char *space, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz, enum hyperdex_client_returncode *status, uint64_t *count), jstring spacename, jobject predicates, jobject mapattributes)
+{
+	const char *in_space;
+	const struct hyperdex_client_attribute_check *in_checks;
+	size_t in_checks_sz;
+	const struct hyperdex_client_map_attribute *in_mapattrs;
+	size_t in_mapattrs_sz;
+	int success = 0;
+	struct hyperdex_client *client = hyperdex_get_client_ptr(env, obj);
+	jobject op = (*env)->NewObject(env, _deferred, _deferred_init, obj);
+	struct hyperdex_java_client_deferred *o = NULL;
+	ERROR_CHECK(0);
+	o = hyperdex_get_deferred_ptr(env, op);
+	ERROR_CHECK(0);
+	success = hyperdex_java_client_convert_spacename(env, obj, o->arena, spacename, &in_space);
+	if (success < 0) return 0;
+	success = hyperdex_java_client_convert_predicates(env, obj, o->arena, predicates, &in_checks, &in_checks_sz);
+	if (success < 0) return 0;
+	success = hyperdex_java_client_convert_mapattributes(env, obj, o->arena, mapattributes, &in_mapattrs, &in_mapattrs_sz);
+	if (success < 0) return 0;
+	o->reqid = f(client, in_space, in_checks, in_checks_sz, in_mapattrs, in_mapattrs_sz, &o->status, &o->count);
+	if (o->reqid < 0)
+	{
+		hyperdex_java_client_throw_exception(env, o->status, hyperdex_client_error_message(client));
+		return 0;
+	}
+	o->encode_return = hyperdex_java_client_deferred_encode_status_count;
+	(*env)->CallObjectMethod(env, obj, _client_add_op, o->reqid, op);
+	ERROR_CHECK(0);
+	return op;
+}
+
+JNIEXPORT HYPERDEX_API jobject JNICALL
+hyperdex_java_client_iterator__spacename_predicates__status_attributes(JNIEnv *env, jobject obj, int64_t (*f)(struct hyperdex_client *client, const char *space, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, enum hyperdex_client_returncode *status, const struct hyperdex_client_attribute **attrs, size_t *attrs_sz), jstring spacename, jobject predicates);
+
+JNIEXPORT HYPERDEX_API jobject JNICALL
+hyperdex_java_client_iterator__spacename_predicates__status_attributes(JNIEnv *env, jobject obj, int64_t (*f)(struct hyperdex_client *client, const char *space, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, enum hyperdex_client_returncode *status, const struct hyperdex_client_attribute **attrs, size_t *attrs_sz), jstring spacename, jobject predicates)
+{
+	const char *in_space;
+	const struct hyperdex_client_attribute_check *in_checks;
+	size_t in_checks_sz;
+	int success = 0;
+	struct hyperdex_client *client = hyperdex_get_client_ptr(env, obj);
+	jobject op = (*env)->NewObject(env, _iterator, _iterator_init, obj);
+	struct hyperdex_java_client_iterator *o = NULL;
+	ERROR_CHECK(0);
+	o = hyperdex_get_iterator_ptr(env, op);
+	ERROR_CHECK(0);
+	success = hyperdex_java_client_convert_spacename(env, obj, o->arena, spacename, &in_space);
+	if (success < 0) return 0;
+	success = hyperdex_java_client_convert_predicates(env, obj, o->arena, predicates, &in_checks, &in_checks_sz);
+	if (success < 0) return 0;
+	o->reqid = f(client, in_space, in_checks, in_checks_sz, &o->status, &o->attrs, &o->attrs_sz);
+	if (o->reqid < 0)
+	{
+		hyperdex_java_client_throw_exception(env, o->status, hyperdex_client_error_message(client));
+		return 0;
+	}
+	o->encode_return = hyperdex_java_client_iterator_encode_status_attributes;
+	(*env)->CallObjectMethod(env, obj, _client_add_op, o->reqid, op);
+	ERROR_CHECK(0);
+	return op;
+}
+
+JNIEXPORT HYPERDEX_API jobject JNICALL
+hyperdex_java_client_asynccall__spacename_predicates__status_description(JNIEnv *env, jobject obj, int64_t (*f)(struct hyperdex_client *client, const char *space, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, enum hyperdex_client_returncode *status, const char **description), jstring spacename, jobject predicates);
+
+JNIEXPORT HYPERDEX_API jobject JNICALL
+hyperdex_java_client_asynccall__spacename_predicates__status_description(JNIEnv *env, jobject obj, int64_t (*f)(struct hyperdex_client *client, const char *space, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, enum hyperdex_client_returncode *status, const char **description), jstring spacename, jobject predicates)
+{
+	const char *in_space;
+	const struct hyperdex_client_attribute_check *in_checks;
+	size_t in_checks_sz;
+	int success = 0;
+	struct hyperdex_client *client = hyperdex_get_client_ptr(env, obj);
+	jobject op = (*env)->NewObject(env, _deferred, _deferred_init, obj);
+	struct hyperdex_java_client_deferred *o = NULL;
+	ERROR_CHECK(0);
+	o = hyperdex_get_deferred_ptr(env, op);
+	ERROR_CHECK(0);
+	success = hyperdex_java_client_convert_spacename(env, obj, o->arena, spacename, &in_space);
+	if (success < 0) return 0;
+	success = hyperdex_java_client_convert_predicates(env, obj, o->arena, predicates, &in_checks, &in_checks_sz);
+	if (success < 0) return 0;
+	o->reqid = f(client, in_space, in_checks, in_checks_sz, &o->status, &o->description);
+	if (o->reqid < 0)
+	{
+		hyperdex_java_client_throw_exception(env, o->status, hyperdex_client_error_message(client));
+		return 0;
+	}
+	o->encode_return = hyperdex_java_client_deferred_encode_status_description;
+	(*env)->CallObjectMethod(env, obj, _client_add_op, o->reqid, op);
+	ERROR_CHECK(0);
+	return op;
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-hyperdex_java_client_asynccall__spacename_predicates__status_description(JNIEnv* env, jobject obj, int64_t (*f)(struct hyperdex_client* client, const char* space, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, enum hyperdex_client_returncode* status, const char** description), jstring spacename, jobject predicates);
+hyperdex_java_client_iterator__spacename_predicates_sortby_limit_maxmin__status_attributes(JNIEnv *env, jobject obj, int64_t (*f)(struct hyperdex_client *client, const char *space, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, const char *sort_by, uint64_t limit, int maxmin, enum hyperdex_client_returncode *status, const struct hyperdex_client_attribute **attrs, size_t *attrs_sz), jstring spacename, jobject predicates, jstring sortby, jint limit, jboolean maxmin);
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-hyperdex_java_client_asynccall__spacename_predicates__status_description(JNIEnv* env, jobject obj, int64_t (*f)(struct hyperdex_client* client, const char* space, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, enum hyperdex_client_returncode* status, const char** description), jstring spacename, jobject predicates)
+hyperdex_java_client_iterator__spacename_predicates_sortby_limit_maxmin__status_attributes(JNIEnv *env, jobject obj, int64_t (*f)(struct hyperdex_client *client, const char *space, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, const char *sort_by, uint64_t limit, int maxmin, enum hyperdex_client_returncode *status, const struct hyperdex_client_attribute **attrs, size_t *attrs_sz), jstring spacename, jobject predicates, jstring sortby, jint limit, jboolean maxmin)
 {
-    const char* in_space;
-    const struct hyperdex_client_attribute_check* in_checks;
-    size_t in_checks_sz;
-    int success = 0;
-    struct hyperdex_client* client = hyperdex_get_client_ptr(env, obj);
-    jobject op = (*env)->NewObject(env, _deferred, _deferred_init, obj);
-    struct hyperdex_java_client_deferred* o = NULL;
-    ERROR_CHECK(0);
-    o = hyperdex_get_deferred_ptr(env, op);
-    ERROR_CHECK(0);
-    success = hyperdex_java_client_convert_spacename(env, obj, o->arena, spacename, &in_space);
-    if (success < 0) return 0;
-    success = hyperdex_java_client_convert_predicates(env, obj, o->arena, predicates, &in_checks, &in_checks_sz);
-    if (success < 0) return 0;
-    o->reqid = f(client, in_space, in_checks, in_checks_sz, &o->status, &o->description);
-
-    if (o->reqid < 0)
-    {
-        hyperdex_java_client_throw_exception(env, o->status, hyperdex_client_error_message(client));
-        return 0;
-    }
-
-    o->encode_return = hyperdex_java_client_deferred_encode_status_description;
-    (*env)->CallObjectMethod(env, obj, _client_add_op, o->reqid, op);
-    ERROR_CHECK(0);
-    return op;
+	const char *in_space;
+	const struct hyperdex_client_attribute_check *in_checks;
+	size_t in_checks_sz;
+	const char *in_sort_by;
+	uint64_t in_limit;
+	int in_maxmin;
+	int success = 0;
+	struct hyperdex_client *client = hyperdex_get_client_ptr(env, obj);
+	jobject op = (*env)->NewObject(env, _iterator, _iterator_init, obj);
+	struct hyperdex_java_client_iterator *o = NULL;
+	ERROR_CHECK(0);
+	o = hyperdex_get_iterator_ptr(env, op);
+	ERROR_CHECK(0);
+	success = hyperdex_java_client_convert_spacename(env, obj, o->arena, spacename, &in_space);
+	if (success < 0) return 0;
+	success = hyperdex_java_client_convert_predicates(env, obj, o->arena, predicates, &in_checks, &in_checks_sz);
+	if (success < 0) return 0;
+	success = hyperdex_java_client_convert_sortby(env, obj, o->arena, sortby, &in_sort_by);
+	if (success < 0) return 0;
+	success = hyperdex_java_client_convert_limit(env, obj, o->arena, limit, &in_limit);
+	if (success < 0) return 0;
+	success = hyperdex_java_client_convert_maxmin(env, obj, o->arena, maxmin, &in_maxmin);
+	if (success < 0) return 0;
+	o->reqid = f(client, in_space, in_checks, in_checks_sz, in_sort_by, in_limit, in_maxmin, &o->status, &o->attrs, &o->attrs_sz);
+	if (o->reqid < 0)
+	{
+		hyperdex_java_client_throw_exception(env, o->status, hyperdex_client_error_message(client));
+		return 0;
+	}
+	o->encode_return = hyperdex_java_client_iterator_encode_status_attributes;
+	(*env)->CallObjectMethod(env, obj, _client_add_op, o->reqid, op);
+	ERROR_CHECK(0);
+	return op;
 }
-
-JNIEXPORT HYPERDEX_API jobject JNICALL
-hyperdex_java_client_iterator__spacename_predicates_sortby_limit_maxmin__status_attributes(JNIEnv* env, jobject obj, int64_t (*f)(struct hyperdex_client* client, const char* space, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, const char* sort_by, uint64_t limit, int maxmin, enum hyperdex_client_returncode* status, const struct hyperdex_client_attribute** attrs, size_t* attrs_sz), jstring spacename, jobject predicates, jstring sortby, jint limit, jboolean maxmin);
-
 JNIEXPORT HYPERDEX_API jobject JNICALL
-hyperdex_java_client_iterator__spacename_predicates_sortby_limit_maxmin__status_attributes(JNIEnv* env, jobject obj, int64_t (*f)(struct hyperdex_client* client, const char* space, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, const char* sort_by, uint64_t limit, int maxmin, enum hyperdex_client_returncode* status, const struct hyperdex_client_attribute** attrs, size_t* attrs_sz), jstring spacename, jobject predicates, jstring sortby, jint limit, jboolean maxmin)
+Java_org_hyperdex_client_Client_async_1get(JNIEnv *env, jobject obj, jstring spacename, jobject key)
 {
-    const char* in_space;
-    const struct hyperdex_client_attribute_check* in_checks;
-    size_t in_checks_sz;
-    const char* in_sort_by;
-    uint64_t in_limit;
-    int in_maxmin;
-    int success = 0;
-    struct hyperdex_client* client = hyperdex_get_client_ptr(env, obj);
-    jobject op = (*env)->NewObject(env, _iterator, _iterator_init, obj);
-    struct hyperdex_java_client_iterator* o = NULL;
-    ERROR_CHECK(0);
-    o = hyperdex_get_iterator_ptr(env, op);
-    ERROR_CHECK(0);
-    success = hyperdex_java_client_convert_spacename(env, obj, o->arena, spacename, &in_space);
-    if (success < 0) return 0;
-    success = hyperdex_java_client_convert_predicates(env, obj, o->arena, predicates, &in_checks, &in_checks_sz);
-    if (success < 0) return 0;
-    success = hyperdex_java_client_convert_sortby(env, obj, o->arena, sortby, &in_sort_by);
-    if (success < 0) return 0;
-    success = hyperdex_java_client_convert_limit(env, obj, o->arena, limit, &in_limit);
-    if (success < 0) return 0;
-    success = hyperdex_java_client_convert_maxmin(env, obj, o->arena, maxmin, &in_maxmin);
-    if (success < 0) return 0;
-    o->reqid = f(client, in_space, in_checks, in_checks_sz, in_sort_by, in_limit, in_maxmin, &o->status, &o->attrs, &o->attrs_sz);
-
-    if (o->reqid < 0)
-    {
-        hyperdex_java_client_throw_exception(env, o->status, hyperdex_client_error_message(client));
-        return 0;
-    }
-
-    o->encode_return = hyperdex_java_client_iterator_encode_status_attributes;
-    (*env)->CallObjectMethod(env, obj, _client_add_op, o->reqid, op);
-    ERROR_CHECK(0);
-    return op;
+	return hyperdex_java_client_asynccall__spacename_key__status_attributes(env, obj, hyperdex_client_get, spacename, key);
 }
+
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1get(JNIEnv* env, jobject obj, jstring spacename, jobject key)
+Java_org_hyperdex_client_Client_async_1get_1partial(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject attributenames)
 {
-    return hyperdex_java_client_asynccall__spacename_key__status_attributes(env, obj, hyperdex_client_get, spacename, key);
+	return hyperdex_java_client_asynccall__spacename_key_attributenames__status_attributes(env, obj, hyperdex_client_get_partial, spacename, key, attributenames);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1get_1partial(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject attributenames)
+Java_org_hyperdex_client_Client_async_1put(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_attributenames__status_attributes(env, obj, hyperdex_client_get_partial, spacename, key, attributenames);
+	return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_put, spacename, key, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1put(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject attributes)
+Java_org_hyperdex_client_Client_async_1cond_1put(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_put, spacename, key, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_put, spacename, key, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1cond_1put(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1cond_1put_1or_1create(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_put, spacename, key, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_put_or_create, spacename, key, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1cond_1put_1or_1create(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1group_1put(JNIEnv *env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_put_or_create, spacename, key, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_put, spacename, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1group_1put(JNIEnv* env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1put_1if_1not_1exist(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_put, spacename, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_put_if_not_exist, spacename, key, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1put_1if_1not_1exist(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject attributes)
+Java_org_hyperdex_client_Client_async_1del(JNIEnv *env, jobject obj, jstring spacename, jobject key)
 {
-    return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_put_if_not_exist, spacename, key, attributes);
+	return hyperdex_java_client_asynccall__spacename_key__status(env, obj, hyperdex_client_del, spacename, key);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1del(JNIEnv* env, jobject obj, jstring spacename, jobject key)
+Java_org_hyperdex_client_Client_async_1cond_1del(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject predicates)
 {
-    return hyperdex_java_client_asynccall__spacename_key__status(env, obj, hyperdex_client_del, spacename, key);
+	return hyperdex_java_client_asynccall__spacename_key_predicates__status(env, obj, hyperdex_client_cond_del, spacename, key, predicates);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1cond_1del(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject predicates)
+Java_org_hyperdex_client_Client_async_1group_1del(JNIEnv *env, jobject obj, jstring spacename, jobject predicates)
 {
-    return hyperdex_java_client_asynccall__spacename_key_predicates__status(env, obj, hyperdex_client_cond_del, spacename, key, predicates);
+	return hyperdex_java_client_asynccall__spacename_predicates__status_count(env, obj, hyperdex_client_group_del, spacename, predicates);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1group_1del(JNIEnv* env, jobject obj, jstring spacename, jobject predicates)
+Java_org_hyperdex_client_Client_async_1atomic_1add(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_predicates__status_count(env, obj, hyperdex_client_group_del, spacename, predicates);
+	return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_atomic_add, spacename, key, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1atomic_1add(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject attributes)
+Java_org_hyperdex_client_Client_async_1cond_1atomic_1add(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_atomic_add, spacename, key, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_atomic_add, spacename, key, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1cond_1atomic_1add(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1group_1atomic_1add(JNIEnv *env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_atomic_add, spacename, key, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_atomic_add, spacename, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1group_1atomic_1add(JNIEnv* env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1atomic_1sub(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_atomic_add, spacename, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_atomic_sub, spacename, key, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1atomic_1sub(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject attributes)
+Java_org_hyperdex_client_Client_async_1cond_1atomic_1sub(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_atomic_sub, spacename, key, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_atomic_sub, spacename, key, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1cond_1atomic_1sub(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1group_1atomic_1sub(JNIEnv *env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_atomic_sub, spacename, key, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_atomic_sub, spacename, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1group_1atomic_1sub(JNIEnv* env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1atomic_1mul(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_atomic_sub, spacename, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_atomic_mul, spacename, key, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1atomic_1mul(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject attributes)
+Java_org_hyperdex_client_Client_async_1cond_1atomic_1mul(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_atomic_mul, spacename, key, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_atomic_mul, spacename, key, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1cond_1atomic_1mul(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1group_1atomic_1mul(JNIEnv *env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_atomic_mul, spacename, key, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_atomic_mul, spacename, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1group_1atomic_1mul(JNIEnv* env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1atomic_1div(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_atomic_mul, spacename, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_atomic_div, spacename, key, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1atomic_1div(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject attributes)
+Java_org_hyperdex_client_Client_async_1cond_1atomic_1div(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_atomic_div, spacename, key, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_atomic_div, spacename, key, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1cond_1atomic_1div(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1group_1atomic_1div(JNIEnv *env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_atomic_div, spacename, key, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_atomic_div, spacename, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1group_1atomic_1div(JNIEnv* env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1atomic_1mod(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_atomic_div, spacename, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_atomic_mod, spacename, key, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1atomic_1mod(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject attributes)
+Java_org_hyperdex_client_Client_async_1cond_1atomic_1mod(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_atomic_mod, spacename, key, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_atomic_mod, spacename, key, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1cond_1atomic_1mod(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1group_1atomic_1mod(JNIEnv *env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_atomic_mod, spacename, key, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_atomic_mod, spacename, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1group_1atomic_1mod(JNIEnv* env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1atomic_1and(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_atomic_mod, spacename, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_atomic_and, spacename, key, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1atomic_1and(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject attributes)
+Java_org_hyperdex_client_Client_async_1cond_1atomic_1and(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_atomic_and, spacename, key, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_atomic_and, spacename, key, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1cond_1atomic_1and(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1group_1atomic_1and(JNIEnv *env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_atomic_and, spacename, key, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_atomic_and, spacename, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1group_1atomic_1and(JNIEnv* env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1atomic_1or(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_atomic_and, spacename, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_atomic_or, spacename, key, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1atomic_1or(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject attributes)
+Java_org_hyperdex_client_Client_async_1cond_1atomic_1or(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_atomic_or, spacename, key, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_atomic_or, spacename, key, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1cond_1atomic_1or(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1group_1atomic_1or(JNIEnv *env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_atomic_or, spacename, key, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_atomic_or, spacename, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1group_1atomic_1or(JNIEnv* env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1atomic_1xor(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_atomic_or, spacename, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_atomic_xor, spacename, key, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1atomic_1xor(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject attributes)
+Java_org_hyperdex_client_Client_async_1cond_1atomic_1xor(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_atomic_xor, spacename, key, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_atomic_xor, spacename, key, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1cond_1atomic_1xor(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1group_1atomic_1xor(JNIEnv *env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_atomic_xor, spacename, key, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_atomic_xor, spacename, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1group_1atomic_1xor(JNIEnv* env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1atomic_1min(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_atomic_xor, spacename, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_atomic_min, spacename, key, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1atomic_1min(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject attributes)
+Java_org_hyperdex_client_Client_async_1cond_1atomic_1min(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_atomic_min, spacename, key, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_atomic_min, spacename, key, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1cond_1atomic_1min(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1group_1atomic_1min(JNIEnv *env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_atomic_min, spacename, key, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_atomic_min, spacename, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1group_1atomic_1min(JNIEnv* env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1atomic_1max(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_atomic_min, spacename, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_atomic_max, spacename, key, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1atomic_1max(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject attributes)
+Java_org_hyperdex_client_Client_async_1cond_1atomic_1max(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_atomic_max, spacename, key, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_atomic_max, spacename, key, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1cond_1atomic_1max(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1group_1atomic_1max(JNIEnv *env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_atomic_max, spacename, key, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_atomic_max, spacename, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1group_1atomic_1max(JNIEnv* env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1string_1prepend(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_atomic_max, spacename, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_string_prepend, spacename, key, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1string_1prepend(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject attributes)
+Java_org_hyperdex_client_Client_async_1cond_1string_1prepend(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_string_prepend, spacename, key, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_string_prepend, spacename, key, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1cond_1string_1prepend(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1group_1string_1prepend(JNIEnv *env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_string_prepend, spacename, key, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_string_prepend, spacename, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1group_1string_1prepend(JNIEnv* env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1string_1append(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_string_prepend, spacename, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_string_append, spacename, key, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1string_1append(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject attributes)
+Java_org_hyperdex_client_Client_async_1cond_1string_1append(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_string_append, spacename, key, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_string_append, spacename, key, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1cond_1string_1append(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1group_1string_1append(JNIEnv *env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_string_append, spacename, key, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_string_append, spacename, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1group_1string_1append(JNIEnv* env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1string_1ltrim(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_string_append, spacename, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_string_ltrim, spacename, key, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1string_1ltrim(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject attributes)
+Java_org_hyperdex_client_Client_async_1cond_1string_1ltrim(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_string_ltrim, spacename, key, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_string_ltrim, spacename, key, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1cond_1string_1ltrim(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1group_1string_1ltrim(JNIEnv *env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_string_ltrim, spacename, key, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_string_ltrim, spacename, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1group_1string_1ltrim(JNIEnv* env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1string_1rtrim(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_string_ltrim, spacename, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_string_rtrim, spacename, key, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1string_1rtrim(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject attributes)
+Java_org_hyperdex_client_Client_async_1cond_1string_1rtrim(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_string_rtrim, spacename, key, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_string_rtrim, spacename, key, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1cond_1string_1rtrim(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1group_1string_1rtrim(JNIEnv *env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_string_rtrim, spacename, key, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_string_rtrim, spacename, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1group_1string_1rtrim(JNIEnv* env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1list_1lpush(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_string_rtrim, spacename, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_list_lpush, spacename, key, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1list_1lpush(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject attributes)
+Java_org_hyperdex_client_Client_async_1cond_1list_1lpush(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_list_lpush, spacename, key, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_list_lpush, spacename, key, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1cond_1list_1lpush(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1group_1list_1lpush(JNIEnv *env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_list_lpush, spacename, key, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_list_lpush, spacename, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1group_1list_1lpush(JNIEnv* env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1list_1rpush(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_list_lpush, spacename, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_list_rpush, spacename, key, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1list_1rpush(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject attributes)
+Java_org_hyperdex_client_Client_async_1cond_1list_1rpush(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_list_rpush, spacename, key, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_list_rpush, spacename, key, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1cond_1list_1rpush(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1group_1list_1rpush(JNIEnv *env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_list_rpush, spacename, key, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_list_rpush, spacename, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1group_1list_1rpush(JNIEnv* env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1set_1add(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_list_rpush, spacename, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_set_add, spacename, key, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1set_1add(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject attributes)
+Java_org_hyperdex_client_Client_async_1cond_1set_1add(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_set_add, spacename, key, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_set_add, spacename, key, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1cond_1set_1add(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1group_1set_1add(JNIEnv *env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_set_add, spacename, key, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_set_add, spacename, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1group_1set_1add(JNIEnv* env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1set_1remove(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_set_add, spacename, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_set_remove, spacename, key, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1set_1remove(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject attributes)
+Java_org_hyperdex_client_Client_async_1cond_1set_1remove(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_set_remove, spacename, key, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_set_remove, spacename, key, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1cond_1set_1remove(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1group_1set_1remove(JNIEnv *env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_set_remove, spacename, key, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_set_remove, spacename, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1group_1set_1remove(JNIEnv* env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1set_1intersect(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_set_remove, spacename, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_set_intersect, spacename, key, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1set_1intersect(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject attributes)
+Java_org_hyperdex_client_Client_async_1cond_1set_1intersect(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_set_intersect, spacename, key, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_set_intersect, spacename, key, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1cond_1set_1intersect(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1group_1set_1intersect(JNIEnv *env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_set_intersect, spacename, key, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_set_intersect, spacename, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1group_1set_1intersect(JNIEnv* env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1set_1union(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_set_intersect, spacename, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_set_union, spacename, key, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1set_1union(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject attributes)
+Java_org_hyperdex_client_Client_async_1cond_1set_1union(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_set_union, spacename, key, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_set_union, spacename, key, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1cond_1set_1union(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1group_1set_1union(JNIEnv *env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_set_union, spacename, key, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_set_union, spacename, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1group_1set_1union(JNIEnv* env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1document_1rename(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_set_union, spacename, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_document_rename, spacename, key, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1document_1rename(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject attributes)
+Java_org_hyperdex_client_Client_async_1cond_1document_1rename(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_document_rename, spacename, key, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_document_rename, spacename, key, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1cond_1document_1rename(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1group_1document_1rename(JNIEnv *env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_document_rename, spacename, key, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_document_rename, spacename, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1group_1document_1rename(JNIEnv* env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1document_1unset(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_document_rename, spacename, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_document_unset, spacename, key, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1document_1unset(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject attributes)
+Java_org_hyperdex_client_Client_async_1cond_1document_1unset(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_document_unset, spacename, key, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_document_unset, spacename, key, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1cond_1document_1unset(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1group_1document_1unset(JNIEnv *env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_document_unset, spacename, key, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_document_unset, spacename, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1group_1document_1unset(JNIEnv* env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1map_1add(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject mapattributes)
 {
-    return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_document_unset, spacename, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_mapattributes__status(env, obj, hyperdex_client_map_add, spacename, key, mapattributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1map_1add(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject mapattributes)
+Java_org_hyperdex_client_Client_async_1cond_1map_1add(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject mapattributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_mapattributes__status(env, obj, hyperdex_client_map_add, spacename, key, mapattributes);
+	return hyperdex_java_client_asynccall__spacename_key_predicates_mapattributes__status(env, obj, hyperdex_client_cond_map_add, spacename, key, predicates, mapattributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1cond_1map_1add(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject mapattributes)
+Java_org_hyperdex_client_Client_async_1group_1map_1add(JNIEnv *env, jobject obj, jstring spacename, jobject predicates, jobject mapattributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_predicates_mapattributes__status(env, obj, hyperdex_client_cond_map_add, spacename, key, predicates, mapattributes);
+	return hyperdex_java_client_asynccall__spacename_predicates_mapattributes__status_count(env, obj, hyperdex_client_group_map_add, spacename, predicates, mapattributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1group_1map_1add(JNIEnv* env, jobject obj, jstring spacename, jobject predicates, jobject mapattributes)
+Java_org_hyperdex_client_Client_async_1map_1remove(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_predicates_mapattributes__status_count(env, obj, hyperdex_client_group_map_add, spacename, predicates, mapattributes);
+	return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_map_remove, spacename, key, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1map_1remove(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject attributes)
+Java_org_hyperdex_client_Client_async_1cond_1map_1remove(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_attributes__status(env, obj, hyperdex_client_map_remove, spacename, key, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_map_remove, spacename, key, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1cond_1map_1remove(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1group_1map_1remove(JNIEnv *env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_predicates_attributes__status(env, obj, hyperdex_client_cond_map_remove, spacename, key, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_map_remove, spacename, predicates, attributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1group_1map_1remove(JNIEnv* env, jobject obj, jstring spacename, jobject predicates, jobject attributes)
+Java_org_hyperdex_client_Client_async_1map_1atomic_1add(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject mapattributes)
 {
-    return hyperdex_java_client_asynccall__spacename_predicates_attributes__status_count(env, obj, hyperdex_client_group_map_remove, spacename, predicates, attributes);
+	return hyperdex_java_client_asynccall__spacename_key_mapattributes__status(env, obj, hyperdex_client_map_atomic_add, spacename, key, mapattributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1map_1atomic_1add(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject mapattributes)
+Java_org_hyperdex_client_Client_async_1cond_1map_1atomic_1add(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject mapattributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_mapattributes__status(env, obj, hyperdex_client_map_atomic_add, spacename, key, mapattributes);
+	return hyperdex_java_client_asynccall__spacename_key_predicates_mapattributes__status(env, obj, hyperdex_client_cond_map_atomic_add, spacename, key, predicates, mapattributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1cond_1map_1atomic_1add(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject mapattributes)
+Java_org_hyperdex_client_Client_async_1group_1map_1atomic_1add(JNIEnv *env, jobject obj, jstring spacename, jobject predicates, jobject mapattributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_predicates_mapattributes__status(env, obj, hyperdex_client_cond_map_atomic_add, spacename, key, predicates, mapattributes);
+	return hyperdex_java_client_asynccall__spacename_predicates_mapattributes__status_count(env, obj, hyperdex_client_group_map_atomic_add, spacename, predicates, mapattributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1group_1map_1atomic_1add(JNIEnv* env, jobject obj, jstring spacename, jobject predicates, jobject mapattributes)
+Java_org_hyperdex_client_Client_async_1map_1atomic_1sub(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject mapattributes)
 {
-    return hyperdex_java_client_asynccall__spacename_predicates_mapattributes__status_count(env, obj, hyperdex_client_group_map_atomic_add, spacename, predicates, mapattributes);
+	return hyperdex_java_client_asynccall__spacename_key_mapattributes__status(env, obj, hyperdex_client_map_atomic_sub, spacename, key, mapattributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1map_1atomic_1sub(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject mapattributes)
+Java_org_hyperdex_client_Client_async_1cond_1map_1atomic_1sub(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject mapattributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_mapattributes__status(env, obj, hyperdex_client_map_atomic_sub, spacename, key, mapattributes);
+	return hyperdex_java_client_asynccall__spacename_key_predicates_mapattributes__status(env, obj, hyperdex_client_cond_map_atomic_sub, spacename, key, predicates, mapattributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1cond_1map_1atomic_1sub(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject mapattributes)
+Java_org_hyperdex_client_Client_async_1group_1map_1atomic_1sub(JNIEnv *env, jobject obj, jstring spacename, jobject predicates, jobject mapattributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_predicates_mapattributes__status(env, obj, hyperdex_client_cond_map_atomic_sub, spacename, key, predicates, mapattributes);
+	return hyperdex_java_client_asynccall__spacename_predicates_mapattributes__status_count(env, obj, hyperdex_client_group_map_atomic_sub, spacename, predicates, mapattributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1group_1map_1atomic_1sub(JNIEnv* env, jobject obj, jstring spacename, jobject predicates, jobject mapattributes)
+Java_org_hyperdex_client_Client_async_1map_1atomic_1mul(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject mapattributes)
 {
-    return hyperdex_java_client_asynccall__spacename_predicates_mapattributes__status_count(env, obj, hyperdex_client_group_map_atomic_sub, spacename, predicates, mapattributes);
+	return hyperdex_java_client_asynccall__spacename_key_mapattributes__status(env, obj, hyperdex_client_map_atomic_mul, spacename, key, mapattributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1map_1atomic_1mul(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject mapattributes)
+Java_org_hyperdex_client_Client_async_1cond_1map_1atomic_1mul(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject mapattributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_mapattributes__status(env, obj, hyperdex_client_map_atomic_mul, spacename, key, mapattributes);
+	return hyperdex_java_client_asynccall__spacename_key_predicates_mapattributes__status(env, obj, hyperdex_client_cond_map_atomic_mul, spacename, key, predicates, mapattributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1cond_1map_1atomic_1mul(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject mapattributes)
+Java_org_hyperdex_client_Client_async_1group_1map_1atomic_1mul(JNIEnv *env, jobject obj, jstring spacename, jobject predicates, jobject mapattributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_predicates_mapattributes__status(env, obj, hyperdex_client_cond_map_atomic_mul, spacename, key, predicates, mapattributes);
+	return hyperdex_java_client_asynccall__spacename_predicates_mapattributes__status_count(env, obj, hyperdex_client_group_map_atomic_mul, spacename, predicates, mapattributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1group_1map_1atomic_1mul(JNIEnv* env, jobject obj, jstring spacename, jobject predicates, jobject mapattributes)
+Java_org_hyperdex_client_Client_async_1map_1atomic_1div(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject mapattributes)
 {
-    return hyperdex_java_client_asynccall__spacename_predicates_mapattributes__status_count(env, obj, hyperdex_client_group_map_atomic_mul, spacename, predicates, mapattributes);
+	return hyperdex_java_client_asynccall__spacename_key_mapattributes__status(env, obj, hyperdex_client_map_atomic_div, spacename, key, mapattributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1map_1atomic_1div(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject mapattributes)
+Java_org_hyperdex_client_Client_async_1cond_1map_1atomic_1div(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject mapattributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_mapattributes__status(env, obj, hyperdex_client_map_atomic_div, spacename, key, mapattributes);
+	return hyperdex_java_client_asynccall__spacename_key_predicates_mapattributes__status(env, obj, hyperdex_client_cond_map_atomic_div, spacename, key, predicates, mapattributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1cond_1map_1atomic_1div(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject mapattributes)
+Java_org_hyperdex_client_Client_async_1group_1map_1atomic_1div(JNIEnv *env, jobject obj, jstring spacename, jobject predicates, jobject mapattributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_predicates_mapattributes__status(env, obj, hyperdex_client_cond_map_atomic_div, spacename, key, predicates, mapattributes);
+	return hyperdex_java_client_asynccall__spacename_predicates_mapattributes__status_count(env, obj, hyperdex_client_group_map_atomic_div, spacename, predicates, mapattributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1group_1map_1atomic_1div(JNIEnv* env, jobject obj, jstring spacename, jobject predicates, jobject mapattributes)
+Java_org_hyperdex_client_Client_async_1map_1atomic_1mod(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject mapattributes)
 {
-    return hyperdex_java_client_asynccall__spacename_predicates_mapattributes__status_count(env, obj, hyperdex_client_group_map_atomic_div, spacename, predicates, mapattributes);
+	return hyperdex_java_client_asynccall__spacename_key_mapattributes__status(env, obj, hyperdex_client_map_atomic_mod, spacename, key, mapattributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1map_1atomic_1mod(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject mapattributes)
+Java_org_hyperdex_client_Client_async_1cond_1map_1atomic_1mod(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject mapattributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_mapattributes__status(env, obj, hyperdex_client_map_atomic_mod, spacename, key, mapattributes);
+	return hyperdex_java_client_asynccall__spacename_key_predicates_mapattributes__status(env, obj, hyperdex_client_cond_map_atomic_mod, spacename, key, predicates, mapattributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1cond_1map_1atomic_1mod(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject mapattributes)
+Java_org_hyperdex_client_Client_async_1group_1map_1atomic_1mod(JNIEnv *env, jobject obj, jstring spacename, jobject predicates, jobject mapattributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_predicates_mapattributes__status(env, obj, hyperdex_client_cond_map_atomic_mod, spacename, key, predicates, mapattributes);
+	return hyperdex_java_client_asynccall__spacename_predicates_mapattributes__status_count(env, obj, hyperdex_client_group_map_atomic_mod, spacename, predicates, mapattributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1group_1map_1atomic_1mod(JNIEnv* env, jobject obj, jstring spacename, jobject predicates, jobject mapattributes)
+Java_org_hyperdex_client_Client_async_1map_1atomic_1and(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject mapattributes)
 {
-    return hyperdex_java_client_asynccall__spacename_predicates_mapattributes__status_count(env, obj, hyperdex_client_group_map_atomic_mod, spacename, predicates, mapattributes);
+	return hyperdex_java_client_asynccall__spacename_key_mapattributes__status(env, obj, hyperdex_client_map_atomic_and, spacename, key, mapattributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1map_1atomic_1and(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject mapattributes)
+Java_org_hyperdex_client_Client_async_1cond_1map_1atomic_1and(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject mapattributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_mapattributes__status(env, obj, hyperdex_client_map_atomic_and, spacename, key, mapattributes);
+	return hyperdex_java_client_asynccall__spacename_key_predicates_mapattributes__status(env, obj, hyperdex_client_cond_map_atomic_and, spacename, key, predicates, mapattributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1cond_1map_1atomic_1and(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject mapattributes)
+Java_org_hyperdex_client_Client_async_1group_1map_1atomic_1and(JNIEnv *env, jobject obj, jstring spacename, jobject predicates, jobject mapattributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_predicates_mapattributes__status(env, obj, hyperdex_client_cond_map_atomic_and, spacename, key, predicates, mapattributes);
+	return hyperdex_java_client_asynccall__spacename_predicates_mapattributes__status_count(env, obj, hyperdex_client_group_map_atomic_and, spacename, predicates, mapattributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1group_1map_1atomic_1and(JNIEnv* env, jobject obj, jstring spacename, jobject predicates, jobject mapattributes)
+Java_org_hyperdex_client_Client_async_1map_1atomic_1or(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject mapattributes)
 {
-    return hyperdex_java_client_asynccall__spacename_predicates_mapattributes__status_count(env, obj, hyperdex_client_group_map_atomic_and, spacename, predicates, mapattributes);
+	return hyperdex_java_client_asynccall__spacename_key_mapattributes__status(env, obj, hyperdex_client_map_atomic_or, spacename, key, mapattributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1map_1atomic_1or(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject mapattributes)
+Java_org_hyperdex_client_Client_async_1cond_1map_1atomic_1or(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject mapattributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_mapattributes__status(env, obj, hyperdex_client_map_atomic_or, spacename, key, mapattributes);
+	return hyperdex_java_client_asynccall__spacename_key_predicates_mapattributes__status(env, obj, hyperdex_client_cond_map_atomic_or, spacename, key, predicates, mapattributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1cond_1map_1atomic_1or(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject mapattributes)
+Java_org_hyperdex_client_Client_async_1group_1map_1atomic_1or(JNIEnv *env, jobject obj, jstring spacename, jobject predicates, jobject mapattributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_predicates_mapattributes__status(env, obj, hyperdex_client_cond_map_atomic_or, spacename, key, predicates, mapattributes);
+	return hyperdex_java_client_asynccall__spacename_predicates_mapattributes__status_count(env, obj, hyperdex_client_group_map_atomic_or, spacename, predicates, mapattributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1group_1map_1atomic_1or(JNIEnv* env, jobject obj, jstring spacename, jobject predicates, jobject mapattributes)
+Java_org_hyperdex_client_Client_async_1map_1atomic_1xor(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject mapattributes)
 {
-    return hyperdex_java_client_asynccall__spacename_predicates_mapattributes__status_count(env, obj, hyperdex_client_group_map_atomic_or, spacename, predicates, mapattributes);
+	return hyperdex_java_client_asynccall__spacename_key_mapattributes__status(env, obj, hyperdex_client_map_atomic_xor, spacename, key, mapattributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1map_1atomic_1xor(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject mapattributes)
+Java_org_hyperdex_client_Client_async_1cond_1map_1atomic_1xor(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject mapattributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_mapattributes__status(env, obj, hyperdex_client_map_atomic_xor, spacename, key, mapattributes);
+	return hyperdex_java_client_asynccall__spacename_key_predicates_mapattributes__status(env, obj, hyperdex_client_cond_map_atomic_xor, spacename, key, predicates, mapattributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1cond_1map_1atomic_1xor(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject mapattributes)
+Java_org_hyperdex_client_Client_async_1group_1map_1atomic_1xor(JNIEnv *env, jobject obj, jstring spacename, jobject predicates, jobject mapattributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_predicates_mapattributes__status(env, obj, hyperdex_client_cond_map_atomic_xor, spacename, key, predicates, mapattributes);
+	return hyperdex_java_client_asynccall__spacename_predicates_mapattributes__status_count(env, obj, hyperdex_client_group_map_atomic_xor, spacename, predicates, mapattributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1group_1map_1atomic_1xor(JNIEnv* env, jobject obj, jstring spacename, jobject predicates, jobject mapattributes)
+Java_org_hyperdex_client_Client_async_1map_1string_1prepend(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject mapattributes)
 {
-    return hyperdex_java_client_asynccall__spacename_predicates_mapattributes__status_count(env, obj, hyperdex_client_group_map_atomic_xor, spacename, predicates, mapattributes);
+	return hyperdex_java_client_asynccall__spacename_key_mapattributes__status(env, obj, hyperdex_client_map_string_prepend, spacename, key, mapattributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1map_1string_1prepend(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject mapattributes)
+Java_org_hyperdex_client_Client_async_1cond_1map_1string_1prepend(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject mapattributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_mapattributes__status(env, obj, hyperdex_client_map_string_prepend, spacename, key, mapattributes);
+	return hyperdex_java_client_asynccall__spacename_key_predicates_mapattributes__status(env, obj, hyperdex_client_cond_map_string_prepend, spacename, key, predicates, mapattributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1cond_1map_1string_1prepend(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject mapattributes)
+Java_org_hyperdex_client_Client_async_1group_1map_1string_1prepend(JNIEnv *env, jobject obj, jstring spacename, jobject predicates, jobject mapattributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_predicates_mapattributes__status(env, obj, hyperdex_client_cond_map_string_prepend, spacename, key, predicates, mapattributes);
+	return hyperdex_java_client_asynccall__spacename_predicates_mapattributes__status_count(env, obj, hyperdex_client_group_map_string_prepend, spacename, predicates, mapattributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1group_1map_1string_1prepend(JNIEnv* env, jobject obj, jstring spacename, jobject predicates, jobject mapattributes)
+Java_org_hyperdex_client_Client_async_1map_1string_1append(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject mapattributes)
 {
-    return hyperdex_java_client_asynccall__spacename_predicates_mapattributes__status_count(env, obj, hyperdex_client_group_map_string_prepend, spacename, predicates, mapattributes);
+	return hyperdex_java_client_asynccall__spacename_key_mapattributes__status(env, obj, hyperdex_client_map_string_append, spacename, key, mapattributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1map_1string_1append(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject mapattributes)
+Java_org_hyperdex_client_Client_async_1cond_1map_1string_1append(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject mapattributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_mapattributes__status(env, obj, hyperdex_client_map_string_append, spacename, key, mapattributes);
+	return hyperdex_java_client_asynccall__spacename_key_predicates_mapattributes__status(env, obj, hyperdex_client_cond_map_string_append, spacename, key, predicates, mapattributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1cond_1map_1string_1append(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject mapattributes)
+Java_org_hyperdex_client_Client_async_1group_1map_1string_1append(JNIEnv *env, jobject obj, jstring spacename, jobject predicates, jobject mapattributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_predicates_mapattributes__status(env, obj, hyperdex_client_cond_map_string_append, spacename, key, predicates, mapattributes);
+	return hyperdex_java_client_asynccall__spacename_predicates_mapattributes__status_count(env, obj, hyperdex_client_group_map_string_append, spacename, predicates, mapattributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1group_1map_1string_1append(JNIEnv* env, jobject obj, jstring spacename, jobject predicates, jobject mapattributes)
+Java_org_hyperdex_client_Client_async_1map_1atomic_1min(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject mapattributes)
 {
-    return hyperdex_java_client_asynccall__spacename_predicates_mapattributes__status_count(env, obj, hyperdex_client_group_map_string_append, spacename, predicates, mapattributes);
+	return hyperdex_java_client_asynccall__spacename_key_mapattributes__status(env, obj, hyperdex_client_map_atomic_min, spacename, key, mapattributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1map_1atomic_1min(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject mapattributes)
+Java_org_hyperdex_client_Client_async_1cond_1map_1atomic_1min(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject mapattributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_mapattributes__status(env, obj, hyperdex_client_map_atomic_min, spacename, key, mapattributes);
+	return hyperdex_java_client_asynccall__spacename_key_predicates_mapattributes__status(env, obj, hyperdex_client_cond_map_atomic_min, spacename, key, predicates, mapattributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1cond_1map_1atomic_1min(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject mapattributes)
+Java_org_hyperdex_client_Client_async_1group_1map_1atomic_1min(JNIEnv *env, jobject obj, jstring spacename, jobject predicates, jobject mapattributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_predicates_mapattributes__status(env, obj, hyperdex_client_cond_map_atomic_min, spacename, key, predicates, mapattributes);
+	return hyperdex_java_client_asynccall__spacename_predicates_mapattributes__status_count(env, obj, hyperdex_client_group_map_atomic_min, spacename, predicates, mapattributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1group_1map_1atomic_1min(JNIEnv* env, jobject obj, jstring spacename, jobject predicates, jobject mapattributes)
+Java_org_hyperdex_client_Client_async_1map_1atomic_1max(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject mapattributes)
 {
-    return hyperdex_java_client_asynccall__spacename_predicates_mapattributes__status_count(env, obj, hyperdex_client_group_map_atomic_min, spacename, predicates, mapattributes);
+	return hyperdex_java_client_asynccall__spacename_key_mapattributes__status(env, obj, hyperdex_client_map_atomic_max, spacename, key, mapattributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1map_1atomic_1max(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject mapattributes)
+Java_org_hyperdex_client_Client_async_1cond_1map_1atomic_1max(JNIEnv *env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject mapattributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_mapattributes__status(env, obj, hyperdex_client_map_atomic_max, spacename, key, mapattributes);
+	return hyperdex_java_client_asynccall__spacename_key_predicates_mapattributes__status(env, obj, hyperdex_client_cond_map_atomic_max, spacename, key, predicates, mapattributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1cond_1map_1atomic_1max(JNIEnv* env, jobject obj, jstring spacename, jobject key, jobject predicates, jobject mapattributes)
+Java_org_hyperdex_client_Client_async_1group_1map_1atomic_1max(JNIEnv *env, jobject obj, jstring spacename, jobject predicates, jobject mapattributes)
 {
-    return hyperdex_java_client_asynccall__spacename_key_predicates_mapattributes__status(env, obj, hyperdex_client_cond_map_atomic_max, spacename, key, predicates, mapattributes);
+	return hyperdex_java_client_asynccall__spacename_predicates_mapattributes__status_count(env, obj, hyperdex_client_group_map_atomic_max, spacename, predicates, mapattributes);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1group_1map_1atomic_1max(JNIEnv* env, jobject obj, jstring spacename, jobject predicates, jobject mapattributes)
+Java_org_hyperdex_client_Client_search(JNIEnv *env, jobject obj, jstring spacename, jobject predicates)
 {
-    return hyperdex_java_client_asynccall__spacename_predicates_mapattributes__status_count(env, obj, hyperdex_client_group_map_atomic_max, spacename, predicates, mapattributes);
+	return hyperdex_java_client_iterator__spacename_predicates__status_attributes(env, obj, hyperdex_client_search, spacename, predicates);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_search(JNIEnv* env, jobject obj, jstring spacename, jobject predicates)
+Java_org_hyperdex_client_Client_async_1search_1describe(JNIEnv *env, jobject obj, jstring spacename, jobject predicates)
 {
-    return hyperdex_java_client_iterator__spacename_predicates__status_attributes(env, obj, hyperdex_client_search, spacename, predicates);
+	return hyperdex_java_client_asynccall__spacename_predicates__status_description(env, obj, hyperdex_client_search_describe, spacename, predicates);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1search_1describe(JNIEnv* env, jobject obj, jstring spacename, jobject predicates)
+Java_org_hyperdex_client_Client_sorted_1search(JNIEnv *env, jobject obj, jstring spacename, jobject predicates, jstring sortby, jint limit, jboolean maxmin)
 {
-    return hyperdex_java_client_asynccall__spacename_predicates__status_description(env, obj, hyperdex_client_search_describe, spacename, predicates);
+	return hyperdex_java_client_iterator__spacename_predicates_sortby_limit_maxmin__status_attributes(env, obj, hyperdex_client_sorted_search, spacename, predicates, sortby, limit, maxmin);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_sorted_1search(JNIEnv* env, jobject obj, jstring spacename, jobject predicates, jstring sortby, jint limit, jboolean maxmin)
+Java_org_hyperdex_client_Client_async_1count(JNIEnv *env, jobject obj, jstring spacename, jobject predicates)
 {
-    return hyperdex_java_client_iterator__spacename_predicates_sortby_limit_maxmin__status_attributes(env, obj, hyperdex_client_sorted_search, spacename, predicates, sortby, limit, maxmin);
+	return hyperdex_java_client_asynccall__spacename_predicates__status_count(env, obj, hyperdex_client_count, spacename, predicates);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Client_async_1count(JNIEnv* env, jobject obj, jstring spacename, jobject predicates)
+Java_org_hyperdex_client_Client_async_1sum(JNIEnv *env, jobject obj, jstring spacename, jobject predicates, jstring key)
 {
-    return hyperdex_java_client_asynccall__spacename_predicates__status_count(env, obj, hyperdex_client_count, spacename, predicates);
+	return hyperdex_java_client_asynccall__spacename_predicates__status_sum(env, obj, hyperdex_client_sum, spacename, predicates, key);
 }
diff --git a/bindings/java/org_hyperdex_client_Client.h b/bindings/java/org_hyperdex_client_Client.h
index f205a9637..70f7e127e 100644
--- a/bindings/java/org_hyperdex_client_Client.h
+++ b/bindings/java/org_hyperdex_client_Client.h
@@ -13,7 +13,7 @@ extern "C" {
  * Signature: ()V
  */
 JNIEXPORT HYPERDEX_API void JNICALL Java_org_hyperdex_client_Client_initialize
-  (JNIEnv *, jclass);
+(JNIEnv *, jclass);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -21,7 +21,7 @@ JNIEXPORT HYPERDEX_API void JNICALL Java_org_hyperdex_client_Client_initialize
  * Signature: ()V
  */
 JNIEXPORT HYPERDEX_API void JNICALL Java_org_hyperdex_client_Client_terminate
-  (JNIEnv *, jclass);
+(JNIEnv *, jclass);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -29,7 +29,7 @@ JNIEXPORT HYPERDEX_API void JNICALL Java_org_hyperdex_client_Client_terminate
  * Signature: (Ljava/lang/String;I)V
  */
 JNIEXPORT HYPERDEX_API void JNICALL Java_org_hyperdex_client_Client__1create
-  (JNIEnv *, jobject, jstring, jint);
+(JNIEnv *, jobject, jstring, jint);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -37,7 +37,7 @@ JNIEXPORT HYPERDEX_API void JNICALL Java_org_hyperdex_client_Client__1create
  * Signature: ()V
  */
 JNIEXPORT HYPERDEX_API void JNICALL Java_org_hyperdex_client_Client__1destroy
-  (JNIEnv *, jobject);
+(JNIEnv *, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -45,7 +45,7 @@ JNIEXPORT HYPERDEX_API void JNICALL Java_org_hyperdex_client_Client__1destroy
  * Signature: ()J
  */
 JNIEXPORT HYPERDEX_API jlong JNICALL Java_org_hyperdex_client_Client_inner_1loop
-  (JNIEnv *, jobject);
+(JNIEnv *, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -53,7 +53,7 @@ JNIEXPORT HYPERDEX_API jlong JNICALL Java_org_hyperdex_client_Client_inner_1loop
  * Signature: (Ljava/lang/String;Ljava/lang/Object;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1get
-  (JNIEnv *, jobject, jstring, jobject);
+(JNIEnv *, jobject, jstring, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -61,7 +61,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1ge
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/List;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1get_1partial
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -69,7 +69,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1ge
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1put
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -77,7 +77,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1pu
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1cond_1put
-  (JNIEnv *, jobject, jstring, jobject, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -85,7 +85,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1co
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1cond_1put_1or_1create
-  (JNIEnv *, jobject, jstring, jobject, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -93,7 +93,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1co
  * Signature: (Ljava/lang/String;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1group_1put
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -101,7 +101,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1gr
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1put_1if_1not_1exist
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -109,7 +109,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1pu
  * Signature: (Ljava/lang/String;Ljava/lang/Object;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1del
-  (JNIEnv *, jobject, jstring, jobject);
+(JNIEnv *, jobject, jstring, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -117,7 +117,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1de
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1cond_1del
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -125,7 +125,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1co
  * Signature: (Ljava/lang/String;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1group_1del
-  (JNIEnv *, jobject, jstring, jobject);
+(JNIEnv *, jobject, jstring, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -133,7 +133,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1gr
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1atomic_1add
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -141,7 +141,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1at
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1cond_1atomic_1add
-  (JNIEnv *, jobject, jstring, jobject, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -149,7 +149,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1co
  * Signature: (Ljava/lang/String;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1group_1atomic_1add
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -157,7 +157,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1gr
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1atomic_1sub
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -165,7 +165,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1at
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1cond_1atomic_1sub
-  (JNIEnv *, jobject, jstring, jobject, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -173,7 +173,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1co
  * Signature: (Ljava/lang/String;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1group_1atomic_1sub
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -181,7 +181,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1gr
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1atomic_1mul
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -189,7 +189,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1at
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1cond_1atomic_1mul
-  (JNIEnv *, jobject, jstring, jobject, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -197,7 +197,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1co
  * Signature: (Ljava/lang/String;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1group_1atomic_1mul
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -205,7 +205,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1gr
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1atomic_1div
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -213,7 +213,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1at
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1cond_1atomic_1div
-  (JNIEnv *, jobject, jstring, jobject, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -221,7 +221,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1co
  * Signature: (Ljava/lang/String;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1group_1atomic_1div
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -229,7 +229,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1gr
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1atomic_1mod
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -237,7 +237,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1at
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1cond_1atomic_1mod
-  (JNIEnv *, jobject, jstring, jobject, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -245,7 +245,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1co
  * Signature: (Ljava/lang/String;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1group_1atomic_1mod
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -253,7 +253,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1gr
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1atomic_1and
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -261,7 +261,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1at
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1cond_1atomic_1and
-  (JNIEnv *, jobject, jstring, jobject, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -269,7 +269,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1co
  * Signature: (Ljava/lang/String;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1group_1atomic_1and
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -277,7 +277,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1gr
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1atomic_1or
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -285,7 +285,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1at
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1cond_1atomic_1or
-  (JNIEnv *, jobject, jstring, jobject, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -293,7 +293,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1co
  * Signature: (Ljava/lang/String;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1group_1atomic_1or
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -301,7 +301,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1gr
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1atomic_1xor
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -309,7 +309,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1at
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1cond_1atomic_1xor
-  (JNIEnv *, jobject, jstring, jobject, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -317,7 +317,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1co
  * Signature: (Ljava/lang/String;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1group_1atomic_1xor
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -325,7 +325,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1gr
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1atomic_1min
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -333,7 +333,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1at
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1cond_1atomic_1min
-  (JNIEnv *, jobject, jstring, jobject, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -341,7 +341,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1co
  * Signature: (Ljava/lang/String;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1group_1atomic_1min
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -349,7 +349,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1gr
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1atomic_1max
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -357,7 +357,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1at
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1cond_1atomic_1max
-  (JNIEnv *, jobject, jstring, jobject, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -365,7 +365,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1co
  * Signature: (Ljava/lang/String;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1group_1atomic_1max
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -373,7 +373,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1gr
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1string_1prepend
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -381,7 +381,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1st
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1cond_1string_1prepend
-  (JNIEnv *, jobject, jstring, jobject, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -389,7 +389,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1co
  * Signature: (Ljava/lang/String;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1group_1string_1prepend
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -397,7 +397,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1gr
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1string_1append
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -405,7 +405,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1st
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1cond_1string_1append
-  (JNIEnv *, jobject, jstring, jobject, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -413,7 +413,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1co
  * Signature: (Ljava/lang/String;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1group_1string_1append
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -421,7 +421,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1gr
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1string_1ltrim
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -429,7 +429,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1st
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1cond_1string_1ltrim
-  (JNIEnv *, jobject, jstring, jobject, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -437,7 +437,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1co
  * Signature: (Ljava/lang/String;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1group_1string_1ltrim
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -445,7 +445,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1gr
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1string_1rtrim
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -453,7 +453,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1st
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1cond_1string_1rtrim
-  (JNIEnv *, jobject, jstring, jobject, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -461,7 +461,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1co
  * Signature: (Ljava/lang/String;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1group_1string_1rtrim
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -469,7 +469,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1gr
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1list_1lpush
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -477,7 +477,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1li
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1cond_1list_1lpush
-  (JNIEnv *, jobject, jstring, jobject, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -485,7 +485,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1co
  * Signature: (Ljava/lang/String;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1group_1list_1lpush
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -493,7 +493,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1gr
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1list_1rpush
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -501,7 +501,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1li
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1cond_1list_1rpush
-  (JNIEnv *, jobject, jstring, jobject, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -509,7 +509,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1co
  * Signature: (Ljava/lang/String;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1group_1list_1rpush
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -517,7 +517,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1gr
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1set_1add
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -525,7 +525,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1se
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1cond_1set_1add
-  (JNIEnv *, jobject, jstring, jobject, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -533,7 +533,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1co
  * Signature: (Ljava/lang/String;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1group_1set_1add
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -541,7 +541,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1gr
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1set_1remove
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -549,7 +549,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1se
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1cond_1set_1remove
-  (JNIEnv *, jobject, jstring, jobject, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -557,7 +557,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1co
  * Signature: (Ljava/lang/String;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1group_1set_1remove
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -565,7 +565,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1gr
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1set_1intersect
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -573,7 +573,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1se
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1cond_1set_1intersect
-  (JNIEnv *, jobject, jstring, jobject, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -581,7 +581,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1co
  * Signature: (Ljava/lang/String;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1group_1set_1intersect
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -589,7 +589,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1gr
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1set_1union
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -597,7 +597,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1se
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1cond_1set_1union
-  (JNIEnv *, jobject, jstring, jobject, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -605,7 +605,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1co
  * Signature: (Ljava/lang/String;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1group_1set_1union
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -613,7 +613,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1gr
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1document_1rename
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -621,7 +621,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1do
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1cond_1document_1rename
-  (JNIEnv *, jobject, jstring, jobject, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -629,7 +629,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1co
  * Signature: (Ljava/lang/String;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1group_1document_1rename
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -637,7 +637,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1gr
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1document_1unset
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -645,7 +645,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1do
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1cond_1document_1unset
-  (JNIEnv *, jobject, jstring, jobject, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -653,7 +653,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1co
  * Signature: (Ljava/lang/String;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1group_1document_1unset
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -661,7 +661,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1gr
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1map_1add
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -669,7 +669,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1ma
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1cond_1map_1add
-  (JNIEnv *, jobject, jstring, jobject, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -677,7 +677,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1co
  * Signature: (Ljava/lang/String;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1group_1map_1add
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -685,7 +685,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1gr
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1map_1remove
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -693,7 +693,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1ma
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1cond_1map_1remove
-  (JNIEnv *, jobject, jstring, jobject, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -701,7 +701,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1co
  * Signature: (Ljava/lang/String;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1group_1map_1remove
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -709,7 +709,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1gr
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1map_1atomic_1add
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -717,7 +717,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1ma
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1cond_1map_1atomic_1add
-  (JNIEnv *, jobject, jstring, jobject, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -725,7 +725,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1co
  * Signature: (Ljava/lang/String;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1group_1map_1atomic_1add
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -733,7 +733,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1gr
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1map_1atomic_1sub
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -741,7 +741,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1ma
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1cond_1map_1atomic_1sub
-  (JNIEnv *, jobject, jstring, jobject, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -749,7 +749,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1co
  * Signature: (Ljava/lang/String;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1group_1map_1atomic_1sub
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -757,7 +757,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1gr
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1map_1atomic_1mul
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -765,7 +765,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1ma
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1cond_1map_1atomic_1mul
-  (JNIEnv *, jobject, jstring, jobject, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -773,7 +773,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1co
  * Signature: (Ljava/lang/String;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1group_1map_1atomic_1mul
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -781,7 +781,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1gr
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1map_1atomic_1div
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -789,7 +789,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1ma
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1cond_1map_1atomic_1div
-  (JNIEnv *, jobject, jstring, jobject, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -797,7 +797,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1co
  * Signature: (Ljava/lang/String;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1group_1map_1atomic_1div
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -805,7 +805,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1gr
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1map_1atomic_1mod
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -813,7 +813,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1ma
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1cond_1map_1atomic_1mod
-  (JNIEnv *, jobject, jstring, jobject, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -821,7 +821,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1co
  * Signature: (Ljava/lang/String;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1group_1map_1atomic_1mod
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -829,7 +829,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1gr
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1map_1atomic_1and
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -837,7 +837,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1ma
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1cond_1map_1atomic_1and
-  (JNIEnv *, jobject, jstring, jobject, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -845,7 +845,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1co
  * Signature: (Ljava/lang/String;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1group_1map_1atomic_1and
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -853,7 +853,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1gr
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1map_1atomic_1or
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -861,7 +861,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1ma
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1cond_1map_1atomic_1or
-  (JNIEnv *, jobject, jstring, jobject, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -869,7 +869,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1co
  * Signature: (Ljava/lang/String;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1group_1map_1atomic_1or
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -877,7 +877,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1gr
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1map_1atomic_1xor
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -885,7 +885,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1ma
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1cond_1map_1atomic_1xor
-  (JNIEnv *, jobject, jstring, jobject, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -893,7 +893,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1co
  * Signature: (Ljava/lang/String;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1group_1map_1atomic_1xor
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -901,7 +901,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1gr
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1map_1string_1prepend
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -909,7 +909,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1ma
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1cond_1map_1string_1prepend
-  (JNIEnv *, jobject, jstring, jobject, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -917,7 +917,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1co
  * Signature: (Ljava/lang/String;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1group_1map_1string_1prepend
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -925,7 +925,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1gr
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1map_1string_1append
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -933,7 +933,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1ma
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1cond_1map_1string_1append
-  (JNIEnv *, jobject, jstring, jobject, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -941,7 +941,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1co
  * Signature: (Ljava/lang/String;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1group_1map_1string_1append
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -949,7 +949,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1gr
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1map_1atomic_1min
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -957,7 +957,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1ma
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1cond_1map_1atomic_1min
-  (JNIEnv *, jobject, jstring, jobject, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -965,7 +965,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1co
  * Signature: (Ljava/lang/String;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1group_1map_1atomic_1min
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -973,7 +973,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1gr
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1map_1atomic_1max
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -981,7 +981,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1ma
  * Signature: (Ljava/lang/String;Ljava/lang/Object;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1cond_1map_1atomic_1max
-  (JNIEnv *, jobject, jstring, jobject, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -989,7 +989,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1co
  * Signature: (Ljava/lang/String;Ljava/util/Map;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1group_1map_1atomic_1max
-  (JNIEnv *, jobject, jstring, jobject, jobject);
+(JNIEnv *, jobject, jstring, jobject, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -997,7 +997,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1gr
  * Signature: (Ljava/lang/String;Ljava/util/Map;)Lorg/hyperdex/client/Iterator;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_search
-  (JNIEnv *, jobject, jstring, jobject);
+(JNIEnv *, jobject, jstring, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -1005,7 +1005,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_search
  * Signature: (Ljava/lang/String;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1search_1describe
-  (JNIEnv *, jobject, jstring, jobject);
+(JNIEnv *, jobject, jstring, jobject);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -1013,7 +1013,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1se
  * Signature: (Ljava/lang/String;Ljava/util/Map;Ljava/lang/String;IZ)Lorg/hyperdex/client/Iterator;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_sorted_1search
-  (JNIEnv *, jobject, jstring, jobject, jstring, jint, jboolean);
+(JNIEnv *, jobject, jstring, jobject, jstring, jint, jboolean);
 
 /*
  * Class:     org_hyperdex_client_Client
@@ -1021,7 +1021,15 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_sorted_1s
  * Signature: (Ljava/lang/String;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1count
-  (JNIEnv *, jobject, jstring, jobject);
+(JNIEnv *, jobject, jstring, jobject);
+
+/*
+ * Class:     org_hyperdex_client_Client
+ * Method:    async_sum
+ * Signature: (Ljava/lang/String;Ljava/util/Map;)Lorg/hyperdex/client/Deferred;
+ */
+JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Client_async_1sum
+(JNIEnv *, jobject, jstring, jobject, jstring);
 
 #ifdef __cplusplus
 }
diff --git a/bindings/java/org_hyperdex_client_Deferred.h b/bindings/java/org_hyperdex_client_Deferred.h
index f00a7a699..52eebe22c 100644
--- a/bindings/java/org_hyperdex_client_Deferred.h
+++ b/bindings/java/org_hyperdex_client_Deferred.h
@@ -13,7 +13,7 @@ extern "C" {
  * Signature: ()V
  */
 JNIEXPORT HYPERDEX_API void JNICALL Java_org_hyperdex_client_Deferred__1create
-  (JNIEnv *, jobject);
+(JNIEnv *, jobject);
 
 /*
  * Class:     org_hyperdex_client_Deferred
@@ -21,7 +21,7 @@ JNIEXPORT HYPERDEX_API void JNICALL Java_org_hyperdex_client_Deferred__1create
  * Signature: ()V
  */
 JNIEXPORT HYPERDEX_API void JNICALL Java_org_hyperdex_client_Deferred__1destroy
-  (JNIEnv *, jobject);
+(JNIEnv *, jobject);
 
 /*
  * Class:     org_hyperdex_client_Deferred
@@ -29,7 +29,7 @@ JNIEXPORT HYPERDEX_API void JNICALL Java_org_hyperdex_client_Deferred__1destroy
  * Signature: ()Ljava/lang/Object;
  */
 JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Deferred_waitForIt
-  (JNIEnv *, jobject);
+(JNIEnv *, jobject);
 
 /*
  * Class:     org_hyperdex_client_Deferred
@@ -37,7 +37,7 @@ JNIEXPORT HYPERDEX_API jobject JNICALL Java_org_hyperdex_client_Deferred_waitFor
  * Signature: ()V
  */
 JNIEXPORT HYPERDEX_API void JNICALL Java_org_hyperdex_client_Deferred_callback
-  (JNIEnv *, jobject);
+(JNIEnv *, jobject);
 
 #ifdef __cplusplus
 }
diff --git a/bindings/java/org_hyperdex_client_GreaterEqual.h b/bindings/java/org_hyperdex_client_GreaterEqual.h
index e2071398b..23666b98b 100644
--- a/bindings/java/org_hyperdex_client_GreaterEqual.h
+++ b/bindings/java/org_hyperdex_client_GreaterEqual.h
@@ -13,7 +13,7 @@ extern "C" {
  * Signature: ()J
  */
 JNIEXPORT HYPERDEX_API jlong JNICALL Java_org_hyperdex_client_GreaterEqual_checksSize
-  (JNIEnv *, jobject);
+(JNIEnv *, jobject);
 
 /*
  * Class:     org_hyperdex_client_GreaterEqual
@@ -21,7 +21,7 @@ JNIEXPORT HYPERDEX_API jlong JNICALL Java_org_hyperdex_client_GreaterEqual_check
  * Signature: (JJJ)J
  */
 JNIEXPORT HYPERDEX_API jlong JNICALL Java_org_hyperdex_client_GreaterEqual_convertChecks
-  (JNIEnv *, jobject, jlong, jlong, jlong);
+(JNIEnv *, jobject, jlong, jlong, jlong);
 
 #ifdef __cplusplus
 }
diff --git a/bindings/java/org_hyperdex_client_GreaterThan.h b/bindings/java/org_hyperdex_client_GreaterThan.h
index f9ef32c60..88a5f3f7d 100644
--- a/bindings/java/org_hyperdex_client_GreaterThan.h
+++ b/bindings/java/org_hyperdex_client_GreaterThan.h
@@ -13,7 +13,7 @@ extern "C" {
  * Signature: ()J
  */
 JNIEXPORT HYPERDEX_API jlong JNICALL Java_org_hyperdex_client_GreaterThan_checksSize
-  (JNIEnv *, jobject);
+(JNIEnv *, jobject);
 
 /*
  * Class:     org_hyperdex_client_GreaterThan
@@ -21,7 +21,7 @@ JNIEXPORT HYPERDEX_API jlong JNICALL Java_org_hyperdex_client_GreaterThan_checks
  * Signature: (JJJ)J
  */
 JNIEXPORT HYPERDEX_API jlong JNICALL Java_org_hyperdex_client_GreaterThan_convertChecks
-  (JNIEnv *, jobject, jlong, jlong, jlong);
+(JNIEnv *, jobject, jlong, jlong, jlong);
 
 #ifdef __cplusplus
 }
diff --git a/bindings/java/org_hyperdex_client_Iterator.h b/bindings/java/org_hyperdex_client_Iterator.h
index c40147c8a..9f617b1aa 100644
--- a/bindings/java/org_hyperdex_client_Iterator.h
+++ b/bindings/java/org_hyperdex_client_Iterator.h
@@ -13,7 +13,7 @@ extern "C" {
  * Signature: ()V
  */
 JNIEXPORT HYPERDEX_API void JNICALL Java_org_hyperdex_client_Iterator__1create
-  (JNIEnv *, jobject);
+(JNIEnv *, jobject);
 
 /*
  * Class:     org_hyperdex_client_Iterator
@@ -21,7 +21,7 @@ JNIEXPORT HYPERDEX_API void JNICALL Java_org_hyperdex_client_Iterator__1create
  * Signature: ()V
  */
 JNIEXPORT HYPERDEX_API void JNICALL Java_org_hyperdex_client_Iterator__1destroy
-  (JNIEnv *, jobject);
+(JNIEnv *, jobject);
 
 /*
  * Class:     org_hyperdex_client_Iterator
@@ -29,7 +29,7 @@ JNIEXPORT HYPERDEX_API void JNICALL Java_org_hyperdex_client_Iterator__1destroy
  * Signature: ()Z
  */
 JNIEXPORT HYPERDEX_API jboolean JNICALL Java_org_hyperdex_client_Iterator_finished
-  (JNIEnv *, jobject);
+(JNIEnv *, jobject);
 
 /*
  * Class:     org_hyperdex_client_Iterator
@@ -37,7 +37,7 @@ JNIEXPORT HYPERDEX_API jboolean JNICALL Java_org_hyperdex_client_Iterator_finish
  * Signature: ()V
  */
 JNIEXPORT HYPERDEX_API void JNICALL Java_org_hyperdex_client_Iterator_callback
-  (JNIEnv *, jobject);
+(JNIEnv *, jobject);
 
 #ifdef __cplusplus
 }
diff --git a/bindings/java/org_hyperdex_client_LengthEquals.h b/bindings/java/org_hyperdex_client_LengthEquals.h
index ed29761c8..74568c6cb 100644
--- a/bindings/java/org_hyperdex_client_LengthEquals.h
+++ b/bindings/java/org_hyperdex_client_LengthEquals.h
@@ -13,7 +13,7 @@ extern "C" {
  * Signature: ()J
  */
 JNIEXPORT HYPERDEX_API jlong JNICALL Java_org_hyperdex_client_LengthEquals_checksSize
-  (JNIEnv *, jobject);
+(JNIEnv *, jobject);
 
 /*
  * Class:     org_hyperdex_client_LengthEquals
@@ -21,7 +21,7 @@ JNIEXPORT HYPERDEX_API jlong JNICALL Java_org_hyperdex_client_LengthEquals_check
  * Signature: (JJJ)J
  */
 JNIEXPORT HYPERDEX_API jlong JNICALL Java_org_hyperdex_client_LengthEquals_convertChecks
-  (JNIEnv *, jobject, jlong, jlong, jlong);
+(JNIEnv *, jobject, jlong, jlong, jlong);
 
 #ifdef __cplusplus
 }
diff --git a/bindings/java/org_hyperdex_client_LengthGreaterEqual.h b/bindings/java/org_hyperdex_client_LengthGreaterEqual.h
index c79ddaa18..55f344f9a 100644
--- a/bindings/java/org_hyperdex_client_LengthGreaterEqual.h
+++ b/bindings/java/org_hyperdex_client_LengthGreaterEqual.h
@@ -13,7 +13,7 @@ extern "C" {
  * Signature: ()J
  */
 JNIEXPORT HYPERDEX_API jlong JNICALL Java_org_hyperdex_client_LengthGreaterEqual_checksSize
-  (JNIEnv *, jobject);
+(JNIEnv *, jobject);
 
 /*
  * Class:     org_hyperdex_client_LengthGreaterEqual
@@ -21,7 +21,7 @@ JNIEXPORT HYPERDEX_API jlong JNICALL Java_org_hyperdex_client_LengthGreaterEqual
  * Signature: (JJJ)J
  */
 JNIEXPORT HYPERDEX_API jlong JNICALL Java_org_hyperdex_client_LengthGreaterEqual_convertChecks
-  (JNIEnv *, jobject, jlong, jlong, jlong);
+(JNIEnv *, jobject, jlong, jlong, jlong);
 
 #ifdef __cplusplus
 }
diff --git a/bindings/java/org_hyperdex_client_LengthLessEqual.h b/bindings/java/org_hyperdex_client_LengthLessEqual.h
index a9948b6e2..fdd87a350 100644
--- a/bindings/java/org_hyperdex_client_LengthLessEqual.h
+++ b/bindings/java/org_hyperdex_client_LengthLessEqual.h
@@ -13,7 +13,7 @@ extern "C" {
  * Signature: ()J
  */
 JNIEXPORT HYPERDEX_API jlong JNICALL Java_org_hyperdex_client_LengthLessEqual_checksSize
-  (JNIEnv *, jobject);
+(JNIEnv *, jobject);
 
 /*
  * Class:     org_hyperdex_client_LengthLessEqual
@@ -21,7 +21,7 @@ JNIEXPORT HYPERDEX_API jlong JNICALL Java_org_hyperdex_client_LengthLessEqual_ch
  * Signature: (JJJ)J
  */
 JNIEXPORT HYPERDEX_API jlong JNICALL Java_org_hyperdex_client_LengthLessEqual_convertChecks
-  (JNIEnv *, jobject, jlong, jlong, jlong);
+(JNIEnv *, jobject, jlong, jlong, jlong);
 
 #ifdef __cplusplus
 }
diff --git a/bindings/java/org_hyperdex_client_LessEqual.h b/bindings/java/org_hyperdex_client_LessEqual.h
index 344cc82b8..b5c3da4c4 100644
--- a/bindings/java/org_hyperdex_client_LessEqual.h
+++ b/bindings/java/org_hyperdex_client_LessEqual.h
@@ -13,7 +13,7 @@ extern "C" {
  * Signature: ()J
  */
 JNIEXPORT HYPERDEX_API jlong JNICALL Java_org_hyperdex_client_LessEqual_checksSize
-  (JNIEnv *, jobject);
+(JNIEnv *, jobject);
 
 /*
  * Class:     org_hyperdex_client_LessEqual
@@ -21,7 +21,7 @@ JNIEXPORT HYPERDEX_API jlong JNICALL Java_org_hyperdex_client_LessEqual_checksSi
  * Signature: (JJJ)J
  */
 JNIEXPORT HYPERDEX_API jlong JNICALL Java_org_hyperdex_client_LessEqual_convertChecks
-  (JNIEnv *, jobject, jlong, jlong, jlong);
+(JNIEnv *, jobject, jlong, jlong, jlong);
 
 #ifdef __cplusplus
 }
diff --git a/bindings/java/org_hyperdex_client_LessThan.h b/bindings/java/org_hyperdex_client_LessThan.h
index 886a97933..fc4b52c47 100644
--- a/bindings/java/org_hyperdex_client_LessThan.h
+++ b/bindings/java/org_hyperdex_client_LessThan.h
@@ -13,7 +13,7 @@ extern "C" {
  * Signature: ()J
  */
 JNIEXPORT HYPERDEX_API jlong JNICALL Java_org_hyperdex_client_LessThan_checksSize
-  (JNIEnv *, jobject);
+(JNIEnv *, jobject);
 
 /*
  * Class:     org_hyperdex_client_LessThan
@@ -21,7 +21,7 @@ JNIEXPORT HYPERDEX_API jlong JNICALL Java_org_hyperdex_client_LessThan_checksSiz
  * Signature: (JJJ)J
  */
 JNIEXPORT HYPERDEX_API jlong JNICALL Java_org_hyperdex_client_LessThan_convertChecks
-  (JNIEnv *, jobject, jlong, jlong, jlong);
+(JNIEnv *, jobject, jlong, jlong, jlong);
 
 #ifdef __cplusplus
 }
diff --git a/bindings/java/org_hyperdex_client_Microtransaction.c b/bindings/java/org_hyperdex_client_Microtransaction.c
index e34371c9b..946d268d8 100644
--- a/bindings/java/org_hyperdex_client_Microtransaction.c
+++ b/bindings/java/org_hyperdex_client_Microtransaction.c
@@ -45,9 +45,9 @@
 #define ERROR_CHECK_VOID() if ((*env)->ExceptionCheck(env) == JNI_TRUE) return
 
 #define REF(NAME, DEF) \
-    tmp_cls = (DEF); \
-    NAME = (jclass) (*env)->NewGlobalRef(env, tmp_cls); \
-    (*env)->DeleteLocalRef(env, tmp_cls);
+	tmp_cls = (DEF); \
+	NAME = (jclass) (*env)->NewGlobalRef(env, tmp_cls); \
+	(*env)->DeleteLocalRef(env, tmp_cls);
 
 static jclass _uxact;
 static jfieldID _uxact_client;
@@ -68,239 +68,220 @@ static jclass _boolean;
 static jmethodID _boolean_init;
 
 JNIEXPORT HYPERDEX_API void JNICALL
-Java_org_hyperdex_client_Microtransaction_initialize(JNIEnv* env, jclass client)
+Java_org_hyperdex_client_Microtransaction_initialize(JNIEnv *env, jclass client)
 {
-    jclass tmp_cls;
-
-    /* cache class Client */
-    REF(_uxact, (*env)->FindClass(env, "org/hyperdex/client/Microtransaction"));
-    _uxact_client = (*env)->GetFieldID(env, _uxact, "client", "Lorg/hyperdex/client/Client;");
-    _uxact_uxact_ptr = (*env)->GetFieldID(env, _uxact, "uxact_ptr", "J");
-    _uxact_deferred_ptr = (*env)->GetFieldID(env, _uxact, "deferred_ptr", "J");
-    REF(_client, (*env)->FindClass(env, "org/hyperdex/client/Client"));
-    _client_ptr = (*env)->GetFieldID(env, _client, "ptr", "J");
-    _client_add_op = (*env)->GetMethodID(env, _client, "add_op", "(JLorg/hyperdex/client/Operation;)V");
-    _client_remove_op = (*env)->GetMethodID(env, _client, "remove_op", "(J)V");
-    REF(_deferred, (*env)->FindClass(env, "org/hyperdex/client/Deferred"));
-    _deferred_ptr = (*env)->GetFieldID(env, _deferred, "ptr", "J");
-    _deferred_init = (*env)->GetMethodID(env, _deferred, "<init>", "(Lorg/hyperdex/client/Client;)V");
-    _deferred_c = (*env)->GetFieldID(env, _deferred, "c", "Lorg/hyperdex/client/Client;");
-    REF(_boolean, (*env)->FindClass(env, "java/lang/Boolean"));
-    _boolean_init = (*env)->GetMethodID(env, _boolean, "<init>", "(Z)V");
-
-    CHECK_CACHE(_uxact);
-    CHECK_CACHE(_uxact_client);
-    CHECK_CACHE(_uxact_uxact_ptr);
-    CHECK_CACHE(_uxact_deferred_ptr);
-    CHECK_CACHE(_client);
-    CHECK_CACHE(_client_ptr);
-    CHECK_CACHE(_client_add_op);
-    CHECK_CACHE(_client_remove_op);
-    CHECK_CACHE(_boolean);
-    CHECK_CACHE(_boolean_init);
-    CHECK_CACHE(_deferred);
-    CHECK_CACHE(_deferred_init);
-    CHECK_CACHE(_deferred_c);
-    CHECK_CACHE(_deferred_ptr);
-
-    ERROR_CHECK_VOID();
+	jclass tmp_cls;
+	/* cache class Client */
+	REF(_uxact, (*env)->FindClass(env, "org/hyperdex/client/Microtransaction"));
+	_uxact_client = (*env)->GetFieldID(env, _uxact, "client", "Lorg/hyperdex/client/Client;");
+	_uxact_uxact_ptr = (*env)->GetFieldID(env, _uxact, "uxact_ptr", "J");
+	_uxact_deferred_ptr = (*env)->GetFieldID(env, _uxact, "deferred_ptr", "J");
+	REF(_client, (*env)->FindClass(env, "org/hyperdex/client/Client"));
+	_client_ptr = (*env)->GetFieldID(env, _client, "ptr", "J");
+	_client_add_op = (*env)->GetMethodID(env, _client, "add_op", "(JLorg/hyperdex/client/Operation;)V");
+	_client_remove_op = (*env)->GetMethodID(env, _client, "remove_op", "(J)V");
+	REF(_deferred, (*env)->FindClass(env, "org/hyperdex/client/Deferred"));
+	_deferred_ptr = (*env)->GetFieldID(env, _deferred, "ptr", "J");
+	_deferred_init = (*env)->GetMethodID(env, _deferred, "<init>", "(Lorg/hyperdex/client/Client;)V");
+	_deferred_c = (*env)->GetFieldID(env, _deferred, "c", "Lorg/hyperdex/client/Client;");
+	REF(_boolean, (*env)->FindClass(env, "java/lang/Boolean"));
+	_boolean_init = (*env)->GetMethodID(env, _boolean, "<init>", "(Z)V");
+	CHECK_CACHE(_uxact);
+	CHECK_CACHE(_uxact_client);
+	CHECK_CACHE(_uxact_uxact_ptr);
+	CHECK_CACHE(_uxact_deferred_ptr);
+	CHECK_CACHE(_client);
+	CHECK_CACHE(_client_ptr);
+	CHECK_CACHE(_client_add_op);
+	CHECK_CACHE(_client_remove_op);
+	CHECK_CACHE(_boolean);
+	CHECK_CACHE(_boolean_init);
+	CHECK_CACHE(_deferred);
+	CHECK_CACHE(_deferred_init);
+	CHECK_CACHE(_deferred_c);
+	CHECK_CACHE(_deferred_ptr);
+	ERROR_CHECK_VOID();
 }
 
 static jobject
-hyperdex_uxact_get_client(JNIEnv* env, jobject obj)
+hyperdex_uxact_get_client(JNIEnv *env, jobject obj)
 {
-    jobject c;
-    c = (*env)->GetObjectField(env, obj, _uxact_client);
-    assert(c);
-    return c;
+	jobject c;
+	c = (*env)->GetObjectField(env, obj, _uxact_client);
+	assert(c);
+	return c;
 }
 
-static struct hyperdex_client*
-hyperdex_uxact_get_client_ptr(JNIEnv* env, jobject obj)
+static struct hyperdex_client *
+hyperdex_uxact_get_client_ptr(JNIEnv *env, jobject obj)
 {
-    jobject c;
-    struct hyperdex_client* x;
-    c = hyperdex_uxact_get_client(env, obj);
-    x = (struct hyperdex_client*) (*env)->GetLongField(env, c, _client_ptr);
-    assert(x);
-    return x;
+	jobject c;
+	struct hyperdex_client *x;
+	c = hyperdex_uxact_get_client(env, obj);
+	x = (struct hyperdex_client *) (*env)->GetLongField(env, c, _client_ptr);
+	assert(x);
+	return x;
 }
 
-static struct hyperdex_client*
-hyperdex_client_get_client_ptr(JNIEnv* env, jobject obj)
+static struct hyperdex_client *
+hyperdex_client_get_client_ptr(JNIEnv *env, jobject obj)
 {
-    struct hyperdex_client* x;
-    x = (struct hyperdex_client*) (*env)->GetLongField(env, obj, _client_ptr);
-    assert(x);
-    return x;
+	struct hyperdex_client *x;
+	x = (struct hyperdex_client *) (*env)->GetLongField(env, obj, _client_ptr);
+	assert(x);
+	return x;
 }
 
-static struct hyperdex_java_client_deferred*
-hyperdex_uxact_get_deferred_ptr(JNIEnv* env, jobject obj)
+static struct hyperdex_java_client_deferred *
+hyperdex_uxact_get_deferred_ptr(JNIEnv *env, jobject obj)
 {
-    struct hyperdex_java_client_deferred* x;
-    x = (struct hyperdex_java_client_deferred*) (*env)->GetLongField(env, obj, _uxact_deferred_ptr);
-    assert(x);
-    return x;
+	struct hyperdex_java_client_deferred *x;
+	x = (struct hyperdex_java_client_deferred *) (*env)->GetLongField(env, obj, _uxact_deferred_ptr);
+	assert(x);
+	return x;
 }
 
-static struct hyperdex_java_client_deferred*
-hyperdex_get_deferred_ptr(JNIEnv* env, jobject obj)
+static struct hyperdex_java_client_deferred *
+hyperdex_get_deferred_ptr(JNIEnv *env, jobject obj)
 {
-    struct hyperdex_java_client_deferred* x;
-    x = (struct hyperdex_java_client_deferred*) (*env)->GetLongField(env, obj, _deferred_ptr);
-    assert(x);
-    return x;
+	struct hyperdex_java_client_deferred *x;
+	x = (struct hyperdex_java_client_deferred *) (*env)->GetLongField(env, obj, _deferred_ptr);
+	assert(x);
+	return x;
 }
 
-static struct hyperdex_ds_arena*
-hyperdex_uxact_get_arena_ptr(JNIEnv* env, jobject obj)
+static struct hyperdex_ds_arena *
+hyperdex_uxact_get_arena_ptr(JNIEnv *env, jobject obj)
 {
-    struct hyperdex_java_client_deferred* x;
-    x = (struct hyperdex_java_client_deferred*) (*env)->GetLongField(env, obj, _uxact_deferred_ptr);
-    assert(x);
-    return x->arena;
+	struct hyperdex_java_client_deferred *x;
+	x = (struct hyperdex_java_client_deferred *) (*env)->GetLongField(env, obj, _uxact_deferred_ptr);
+	assert(x);
+	return x->arena;
 }
 
-static struct hyperdex_client_microtransaction*
-hyperdex_uxact_get_uxact_ptr(JNIEnv* env, jobject obj)
+static struct hyperdex_client_microtransaction *
+hyperdex_uxact_get_uxact_ptr(JNIEnv *env, jobject obj)
 {
-    struct hyperdex_client_microtransaction* x;
-    x = (struct hyperdex_client_microtransaction*) (*env)->GetLongField(env, obj, _uxact_uxact_ptr);
-    assert(x);
-    return x;
+	struct hyperdex_client_microtransaction *x;
+	x = (struct hyperdex_client_microtransaction *) (*env)->GetLongField(env, obj, _uxact_uxact_ptr);
+	assert(x);
+	return x;
 }
 
 JNIEXPORT HYPERDEX_API void JNICALL
-Java_org_hyperdex_client_Microtransaction__1create(JNIEnv* env, jobject uxact, jstring _space)
+Java_org_hyperdex_client_Microtransaction__1create(JNIEnv *env, jobject uxact, jstring _space)
 {
-    struct hyperdex_client *client;
-    struct hyperdex_client_microtransaction *uxact_ptr;
-    const char *space;
-    struct hyperdex_java_client_deferred *deferred;
-
-    deferred = (struct hyperdex_java_client_deferred*)malloc(sizeof(struct hyperdex_java_client_deferred));
-    memset(deferred, 0, sizeof(struct hyperdex_java_client_deferred));
-
-    deferred->arena = hyperdex_ds_arena_create();
-
-    if (!deferred->arena)
-    {
-        /* all other resources are caught by the finalizer? */
-        hyperdex_java_out_of_memory(env);
-        return;
-    }
-
-    deferred->status = HYPERDEX_CLIENT_GARBAGE;
-
-    space = (*env)->GetStringUTFChars(env, _space, NULL);
-
-    client = hyperdex_uxact_get_client_ptr(env, uxact);
-    uxact_ptr = hyperdex_client_uxact_init(client, space, &deferred->status);
-
-    (*env)->SetLongField(env, uxact, _uxact_uxact_ptr, (long)uxact_ptr);
-    (*env)->SetLongField(env, uxact, _uxact_deferred_ptr, (long)deferred);
+	struct hyperdex_client *client;
+	struct hyperdex_client_microtransaction *uxact_ptr;
+	const char *space;
+	struct hyperdex_java_client_deferred *deferred;
+	deferred = (struct hyperdex_java_client_deferred *)malloc(sizeof(struct hyperdex_java_client_deferred));
+	memset(deferred, 0, sizeof(struct hyperdex_java_client_deferred));
+	deferred->arena = hyperdex_ds_arena_create();
+	if (!deferred->arena)
+	{
+		/* all other resources are caught by the finalizer? */
+		hyperdex_java_out_of_memory(env);
+		return;
+	}
+	deferred->status = HYPERDEX_CLIENT_GARBAGE;
+	space = (*env)->GetStringUTFChars(env, _space, NULL);
+	client = hyperdex_uxact_get_client_ptr(env, uxact);
+	uxact_ptr = hyperdex_client_uxact_init(client, space, &deferred->status);
+	(*env)->SetLongField(env, uxact, _uxact_uxact_ptr, (long)uxact_ptr);
+	(*env)->SetLongField(env, uxact, _uxact_deferred_ptr, (long)deferred);
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Microtransaction_async_1cond_1commit(JNIEnv* env, jobject uxact, jstring jkey, jobject checks)
+Java_org_hyperdex_client_Microtransaction_async_1cond_1commit(JNIEnv *env, jobject uxact, jstring jkey, jobject checks)
 {
-    const char* key;
-    size_t key_sz;
-    const struct hyperdex_client_attribute_check *chks;
-    size_t chks_sz;
-    struct hyperdex_client* client_ptr = hyperdex_uxact_get_client_ptr(env, uxact);
-    struct hyperdex_client_microtransaction *uxact_ptr = hyperdex_uxact_get_uxact_ptr(env, uxact);
-    jobject client = hyperdex_uxact_get_client(env, uxact);
-    jobject op = (*env)->NewObject(env, _deferred, _deferred_init, client);
-    struct hyperdex_java_client_deferred* o = hyperdex_uxact_get_deferred_ptr(env, uxact);
-    ERROR_CHECK(0);
-
-    hyperdex_java_client_convert_key(env, client, o->arena, jkey, &key, &key_sz);
-    hyperdex_java_client_convert_predicates(env, client, o->arena, checks, &chks, &chks_sz);
-    o->encode_return = hyperdex_java_client_deferred_encode_status;
-    o->reqid = hyperdex_client_uxact_cond_commit(client_ptr, uxact_ptr, key, key_sz, chks, chks_sz);
-
-    (*env)->SetLongField(env, op, _deferred_ptr, (long)o);
-
-    if (o->reqid < 0)
-    {
-        hyperdex_java_client_throw_exception(env, o->status, hyperdex_client_error_message(client_ptr));
-        return NULL;
-    }
-    (*env)->CallObjectMethod(env, client, _client_add_op, o->reqid, op);
-    ERROR_CHECK(0);
-    return op;
+	const char *key;
+	size_t key_sz;
+	const struct hyperdex_client_attribute_check *chks;
+	size_t chks_sz;
+	struct hyperdex_client *client_ptr = hyperdex_uxact_get_client_ptr(env, uxact);
+	struct hyperdex_client_microtransaction *uxact_ptr = hyperdex_uxact_get_uxact_ptr(env, uxact);
+	jobject client = hyperdex_uxact_get_client(env, uxact);
+	jobject op = (*env)->NewObject(env, _deferred, _deferred_init, client);
+	struct hyperdex_java_client_deferred *o = hyperdex_uxact_get_deferred_ptr(env, uxact);
+	ERROR_CHECK(0);
+	hyperdex_java_client_convert_key(env, client, o->arena, jkey, &key, &key_sz);
+	hyperdex_java_client_convert_predicates(env, client, o->arena, checks, &chks, &chks_sz);
+	o->encode_return = hyperdex_java_client_deferred_encode_status;
+	o->reqid = hyperdex_client_uxact_cond_commit(client_ptr, uxact_ptr, key, key_sz, chks, chks_sz);
+	(*env)->SetLongField(env, op, _deferred_ptr, (long)o);
+	if (o->reqid < 0)
+	{
+		hyperdex_java_client_throw_exception(env, o->status, hyperdex_client_error_message(client_ptr));
+		return NULL;
+	}
+	(*env)->CallObjectMethod(env, client, _client_add_op, o->reqid, op);
+	ERROR_CHECK(0);
+	return op;
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Microtransaction_async_1group_1commit(JNIEnv* env, jobject uxact, jobject checks)
+Java_org_hyperdex_client_Microtransaction_async_1group_1commit(JNIEnv *env, jobject uxact, jobject checks)
 {
-    const struct hyperdex_client_attribute_check *chks;
-    size_t chks_sz;
-    struct hyperdex_client* client_ptr = hyperdex_uxact_get_client_ptr(env, uxact);
-    struct hyperdex_client_microtransaction *uxact_ptr = hyperdex_uxact_get_uxact_ptr(env, uxact);
-    jobject client = hyperdex_uxact_get_client(env, uxact);
-    jobject op = (*env)->NewObject(env, _deferred, _deferred_init, client);
-    struct hyperdex_java_client_deferred* o = hyperdex_uxact_get_deferred_ptr(env, uxact);
-    ERROR_CHECK(0);
-
-    hyperdex_java_client_convert_predicates(env, client, o->arena, checks, &chks, &chks_sz);
-    o->encode_return = hyperdex_java_client_deferred_encode_status_count;
-    o->reqid = hyperdex_client_uxact_group_commit(client_ptr, uxact_ptr, chks, chks_sz, &o->count);
-
-    (*env)->SetLongField(env, op, _deferred_ptr, (long)o);
-
-    if (o->reqid < 0)
-    {
-        hyperdex_java_client_throw_exception(env, o->status, hyperdex_client_error_message(client_ptr));
-        return NULL;
-    }
-    (*env)->CallObjectMethod(env, client, _client_add_op, o->reqid, op);
-    ERROR_CHECK(0);
-    return op;
+	const struct hyperdex_client_attribute_check *chks;
+	size_t chks_sz;
+	struct hyperdex_client *client_ptr = hyperdex_uxact_get_client_ptr(env, uxact);
+	struct hyperdex_client_microtransaction *uxact_ptr = hyperdex_uxact_get_uxact_ptr(env, uxact);
+	jobject client = hyperdex_uxact_get_client(env, uxact);
+	jobject op = (*env)->NewObject(env, _deferred, _deferred_init, client);
+	struct hyperdex_java_client_deferred *o = hyperdex_uxact_get_deferred_ptr(env, uxact);
+	ERROR_CHECK(0);
+	hyperdex_java_client_convert_predicates(env, client, o->arena, checks, &chks, &chks_sz);
+	o->encode_return = hyperdex_java_client_deferred_encode_status_count;
+	o->reqid = hyperdex_client_uxact_group_commit(client_ptr, uxact_ptr, chks, chks_sz, &o->count);
+	(*env)->SetLongField(env, op, _deferred_ptr, (long)o);
+	if (o->reqid < 0)
+	{
+		hyperdex_java_client_throw_exception(env, o->status, hyperdex_client_error_message(client_ptr));
+		return NULL;
+	}
+	(*env)->CallObjectMethod(env, client, _client_add_op, o->reqid, op);
+	ERROR_CHECK(0);
+	return op;
 }
 
 JNIEXPORT HYPERDEX_API jobject JNICALL
-Java_org_hyperdex_client_Microtransaction_async_1commit(JNIEnv* env, jobject uxact, jstring key)
+Java_org_hyperdex_client_Microtransaction_async_1commit(JNIEnv *env, jobject uxact, jstring key)
 {
-    const char* in_key;
-    size_t in_key_sz;
-    struct hyperdex_client* client_ptr = hyperdex_uxact_get_client_ptr(env, uxact);
-    struct hyperdex_client_microtransaction *uxact_ptr = hyperdex_uxact_get_uxact_ptr(env, uxact);
-    jobject client = hyperdex_uxact_get_client(env, uxact);
-    jobject op = (*env)->NewObject(env, _deferred, _deferred_init, client);
-    struct hyperdex_java_client_deferred* o = hyperdex_uxact_get_deferred_ptr(env, uxact);
-    ERROR_CHECK(0);
-
-    hyperdex_java_client_convert_key(env, client, o->arena, key, &in_key, &in_key_sz);
-    o->encode_return = hyperdex_java_client_deferred_encode_status;
-    o->reqid = hyperdex_client_uxact_commit(client_ptr, uxact_ptr, in_key, in_key_sz);
-
-    (*env)->SetLongField(env, op, _deferred_ptr, (long)o);
-
-    if (o->reqid < 0)
-    {
-        hyperdex_java_client_throw_exception(env, o->status, hyperdex_client_error_message(client_ptr));
-        return NULL;
-    }
-    (*env)->CallObjectMethod(env, client, _client_add_op, o->reqid, op);
-    ERROR_CHECK(0);
-    return op;
+	const char *in_key;
+	size_t in_key_sz;
+	struct hyperdex_client *client_ptr = hyperdex_uxact_get_client_ptr(env, uxact);
+	struct hyperdex_client_microtransaction *uxact_ptr = hyperdex_uxact_get_uxact_ptr(env, uxact);
+	jobject client = hyperdex_uxact_get_client(env, uxact);
+	jobject op = (*env)->NewObject(env, _deferred, _deferred_init, client);
+	struct hyperdex_java_client_deferred *o = hyperdex_uxact_get_deferred_ptr(env, uxact);
+	ERROR_CHECK(0);
+	hyperdex_java_client_convert_key(env, client, o->arena, key, &in_key, &in_key_sz);
+	o->encode_return = hyperdex_java_client_deferred_encode_status;
+	o->reqid = hyperdex_client_uxact_commit(client_ptr, uxact_ptr, in_key, in_key_sz);
+	(*env)->SetLongField(env, op, _deferred_ptr, (long)o);
+	if (o->reqid < 0)
+	{
+		hyperdex_java_client_throw_exception(env, o->status, hyperdex_client_error_message(client_ptr));
+		return NULL;
+	}
+	(*env)->CallObjectMethod(env, client, _client_add_op, o->reqid, op);
+	ERROR_CHECK(0);
+	return op;
 }
 
 JNIEXPORT HYPERDEX_API void JNICALL
-Java_org_hyperdex_client_Microtransaction__1destroy(JNIEnv* env, jclass uxact)
+Java_org_hyperdex_client_Microtransaction__1destroy(JNIEnv *env, jclass uxact)
 {
-    ERROR_CHECK_VOID();
+	ERROR_CHECK_VOID();
 }
 
 JNIEXPORT HYPERDEX_API void JNICALL
-Java_org_hyperdex_client_Microtransaction_terminate(JNIEnv* env, jclass uxact)
+Java_org_hyperdex_client_Microtransaction_terminate(JNIEnv *env, jclass uxact)
 {
-    (*env)->DeleteGlobalRef(env, _uxact);
-    (*env)->DeleteGlobalRef(env, _client);
-    (void) uxact;
+	(*env)->DeleteGlobalRef(env, _uxact);
+	(*env)->DeleteGlobalRef(env, _client);
+	(void) uxact;
 }
 
 #include "bindings/java/org_hyperdex_client_Microtransaction.definitions.c"
diff --git a/bindings/java/org_hyperdex_client_Range.h b/bindings/java/org_hyperdex_client_Range.h
index 7c9737629..96c2ca8c5 100644
--- a/bindings/java/org_hyperdex_client_Range.h
+++ b/bindings/java/org_hyperdex_client_Range.h
@@ -13,7 +13,7 @@ extern "C" {
  * Signature: ()J
  */
 JNIEXPORT HYPERDEX_API jlong JNICALL Java_org_hyperdex_client_Range_checksSize
-  (JNIEnv *, jobject);
+(JNIEnv *, jobject);
 
 /*
  * Class:     org_hyperdex_client_Range
@@ -21,7 +21,7 @@ JNIEXPORT HYPERDEX_API jlong JNICALL Java_org_hyperdex_client_Range_checksSize
  * Signature: (JJJ)J
  */
 JNIEXPORT HYPERDEX_API jlong JNICALL Java_org_hyperdex_client_Range_convertChecks
-  (JNIEnv *, jobject, jlong, jlong, jlong);
+(JNIEnv *, jobject, jlong, jlong, jlong);
 
 #ifdef __cplusplus
 }
diff --git a/bindings/java/org_hyperdex_client_Regex.h b/bindings/java/org_hyperdex_client_Regex.h
index cf245786a..637506e57 100644
--- a/bindings/java/org_hyperdex_client_Regex.h
+++ b/bindings/java/org_hyperdex_client_Regex.h
@@ -13,7 +13,7 @@ extern "C" {
  * Signature: ()J
  */
 JNIEXPORT HYPERDEX_API jlong JNICALL Java_org_hyperdex_client_Regex_checksSize
-  (JNIEnv *, jobject);
+(JNIEnv *, jobject);
 
 /*
  * Class:     org_hyperdex_client_Regex
@@ -21,7 +21,7 @@ JNIEXPORT HYPERDEX_API jlong JNICALL Java_org_hyperdex_client_Regex_checksSize
  * Signature: (JJJ)J
  */
 JNIEXPORT HYPERDEX_API jlong JNICALL Java_org_hyperdex_client_Regex_convertChecks
-  (JNIEnv *, jobject, jlong, jlong, jlong);
+(JNIEnv *, jobject, jlong, jlong, jlong);
 
 #ifdef __cplusplus
 }
diff --git a/bindings/node.js/client.cc b/bindings/node.js/client.cc
index 37d09b325..02a47f84f 100644
--- a/bindings/node.js/client.cc
+++ b/bindings/node.js/client.cc
@@ -57,286 +57,286 @@ class Operation;
 
 class HyperDexClient : public node::ObjectWrap
 {
-    public:
-        static v8::Persistent<v8::Function> ctor;
-        static v8::Persistent<v8::Function> global_err;
-        static v8::Persistent<v8::Function> type_hint;
-        static v8::Persistent<v8::Function> predicate;
-        static void Init(v8::Handle<v8::Object> exports);
-        static v8::Handle<v8::Value> New(const v8::Arguments& args);
-
-    public:
-        HyperDexClient(const char* host, uint16_t port);
-        ~HyperDexClient() throw ();
-
-    public:
-        static v8::Handle<v8::Value> asInt(const v8::Arguments& args);
-        static v8::Handle<v8::Value> asFloat(const v8::Arguments& args);
-        static v8::Handle<v8::Value> asList(const v8::Arguments& args);
-        static v8::Handle<v8::Value> asSet(const v8::Arguments& args);
-        static v8::Handle<v8::Value> asMap(const v8::Arguments& args);
-        static v8::Handle<v8::Value> loop(const v8::Arguments& args);
-        static v8::Handle<v8::Value> loop_error(const v8::Arguments& args);
-
-        static v8::Handle<v8::Value> Equals(const v8::Arguments& args);
-        static v8::Handle<v8::Value> LessThan(const v8::Arguments& args);
-        static v8::Handle<v8::Value> LessEqual(const v8::Arguments& args);
-        static v8::Handle<v8::Value> GreaterEqual(const v8::Arguments& args);
-        static v8::Handle<v8::Value> GreaterThan(const v8::Arguments& args);
-        static v8::Handle<v8::Value> Regex(const v8::Arguments& args);
-        static v8::Handle<v8::Value> LengthEquals(const v8::Arguments& args);
-        static v8::Handle<v8::Value> LengthLessEqual(const v8::Arguments& args);
-        static v8::Handle<v8::Value> LengthGreaterEqual(const v8::Arguments& args);
-        static v8::Handle<v8::Value> Contains(const v8::Arguments& args);
+public:
+	static v8::Persistent<v8::Function> ctor;
+	static v8::Persistent<v8::Function> global_err;
+	static v8::Persistent<v8::Function> type_hint;
+	static v8::Persistent<v8::Function> predicate;
+	static void Init(v8::Handle<v8::Object> exports);
+	static v8::Handle<v8::Value> New(const v8::Arguments &args);
+
+public:
+	HyperDexClient(const char *host, uint16_t port);
+	~HyperDexClient() throw ();
+
+public:
+	static v8::Handle<v8::Value> asInt(const v8::Arguments &args);
+	static v8::Handle<v8::Value> asFloat(const v8::Arguments &args);
+	static v8::Handle<v8::Value> asList(const v8::Arguments &args);
+	static v8::Handle<v8::Value> asSet(const v8::Arguments &args);
+	static v8::Handle<v8::Value> asMap(const v8::Arguments &args);
+	static v8::Handle<v8::Value> loop(const v8::Arguments &args);
+	static v8::Handle<v8::Value> loop_error(const v8::Arguments &args);
+
+	static v8::Handle<v8::Value> Equals(const v8::Arguments &args);
+	static v8::Handle<v8::Value> LessThan(const v8::Arguments &args);
+	static v8::Handle<v8::Value> LessEqual(const v8::Arguments &args);
+	static v8::Handle<v8::Value> GreaterEqual(const v8::Arguments &args);
+	static v8::Handle<v8::Value> GreaterThan(const v8::Arguments &args);
+	static v8::Handle<v8::Value> Regex(const v8::Arguments &args);
+	static v8::Handle<v8::Value> LengthEquals(const v8::Arguments &args);
+	static v8::Handle<v8::Value> LengthLessEqual(const v8::Arguments &args);
+	static v8::Handle<v8::Value> LengthGreaterEqual(const v8::Arguments &args);
+	static v8::Handle<v8::Value> Contains(const v8::Arguments &args);
 
 #include "client.declarations.cc"
 
-    public:
-        hyperdex_client* client() { return m_cl; }
-        void add(int64_t reqid, e::intrusive_ptr<Operation> op);
-        void loop(int timeout);
-        void poll_start();
-        void poll_stop();
-
-    public:
-        static void poll_callback(uv_poll_t* watcher, int status, int revents);
-        static void poll_cleanup(uv_handle_t* handle);
-
-    private:
-        hyperdex_client* m_cl;
-        std::map<int64_t, e::intrusive_ptr<Operation> > m_ops;
-        v8::Persistent<v8::Object> m_callback;
-        uv_poll_t* m_poll;
-        bool m_poll_active;
+public:
+	hyperdex_client *client() { return m_cl; }
+	void add(int64_t reqid, e::intrusive_ptr<Operation> op);
+	void loop(int timeout);
+	void poll_start();
+	void poll_stop();
+
+public:
+	static void poll_callback(uv_poll_t *watcher, int status, int revents);
+	static void poll_cleanup(uv_handle_t *handle);
+
+private:
+	hyperdex_client *m_cl;
+	std::map<int64_t, e::intrusive_ptr<Operation> > m_ops;
+	v8::Persistent<v8::Object> m_callback;
+	uv_poll_t *m_poll;
+	bool m_poll_active;
 };
 
-typedef int (*elem_string_fptr)(void*, const char*, size_t, enum hyperdex_ds_returncode*);
-typedef int (*elem_int_fptr)(void*, int64_t, enum hyperdex_ds_returncode*);
-typedef int (*elem_float_fptr)(void*, double, enum hyperdex_ds_returncode*);
+typedef int (*elem_string_fptr)(void *, const char *, size_t, enum hyperdex_ds_returncode *);
+typedef int (*elem_int_fptr)(void *, int64_t, enum hyperdex_ds_returncode *);
+typedef int (*elem_float_fptr)(void *, double, enum hyperdex_ds_returncode *);
 
 class Operation
 {
-    public:
-        Operation(v8::Handle<v8::Object>& c1, HyperDexClient* c2);
-        ~Operation() throw ();
-
-    public:
-        typedef bool (Operation::*type_converter)(v8::Handle<v8::Value>&, const char**, size_t*, hyperdatatype*);
-
-        bool set_callback(v8::Handle<v8::Function>& func);
-        bool set_callback(v8::Handle<v8::Function>& func,
-                          v8::Handle<v8::Function>& done);
-        bool convert_error(v8::Handle<v8::Value>& _value,
-                           const char** value, size_t* value_sz,
-                           hyperdatatype* datatype);
-        bool convert_int(v8::Handle<v8::Value>& _value,
-                         const char** value, size_t* value_sz,
-                         hyperdatatype* datatype);
-        bool convert_float(v8::Handle<v8::Value>& _value,
-                           const char** value, size_t* value_sz,
-                           hyperdatatype* datatype);
-        bool convert_elem(v8::Handle<v8::Value>& value, void* x,
-                          elem_string_fptr f_string,
-                          elem_int_fptr f_int,
-                          elem_float_fptr f_float);
-        bool convert_list(v8::Handle<v8::Value>& _value,
-                          const char** value, size_t* value_sz,
-                          hyperdatatype* datatype);
-        bool convert_set(v8::Handle<v8::Value>& _value,
-                         const char** value, size_t* value_sz,
-                         hyperdatatype* datatype);
-        bool convert_map(v8::Handle<v8::Value>& _value,
-                         const char** value, size_t* value_sz,
-                         hyperdatatype* datatype);
-        bool convert_type(v8::Handle<v8::Value>& _value,
-                          const char** value, size_t* value_sz,
-                          hyperdatatype* datatype,
-                          bool make_callback_on_error,
-                          bool may_default_to_json);
-        bool convert_cstring(v8::Handle<v8::Value>& _cstring,
-                             const char** cstring);
-
-        bool convert_spacename(v8::Handle<v8::Value>& _spacename,
-                               const char** spacename);
-        bool convert_key(v8::Handle<v8::Value>& _key,
-                         const char** key, size_t* key_sz);
-        bool convert_attributes(v8::Handle<v8::Value>& _attributes,
-                                const hyperdex_client_attribute** attrs,
-                                size_t* attrs_sz);
-        bool convert_document_predicates(const std::string& s,
-                                         v8::Handle<v8::Object>& v,
-                                         std::vector<hyperdex_client_attribute_check>* checks);
-        bool convert_predicates(v8::Handle<v8::Value>& _predicates,
-                                const hyperdex_client_attribute_check** checks,
-                                size_t* checks_sz);
-        bool convert_mapattributes(v8::Handle<v8::Value>& _predicates,
-                                   const hyperdex_client_map_attribute** checks,
-                                   size_t* checks_sz);
-        bool convert_attributenames(v8::Handle<v8::Value>& _attributenames,
-                                    const char*** attributenames,
-                                    size_t* attributenames_sz);
-        bool convert_sortby(v8::Handle<v8::Value>& _sortby,
-                            const char** sortby);
-        bool convert_limit(v8::Handle<v8::Value>& _limit,
-                           uint64_t* limit);
-        bool convert_maxmin(v8::Handle<v8::Value>& _maxmin,
-                            int* maximize);
-
-        // 20 Sept 2015 - William Whitacre
-        // Patch against 1.8.1: Enable macaroon authorization.
-
-        // Convert a v8 array of strings to a character pointer array.
-        bool convert_auth_context(v8::Handle<v8::Value> &_value,
-                                  const char ***p_auth, size_t *p_auth_sz);
-
-        // Set and clear the auth context using the hyperdex_client API.
-        bool set_auth_context(v8::Handle<v8::Value> &_value);
-        bool clear_auth_context();
-
-        bool build_string(const char* value, size_t value_sz,
-                          v8::Local<v8::Value>& retval,
-                          v8::Local<v8::Value>& error);
-        bool build_int(const char* value, size_t value_sz,
-                       v8::Local<v8::Value>& retval,
-                       v8::Local<v8::Value>& error);
-        bool build_float(const char* value, size_t value_sz,
-                         v8::Local<v8::Value>& retval,
-                         v8::Local<v8::Value>& error);
-        bool build_document(const char* value, size_t value_sz,
-                            v8::Local<v8::Value>& retval,
-                            v8::Local<v8::Value>& error);
-        bool build_list_string(const char* value, size_t value_sz,
-                               v8::Local<v8::Value>& retval,
-                               v8::Local<v8::Value>& error);
-        bool build_list_int(const char* value, size_t value_sz,
-                            v8::Local<v8::Value>& retval,
-                            v8::Local<v8::Value>& error);
-        bool build_list_float(const char* value, size_t value_sz,
-                              v8::Local<v8::Value>& retval,
-                              v8::Local<v8::Value>& error);
-        bool build_set_string(const char* value, size_t value_sz,
-                              v8::Local<v8::Value>& retval,
-                              v8::Local<v8::Value>& error);
-        bool build_set_int(const char* value, size_t value_sz,
-                           v8::Local<v8::Value>& retval,
-                           v8::Local<v8::Value>& error);
-        bool build_set_float(const char* value, size_t value_sz,
-                             v8::Local<v8::Value>& retval,
-                             v8::Local<v8::Value>& error);
-        bool build_map_string_string(const char* value, size_t value_sz,
-                                     v8::Local<v8::Value>& retval,
-                                     v8::Local<v8::Value>& error);
-        bool build_map_string_int(const char* value, size_t value_sz,
-                                  v8::Local<v8::Value>& retval,
-                                  v8::Local<v8::Value>& error);
-        bool build_map_string_float(const char* value, size_t value_sz,
-                                    v8::Local<v8::Value>& retval,
-                                    v8::Local<v8::Value>& error);
-        bool build_map_int_string(const char* value, size_t value_sz,
-                                  v8::Local<v8::Value>& retval,
-                                  v8::Local<v8::Value>& error);
-        bool build_map_int_int(const char* value, size_t value_sz,
-                               v8::Local<v8::Value>& retval,
-                               v8::Local<v8::Value>& error);
-        bool build_map_int_float(const char* value, size_t value_sz,
-                                 v8::Local<v8::Value>& retval,
-                                 v8::Local<v8::Value>& error);
-        bool build_map_float_string(const char* value, size_t value_sz,
-                                    v8::Local<v8::Value>& retval,
-                                    v8::Local<v8::Value>& error);
-        bool build_map_float_int(const char* value, size_t value_sz,
-                                 v8::Local<v8::Value>& retval,
-                                 v8::Local<v8::Value>& error);
-        bool build_map_float_float(const char* value, size_t value_sz,
-                                   v8::Local<v8::Value>& retval,
-                                   v8::Local<v8::Value>& error);
-        bool build_attribute(const hyperdex_client_attribute* attr,
-                             v8::Local<v8::Value>& retval,
-                             v8::Local<v8::Value>& error);
-        void build_attributes(v8::Local<v8::Value>& retval,
-                              v8::Local<v8::Value>& error);
-
-        void encode_asynccall_status();
-        void encode_asynccall_status_attributes();
-        void encode_asynccall_status_count();
-        void encode_asynccall_status_description();
-        void encode_iterator_status_attributes();
-
-    public:
-        void make_callback(v8::Handle<v8::Value>& first,
-                           v8::Handle<v8::Value>& second);
-        void make_callback_done();
-        static v8::Local<v8::Value> error_from_status(hyperdex_client* client,
-                                                      hyperdex_client_returncode status);
-        v8::Local<v8::Value> error_from_status();
-        v8::Local<v8::Value> error_message(const char* msg);
-        v8::Local<v8::Value> error_out_of_memory();
-        void callback_error(v8::Handle<v8::Value>& err);
-        void callback_error_from_status();
-        void callback_error_message(const char* msg);
-        void callback_error_out_of_memory();
-
-    public:
-        HyperDexClient* client;
-        int64_t reqid;
-        enum hyperdex_client_returncode status;
-        const struct hyperdex_client_attribute* attrs;
-        size_t attrs_sz;
-        const char* description;
-        uint64_t count;
-        bool finished;
-        void (Operation::*encode_return)();
-        const char **m_auth;
-
-    private:
-        void inc() { ++m_ref; }
-        void dec() { if (--m_ref == 0) delete this; }
-        friend class e::intrusive_ptr<Operation>;
-
-    private:
-        size_t m_ref;
-        hyperdex_ds_arena* m_arena;
-        v8::Persistent<v8::Object> m_client;
-        v8::Persistent<v8::Object> m_callback;
-        v8::Persistent<v8::Object> m_callback_done;
-        bool m_has_callback_done;
+public:
+	Operation(v8::Handle<v8::Object> &c1, HyperDexClient *c2);
+	~Operation() throw ();
+
+public:
+	typedef bool (Operation::*type_converter)(v8::Handle<v8::Value> &, const char **, size_t *, hyperdatatype *);
+
+	bool set_callback(v8::Handle<v8::Function> &func);
+	bool set_callback(v8::Handle<v8::Function> &func,
+	                  v8::Handle<v8::Function> &done);
+	bool convert_error(v8::Handle<v8::Value> &_value,
+	                   const char **value, size_t *value_sz,
+	                   hyperdatatype *datatype);
+	bool convert_int(v8::Handle<v8::Value> &_value,
+	                 const char **value, size_t *value_sz,
+	                 hyperdatatype *datatype);
+	bool convert_float(v8::Handle<v8::Value> &_value,
+	                   const char **value, size_t *value_sz,
+	                   hyperdatatype *datatype);
+	bool convert_elem(v8::Handle<v8::Value> &value, void *x,
+	                  elem_string_fptr f_string,
+	                  elem_int_fptr f_int,
+	                  elem_float_fptr f_float);
+	bool convert_list(v8::Handle<v8::Value> &_value,
+	                  const char **value, size_t *value_sz,
+	                  hyperdatatype *datatype);
+	bool convert_set(v8::Handle<v8::Value> &_value,
+	                 const char **value, size_t *value_sz,
+	                 hyperdatatype *datatype);
+	bool convert_map(v8::Handle<v8::Value> &_value,
+	                 const char **value, size_t *value_sz,
+	                 hyperdatatype *datatype);
+	bool convert_type(v8::Handle<v8::Value> &_value,
+	                  const char **value, size_t *value_sz,
+	                  hyperdatatype *datatype,
+	                  bool make_callback_on_error,
+	                  bool may_default_to_json);
+	bool convert_cstring(v8::Handle<v8::Value> &_cstring,
+	                     const char **cstring);
+
+	bool convert_spacename(v8::Handle<v8::Value> &_spacename,
+	                       const char **spacename);
+	bool convert_key(v8::Handle<v8::Value> &_key,
+	                 const char **key, size_t *key_sz);
+	bool convert_attributes(v8::Handle<v8::Value> &_attributes,
+	                        const hyperdex_client_attribute **attrs,
+	                        size_t *attrs_sz);
+	bool convert_document_predicates(const std::string &s,
+	                                 v8::Handle<v8::Object> &v,
+	                                 std::vector<hyperdex_client_attribute_check> *checks);
+	bool convert_predicates(v8::Handle<v8::Value> &_predicates,
+	                        const hyperdex_client_attribute_check **checks,
+	                        size_t *checks_sz);
+	bool convert_mapattributes(v8::Handle<v8::Value> &_predicates,
+	                           const hyperdex_client_map_attribute **checks,
+	                           size_t *checks_sz);
+	bool convert_attributenames(v8::Handle<v8::Value> &_attributenames,
+	                            const char *** attributenames,
+	                            size_t *attributenames_sz);
+	bool convert_sortby(v8::Handle<v8::Value> &_sortby,
+	                    const char **sortby);
+	bool convert_limit(v8::Handle<v8::Value> &_limit,
+	                   uint64_t *limit);
+	bool convert_maxmin(v8::Handle<v8::Value> &_maxmin,
+	                    int *maximize);
+
+	// 20 Sept 2015 - William Whitacre
+	// Patch against 1.8.1: Enable macaroon authorization.
+
+	// Convert a v8 array of strings to a character pointer array.
+	bool convert_auth_context(v8::Handle<v8::Value> &_value,
+	                          const char ***p_auth, size_t *p_auth_sz);
+
+	// Set and clear the auth context using the hyperdex_client API.
+	bool set_auth_context(v8::Handle<v8::Value> &_value);
+	bool clear_auth_context();
+
+	bool build_string(const char *value, size_t value_sz,
+	                  v8::Local<v8::Value> &retval,
+	                  v8::Local<v8::Value> &error);
+	bool build_int(const char *value, size_t value_sz,
+	               v8::Local<v8::Value> &retval,
+	               v8::Local<v8::Value> &error);
+	bool build_float(const char *value, size_t value_sz,
+	                 v8::Local<v8::Value> &retval,
+	                 v8::Local<v8::Value> &error);
+	bool build_document(const char *value, size_t value_sz,
+	                    v8::Local<v8::Value> &retval,
+	                    v8::Local<v8::Value> &error);
+	bool build_list_string(const char *value, size_t value_sz,
+	                       v8::Local<v8::Value> &retval,
+	                       v8::Local<v8::Value> &error);
+	bool build_list_int(const char *value, size_t value_sz,
+	                    v8::Local<v8::Value> &retval,
+	                    v8::Local<v8::Value> &error);
+	bool build_list_float(const char *value, size_t value_sz,
+	                      v8::Local<v8::Value> &retval,
+	                      v8::Local<v8::Value> &error);
+	bool build_set_string(const char *value, size_t value_sz,
+	                      v8::Local<v8::Value> &retval,
+	                      v8::Local<v8::Value> &error);
+	bool build_set_int(const char *value, size_t value_sz,
+	                   v8::Local<v8::Value> &retval,
+	                   v8::Local<v8::Value> &error);
+	bool build_set_float(const char *value, size_t value_sz,
+	                     v8::Local<v8::Value> &retval,
+	                     v8::Local<v8::Value> &error);
+	bool build_map_string_string(const char *value, size_t value_sz,
+	                             v8::Local<v8::Value> &retval,
+	                             v8::Local<v8::Value> &error);
+	bool build_map_string_int(const char *value, size_t value_sz,
+	                          v8::Local<v8::Value> &retval,
+	                          v8::Local<v8::Value> &error);
+	bool build_map_string_float(const char *value, size_t value_sz,
+	                            v8::Local<v8::Value> &retval,
+	                            v8::Local<v8::Value> &error);
+	bool build_map_int_string(const char *value, size_t value_sz,
+	                          v8::Local<v8::Value> &retval,
+	                          v8::Local<v8::Value> &error);
+	bool build_map_int_int(const char *value, size_t value_sz,
+	                       v8::Local<v8::Value> &retval,
+	                       v8::Local<v8::Value> &error);
+	bool build_map_int_float(const char *value, size_t value_sz,
+	                         v8::Local<v8::Value> &retval,
+	                         v8::Local<v8::Value> &error);
+	bool build_map_float_string(const char *value, size_t value_sz,
+	                            v8::Local<v8::Value> &retval,
+	                            v8::Local<v8::Value> &error);
+	bool build_map_float_int(const char *value, size_t value_sz,
+	                         v8::Local<v8::Value> &retval,
+	                         v8::Local<v8::Value> &error);
+	bool build_map_float_float(const char *value, size_t value_sz,
+	                           v8::Local<v8::Value> &retval,
+	                           v8::Local<v8::Value> &error);
+	bool build_attribute(const hyperdex_client_attribute *attr,
+	                     v8::Local<v8::Value> &retval,
+	                     v8::Local<v8::Value> &error);
+	void build_attributes(v8::Local<v8::Value> &retval,
+	                      v8::Local<v8::Value> &error);
+
+	void encode_asynccall_status();
+	void encode_asynccall_status_attributes();
+	void encode_asynccall_status_count();
+	void encode_asynccall_status_description();
+	void encode_iterator_status_attributes();
+
+public:
+	void make_callback(v8::Handle<v8::Value> &first,
+	                   v8::Handle<v8::Value> &second);
+	void make_callback_done();
+	static v8::Local<v8::Value> error_from_status(hyperdex_client *client,
+	                                              hyperdex_client_returncode status);
+	v8::Local<v8::Value> error_from_status();
+	v8::Local<v8::Value> error_message(const char *msg);
+	v8::Local<v8::Value> error_out_of_memory();
+	void callback_error(v8::Handle<v8::Value> &err);
+	void callback_error_from_status();
+	void callback_error_message(const char *msg);
+	void callback_error_out_of_memory();
+
+public:
+	HyperDexClient *client;
+	int64_t reqid;
+	enum hyperdex_client_returncode status;
+	const struct hyperdex_client_attribute *attrs;
+	size_t attrs_sz;
+	const char *description;
+	uint64_t count;
+	bool finished;
+	void (Operation::*encode_return)();
+	const char **m_auth;
+
+private:
+	void inc() { ++m_ref; }
+	void dec() { if (--m_ref == 0) delete this; }
+	friend class e::intrusive_ptr<Operation>;
+
+private:
+	size_t m_ref;
+	hyperdex_ds_arena *m_arena;
+	v8::Persistent<v8::Object> m_client;
+	v8::Persistent<v8::Object> m_callback;
+	v8::Persistent<v8::Object> m_callback_done;
+	bool m_has_callback_done;
 };
 
 class TypeHint : public node::ObjectWrap
 {
-    public:
-        static v8::Handle<v8::Value> New(const v8::Arguments& args);
+public:
+	static v8::Handle<v8::Value> New(const v8::Arguments &args);
 
-    public:
-        TypeHint(hyperdatatype t, v8::Local<v8::Value>& o);
-        ~TypeHint() throw ();
+public:
+	TypeHint(hyperdatatype t, v8::Local<v8::Value> &o);
+	~TypeHint() throw ();
 
-    public:
-        Operation::type_converter get_converter();
-        v8::Handle<v8::Value> value();
-        hyperdatatype get_type();
+public:
+	Operation::type_converter get_converter();
+	v8::Handle<v8::Value> value();
+	hyperdatatype get_type();
 
-    private:
-        hyperdatatype m_type;
-        v8::Persistent<v8::Value> m_obj;
+private:
+	hyperdatatype m_type;
+	v8::Persistent<v8::Value> m_obj;
 };
 
 class Predicate : public node::ObjectWrap
 {
-    public:
-        static v8::Handle<v8::Value> New(const v8::Arguments& args);
+public:
+	static v8::Handle<v8::Value> New(const v8::Arguments &args);
 
-    public:
-        Predicate(hyperpredicate p, v8::Local<v8::Value>& v);
-        ~Predicate() throw ();
+public:
+	Predicate(hyperpredicate p, v8::Local<v8::Value> &v);
+	~Predicate() throw ();
 
-    public:
-        v8::Handle<v8::Value> value();
-        hyperpredicate get_pred();
+public:
+	v8::Handle<v8::Value> value();
+	hyperpredicate get_pred();
 
-    private:
-        hyperpredicate m_pred;
-        v8::Persistent<v8::Value> m_obj;
+private:
+	hyperpredicate m_pred;
+	v8::Persistent<v8::Value> m_obj;
 };
 
 v8::Persistent<v8::Function> HyperDexClient::ctor;
@@ -347,337 +347,300 @@ v8::Persistent<v8::Function> HyperDexClient::predicate;
 void
 HyperDexClient :: Init(v8::Handle<v8::Object> target)
 {
-    v8::Local<v8::FunctionTemplate> tpl
-        = v8::FunctionTemplate::New(HyperDexClient::New);
-    tpl->SetClassName(v8::String::NewSymbol("Client"));
-    tpl->InstanceTemplate()->SetInternalFieldCount(1);
-
-    NODE_SET_PROTOTYPE_METHOD(tpl, "asInt", HyperDexClient::asInt);
-    NODE_SET_PROTOTYPE_METHOD(tpl, "asInt", HyperDexClient::asInt);
-    NODE_SET_PROTOTYPE_METHOD(tpl, "asFloat", HyperDexClient::asFloat);
-    NODE_SET_PROTOTYPE_METHOD(tpl, "asList", HyperDexClient::asList);
-    NODE_SET_PROTOTYPE_METHOD(tpl, "asSet", HyperDexClient::asSet);
-    NODE_SET_PROTOTYPE_METHOD(tpl, "asMap", HyperDexClient::asMap);
-
-    NODE_SET_PROTOTYPE_METHOD(tpl, "Equals", HyperDexClient::Equals);
-    NODE_SET_PROTOTYPE_METHOD(tpl, "LessThan", HyperDexClient::LessThan);
-    NODE_SET_PROTOTYPE_METHOD(tpl, "LessEqual", HyperDexClient::LessEqual);
-    NODE_SET_PROTOTYPE_METHOD(tpl, "GreaterEqual", HyperDexClient::GreaterEqual);
-    NODE_SET_PROTOTYPE_METHOD(tpl, "GreaterThan", HyperDexClient::GreaterThan);
-    NODE_SET_PROTOTYPE_METHOD(tpl, "Regex", HyperDexClient::Regex);
-    NODE_SET_PROTOTYPE_METHOD(tpl, "LengthEquals", HyperDexClient::LengthEquals);
-    NODE_SET_PROTOTYPE_METHOD(tpl, "LengthLessEqual", HyperDexClient::LengthLessEqual);
-    NODE_SET_PROTOTYPE_METHOD(tpl, "LengthGreaterEqual", HyperDexClient::LengthGreaterEqual);
-    NODE_SET_PROTOTYPE_METHOD(tpl, "Contains", HyperDexClient::Contains);
-
-    NODE_SET_PROTOTYPE_METHOD(tpl, "loop", HyperDexClient::loop);
+	v8::Local<v8::FunctionTemplate> tpl
+	    = v8::FunctionTemplate::New(HyperDexClient::New);
+	tpl->SetClassName(v8::String::NewSymbol("Client"));
+	tpl->InstanceTemplate()->SetInternalFieldCount(1);
+	NODE_SET_PROTOTYPE_METHOD(tpl, "asInt", HyperDexClient::asInt);
+	NODE_SET_PROTOTYPE_METHOD(tpl, "asInt", HyperDexClient::asInt);
+	NODE_SET_PROTOTYPE_METHOD(tpl, "asFloat", HyperDexClient::asFloat);
+	NODE_SET_PROTOTYPE_METHOD(tpl, "asList", HyperDexClient::asList);
+	NODE_SET_PROTOTYPE_METHOD(tpl, "asSet", HyperDexClient::asSet);
+	NODE_SET_PROTOTYPE_METHOD(tpl, "asMap", HyperDexClient::asMap);
+	NODE_SET_PROTOTYPE_METHOD(tpl, "Equals", HyperDexClient::Equals);
+	NODE_SET_PROTOTYPE_METHOD(tpl, "LessThan", HyperDexClient::LessThan);
+	NODE_SET_PROTOTYPE_METHOD(tpl, "LessEqual", HyperDexClient::LessEqual);
+	NODE_SET_PROTOTYPE_METHOD(tpl, "GreaterEqual", HyperDexClient::GreaterEqual);
+	NODE_SET_PROTOTYPE_METHOD(tpl, "GreaterThan", HyperDexClient::GreaterThan);
+	NODE_SET_PROTOTYPE_METHOD(tpl, "Regex", HyperDexClient::Regex);
+	NODE_SET_PROTOTYPE_METHOD(tpl, "LengthEquals", HyperDexClient::LengthEquals);
+	NODE_SET_PROTOTYPE_METHOD(tpl, "LengthLessEqual", HyperDexClient::LengthLessEqual);
+	NODE_SET_PROTOTYPE_METHOD(tpl, "LengthGreaterEqual", HyperDexClient::LengthGreaterEqual);
+	NODE_SET_PROTOTYPE_METHOD(tpl, "Contains", HyperDexClient::Contains);
+	NODE_SET_PROTOTYPE_METHOD(tpl, "loop", HyperDexClient::loop);
 #include "client.prototypes.cc"
-
-    ctor = v8::Persistent<v8::Function>::New(tpl->GetFunction());
-    target->Set(v8::String::NewSymbol("Client"), ctor);
-
-    v8::Local<v8::FunctionTemplate> tpl_err
-        = v8::FunctionTemplate::New(HyperDexClient::loop_error);
-    global_err = v8::Persistent<v8::Function>::New(tpl_err->GetFunction());
-
-    v8::Local<v8::FunctionTemplate> tpl_type
-        = v8::FunctionTemplate::New(TypeHint::New);
-    tpl_type->SetClassName(v8::String::NewSymbol("TypeHint"));
-    tpl_type->InstanceTemplate()->SetInternalFieldCount(1);
-    type_hint = v8::Persistent<v8::Function>::New(tpl_type->GetFunction());
-
-    v8::Local<v8::FunctionTemplate> tpl_pred
-        = v8::FunctionTemplate::New(Predicate::New);
-    tpl_pred->SetClassName(v8::String::NewSymbol("Predicate"));
-    tpl_pred->InstanceTemplate()->SetInternalFieldCount(2);
-    predicate = v8::Persistent<v8::Function>::New(tpl_pred->GetFunction());
+	ctor = v8::Persistent<v8::Function>::New(tpl->GetFunction());
+	target->Set(v8::String::NewSymbol("Client"), ctor);
+	v8::Local<v8::FunctionTemplate> tpl_err
+	    = v8::FunctionTemplate::New(HyperDexClient::loop_error);
+	global_err = v8::Persistent<v8::Function>::New(tpl_err->GetFunction());
+	v8::Local<v8::FunctionTemplate> tpl_type
+	    = v8::FunctionTemplate::New(TypeHint::New);
+	tpl_type->SetClassName(v8::String::NewSymbol("TypeHint"));
+	tpl_type->InstanceTemplate()->SetInternalFieldCount(1);
+	type_hint = v8::Persistent<v8::Function>::New(tpl_type->GetFunction());
+	v8::Local<v8::FunctionTemplate> tpl_pred
+	    = v8::FunctionTemplate::New(Predicate::New);
+	tpl_pred->SetClassName(v8::String::NewSymbol("Predicate"));
+	tpl_pred->InstanceTemplate()->SetInternalFieldCount(2);
+	predicate = v8::Persistent<v8::Function>::New(tpl_pred->GetFunction());
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: New(const v8::Arguments& args)
-{
-    v8::HandleScope scope;
-
-    if (!args.IsConstructCall())
-    {
-        return v8::ThrowException(v8::String::New("client must be constructed with \"new\""));
-    }
-
-    if (args.Length() != 2)
-    {
-        return v8::ThrowException(v8::String::New("constructor requires (host, port) arguments"));
-    }
-
-    if (args[0].IsEmpty() || !args[0]->IsString())
-    {
-        return v8::ThrowException(v8::String::New("constructor requires that the \"host\" argument be a string"));
-    }
-
-    if (args[1].IsEmpty() || !args[1]->IsNumber())
-    {
-        return v8::ThrowException(v8::String::New("constructor requires that the \"port\" argument be a number"));
-    }
-
-    v8::Local<v8::String> _host = args[0].As<v8::String>();
-    v8::Local<v8::Integer> _port = args[1].As<v8::Integer>();
-    v8::String::AsciiValue s(_host);
-
-    const char* host = *s;
-    uint16_t port = _port->Value();
-
-    HyperDexClient* c = new HyperDexClient(host, port);
-    c->Wrap(args.This());
-    return scope.Close(args.This());
-}
-
-HyperDexClient :: HyperDexClient(const char* host, uint16_t port)
-    : m_cl(hyperdex_client_create(host, port))
-    , m_poll(NULL)
-    , m_poll_active(false)
-{
-    if (m_cl)
-    {
-        m_poll = new uv_poll_t;
-        uv_poll_init_socket(uv_default_loop(), m_poll, hyperdex_client_poll_fd(m_cl));
-        m_poll->data = this;
-    }
-
-    v8::Local<v8::Function> func(v8::Local<v8::Function>::New(global_err));
-    v8::Local<v8::Object> cbobj = v8::Object::New();
-    cbobj->Set(v8::String::NewSymbol("callback"), func);
-    m_callback = v8::Persistent<v8::Object>::New(cbobj);
+HyperDexClient :: New(const v8::Arguments &args)
+{
+	v8::HandleScope scope;
+	if (!args.IsConstructCall())
+	{
+		return v8::ThrowException(v8::String::New("client must be constructed with \"new\""));
+	}
+	if (args.Length() != 2)
+	{
+		return v8::ThrowException(v8::String::New("constructor requires (host, port) arguments"));
+	}
+	if (args[0].IsEmpty() || !args[0]->IsString())
+	{
+		return v8::ThrowException(v8::String::New("constructor requires that the \"host\" argument be a string"));
+	}
+	if (args[1].IsEmpty() || !args[1]->IsNumber())
+	{
+		return v8::ThrowException(v8::String::New("constructor requires that the \"port\" argument be a number"));
+	}
+	v8::Local<v8::String> _host = args[0].As<v8::String>();
+	v8::Local<v8::Integer> _port = args[1].As<v8::Integer>();
+	v8::String::AsciiValue s(_host);
+	const char *host = *s;
+	uint16_t port = _port->Value();
+	HyperDexClient *c = new HyperDexClient(host, port);
+	c->Wrap(args.This());
+	return scope.Close(args.This());
+}
+
+HyperDexClient :: HyperDexClient(const char *host, uint16_t port)
+	: m_cl(hyperdex_client_create(host, port))
+	, m_poll(NULL)
+	, m_poll_active(false)
+{
+	if (m_cl)
+	{
+		m_poll = new uv_poll_t;
+		uv_poll_init_socket(uv_default_loop(), m_poll, hyperdex_client_poll_fd(m_cl));
+		m_poll->data = this;
+	}
+	v8::Local<v8::Function> func(v8::Local<v8::Function>::New(global_err));
+	v8::Local<v8::Object> cbobj = v8::Object::New();
+	cbobj->Set(v8::String::NewSymbol("callback"), func);
+	m_callback = v8::Persistent<v8::Object>::New(cbobj);
 }
 
 HyperDexClient :: ~HyperDexClient() throw ()
 {
-    if (m_cl)
-    {
-        hyperdex_client_destroy(m_cl);
-    }
-
-    if (m_poll)
-    {
-        m_poll->data = NULL;
-        poll_stop();
-        uv_close(reinterpret_cast<uv_handle_t*>(m_poll), poll_cleanup);
-    }
-
-    if (!m_callback.IsEmpty())
-    {
-        m_callback.Dispose();
-        m_callback.Clear();
-    }
+	if (m_cl)
+	{
+		hyperdex_client_destroy(m_cl);
+	}
+	if (m_poll)
+	{
+		m_poll->data = NULL;
+		poll_stop();
+		uv_close(reinterpret_cast<uv_handle_t *>(m_poll), poll_cleanup);
+	}
+	if (!m_callback.IsEmpty())
+	{
+		m_callback.Dispose();
+		m_callback.Clear();
+	}
 }
 
 void
 HyperDexClient :: add(int64_t reqid, e::intrusive_ptr<Operation> op)
 {
-    m_ops[reqid] = op;
-    poll_start();
+	m_ops[reqid] = op;
+	poll_start();
 }
 
 void
 HyperDexClient :: loop(int timeout)
 {
-    enum hyperdex_client_returncode rc;
-    int64_t ret = hyperdex_client_loop(m_cl, timeout, &rc);
-
-    if (ret < 0 && timeout == 0 && rc == HYPERDEX_CLIENT_TIMEOUT)
-    {
-        return;
-    }
-
-    if (ret < 0)
-    {
-        v8::Local<v8::Object> obj = v8::Local<v8::Object>::New(m_callback);
-        v8::Local<v8::Function> callback
-            = obj->Get(v8::String::NewSymbol("callback")).As<v8::Function>();
-        v8::Local<v8::Value> err = Operation::error_from_status(m_cl, rc);
-        v8::Handle<v8::Value> argv[] = { err };
-        node::MakeCallback(v8::Context::GetCurrent()->Global(), callback, 1, argv);
-        return;
-    }
-
-    std::map<int64_t, e::intrusive_ptr<Operation> >::iterator it;
-    it = m_ops.find(ret);
-    assert(it != m_ops.end());
-    (*it->second.*it->second->encode_return)();
-
-    if (it->second->finished)
-    {
-        m_ops.erase(it);
-    }
-
-    if (m_ops.empty())
-    {
-        poll_stop();
-    }
+	enum hyperdex_client_returncode rc;
+	int64_t ret = hyperdex_client_loop(m_cl, timeout, &rc);
+	if (ret < 0 && timeout == 0 && rc == HYPERDEX_CLIENT_TIMEOUT)
+	{
+		return;
+	}
+	if (ret < 0)
+	{
+		v8::Local<v8::Object> obj = v8::Local<v8::Object>::New(m_callback);
+		v8::Local<v8::Function> callback
+		    = obj->Get(v8::String::NewSymbol("callback")).As<v8::Function>();
+		v8::Local<v8::Value> err = Operation::error_from_status(m_cl, rc);
+		v8::Handle<v8::Value> argv[] = { err };
+		node::MakeCallback(v8::Context::GetCurrent()->Global(), callback, 1, argv);
+		return;
+	}
+	std::map<int64_t, e::intrusive_ptr<Operation> >::iterator it;
+	it = m_ops.find(ret);
+	assert(it != m_ops.end());
+	(*it->second.*it->second->encode_return)();
+	if (it->second->finished)
+	{
+		m_ops.erase(it);
+	}
+	if (m_ops.empty())
+	{
+		poll_stop();
+	}
 }
 
 void
 HyperDexClient :: poll_start()
 {
-    if (m_poll_active || !m_poll)
-    {
-        return;
-    }
-
-    m_poll_active = true;
-    uv_poll_start(m_poll, UV_READABLE, poll_callback);
+	if (m_poll_active || !m_poll)
+	{
+		return;
+	}
+	m_poll_active = true;
+	uv_poll_start(m_poll, UV_READABLE, poll_callback);
 }
 
 void
 HyperDexClient :: poll_stop()
 {
-    if (!m_poll_active || !m_poll)
-    {
-        return;
-    }
-
-    uv_poll_stop(m_poll);
-    m_poll_active = false;
+	if (!m_poll_active || !m_poll)
+	{
+		return;
+	}
+	uv_poll_stop(m_poll);
+	m_poll_active = false;
 }
 
 void
-HyperDexClient :: poll_callback(uv_poll_t* watcher, int status, int revents)
+HyperDexClient :: poll_callback(uv_poll_t *watcher, int status, int revents)
 {
-    HyperDexClient* cl = reinterpret_cast<HyperDexClient*>(watcher->data);
-
-    if (cl)
-    {
-        cl->loop(0);
-    }
+	HyperDexClient *cl = reinterpret_cast<HyperDexClient *>(watcher->data);
+	if (cl)
+	{
+		cl->loop(0);
+	}
 }
 
 void
-HyperDexClient :: poll_cleanup(uv_handle_t* handle)
+HyperDexClient :: poll_cleanup(uv_handle_t *handle)
 {
-    uv_poll_t* poll = reinterpret_cast<uv_poll_t*>(handle);
-
-    if (handle)
-    {
-        delete poll;
-    }
+	uv_poll_t *poll = reinterpret_cast<uv_poll_t *>(handle);
+	if (handle)
+	{
+		delete poll;
+	}
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: loop(const v8::Arguments& args)
+HyperDexClient :: loop(const v8::Arguments &args)
 {
-    v8::HandleScope scope;
-    int timeout = -1;
-
-    if (args.Length() > 0 && args[0]->IsNumber())
-    {
-        timeout = args[0]->IntegerValue();
-    }
-
-    HyperDexClient* client = node::ObjectWrap::Unwrap<HyperDexClient>(args.This());
-    client->loop(timeout);
-    return scope.Close(v8::Undefined());
+	v8::HandleScope scope;
+	int timeout = -1;
+	if (args.Length() > 0 && args[0]->IsNumber())
+	{
+		timeout = args[0]->IntegerValue();
+	}
+	HyperDexClient *client = node::ObjectWrap::Unwrap<HyperDexClient>(args.This());
+	client->loop(timeout);
+	return scope.Close(v8::Undefined());
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: loop_error(const v8::Arguments& args)
+HyperDexClient :: loop_error(const v8::Arguments &args)
 {
-    v8::HandleScope scope;
-
-    if (args.Length() > 0)
-    {
-        v8::ThrowException(args[0]);
-    }
-
-    return scope.Close(v8::Undefined());
+	v8::HandleScope scope;
+	if (args.Length() > 0)
+	{
+		v8::ThrowException(args[0]);
+	}
+	return scope.Close(v8::Undefined());
 }
 
 v8::Handle<v8::Value>
-TypeHint :: New(const v8::Arguments& args)
-{
-    v8::HandleScope scope;
-
-    if (!args.IsConstructCall())
-    {
-        return v8::ThrowException(v8::String::New("client must be constructed with \"new\""));
-    }
-
-    if (args.Length() != 2)
-    {
-        return v8::ThrowException(v8::String::New("type hint requires (type, obj) arguments"));
-    }
-
-    if (args[0].IsEmpty() || !args[0]->IsString())
-    {
-        return v8::ThrowException(v8::String::New("type hint requires that the \"type\" argument be a string"));
-    }
-
-    if (args[1].IsEmpty())
-    {
-        return v8::ThrowException(v8::String::New("type hint requires something to cast"));
-    }
-
-    v8::Local<v8::String> _type = args[0].As<v8::String>();
-    v8::String::AsciiValue s(_type);
-    hyperdatatype t = HYPERDATATYPE_GARBAGE;
-
-    if (strcmp("int", *s) == 0 ||
-        strcmp("int64", *s) == 0)
-    {
-        t = HYPERDATATYPE_INT64;
-    }
-    else if (strcmp("float", *s) == 0)
-    {
-        t = HYPERDATATYPE_FLOAT;
-    }
-    else if (strcmp("list", *s) == 0)
-    {
-        t = HYPERDATATYPE_LIST_GENERIC;
-    }
-    else if (strcmp("set", *s) == 0)
-    {
-        t = HYPERDATATYPE_SET_GENERIC;
-    }
-    else if (strcmp("map", *s) == 0)
-    {
-        t = HYPERDATATYPE_MAP_GENERIC;
-    }
-    else
-    {
-        return v8::ThrowException(v8::String::New("cannot cast unknown type"));
-    }
-
-    v8::Local<v8::Value> obj = v8::Local<v8::Value>::New(args[1]);
-    TypeHint* th = new TypeHint(t, obj);
-    th->Wrap(args.This());
-    return scope.Close(args.This());
-}
-
-TypeHint :: TypeHint(hyperdatatype t, v8::Local<v8::Value>& o)
-    : m_type(t)
-    , m_obj()
-{
-    if (!o.IsEmpty())
-    {
-        m_obj = v8::Persistent<v8::Value>::New(o);
-    }
+TypeHint :: New(const v8::Arguments &args)
+{
+	v8::HandleScope scope;
+	if (!args.IsConstructCall())
+	{
+		return v8::ThrowException(v8::String::New("client must be constructed with \"new\""));
+	}
+	if (args.Length() != 2)
+	{
+		return v8::ThrowException(v8::String::New("type hint requires (type, obj) arguments"));
+	}
+	if (args[0].IsEmpty() || !args[0]->IsString())
+	{
+		return v8::ThrowException(v8::String::New("type hint requires that the \"type\" argument be a string"));
+	}
+	if (args[1].IsEmpty())
+	{
+		return v8::ThrowException(v8::String::New("type hint requires something to cast"));
+	}
+	v8::Local<v8::String> _type = args[0].As<v8::String>();
+	v8::String::AsciiValue s(_type);
+	hyperdatatype t = HYPERDATATYPE_GARBAGE;
+	if (strcmp("int", *s) == 0 ||
+	    strcmp("int64", *s) == 0)
+	{
+		t = HYPERDATATYPE_INT64;
+	}
+	else if (strcmp("float", *s) == 0)
+	{
+		t = HYPERDATATYPE_FLOAT;
+	}
+	else if (strcmp("list", *s) == 0)
+	{
+		t = HYPERDATATYPE_LIST_GENERIC;
+	}
+	else if (strcmp("set", *s) == 0)
+	{
+		t = HYPERDATATYPE_SET_GENERIC;
+	}
+	else if (strcmp("map", *s) == 0)
+	{
+		t = HYPERDATATYPE_MAP_GENERIC;
+	}
+	else
+	{
+		return v8::ThrowException(v8::String::New("cannot cast unknown type"));
+	}
+	v8::Local<v8::Value> obj = v8::Local<v8::Value>::New(args[1]);
+	TypeHint *th = new TypeHint(t, obj);
+	th->Wrap(args.This());
+	return scope.Close(args.This());
+}
+
+TypeHint :: TypeHint(hyperdatatype t, v8::Local<v8::Value> &o)
+	: m_type(t)
+	, m_obj()
+{
+	if (!o.IsEmpty())
+	{
+		m_obj = v8::Persistent<v8::Value>::New(o);
+	}
 }
 
 TypeHint :: ~TypeHint() throw ()
 {
-    if (!m_obj.IsEmpty())
-    {
-        m_obj.Dispose();
-        m_obj.Clear();
-    }
+	if (!m_obj.IsEmpty())
+	{
+		m_obj.Dispose();
+		m_obj.Clear();
+	}
 }
 
 #define HYPERDEX_TYPE_CAST(X, Y) \
-    v8::Handle<v8::Value> \
-    HyperDexClient :: X(const v8::Arguments& args) \
-    { \
-        v8::Local<v8::Function> th = v8::Local<v8::Function>::New(type_hint); \
-        v8::Local<v8::Value> t(v8::String::New(Y)); \
-        v8::Handle<v8::Value> argv[] = {t, args[0]}; \
-        return th->NewInstance(2, argv); \
-    }
+	v8::Handle<v8::Value> \
+	HyperDexClient :: X(const v8::Arguments& args) \
+	{ \
+		v8::Local<v8::Function> th = v8::Local<v8::Function>::New(type_hint); \
+		v8::Local<v8::Value> t(v8::String::New(Y)); \
+		v8::Handle<v8::Value> argv[] = {t, args[0]}; \
+		return th->NewInstance(2, argv); \
+	}
 
 HYPERDEX_TYPE_CAST(asInt, "int");
 HYPERDEX_TYPE_CAST(asFloat, "float");
@@ -688,138 +651,131 @@ HYPERDEX_TYPE_CAST(asMap, "map");
 Operation::type_converter
 TypeHint :: get_converter()
 {
-    switch (m_type)
-    {
-        case HYPERDATATYPE_INT64:
-            return &Operation::convert_int;
-        case HYPERDATATYPE_FLOAT:
-            return &Operation::convert_float;
-        case HYPERDATATYPE_LIST_GENERIC:
-            return &Operation::convert_list;
-        case HYPERDATATYPE_SET_GENERIC:
-            return &Operation::convert_set;
-        case HYPERDATATYPE_MAP_GENERIC:
-            return &Operation::convert_map;
-        case HYPERDATATYPE_GENERIC:
-        case HYPERDATATYPE_STRING:
-        case HYPERDATATYPE_LIST_STRING:
-        case HYPERDATATYPE_LIST_INT64:
-        case HYPERDATATYPE_LIST_FLOAT:
-        case HYPERDATATYPE_SET_STRING:
-        case HYPERDATATYPE_SET_INT64:
-        case HYPERDATATYPE_SET_FLOAT:
-        case HYPERDATATYPE_MAP_STRING_KEYONLY:
-        case HYPERDATATYPE_MAP_STRING_STRING:
-        case HYPERDATATYPE_MAP_STRING_INT64:
-        case HYPERDATATYPE_MAP_STRING_FLOAT:
-        case HYPERDATATYPE_MAP_INT64_KEYONLY:
-        case HYPERDATATYPE_MAP_INT64_STRING:
-        case HYPERDATATYPE_MAP_INT64_INT64:
-        case HYPERDATATYPE_MAP_INT64_FLOAT:
-        case HYPERDATATYPE_MAP_FLOAT_KEYONLY:
-        case HYPERDATATYPE_MAP_FLOAT_STRING:
-        case HYPERDATATYPE_MAP_FLOAT_INT64:
-        case HYPERDATATYPE_MAP_FLOAT_FLOAT:
-        case HYPERDATATYPE_GARBAGE:
-        default:
-            return &Operation::convert_error;
-    }
+	switch (m_type)
+	{
+	case HYPERDATATYPE_INT64:
+		return &Operation::convert_int;
+	case HYPERDATATYPE_FLOAT:
+		return &Operation::convert_float;
+	case HYPERDATATYPE_LIST_GENERIC:
+		return &Operation::convert_list;
+	case HYPERDATATYPE_SET_GENERIC:
+		return &Operation::convert_set;
+	case HYPERDATATYPE_MAP_GENERIC:
+		return &Operation::convert_map;
+	case HYPERDATATYPE_GENERIC:
+	case HYPERDATATYPE_STRING:
+	case HYPERDATATYPE_LIST_STRING:
+	case HYPERDATATYPE_LIST_INT64:
+	case HYPERDATATYPE_LIST_FLOAT:
+	case HYPERDATATYPE_SET_STRING:
+	case HYPERDATATYPE_SET_INT64:
+	case HYPERDATATYPE_SET_FLOAT:
+	case HYPERDATATYPE_MAP_STRING_KEYONLY:
+	case HYPERDATATYPE_MAP_STRING_STRING:
+	case HYPERDATATYPE_MAP_STRING_INT64:
+	case HYPERDATATYPE_MAP_STRING_FLOAT:
+	case HYPERDATATYPE_MAP_INT64_KEYONLY:
+	case HYPERDATATYPE_MAP_INT64_STRING:
+	case HYPERDATATYPE_MAP_INT64_INT64:
+	case HYPERDATATYPE_MAP_INT64_FLOAT:
+	case HYPERDATATYPE_MAP_FLOAT_KEYONLY:
+	case HYPERDATATYPE_MAP_FLOAT_STRING:
+	case HYPERDATATYPE_MAP_FLOAT_INT64:
+	case HYPERDATATYPE_MAP_FLOAT_FLOAT:
+	case HYPERDATATYPE_GARBAGE:
+	default:
+		return &Operation::convert_error;
+	}
 }
 
 v8::Handle<v8::Value>
 TypeHint :: value()
 {
-    v8::HandleScope scope;
-    return scope.Close(v8::Local<v8::Value>::New(m_obj));
+	v8::HandleScope scope;
+	return scope.Close(v8::Local<v8::Value>::New(m_obj));
 }
 
 hyperdatatype
 TypeHint :: get_type()
 {
-    return m_type;
+	return m_type;
 }
 
 v8::Handle<v8::Value>
-Predicate :: New(const v8::Arguments& args)
-{
-    v8::HandleScope scope;
-
-    if (!args.IsConstructCall())
-    {
-        return v8::ThrowException(v8::String::New("client must be constructed with \"new\""));
-    }
-
-    if (args.Length() != 2)
-    {
-        return v8::ThrowException(v8::String::New("predicate requires (predicate, obj) arguments"));
-    }
-
-    if (args[0].IsEmpty() || !args[0]->IsNumber())
-    {
-        return v8::ThrowException(v8::String::New("predicate requires that the \"predicate\" argument be a number"));
-    }
-
-    if (args[1].IsEmpty())
-    {
-        return v8::ThrowException(v8::String::New("predicate requires something to cast"));
-    }
-
-    int _p = args[0].As<v8::Number>()->Value();
-    hyperpredicate p = static_cast<hyperpredicate>(_p);
-
-    switch (p)
-    {
-        case HYPERPREDICATE_FAIL:
-        case HYPERPREDICATE_EQUALS:
-        case HYPERPREDICATE_LESS_THAN:
-        case HYPERPREDICATE_LESS_EQUAL:
-        case HYPERPREDICATE_GREATER_EQUAL:
-        case HYPERPREDICATE_GREATER_THAN:
-        case HYPERPREDICATE_CONTAINS_LESS_THAN:
-        case HYPERPREDICATE_REGEX:
-        case HYPERPREDICATE_LENGTH_EQUALS:
-        case HYPERPREDICATE_LENGTH_LESS_EQUAL:
-        case HYPERPREDICATE_LENGTH_GREATER_EQUAL:
-        case HYPERPREDICATE_CONTAINS:
-            break;
-        default:
-            abort();
-    }
-
-    v8::Local<v8::Value> obj = v8::Local<v8::Value>::New(args[1]);
-    Predicate* pred = new Predicate(p, obj);
-    pred->Wrap(args.This());
-    return scope.Close(args.This());
-}
-
-Predicate :: Predicate(hyperpredicate p, v8::Local<v8::Value>& o)
-    : m_pred(p)
-    , m_obj()
-{
-    if (!o.IsEmpty())
-    {
-        m_obj = v8::Persistent<v8::Value>::New(o);
-    }
+Predicate :: New(const v8::Arguments &args)
+{
+	v8::HandleScope scope;
+	if (!args.IsConstructCall())
+	{
+		return v8::ThrowException(v8::String::New("client must be constructed with \"new\""));
+	}
+	if (args.Length() != 2)
+	{
+		return v8::ThrowException(v8::String::New("predicate requires (predicate, obj) arguments"));
+	}
+	if (args[0].IsEmpty() || !args[0]->IsNumber())
+	{
+		return v8::ThrowException(v8::String::New("predicate requires that the \"predicate\" argument be a number"));
+	}
+	if (args[1].IsEmpty())
+	{
+		return v8::ThrowException(v8::String::New("predicate requires something to cast"));
+	}
+	int _p = args[0].As<v8::Number>()->Value();
+	hyperpredicate p = static_cast<hyperpredicate>(_p);
+	switch (p)
+	{
+	case HYPERPREDICATE_FAIL:
+	case HYPERPREDICATE_EQUALS:
+	case HYPERPREDICATE_LESS_THAN:
+	case HYPERPREDICATE_LESS_EQUAL:
+	case HYPERPREDICATE_GREATER_EQUAL:
+	case HYPERPREDICATE_GREATER_THAN:
+	case HYPERPREDICATE_CONTAINS_LESS_THAN:
+	case HYPERPREDICATE_REGEX:
+	case HYPERPREDICATE_LENGTH_EQUALS:
+	case HYPERPREDICATE_LENGTH_LESS_EQUAL:
+	case HYPERPREDICATE_LENGTH_GREATER_EQUAL:
+	case HYPERPREDICATE_CONTAINS:
+		break;
+	default:
+		abort();
+	}
+	v8::Local<v8::Value> obj = v8::Local<v8::Value>::New(args[1]);
+	Predicate *pred = new Predicate(p, obj);
+	pred->Wrap(args.This());
+	return scope.Close(args.This());
+}
+
+Predicate :: Predicate(hyperpredicate p, v8::Local<v8::Value> &o)
+	: m_pred(p)
+	, m_obj()
+{
+	if (!o.IsEmpty())
+	{
+		m_obj = v8::Persistent<v8::Value>::New(o);
+	}
 }
 
 Predicate :: ~Predicate() throw ()
 {
-    if (!m_obj.IsEmpty())
-    {
-        m_obj.Dispose();
-        m_obj.Clear();
-    }
+	if (!m_obj.IsEmpty())
+	{
+		m_obj.Dispose();
+		m_obj.Clear();
+	}
 }
 
 #define HYPERDEX_PRED_CAST(X, Y) \
-    v8::Handle<v8::Value> \
-    HyperDexClient :: X(const v8::Arguments& args) \
-    { \
-        v8::Local<v8::Function> pred = v8::Local<v8::Function>::New(predicate); \
-        v8::Local<v8::Value> p(v8::Integer::New(Y)); \
-        v8::Handle<v8::Value> argv[] = {p, args[0]}; \
-        return pred->NewInstance(2, argv); \
-    }
+	v8::Handle<v8::Value> \
+	HyperDexClient :: X(const v8::Arguments& args) \
+	{ \
+		v8::Local<v8::Function> pred = v8::Local<v8::Function>::New(predicate); \
+		v8::Local<v8::Value> p(v8::Integer::New(Y)); \
+		v8::Handle<v8::Value> argv[] = {p, args[0]}; \
+		return pred->NewInstance(2, argv); \
+	}
 
 HYPERDEX_PRED_CAST(Equals,              HYPERPREDICATE_EQUALS)
 HYPERDEX_PRED_CAST(LessThan,            HYPERPREDICATE_LESS_THAN)
@@ -835,849 +791,736 @@ HYPERDEX_PRED_CAST(Contains,            HYPERPREDICATE_CONTAINS)
 v8::Handle<v8::Value>
 Predicate :: value()
 {
-    v8::HandleScope scope;
-    return scope.Close(v8::Local<v8::Value>::New(m_obj));
+	v8::HandleScope scope;
+	return scope.Close(v8::Local<v8::Value>::New(m_obj));
 }
 
 hyperpredicate
 Predicate :: get_pred()
 {
-    return m_pred;
+	return m_pred;
 }
 
 #include "client.definitions.cc"
 
-Operation :: Operation(v8::Handle<v8::Object>& c1, HyperDexClient* c2)
-    : client(c2)
-    , reqid(-1)
-    , status(HYPERDEX_CLIENT_GARBAGE)
-    , attrs(NULL)
-    , attrs_sz(0)
-    , description(NULL)
-    , count(0)
-    , finished(false)
-    , encode_return()
-    , m_auth(NULL)
-    , m_ref(0)
-    , m_arena(hyperdex_ds_arena_create())
-    , m_client()
-    , m_callback()
-    , m_callback_done()
-    , m_has_callback_done(false)
-{
-    m_client = v8::Persistent<v8::Object>::New(c1);
-    v8::Local<v8::Object> cbobj1 = v8::Object::New();
-    m_callback = v8::Persistent<v8::Object>::New(cbobj1);
-    v8::Local<v8::Object> cbobj2 = v8::Object::New();
-    m_callback_done = v8::Persistent<v8::Object>::New(cbobj2);
+Operation :: Operation(v8::Handle<v8::Object> &c1, HyperDexClient *c2)
+	: client(c2)
+	, reqid(-1)
+	, status(HYPERDEX_CLIENT_GARBAGE)
+	, attrs(NULL)
+	, attrs_sz(0)
+	, description(NULL)
+	, count(0)
+	, finished(false)
+	, encode_return()
+	, m_auth(NULL)
+	, m_ref(0)
+	, m_arena(hyperdex_ds_arena_create())
+	, m_client()
+	, m_callback()
+	, m_callback_done()
+	, m_has_callback_done(false)
+{
+	m_client = v8::Persistent<v8::Object>::New(c1);
+	v8::Local<v8::Object> cbobj1 = v8::Object::New();
+	m_callback = v8::Persistent<v8::Object>::New(cbobj1);
+	v8::Local<v8::Object> cbobj2 = v8::Object::New();
+	m_callback_done = v8::Persistent<v8::Object>::New(cbobj2);
 }
 
 Operation :: ~Operation() throw ()
 {
-    if (m_arena)
-    {
-        hyperdex_ds_arena_destroy(m_arena);
-    }
-
-    if (attrs)
-    {
-        hyperdex_client_destroy_attrs(attrs, attrs_sz);
-    }
-
-    if (m_auth)
-    {
-        free((void *)m_auth);
-    }
-
-    if (description)
-    {
-        free((void*)description);
-    }
-
-    if (!m_client.IsEmpty())
-    {
-        m_client.Dispose();
-        m_client.Clear();
-    }
-
-    if (!m_callback.IsEmpty())
-    {
-        m_callback.Dispose();
-        m_callback.Clear();
-    }
+	if (m_arena)
+	{
+		hyperdex_ds_arena_destroy(m_arena);
+	}
+	if (attrs)
+	{
+		hyperdex_client_destroy_attrs(attrs, attrs_sz);
+	}
+	if (m_auth)
+	{
+		free((void *)m_auth);
+	}
+	if (description)
+	{
+		free((void *)description);
+	}
+	if (!m_client.IsEmpty())
+	{
+		m_client.Dispose();
+		m_client.Clear();
+	}
+	if (!m_callback.IsEmpty())
+	{
+		m_callback.Dispose();
+		m_callback.Clear();
+	}
 }
 
 bool
-Operation :: set_callback(v8::Handle<v8::Function>& func)
+Operation :: set_callback(v8::Handle<v8::Function> &func)
 {
-    v8::Local<v8::Object>::New(m_callback)->Set(v8::String::NewSymbol("callback"), func);
-    m_has_callback_done = false;
-    return true;
+	v8::Local<v8::Object>::New(m_callback)->Set(v8::String::NewSymbol("callback"), func);
+	m_has_callback_done = false;
+	return true;
 }
 
 bool
-Operation :: set_callback(v8::Handle<v8::Function>& func, v8::Handle<v8::Function>& done)
+Operation :: set_callback(v8::Handle<v8::Function> &func, v8::Handle<v8::Function> &done)
 {
-    v8::Local<v8::Object>::New(m_callback)->Set(v8::String::NewSymbol("callback"), func);
-    v8::Local<v8::Object>::New(m_callback_done)->Set(v8::String::NewSymbol("callback"), done);
-    m_has_callback_done = true;
-    return true;
+	v8::Local<v8::Object>::New(m_callback)->Set(v8::String::NewSymbol("callback"), func);
+	v8::Local<v8::Object>::New(m_callback_done)->Set(v8::String::NewSymbol("callback"), done);
+	m_has_callback_done = true;
+	return true;
 }
 
 bool
-Operation :: convert_error(v8::Handle<v8::Value>& _value,
-                           const char** value, size_t* value_sz,
-                           hyperdatatype* datatype)
+Operation :: convert_error(v8::Handle<v8::Value> &_value,
+                           const char **value, size_t *value_sz,
+                           hyperdatatype *datatype)
 {
-    this->callback_error_message("cannot convert to HyperDex type");
-    return false;
+	this->callback_error_message("cannot convert to HyperDex type");
+	return false;
 }
 
 bool
-Operation :: convert_int(v8::Handle<v8::Value>& _value,
-                         const char** value, size_t* value_sz,
-                         hyperdatatype* datatype)
-{
-    if (_value->IsNumber())
-    {
-        double _num = _value.As<v8::Number>()->Value();
-        int64_t num = _num;
-        hyperdex_ds_returncode error;
-
-        if (hyperdex_ds_copy_int(m_arena, num, &error, value, value_sz) < 0)
-        {
-            this->callback_error_out_of_memory();
-            return false;
-        }
-
-        *datatype = HYPERDATATYPE_INT64;
-        return true;
-    }
-    else
-    {
-        this->callback_error_message("cannot convert to an int");
-        return false;
-    }
+Operation :: convert_int(v8::Handle<v8::Value> &_value,
+                         const char **value, size_t *value_sz,
+                         hyperdatatype *datatype)
+{
+	if (_value->IsNumber())
+	{
+		double _num = _value.As<v8::Number>()->Value();
+		int64_t num = _num;
+		hyperdex_ds_returncode error;
+		if (hyperdex_ds_copy_int(m_arena, num, &error, value, value_sz) < 0)
+		{
+			this->callback_error_out_of_memory();
+			return false;
+		}
+		*datatype = HYPERDATATYPE_INT64;
+		return true;
+	}
+	else
+	{
+		this->callback_error_message("cannot convert to an int");
+		return false;
+	}
 }
 
 bool
-Operation :: convert_float(v8::Handle<v8::Value>& _value,
-                           const char** value, size_t* value_sz,
-                           hyperdatatype* datatype)
-{
-    if (_value->IsNumber())
-    {
-        double num = _value.As<v8::Number>()->Value();
-        hyperdex_ds_returncode error;
-
-        if (hyperdex_ds_copy_float(m_arena, num, &error, value, value_sz) < 0)
-        {
-            this->callback_error_out_of_memory();
-            return false;
-        }
-
-        *datatype = HYPERDATATYPE_FLOAT;
-        return true;
-    }
-    else
-    {
-        this->callback_error_message("cannot convert to a float");
-        return false;
-    }
+Operation :: convert_float(v8::Handle<v8::Value> &_value,
+                           const char **value, size_t *value_sz,
+                           hyperdatatype *datatype)
+{
+	if (_value->IsNumber())
+	{
+		double num = _value.As<v8::Number>()->Value();
+		hyperdex_ds_returncode error;
+		if (hyperdex_ds_copy_float(m_arena, num, &error, value, value_sz) < 0)
+		{
+			this->callback_error_out_of_memory();
+			return false;
+		}
+		*datatype = HYPERDATATYPE_FLOAT;
+		return true;
+	}
+	else
+	{
+		this->callback_error_message("cannot convert to a float");
+		return false;
+	}
 }
 
 #define HDJS_HANDLE_ELEM_ERROR(X, TYPE) \
-    switch (X) \
-    { \
-        case HYPERDEX_DS_NOMEM: \
-            this->callback_error_out_of_memory(); \
-            return false; \
-        case HYPERDEX_DS_MIXED_TYPES: \
-            this->callback_error_message("Cannot add " TYPE " to a heterogenous container"); \
-            return false; \
-        case HYPERDEX_DS_SUCCESS: \
-        case HYPERDEX_DS_STRING_TOO_LONG: \
-        case HYPERDEX_DS_WRONG_STATE: \
-        default: \
-            this->callback_error_message("Cannot convert " TYPE " to a HyperDex type"); \
-            return false; \
-    }
+	switch (X) \
+	{ \
+	case HYPERDEX_DS_NOMEM: \
+		this->callback_error_out_of_memory(); \
+		return false; \
+	case HYPERDEX_DS_MIXED_TYPES: \
+		this->callback_error_message("Cannot add " TYPE " to a heterogenous container"); \
+		return false; \
+	case HYPERDEX_DS_SUCCESS: \
+	case HYPERDEX_DS_STRING_TOO_LONG: \
+	case HYPERDEX_DS_WRONG_STATE: \
+	default: \
+		this->callback_error_message("Cannot convert " TYPE " to a HyperDex type"); \
+		return false; \
+	}
 
 bool
-Operation :: convert_elem(v8::Handle<v8::Value>& value, void* x,
+Operation :: convert_elem(v8::Handle<v8::Value> &value, void *x,
                           elem_string_fptr f_string,
                           elem_int_fptr f_int,
                           elem_float_fptr f_float)
 {
-    if (value.IsEmpty())
-    {
-        this->callback_error_message("cannot convert undefined to HyperDex type");
-        return false;
-    }
-
-    if (value->IsObject() &&
-        value->ToObject()->GetConstructor()->StrictEquals(HyperDexClient::type_hint))
-    {
-        TypeHint* hint = node::ObjectWrap::Unwrap<TypeHint>(value.As<v8::Object>());
-        assert(hint);
-
-        if (hint->get_type() == HYPERDATATYPE_INT64)
-        {
-            double _num = hint->value().As<v8::Number>()->Value();
-            int64_t num = _num;
-            hyperdex_ds_returncode error;
-
-            if (f_int(x, num, &error) < 0)
-            {
-                HDJS_HANDLE_ELEM_ERROR(error, "int");
-            }
-
-            return true;
-        }
-        else if (hint->get_type() == HYPERDATATYPE_FLOAT)
-        {
-            double num = hint->value().As<v8::Number>()->Value();
-            hyperdex_ds_returncode error;
-
-            if (f_float(x, num, &error) < 0)
-            {
-                HDJS_HANDLE_ELEM_ERROR(error, "float");
-            }
-
-            return true;
-        }
-        else
-        {
-            this->callback_error_message("cannot convert to HyperDex type");
-            return false;
-        }
-    }
-
-    if (value->IsNumber())
-    {
-        double _num = value.As<v8::Number>()->Value();
-        int64_t num = _num;
-        hyperdex_ds_returncode error;
-
-        if (f_int(x, num, &error) < 0)
-        {
-            HDJS_HANDLE_ELEM_ERROR(error, "int");
-        }
-
-        return true;
-    }
-
-    if (node::Buffer::HasInstance(value->ToObject()))
-    {
-        size_t sz = node::Buffer::Length(value->ToObject());
-        char* data = node::Buffer::Data(value->ToObject());
-        hyperdex_ds_returncode error;
-
-        if (f_string(x, data, sz, &error) < 0)
-        {
-            HDJS_HANDLE_ELEM_ERROR(error, "string");
-        }
-
-        return true;
-    }
-
-    if (value->IsString())
-    {
-        hyperdex_ds_returncode error;
-        v8::String::Utf8Value s(value);
-
-        if (s.length() == 0 && *s == NULL)
-        {
-            this->callback_error_message("cannot convert object to string");
-            return false;
-        }
-
-        if (f_string(x, *s, s.length(), &error) < 0)
-        {
-            HDJS_HANDLE_ELEM_ERROR(error, "string");
-        }
-
-        return true;
-    }
-
-    this->callback_error_message("cannot convert to HyperDex type");
-    return false;
+	if (value.IsEmpty())
+	{
+		this->callback_error_message("cannot convert undefined to HyperDex type");
+		return false;
+	}
+	if (value->IsObject() &&
+	    value->ToObject()->GetConstructor()->StrictEquals(HyperDexClient::type_hint))
+	{
+		TypeHint *hint = node::ObjectWrap::Unwrap<TypeHint>(value.As<v8::Object>());
+		assert(hint);
+		if (hint->get_type() == HYPERDATATYPE_INT64)
+		{
+			double _num = hint->value().As<v8::Number>()->Value();
+			int64_t num = _num;
+			hyperdex_ds_returncode error;
+			if (f_int(x, num, &error) < 0)
+			{
+				HDJS_HANDLE_ELEM_ERROR(error, "int");
+			}
+			return true;
+		}
+		else if (hint->get_type() == HYPERDATATYPE_FLOAT)
+		{
+			double num = hint->value().As<v8::Number>()->Value();
+			hyperdex_ds_returncode error;
+			if (f_float(x, num, &error) < 0)
+			{
+				HDJS_HANDLE_ELEM_ERROR(error, "float");
+			}
+			return true;
+		}
+		else
+		{
+			this->callback_error_message("cannot convert to HyperDex type");
+			return false;
+		}
+	}
+	if (value->IsNumber())
+	{
+		double _num = value.As<v8::Number>()->Value();
+		int64_t num = _num;
+		hyperdex_ds_returncode error;
+		if (f_int(x, num, &error) < 0)
+		{
+			HDJS_HANDLE_ELEM_ERROR(error, "int");
+		}
+		return true;
+	}
+	if (node::Buffer::HasInstance(value->ToObject()))
+	{
+		size_t sz = node::Buffer::Length(value->ToObject());
+		char *data = node::Buffer::Data(value->ToObject());
+		hyperdex_ds_returncode error;
+		if (f_string(x, data, sz, &error) < 0)
+		{
+			HDJS_HANDLE_ELEM_ERROR(error, "string");
+		}
+		return true;
+	}
+	if (value->IsString())
+	{
+		hyperdex_ds_returncode error;
+		v8::String::Utf8Value s(value);
+		if (s.length() == 0 && *s == NULL)
+		{
+			this->callback_error_message("cannot convert object to string");
+			return false;
+		}
+		if (f_string(x, *s, s.length(), &error) < 0)
+		{
+			HDJS_HANDLE_ELEM_ERROR(error, "string");
+		}
+		return true;
+	}
+	this->callback_error_message("cannot convert to HyperDex type");
+	return false;
 }
 
 bool
-Operation :: convert_list(v8::Handle<v8::Value>& _value,
-                          const char** value, size_t* value_sz,
-                          hyperdatatype* datatype)
-{
-    if (!_value->IsArray())
-    {
-        this->callback_error_message("lists must be specified as arrays");
-        return false;
-    }
-
-    struct hyperdex_ds_list* list;
-    enum hyperdex_ds_returncode error;
-    list = hyperdex_ds_allocate_list(m_arena);
-
-    if (!list)
-    {
-        this->callback_error_out_of_memory();
-        return false;
-    }
-
-    v8::Local<v8::Array> arr = v8::Local<v8::Array>::New(_value.As<v8::Array>());
-
-    for (size_t i = 0; i < arr->Length(); ++i)
-    {
-        v8::Local<v8::Value> entry = arr->Get(i);
-
-        if (!this->convert_elem(entry, list,
-                (elem_string_fptr) hyperdex_ds_list_append_string,
-                (elem_int_fptr) hyperdex_ds_list_append_int,
-                (elem_float_fptr) hyperdex_ds_list_append_float))
-        {
-            return false;
-        }
-    }
-
-    if (hyperdex_ds_list_finalize(list, &error, value, value_sz, datatype) < 0)
-    {
-        this->callback_error_out_of_memory();
-        return false;
-    }
-
-    return true;
+Operation :: convert_list(v8::Handle<v8::Value> &_value,
+                          const char **value, size_t *value_sz,
+                          hyperdatatype *datatype)
+{
+	if (!_value->IsArray())
+	{
+		this->callback_error_message("lists must be specified as arrays");
+		return false;
+	}
+	struct hyperdex_ds_list *list;
+	enum hyperdex_ds_returncode error;
+	list = hyperdex_ds_allocate_list(m_arena);
+	if (!list)
+	{
+		this->callback_error_out_of_memory();
+		return false;
+	}
+	v8::Local<v8::Array> arr = v8::Local<v8::Array>::New(_value.As<v8::Array>());
+	for (size_t i = 0; i < arr->Length(); ++i)
+	{
+		v8::Local<v8::Value> entry = arr->Get(i);
+		if (!this->convert_elem(entry, list,
+		                        (elem_string_fptr) hyperdex_ds_list_append_string,
+		                        (elem_int_fptr) hyperdex_ds_list_append_int,
+		                        (elem_float_fptr) hyperdex_ds_list_append_float))
+		{
+			return false;
+		}
+	}
+	if (hyperdex_ds_list_finalize(list, &error, value, value_sz, datatype) < 0)
+	{
+		this->callback_error_out_of_memory();
+		return false;
+	}
+	return true;
 }
 
 bool
-Operation :: convert_set(v8::Handle<v8::Value>& _value,
-                         const char** value, size_t* value_sz,
-                         hyperdatatype* datatype)
-{
-    if (!_value->IsArray())
-    {
-        this->callback_error_message("sets must be specified as arrays");
-        return false;
-    }
-
-    struct hyperdex_ds_set* set;
-    enum hyperdex_ds_returncode error;
-    set = hyperdex_ds_allocate_set(m_arena);
-
-    if (!set)
-    {
-        this->callback_error_out_of_memory();
-        return false;
-    }
-
-    v8::Local<v8::Array> arr = v8::Local<v8::Array>::New(_value.As<v8::Array>());
-
-    for (size_t i = 0; i < arr->Length(); ++i)
-    {
-        v8::Local<v8::Value> entry = arr->Get(i);
-
-        if (!this->convert_elem(entry, set,
-                (elem_string_fptr) hyperdex_ds_set_insert_string,
-                (elem_int_fptr) hyperdex_ds_set_insert_int,
-                (elem_float_fptr) hyperdex_ds_set_insert_float))
-        {
-            return false;
-        }
-    }
-
-    if (hyperdex_ds_set_finalize(set, &error, value, value_sz, datatype) < 0)
-    {
-        this->callback_error_out_of_memory();
-        return false;
-    }
-
-    return true;
+Operation :: convert_set(v8::Handle<v8::Value> &_value,
+                         const char **value, size_t *value_sz,
+                         hyperdatatype *datatype)
+{
+	if (!_value->IsArray())
+	{
+		this->callback_error_message("sets must be specified as arrays");
+		return false;
+	}
+	struct hyperdex_ds_set *set;
+	enum hyperdex_ds_returncode error;
+	set = hyperdex_ds_allocate_set(m_arena);
+	if (!set)
+	{
+		this->callback_error_out_of_memory();
+		return false;
+	}
+	v8::Local<v8::Array> arr = v8::Local<v8::Array>::New(_value.As<v8::Array>());
+	for (size_t i = 0; i < arr->Length(); ++i)
+	{
+		v8::Local<v8::Value> entry = arr->Get(i);
+		if (!this->convert_elem(entry, set,
+		                        (elem_string_fptr) hyperdex_ds_set_insert_string,
+		                        (elem_int_fptr) hyperdex_ds_set_insert_int,
+		                        (elem_float_fptr) hyperdex_ds_set_insert_float))
+		{
+			return false;
+		}
+	}
+	if (hyperdex_ds_set_finalize(set, &error, value, value_sz, datatype) < 0)
+	{
+		this->callback_error_out_of_memory();
+		return false;
+	}
+	return true;
 }
 
 bool
-Operation :: convert_map(v8::Handle<v8::Value>& _value,
-                         const char** value, size_t* value_sz,
-                         hyperdatatype* datatype)
-{
-    if (!_value->IsArray())
-    {
-        this->callback_error_message("maps must be specified as arrays");
-        return false;
-    }
-
-    struct hyperdex_ds_map* map;
-    enum hyperdex_ds_returncode error;
-    map = hyperdex_ds_allocate_map(m_arena);
-
-    if (!map)
-    {
-        this->callback_error_out_of_memory();
-        return false;
-    }
-
-    v8::Local<v8::Array> arr = v8::Local<v8::Array>::New(_value.As<v8::Array>());
-
-    for (size_t i = 0; i < arr->Length(); ++i)
-    {
-        v8::Local<v8::Value> _pair = arr->Get(i);
-
-        if (!_pair->IsArray())
-        {
-            this->callback_error_message("map pairs must be specified as arrays");
-            return false;
-        }
-
-        v8::Local<v8::Array> pair = _pair.As<v8::Array>();
-
-        if (pair->Length() != 2)
-        {
-            this->callback_error_message("map pairs must be of length 2");
-            return false;
-        }
-
-        v8::Local<v8::Value> key = pair->Get(0);
-        v8::Local<v8::Value> val = pair->Get(1);
-
-        if (!this->convert_elem(key, map,
-                (elem_string_fptr) hyperdex_ds_map_insert_key_string,
-                (elem_int_fptr) hyperdex_ds_map_insert_key_int,
-                (elem_float_fptr) hyperdex_ds_map_insert_key_float) ||
-            !this->convert_elem(val, map,
-                (elem_string_fptr) hyperdex_ds_map_insert_val_string,
-                (elem_int_fptr) hyperdex_ds_map_insert_val_int,
-                (elem_float_fptr) hyperdex_ds_map_insert_val_float))
-        {
-            return false;
-        }
-    }
-
-    if (hyperdex_ds_map_finalize(map, &error, value, value_sz, datatype) < 0)
-    {
-        this->callback_error_out_of_memory();
-        return false;
-    }
-
-    return true;
+Operation :: convert_map(v8::Handle<v8::Value> &_value,
+                         const char **value, size_t *value_sz,
+                         hyperdatatype *datatype)
+{
+	if (!_value->IsArray())
+	{
+		this->callback_error_message("maps must be specified as arrays");
+		return false;
+	}
+	struct hyperdex_ds_map *map;
+	enum hyperdex_ds_returncode error;
+	map = hyperdex_ds_allocate_map(m_arena);
+	if (!map)
+	{
+		this->callback_error_out_of_memory();
+		return false;
+	}
+	v8::Local<v8::Array> arr = v8::Local<v8::Array>::New(_value.As<v8::Array>());
+	for (size_t i = 0; i < arr->Length(); ++i)
+	{
+		v8::Local<v8::Value> _pair = arr->Get(i);
+		if (!_pair->IsArray())
+		{
+			this->callback_error_message("map pairs must be specified as arrays");
+			return false;
+		}
+		v8::Local<v8::Array> pair = _pair.As<v8::Array>();
+		if (pair->Length() != 2)
+		{
+			this->callback_error_message("map pairs must be of length 2");
+			return false;
+		}
+		v8::Local<v8::Value> key = pair->Get(0);
+		v8::Local<v8::Value> val = pair->Get(1);
+		if (!this->convert_elem(key, map,
+		                        (elem_string_fptr) hyperdex_ds_map_insert_key_string,
+		                        (elem_int_fptr) hyperdex_ds_map_insert_key_int,
+		                        (elem_float_fptr) hyperdex_ds_map_insert_key_float) ||
+		    !this->convert_elem(val, map,
+		                        (elem_string_fptr) hyperdex_ds_map_insert_val_string,
+		                        (elem_int_fptr) hyperdex_ds_map_insert_val_int,
+		                        (elem_float_fptr) hyperdex_ds_map_insert_val_float))
+		{
+			return false;
+		}
+	}
+	if (hyperdex_ds_map_finalize(map, &error, value, value_sz, datatype) < 0)
+	{
+		this->callback_error_out_of_memory();
+		return false;
+	}
+	return true;
 }
 
 bool
-Operation :: convert_cstring(v8::Handle<v8::Value>& _cstring,
-                             const char** cstring)
-{
-    v8::String::Utf8Value s(_cstring);
-
-    if (s.length() == 0 && *s == NULL)
-    {
-        this->callback_error_message("cannot convert object to string");
-        return false;
-    }
-
-    hyperdex_ds_returncode error;
-    size_t sz;
-
-    if (hyperdex_ds_copy_string(m_arena, *s, s.length() + 1, &error, cstring, &sz) < 0)
-    {
-        this->callback_error_out_of_memory();
-        return false;
-    }
-
-    return true;
+Operation :: convert_cstring(v8::Handle<v8::Value> &_cstring,
+                             const char **cstring)
+{
+	v8::String::Utf8Value s(_cstring);
+	if (s.length() == 0 && *s == NULL)
+	{
+		this->callback_error_message("cannot convert object to string");
+		return false;
+	}
+	hyperdex_ds_returncode error;
+	size_t sz;
+	if (hyperdex_ds_copy_string(m_arena, *s, s.length() + 1, &error, cstring, &sz) < 0)
+	{
+		this->callback_error_out_of_memory();
+		return false;
+	}
+	return true;
 }
 
 bool
-Operation :: convert_type(v8::Handle<v8::Value>& _value,
-                          const char** value, size_t* value_sz,
-                          hyperdatatype* datatype,
+Operation :: convert_type(v8::Handle<v8::Value> &_value,
+                          const char **value, size_t *value_sz,
+                          hyperdatatype *datatype,
                           bool make_callback_on_error,
                           bool may_default_to_json)
 {
-    if (_value.IsEmpty())
-    {
-        if (make_callback_on_error)
-        {
-            this->callback_error_message("cannot convert undefined to HyperDex type");
-        }
-
-        return false;
-    }
-
-    if (_value->IsObject() &&
-        _value->ToObject()->GetConstructor()->StrictEquals(HyperDexClient::type_hint))
-    {
-        TypeHint* hint = node::ObjectWrap::Unwrap<TypeHint>(_value.As<v8::Object>());
-        assert(hint);
-        Operation::type_converter conv = hint->get_converter();
-        v8::Local<v8::Value> inner = v8::Local<v8::Value>::New(hint->value());
-        return (this->*conv)(inner, value, value_sz, datatype);
-    }
-
-    if (_value->IsNumber())
-    {
-        double _num = _value.As<v8::Number>()->Value();
-        int64_t num = _num;
-        hyperdex_ds_returncode error;
-
-        if (hyperdex_ds_copy_int(m_arena, num, &error, value, value_sz) < 0)
-        {
-            if (make_callback_on_error)
-            {
-                this->callback_error_out_of_memory();
-            }
-
-            return false;
-        }
-
-        *datatype = HYPERDATATYPE_INT64;
-        return true;
-    }
-
-    if (node::Buffer::HasInstance(_value->ToObject()))
-    {
-        size_t sz = node::Buffer::Length(_value->ToObject());
-        char* data = node::Buffer::Data(_value->ToObject());
-        hyperdex_ds_returncode error;
-
-        if (hyperdex_ds_copy_string(m_arena, data, sz, &error, value, value_sz) < 0)
-        {
-            if (make_callback_on_error)
-            {
-                this->callback_error_out_of_memory();
-            }
-
-            return false;
-        }
-
-        *datatype = HYPERDATATYPE_STRING;
-        return true;
-    }
-
-    if (_value->IsString())
-    {
-        v8::String::Utf8Value s(_value);
-
-        if (s.length() == 0 && *s == NULL)
-        {
-            if (make_callback_on_error)
-            {
-                this->callback_error_message("cannot convert object to string");
-            }
-
-            return false;
-        }
-
-        hyperdex_ds_returncode error;
-
-        if (hyperdex_ds_copy_string(m_arena, *s, s.length(), &error, value, value_sz) < 0)
-        {
-            if (make_callback_on_error)
-            {
-                this->callback_error_out_of_memory();
-            }
-
-            return false;
-        }
-
-        *datatype = HYPERDATATYPE_STRING;
-        return true;
-    }
-
-    if (may_default_to_json)
-    {
-        v8::Local<v8::Object> global = v8::Context::GetCurrent()->Global();
-        v8::Local<v8::Object> JSON = global->Get(v8::String::New("JSON"))->ToObject();
-        v8::Handle<v8::Function> parse = v8::Handle<v8::Function>::Cast(JSON->Get(v8::String::New("stringify")));
-        v8::Handle<v8::Value> argv[1] = { _value };
-        v8::Local<v8::Value> str = v8::Local<v8::Value>::New(parse->Call(JSON, 1, argv));
-        v8::String::Utf8Value s(str);
-
-        if (s.length() == 0 && *s == NULL)
-        {
-            if (make_callback_on_error)
-            {
-                this->callback_error_message("cannot convert object to JSON");
-            }
-
-            return false;
-        }
-
-        hyperdex_ds_returncode error;
-
-        if (hyperdex_ds_copy_string(m_arena, *s, s.length(), &error, value, value_sz) < 0)
-        {
-            if (make_callback_on_error)
-            {
-                this->callback_error_out_of_memory();
-            }
-
-            return false;
-        }
-
-        *datatype = HYPERDATATYPE_DOCUMENT;
-        return true;
-    }
-
-    if (make_callback_on_error)
-    {
-        this->callback_error_message("cannot convert to HyperDex type");
-    }
-
-    return false;
+	if (_value.IsEmpty())
+	{
+		if (make_callback_on_error)
+		{
+			this->callback_error_message("cannot convert undefined to HyperDex type");
+		}
+		return false;
+	}
+	if (_value->IsObject() &&
+	    _value->ToObject()->GetConstructor()->StrictEquals(HyperDexClient::type_hint))
+	{
+		TypeHint *hint = node::ObjectWrap::Unwrap<TypeHint>(_value.As<v8::Object>());
+		assert(hint);
+		Operation::type_converter conv = hint->get_converter();
+		v8::Local<v8::Value> inner = v8::Local<v8::Value>::New(hint->value());
+		return (this->*conv)(inner, value, value_sz, datatype);
+	}
+	if (_value->IsNumber())
+	{
+		double _num = _value.As<v8::Number>()->Value();
+		int64_t num = _num;
+		hyperdex_ds_returncode error;
+		if (hyperdex_ds_copy_int(m_arena, num, &error, value, value_sz) < 0)
+		{
+			if (make_callback_on_error)
+			{
+				this->callback_error_out_of_memory();
+			}
+			return false;
+		}
+		*datatype = HYPERDATATYPE_INT64;
+		return true;
+	}
+	if (node::Buffer::HasInstance(_value->ToObject()))
+	{
+		size_t sz = node::Buffer::Length(_value->ToObject());
+		char *data = node::Buffer::Data(_value->ToObject());
+		hyperdex_ds_returncode error;
+		if (hyperdex_ds_copy_string(m_arena, data, sz, &error, value, value_sz) < 0)
+		{
+			if (make_callback_on_error)
+			{
+				this->callback_error_out_of_memory();
+			}
+			return false;
+		}
+		*datatype = HYPERDATATYPE_STRING;
+		return true;
+	}
+	if (_value->IsString())
+	{
+		v8::String::Utf8Value s(_value);
+		if (s.length() == 0 && *s == NULL)
+		{
+			if (make_callback_on_error)
+			{
+				this->callback_error_message("cannot convert object to string");
+			}
+			return false;
+		}
+		hyperdex_ds_returncode error;
+		if (hyperdex_ds_copy_string(m_arena, *s, s.length(), &error, value, value_sz) < 0)
+		{
+			if (make_callback_on_error)
+			{
+				this->callback_error_out_of_memory();
+			}
+			return false;
+		}
+		*datatype = HYPERDATATYPE_STRING;
+		return true;
+	}
+	if (may_default_to_json)
+	{
+		v8::Local<v8::Object> global = v8::Context::GetCurrent()->Global();
+		v8::Local<v8::Object> JSON = global->Get(v8::String::New("JSON"))->ToObject();
+		v8::Handle<v8::Function> parse = v8::Handle<v8::Function>::Cast(JSON->Get(v8::String::New("stringify")));
+		v8::Handle<v8::Value> argv[1] = { _value };
+		v8::Local<v8::Value> str = v8::Local<v8::Value>::New(parse->Call(JSON, 1, argv));
+		v8::String::Utf8Value s(str);
+		if (s.length() == 0 && *s == NULL)
+		{
+			if (make_callback_on_error)
+			{
+				this->callback_error_message("cannot convert object to JSON");
+			}
+			return false;
+		}
+		hyperdex_ds_returncode error;
+		if (hyperdex_ds_copy_string(m_arena, *s, s.length(), &error, value, value_sz) < 0)
+		{
+			if (make_callback_on_error)
+			{
+				this->callback_error_out_of_memory();
+			}
+			return false;
+		}
+		*datatype = HYPERDATATYPE_DOCUMENT;
+		return true;
+	}
+	if (make_callback_on_error)
+	{
+		this->callback_error_message("cannot convert to HyperDex type");
+	}
+	return false;
 }
 
 bool
-Operation :: convert_spacename(v8::Handle<v8::Value>& _spacename,
-                               const char** spacename)
+Operation :: convert_spacename(v8::Handle<v8::Value> &_spacename,
+                               const char **spacename)
 {
-    return convert_cstring(_spacename, spacename);
+	return convert_cstring(_spacename, spacename);
 }
 
 bool
-Operation :: convert_key(v8::Handle<v8::Value>& _key,
-                         const char** key, size_t* key_sz)
+Operation :: convert_key(v8::Handle<v8::Value> &_key,
+                         const char **key, size_t *key_sz)
 {
-    hyperdatatype datatype;
-    return convert_type(_key, key, key_sz, &datatype, true, false);
+	hyperdatatype datatype;
+	return convert_type(_key, key, key_sz, &datatype, true, false);
 }
 
 bool
-Operation :: convert_attributes(v8::Handle<v8::Value>& x,
-                                const hyperdex_client_attribute** _attrs,
-                                size_t* _attrs_sz)
-{
-    if (!x->IsObject())
-    {
-        this->callback_error_message("attributes must be an object");
-        return false;
-    }
-
-    v8::Local<v8::Object> attributes = x->ToObject();
-    v8::Local<v8::Array> arr = attributes->GetPropertyNames();
-    size_t ret_attrs_sz = arr->Length();
-    struct hyperdex_client_attribute* ret_attrs;
-    ret_attrs = hyperdex_ds_allocate_attribute(m_arena, ret_attrs_sz);
-
-    if (!ret_attrs)
-    {
-        this->callback_error_out_of_memory();
-        return false;
-    }
-
-    *_attrs = ret_attrs;
-    *_attrs_sz = ret_attrs_sz;
-
-    for (size_t i = 0; i < arr->Length(); ++i)
-    {
-        v8::Local<v8::Value> key = arr->Get(i);
-        v8::Local<v8::Value> val = attributes->Get(key);
-
-        if (!convert_cstring(key, &ret_attrs[i].attr) ||
-            !convert_type(val, &ret_attrs[i].value,
-                               &ret_attrs[i].value_sz,
-                               &ret_attrs[i].datatype, true, true))
-        {
-            return false;
-        }
-    }
-
-    return true;
+Operation :: convert_attributes(v8::Handle<v8::Value> &x,
+                                const hyperdex_client_attribute **_attrs,
+                                size_t *_attrs_sz)
+{
+	if (!x->IsObject())
+	{
+		this->callback_error_message("attributes must be an object");
+		return false;
+	}
+	v8::Local<v8::Object> attributes = x->ToObject();
+	v8::Local<v8::Array> arr = attributes->GetPropertyNames();
+	size_t ret_attrs_sz = arr->Length();
+	struct hyperdex_client_attribute *ret_attrs;
+	ret_attrs = hyperdex_ds_allocate_attribute(m_arena, ret_attrs_sz);
+	if (!ret_attrs)
+	{
+		this->callback_error_out_of_memory();
+		return false;
+	}
+	*_attrs = ret_attrs;
+	*_attrs_sz = ret_attrs_sz;
+	for (size_t i = 0; i < arr->Length(); ++i)
+	{
+		v8::Local<v8::Value> key = arr->Get(i);
+		v8::Local<v8::Value> val = attributes->Get(key);
+		if (!convert_cstring(key, &ret_attrs[i].attr) ||
+		    !convert_type(val, &ret_attrs[i].value,
+		                  &ret_attrs[i].value_sz,
+		                  &ret_attrs[i].datatype, true, true))
+		{
+			return false;
+		}
+	}
+	return true;
 }
 
 bool
-Operation :: convert_document_predicates(const std::string& prefix,
-                                         v8::Handle<v8::Object>& x,
-                                         std::vector<hyperdex_client_attribute_check>* checks)
-{
-    v8::Local<v8::Array> arr = x->GetPropertyNames();
-
-    for (size_t i = 0; i < arr->Length(); ++i)
-    {
-        hyperdex_client_attribute_check check;
-        v8::Local<v8::Value> key = arr->Get(i);
-        v8::Local<v8::Value> val = x->Get(key);
-        hyperdex_ds_returncode error;
-        size_t sz;
-
-        if (convert_type(val, &check.value,
-                              &check.value_sz,
-                              &check.datatype, false, false))
-        {
-            if (!convert_cstring(key, &check.attr))
-            {
-                return false;
-            }
-
-            std::string attr = prefix + check.attr;
-
-            if (hyperdex_ds_copy_string(m_arena, attr.c_str(), attr.size() + 1, &error, &check.attr, &sz) < 0)
-            {
-                this->callback_error_out_of_memory();
-                return false;
-            }
-
-            check.predicate = HYPERPREDICATE_EQUALS;
-            checks->push_back(check);
-        }
-        else if (val->IsObject() &&
-                 val->ToObject()->GetConstructor()->StrictEquals(HyperDexClient::predicate))
-        {
-            Predicate* pred = node::ObjectWrap::Unwrap<Predicate>(val.As<v8::Object>());
-            v8::Local<v8::Value> v = v8::Local<v8::Value>::New(pred->value());
-
-            if (!convert_cstring(key, &check.attr) ||
-                !convert_type(v, &check.value,
-                              &check.value_sz,
-                              &check.datatype, true, false))
-            {
-                return false;
-            }
-
-            std::string attr = prefix + check.attr;
-
-            if (hyperdex_ds_copy_string(m_arena, attr.c_str(), attr.size() + 1, &error, &check.attr, &sz) < 0)
-            {
-                this->callback_error_out_of_memory();
-                return false;
-            }
-
-            check.predicate = pred->get_pred();
-            checks->push_back(check);
-        }
-        else if (val->IsObject())
-        {
-            v8::String::Utf8Value s(key);
-
-            if (s.length() == 0 && *s == NULL)
-            {
-                this->callback_error_message("cannot convert object to string");
-                return false;
-            }
-
-            std::string ss(prefix);
-            ss.append(*s, s.length());
-            ss.append(".", 1);
-            v8::Local<v8::Object> ps = val->ToObject();
-
-            if (!convert_document_predicates(ss, ps, checks))
-            {
-                return false;
-            }
-        }
-    }
-
-    return true;
+Operation :: convert_document_predicates(const std::string &prefix,
+                                         v8::Handle<v8::Object> &x,
+                                         std::vector<hyperdex_client_attribute_check> *checks)
+{
+	v8::Local<v8::Array> arr = x->GetPropertyNames();
+	for (size_t i = 0; i < arr->Length(); ++i)
+	{
+		hyperdex_client_attribute_check check;
+		v8::Local<v8::Value> key = arr->Get(i);
+		v8::Local<v8::Value> val = x->Get(key);
+		hyperdex_ds_returncode error;
+		size_t sz;
+		if (convert_type(val, &check.value,
+		                 &check.value_sz,
+		                 &check.datatype, false, false))
+		{
+			if (!convert_cstring(key, &check.attr))
+			{
+				return false;
+			}
+			std::string attr = prefix + check.attr;
+			if (hyperdex_ds_copy_string(m_arena, attr.c_str(), attr.size() + 1, &error, &check.attr, &sz) < 0)
+			{
+				this->callback_error_out_of_memory();
+				return false;
+			}
+			check.predicate = HYPERPREDICATE_EQUALS;
+			checks->push_back(check);
+		}
+		else if (val->IsObject() &&
+		         val->ToObject()->GetConstructor()->StrictEquals(HyperDexClient::predicate))
+		{
+			Predicate *pred = node::ObjectWrap::Unwrap<Predicate>(val.As<v8::Object>());
+			v8::Local<v8::Value> v = v8::Local<v8::Value>::New(pred->value());
+			if (!convert_cstring(key, &check.attr) ||
+			    !convert_type(v, &check.value,
+			                  &check.value_sz,
+			                  &check.datatype, true, false))
+			{
+				return false;
+			}
+			std::string attr = prefix + check.attr;
+			if (hyperdex_ds_copy_string(m_arena, attr.c_str(), attr.size() + 1, &error, &check.attr, &sz) < 0)
+			{
+				this->callback_error_out_of_memory();
+				return false;
+			}
+			check.predicate = pred->get_pred();
+			checks->push_back(check);
+		}
+		else if (val->IsObject())
+		{
+			v8::String::Utf8Value s(key);
+			if (s.length() == 0 && *s == NULL)
+			{
+				this->callback_error_message("cannot convert object to string");
+				return false;
+			}
+			std::string ss(prefix);
+			ss.append(*s, s.length());
+			ss.append(".", 1);
+			v8::Local<v8::Object> ps = val->ToObject();
+			if (!convert_document_predicates(ss, ps, checks))
+			{
+				return false;
+			}
+		}
+	}
+	return true;
 }
 
 bool
-Operation :: convert_predicates(v8::Handle<v8::Value>& x,
-                                const hyperdex_client_attribute_check** _checks,
-                                size_t* _checks_sz)
-{
-    if (!x->IsObject())
-    {
-        this->callback_error_message("predicates must be an object");
-        return false;
-    }
-
-    v8::Local<v8::Object> predicates = x->ToObject();
-    std::vector<hyperdex_client_attribute_check> checks;
-
-    if (!convert_document_predicates("", predicates, &checks))
-    {
-        return false;
-    }
-
-    hyperdex_client_attribute_check* cs;
-    *_checks = cs = hyperdex_ds_allocate_attribute_check(m_arena, checks.size());
-    *_checks_sz = checks.size();
-
-    if (!*_checks)
-    {
-        this->callback_error_out_of_memory();
-        return false;
-    }
-
-    for (size_t i = 0; i < checks.size(); ++i)
-    {
-        cs[i] = checks[i];
-    }
-
-    return true;
+Operation :: convert_predicates(v8::Handle<v8::Value> &x,
+                                const hyperdex_client_attribute_check **_checks,
+                                size_t *_checks_sz)
+{
+	if (!x->IsObject())
+	{
+		this->callback_error_message("predicates must be an object");
+		return false;
+	}
+	v8::Local<v8::Object> predicates = x->ToObject();
+	std::vector<hyperdex_client_attribute_check> checks;
+	if (!convert_document_predicates("", predicates, &checks))
+	{
+		return false;
+	}
+	hyperdex_client_attribute_check *cs;
+	*_checks = cs = hyperdex_ds_allocate_attribute_check(m_arena, checks.size());
+	*_checks_sz = checks.size();
+	if (!*_checks)
+	{
+		this->callback_error_out_of_memory();
+		return false;
+	}
+	for (size_t i = 0; i < checks.size(); ++i)
+	{
+		cs[i] = checks[i];
+	}
+	return true;
 }
 
 bool
-Operation :: convert_mapattributes(v8::Handle<v8::Value>& _predicates,
-                                   const hyperdex_client_map_attribute** _mapattrs,
-                                   size_t* _mapattrs_sz)
+Operation :: convert_mapattributes(v8::Handle<v8::Value> &_predicates,
+                                   const hyperdex_client_map_attribute **_mapattrs,
+                                   size_t *_mapattrs_sz)
 {
-    v8::ThrowException(v8::String::New("mapattributes not yet supported")); // XXX
-    *_mapattrs = NULL;
-    *_mapattrs_sz = 0;
-    return false;
+	v8::ThrowException(v8::String::New("mapattributes not yet supported")); // XXX
+	*_mapattrs = NULL;
+	*_mapattrs_sz = 0;
+	return false;
 }
 
 bool
-Operation :: convert_attributenames(v8::Handle<v8::Value>& x,
-                                    const char*** attributenames,
-                                    size_t* attributenames_sz)
-{
-    if (!x->IsArray())
-    {
-        this->callback_error_message("attribute names must be an array");
-        return false;
-    }
-
-    v8::Handle<v8::Array> arr = v8::Handle<v8::Array>::Cast(x);
-    *attributenames_sz = arr->Length();
-    const char** ret = static_cast<const char**>(hyperdex_ds_malloc(m_arena, sizeof(char*) * *attributenames_sz));
-
-    if (!ret)
-    {
-        this->callback_error_out_of_memory();
-        return false;
-    }
-
-    *attributenames = ret;
-
-    for (size_t i = 0; i < arr->Length(); ++i)
-    {
-        v8::Local<v8::Value> key = arr->Get(i);
-
-        if (!convert_cstring(key, &ret[i]))
-        {
-            return false;
-        }
-    }
-
-    return true;
+Operation :: convert_attributenames(v8::Handle<v8::Value> &x,
+                                    const char *** attributenames,
+                                    size_t *attributenames_sz)
+{
+	if (!x->IsArray())
+	{
+		this->callback_error_message("attribute names must be an array");
+		return false;
+	}
+	v8::Handle<v8::Array> arr = v8::Handle<v8::Array>::Cast(x);
+	*attributenames_sz = arr->Length();
+	const char **ret = static_cast<const char **>(hyperdex_ds_malloc(m_arena, sizeof(char *) * *attributenames_sz));
+	if (!ret)
+	{
+		this->callback_error_out_of_memory();
+		return false;
+	}
+	*attributenames = ret;
+	for (size_t i = 0; i < arr->Length(); ++i)
+	{
+		v8::Local<v8::Value> key = arr->Get(i);
+		if (!convert_cstring(key, &ret[i]))
+		{
+			return false;
+		}
+	}
+	return true;
 }
 
 bool
-Operation :: convert_sortby(v8::Handle<v8::Value>& _sortby,
-                            const char** sortby)
+Operation :: convert_sortby(v8::Handle<v8::Value> &_sortby,
+                            const char **sortby)
 {
-    return convert_cstring(_sortby, sortby);
+	return convert_cstring(_sortby, sortby);
 }
 
 bool
-Operation :: convert_limit(v8::Handle<v8::Value>& _limit,
-                           uint64_t* limit)
+Operation :: convert_limit(v8::Handle<v8::Value> &_limit,
+                           uint64_t *limit)
 {
-    if (!_limit->IsNumber())
-    {
-        this->callback_error_message("limit must be numeric");
-        return false;
-    }
-
-    *limit = _limit->IntegerValue();
-    return true;
+	if (!_limit->IsNumber())
+	{
+		this->callback_error_message("limit must be numeric");
+		return false;
+	}
+	*limit = _limit->IntegerValue();
+	return true;
 }
 
 bool
-Operation :: convert_maxmin(v8::Handle<v8::Value>& _maxmin,
-                            int* maximize)
+Operation :: convert_maxmin(v8::Handle<v8::Value> &_maxmin,
+                            int *maximize)
 {
-    *maximize = _maxmin->IsTrue() ? 1 : 0;
-    return true;
+	*maximize = _maxmin->IsTrue() ? 1 : 0;
+	return true;
 }
 
 // 20 Sept 2015 - William Whitacre
@@ -1686,1136 +1529,1019 @@ bool
 Operation :: convert_auth_context(v8::Handle<v8::Value> &_value,
                                   const char ***p_auth, size_t *p_auth_sz)
 {
-    // Make sure this is an array we've been passed.
-    if (!_value->IsArray())
-    {
-        this->callback_error_message("auth must be specified as an array");
-        return false;
-    }
-
-    // Reference it as an array.
-    v8::Local<v8::Array> arr =
-        v8::Local<v8::Array>::New(_value.As<v8::Array>());
-
-    // Allocate the pointer array for storing the authorization chain.
-    const size_t auth_sz = arr->Length();
-    const char **auth = reinterpret_cast<const char **>(malloc(auth_sz * sizeof(const char *)));
-
-    // Loop through the array elements.
-    for (size_t i = 0; i < auth_sz; ++i)
-    {
-        // Retrieve array element at index i.
-        v8::Local<v8::Value> _M = arr->Get(i);
-
-        // Make sure it's actually a string and use the convert_cstring member
-        // function to copy the string.
-        if (_M.IsEmpty() ||
-            !(_M->IsString() && this->convert_cstring(_M, &auth[i])))
-        {
-            this->callback_error_message("auth must be an array of strings");
-            return false;
-        }
-    }
-
-    // Copy the resulting pointers to the return arguments.
-    *p_auth_sz = auth_sz;
-    *p_auth = auth;
-
-    // Everything worked ok.
-    return true;
+	// Make sure this is an array we've been passed.
+	if (!_value->IsArray())
+	{
+		this->callback_error_message("auth must be specified as an array");
+		return false;
+	}
+	// Reference it as an array.
+	v8::Local<v8::Array> arr =
+	    v8::Local<v8::Array>::New(_value.As<v8::Array>());
+	// Allocate the pointer array for storing the authorization chain.
+	const size_t auth_sz = arr->Length();
+	const char **auth = reinterpret_cast<const char **>(malloc(auth_sz * sizeof(const char *)));
+	// Loop through the array elements.
+	for (size_t i = 0; i < auth_sz; ++i)
+	{
+		// Retrieve array element at index i.
+		v8::Local<v8::Value> _M = arr->Get(i);
+		// Make sure it's actually a string and use the convert_cstring member
+		// function to copy the string.
+		if (_M.IsEmpty() ||
+		    !(_M->IsString() && this->convert_cstring(_M, &auth[i])))
+		{
+			this->callback_error_message("auth must be an array of strings");
+			return false;
+		}
+	}
+	// Copy the resulting pointers to the return arguments.
+	*p_auth_sz = auth_sz;
+	*p_auth = auth;
+	// Everything worked ok.
+	return true;
 }
 
 bool
 Operation :: set_auth_context(v8::Handle<v8::Value> &_value)
 {
-    // Clear the authorization context if it's already been set (wierd).
-    this->clear_auth_context();
-    size_t auth_sz;
-
-    // Convert the authorization context object to an array of character
-    // pointers.
-    if (this->convert_auth_context(_value, &this->m_auth, &auth_sz))
-    {
-        // Call hyperdex client to set the authorization context.
-        hyperdex_client_set_auth_context(
-            this->client->client(),
-            this->m_auth, auth_sz
-        );
-        return true;
-    }
-    else
-    {
-        // Something went wrong during conversion!
-        return false;
-    }
+	// Clear the authorization context if it's already been set (wierd).
+	this->clear_auth_context();
+	size_t auth_sz;
+	// Convert the authorization context object to an array of character
+	// pointers.
+	if (this->convert_auth_context(_value, &this->m_auth, &auth_sz))
+	{
+		// Call hyperdex client to set the authorization context.
+		hyperdex_client_set_auth_context(
+		    this->client->client(),
+		    this->m_auth, auth_sz
+		);
+		return true;
+	}
+	else
+	{
+		// Something went wrong during conversion!
+		return false;
+	}
 }
 
 bool
 Operation :: clear_auth_context()
 {
-    // Make sure the authorization context has been set.
-    if (this->m_auth != NULL)
-    {
-        // Call hyperdex client to clear the authorization context.
-        hyperdex_client_clear_auth_context(this->client->client());
-
-        // Free the array.
-        free((void *)this->m_auth);
-        this->m_auth = NULL;
-    }
-
-    // this->m_auth is always null at this point, and if an array was there
-    // it was freed.
-    return true;
+	// Make sure the authorization context has been set.
+	if (this->m_auth != NULL)
+	{
+		// Call hyperdex client to clear the authorization context.
+		hyperdex_client_clear_auth_context(this->client->client());
+		// Free the array.
+		free((void *)this->m_auth);
+		this->m_auth = NULL;
+	}
+	// this->m_auth is always null at this point, and if an array was there
+	// it was freed.
+	return true;
 }
 
 bool
-Operation :: build_string(const char* value, size_t value_sz,
-                          v8::Local<v8::Value>& retval,
-                          v8::Local<v8::Value>& error)
-{
-    node::Buffer* buf = node::Buffer::New(value_sz);
-    memmove(node::Buffer::Data(buf), value, value_sz);
-    v8::Local<v8::Object> global = v8::Context::GetCurrent()->Global();
-    v8::Local<v8::Function> buf_ctor
-        = v8::Local<v8::Function>::Cast(global->Get(v8::String::NewSymbol("Buffer")));
-    v8::Local<v8::Integer> A(v8::Integer::New(value_sz));
-    v8::Local<v8::Integer> B(v8::Integer::New(0));
-    v8::Handle<v8::Value> argv[3] = { buf->handle_, A, B };
-    v8::Local<v8::Object> jsbuf = buf_ctor->NewInstance(3, argv);
-    retval = jsbuf;
-    return true;
+Operation :: build_string(const char *value, size_t value_sz,
+                          v8::Local<v8::Value> &retval,
+                          v8::Local<v8::Value> &error)
+{
+	node::Buffer *buf = node::Buffer::New(value_sz);
+	memmove(node::Buffer::Data(buf), value, value_sz);
+	v8::Local<v8::Object> global = v8::Context::GetCurrent()->Global();
+	v8::Local<v8::Function> buf_ctor
+	    = v8::Local<v8::Function>::Cast(global->Get(v8::String::NewSymbol("Buffer")));
+	v8::Local<v8::Integer> A(v8::Integer::New(value_sz));
+	v8::Local<v8::Integer> B(v8::Integer::New(0));
+	v8::Handle<v8::Value> argv[3] = { buf->handle_, A, B };
+	v8::Local<v8::Object> jsbuf = buf_ctor->NewInstance(3, argv);
+	retval = jsbuf;
+	return true;
 }
 
 bool
-Operation :: build_int(const char* value, size_t value_sz,
-                       v8::Local<v8::Value>& retval,
-                       v8::Local<v8::Value>& error)
+Operation :: build_int(const char *value, size_t value_sz,
+                       v8::Local<v8::Value> &retval,
+                       v8::Local<v8::Value> &error)
 {
-    int64_t tmp;
-
-    if (hyperdex_ds_unpack_int(value, value_sz, &tmp) < 0)
-    {
-        return false;
-    }
-
-    retval = v8::Integer::New(tmp);
-    return true;
+	int64_t tmp;
+	if (hyperdex_ds_unpack_int(value, value_sz, &tmp) < 0)
+	{
+		return false;
+	}
+	retval = v8::Integer::New(tmp);
+	return true;
 }
 
 bool
-Operation :: build_float(const char* value, size_t value_sz,
-                         v8::Local<v8::Value>& retval,
-                         v8::Local<v8::Value>& error)
+Operation :: build_float(const char *value, size_t value_sz,
+                         v8::Local<v8::Value> &retval,
+                         v8::Local<v8::Value> &error)
 {
-    double tmp;
-
-    if (hyperdex_ds_unpack_float(value, value_sz, &tmp) < 0)
-    {
-        return false;
-    }
-
-    retval = v8::Number::New(tmp);
-    return true;
+	double tmp;
+	if (hyperdex_ds_unpack_float(value, value_sz, &tmp) < 0)
+	{
+		return false;
+	}
+	retval = v8::Number::New(tmp);
+	return true;
 }
 
 bool
-Operation :: build_document(const char* value, size_t value_sz,
-                            v8::Local<v8::Value>& retval,
-                            v8::Local<v8::Value>& error)
+Operation :: build_document(const char *value, size_t value_sz,
+                            v8::Local<v8::Value> &retval,
+                            v8::Local<v8::Value> &error)
 {
-    v8::Local<v8::Object> global = v8::Context::GetCurrent()->Global();
-    v8::Local<v8::Object> JSON = global->Get(v8::String::New("JSON"))->ToObject();
-    v8::Handle<v8::Function> parse = v8::Handle<v8::Function>::Cast(JSON->Get(v8::String::New("parse")));
-    v8::Local<v8::String> str(v8::String::New(value, value_sz));
-    v8::Handle<v8::Value> argv[1] = { str };
-    retval = v8::Local<v8::Value>::New(parse->Call(JSON, 1, argv));
-    return true;
+	v8::Local<v8::Object> global = v8::Context::GetCurrent()->Global();
+	v8::Local<v8::Object> JSON = global->Get(v8::String::New("JSON"))->ToObject();
+	v8::Handle<v8::Function> parse = v8::Handle<v8::Function>::Cast(JSON->Get(v8::String::New("parse")));
+	v8::Local<v8::String> str(v8::String::New(value, value_sz));
+	v8::Handle<v8::Value> argv[1] = { str };
+	retval = v8::Local<v8::Value>::New(parse->Call(JSON, 1, argv));
+	return true;
 }
 
 bool
-Operation :: build_list_string(const char* value, size_t value_sz,
-                               v8::Local<v8::Value>& retval,
-                               v8::Local<v8::Value>& error)
-{
-    hyperdex_ds_iterator iter;
-    hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_LIST_STRING, value, value_sz);
-    const char* tmp_str = NULL;
-    size_t tmp_str_sz = 0;
-    size_t len = 0;
-    int result = 0;
-
-    while ((result = hyperdex_ds_iterate_list_string_next(&iter, &tmp_str, &tmp_str_sz)) > 0)
-    {
-        ++len;
-    }
-
-    if (result < 0)
-    {
-        error = error_message("server sent malformed list(string)");
-        return false;
-    }
-
-    hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_LIST_STRING, value, value_sz);
-    v8::Local<v8::Array> arr(v8::Array::New(len));
-    size_t idx = 0;
-
-    while ((result = hyperdex_ds_iterate_list_string_next(&iter, &tmp_str, &tmp_str_sz)) > 0)
-    {
-        v8::Local<v8::Value> elem;
-
-        if (!build_string(tmp_str, tmp_str_sz, elem, error))
-        {
-            return false;
-        }
-
-        arr->Set(idx, elem);
-        ++idx;
-    }
-
-    retval = arr;
-    return true;
+Operation :: build_list_string(const char *value, size_t value_sz,
+                               v8::Local<v8::Value> &retval,
+                               v8::Local<v8::Value> &error)
+{
+	hyperdex_ds_iterator iter;
+	hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_LIST_STRING, value, value_sz);
+	const char *tmp_str = NULL;
+	size_t tmp_str_sz = 0;
+	size_t len = 0;
+	int result = 0;
+	while ((result = hyperdex_ds_iterate_list_string_next(&iter, &tmp_str, &tmp_str_sz)) > 0)
+	{
+		++len;
+	}
+	if (result < 0)
+	{
+		error = error_message("server sent malformed list(string)");
+		return false;
+	}
+	hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_LIST_STRING, value, value_sz);
+	v8::Local<v8::Array> arr(v8::Array::New(len));
+	size_t idx = 0;
+	while ((result = hyperdex_ds_iterate_list_string_next(&iter, &tmp_str, &tmp_str_sz)) > 0)
+	{
+		v8::Local<v8::Value> elem;
+		if (!build_string(tmp_str, tmp_str_sz, elem, error))
+		{
+			return false;
+		}
+		arr->Set(idx, elem);
+		++idx;
+	}
+	retval = arr;
+	return true;
 }
 
 bool
-Operation :: build_list_int(const char* value, size_t value_sz,
-                            v8::Local<v8::Value>& retval,
-                            v8::Local<v8::Value>& error)
-{
-    hyperdex_ds_iterator iter;
-    hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_LIST_INT64, value, value_sz);
-    int64_t tmp;
-    size_t len = 0;
-    int result = 0;
-
-    while ((result = hyperdex_ds_iterate_list_int_next(&iter, &tmp)) > 0)
-    {
-        ++len;
-    }
-
-    if (result < 0)
-    {
-        error = error_message("server sent malformed list(int)");
-        return false;
-    }
-
-    hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_LIST_INT64, value, value_sz);
-    v8::Local<v8::Array> arr(v8::Array::New(len));
-    size_t idx = 0;
-
-    while ((result = hyperdex_ds_iterate_list_int_next(&iter, &tmp)) > 0)
-    {
-        v8::Local<v8::Value> elem(v8::Integer::New(tmp));
-        arr->Set(idx, elem);
-        ++idx;
-    }
-
-    retval = arr;
-    return true;
+Operation :: build_list_int(const char *value, size_t value_sz,
+                            v8::Local<v8::Value> &retval,
+                            v8::Local<v8::Value> &error)
+{
+	hyperdex_ds_iterator iter;
+	hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_LIST_INT64, value, value_sz);
+	int64_t tmp;
+	size_t len = 0;
+	int result = 0;
+	while ((result = hyperdex_ds_iterate_list_int_next(&iter, &tmp)) > 0)
+	{
+		++len;
+	}
+	if (result < 0)
+	{
+		error = error_message("server sent malformed list(int)");
+		return false;
+	}
+	hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_LIST_INT64, value, value_sz);
+	v8::Local<v8::Array> arr(v8::Array::New(len));
+	size_t idx = 0;
+	while ((result = hyperdex_ds_iterate_list_int_next(&iter, &tmp)) > 0)
+	{
+		v8::Local<v8::Value> elem(v8::Integer::New(tmp));
+		arr->Set(idx, elem);
+		++idx;
+	}
+	retval = arr;
+	return true;
 }
 
 bool
-Operation :: build_list_float(const char* value, size_t value_sz,
-                              v8::Local<v8::Value>& retval,
-                              v8::Local<v8::Value>& error)
-{
-    hyperdex_ds_iterator iter;
-    hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_LIST_FLOAT, value, value_sz);
-    double tmp;
-    size_t len = 0;
-    int result = 0;
-
-    while ((result = hyperdex_ds_iterate_list_float_next(&iter, &tmp)) > 0)
-    {
-        ++len;
-    }
-
-    if (result < 0)
-    {
-        error = error_message("server sent malformed list(float)");
-        return false;
-    }
-
-    hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_LIST_FLOAT, value, value_sz);
-    v8::Local<v8::Array> arr(v8::Array::New(len));
-    size_t idx = 0;
-
-    while ((result = hyperdex_ds_iterate_list_float_next(&iter, &tmp)) > 0)
-    {
-        v8::Local<v8::Value> elem(v8::Number::New(tmp));
-        arr->Set(idx, elem);
-        ++idx;
-    }
-
-    retval = arr;
-    return true;
+Operation :: build_list_float(const char *value, size_t value_sz,
+                              v8::Local<v8::Value> &retval,
+                              v8::Local<v8::Value> &error)
+{
+	hyperdex_ds_iterator iter;
+	hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_LIST_FLOAT, value, value_sz);
+	double tmp;
+	size_t len = 0;
+	int result = 0;
+	while ((result = hyperdex_ds_iterate_list_float_next(&iter, &tmp)) > 0)
+	{
+		++len;
+	}
+	if (result < 0)
+	{
+		error = error_message("server sent malformed list(float)");
+		return false;
+	}
+	hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_LIST_FLOAT, value, value_sz);
+	v8::Local<v8::Array> arr(v8::Array::New(len));
+	size_t idx = 0;
+	while ((result = hyperdex_ds_iterate_list_float_next(&iter, &tmp)) > 0)
+	{
+		v8::Local<v8::Value> elem(v8::Number::New(tmp));
+		arr->Set(idx, elem);
+		++idx;
+	}
+	retval = arr;
+	return true;
 }
 
 bool
-Operation :: build_set_string(const char* value, size_t value_sz,
-                               v8::Local<v8::Value>& retval,
-                               v8::Local<v8::Value>& error)
-{
-    hyperdex_ds_iterator iter;
-    hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_SET_STRING, value, value_sz);
-    const char* tmp_str = NULL;
-    size_t tmp_str_sz = 0;
-    size_t len = 0;
-    int result = 0;
-
-    while ((result = hyperdex_ds_iterate_set_string_next(&iter, &tmp_str, &tmp_str_sz)) > 0)
-    {
-        ++len;
-    }
-
-    if (result < 0)
-    {
-        error = error_message("server sent malformed set(string)");
-        return false;
-    }
-
-    hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_SET_STRING, value, value_sz);
-    v8::Local<v8::Array> arr(v8::Array::New(len));
-    size_t idx = 0;
-
-    while ((result = hyperdex_ds_iterate_set_string_next(&iter, &tmp_str, &tmp_str_sz)) > 0)
-    {
-        v8::Local<v8::Value> elem;
-
-        if (!build_string(tmp_str, tmp_str_sz, elem, error))
-        {
-            return false;
-        }
-
-        arr->Set(idx, elem);
-        ++idx;
-    }
-
-    retval = arr;
-    return true;
+Operation :: build_set_string(const char *value, size_t value_sz,
+                              v8::Local<v8::Value> &retval,
+                              v8::Local<v8::Value> &error)
+{
+	hyperdex_ds_iterator iter;
+	hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_SET_STRING, value, value_sz);
+	const char *tmp_str = NULL;
+	size_t tmp_str_sz = 0;
+	size_t len = 0;
+	int result = 0;
+	while ((result = hyperdex_ds_iterate_set_string_next(&iter, &tmp_str, &tmp_str_sz)) > 0)
+	{
+		++len;
+	}
+	if (result < 0)
+	{
+		error = error_message("server sent malformed set(string)");
+		return false;
+	}
+	hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_SET_STRING, value, value_sz);
+	v8::Local<v8::Array> arr(v8::Array::New(len));
+	size_t idx = 0;
+	while ((result = hyperdex_ds_iterate_set_string_next(&iter, &tmp_str, &tmp_str_sz)) > 0)
+	{
+		v8::Local<v8::Value> elem;
+		if (!build_string(tmp_str, tmp_str_sz, elem, error))
+		{
+			return false;
+		}
+		arr->Set(idx, elem);
+		++idx;
+	}
+	retval = arr;
+	return true;
 }
 
 bool
-Operation :: build_set_int(const char* value, size_t value_sz,
-                            v8::Local<v8::Value>& retval,
-                            v8::Local<v8::Value>& error)
-{
-    hyperdex_ds_iterator iter;
-    hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_SET_INT64, value, value_sz);
-    int64_t tmp;
-    size_t len = 0;
-    int result = 0;
-
-    while ((result = hyperdex_ds_iterate_set_int_next(&iter, &tmp)) > 0)
-    {
-        ++len;
-    }
-
-    if (result < 0)
-    {
-        error = error_message("server sent malformed set(int)");
-        return false;
-    }
-
-    hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_SET_INT64, value, value_sz);
-    v8::Local<v8::Array> arr(v8::Array::New(len));
-    size_t idx = 0;
-
-    while ((result = hyperdex_ds_iterate_set_int_next(&iter, &tmp)) > 0)
-    {
-        v8::Local<v8::Value> elem(v8::Integer::New(tmp));
-        arr->Set(idx, elem);
-        ++idx;
-    }
-
-    retval = arr;
-    return true;
+Operation :: build_set_int(const char *value, size_t value_sz,
+                           v8::Local<v8::Value> &retval,
+                           v8::Local<v8::Value> &error)
+{
+	hyperdex_ds_iterator iter;
+	hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_SET_INT64, value, value_sz);
+	int64_t tmp;
+	size_t len = 0;
+	int result = 0;
+	while ((result = hyperdex_ds_iterate_set_int_next(&iter, &tmp)) > 0)
+	{
+		++len;
+	}
+	if (result < 0)
+	{
+		error = error_message("server sent malformed set(int)");
+		return false;
+	}
+	hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_SET_INT64, value, value_sz);
+	v8::Local<v8::Array> arr(v8::Array::New(len));
+	size_t idx = 0;
+	while ((result = hyperdex_ds_iterate_set_int_next(&iter, &tmp)) > 0)
+	{
+		v8::Local<v8::Value> elem(v8::Integer::New(tmp));
+		arr->Set(idx, elem);
+		++idx;
+	}
+	retval = arr;
+	return true;
 }
 
 bool
-Operation :: build_set_float(const char* value, size_t value_sz,
-                              v8::Local<v8::Value>& retval,
-                              v8::Local<v8::Value>& error)
-{
-    hyperdex_ds_iterator iter;
-    hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_SET_FLOAT, value, value_sz);
-    double tmp;
-    size_t len = 0;
-    int result = 0;
-
-    while ((result = hyperdex_ds_iterate_set_float_next(&iter, &tmp)) > 0)
-    {
-        ++len;
-    }
-
-    if (result < 0)
-    {
-        error = error_message("server sent malformed set(float)");
-        return false;
-    }
-
-    hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_SET_FLOAT, value, value_sz);
-    v8::Local<v8::Array> arr(v8::Array::New(len));
-    size_t idx = 0;
-
-    while ((result = hyperdex_ds_iterate_set_float_next(&iter, &tmp)) > 0)
-    {
-        v8::Local<v8::Value> elem(v8::Number::New(tmp));
-        arr->Set(idx, elem);
-        ++idx;
-    }
-
-    retval = arr;
-    return true;
+Operation :: build_set_float(const char *value, size_t value_sz,
+                             v8::Local<v8::Value> &retval,
+                             v8::Local<v8::Value> &error)
+{
+	hyperdex_ds_iterator iter;
+	hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_SET_FLOAT, value, value_sz);
+	double tmp;
+	size_t len = 0;
+	int result = 0;
+	while ((result = hyperdex_ds_iterate_set_float_next(&iter, &tmp)) > 0)
+	{
+		++len;
+	}
+	if (result < 0)
+	{
+		error = error_message("server sent malformed set(float)");
+		return false;
+	}
+	hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_SET_FLOAT, value, value_sz);
+	v8::Local<v8::Array> arr(v8::Array::New(len));
+	size_t idx = 0;
+	while ((result = hyperdex_ds_iterate_set_float_next(&iter, &tmp)) > 0)
+	{
+		v8::Local<v8::Value> elem(v8::Number::New(tmp));
+		arr->Set(idx, elem);
+		++idx;
+	}
+	retval = arr;
+	return true;
 }
 
 bool
-Operation :: build_map_string_string(const char* value, size_t value_sz,
-                                      v8::Local<v8::Value>& retval,
-                                      v8::Local<v8::Value>& error)
-{
-    hyperdex_ds_iterator iter;
-    hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_MAP_STRING_STRING, value, value_sz);
-    const char* k = NULL;
-    const char* v = NULL;
-    size_t k_sz = 0;
-    size_t v_sz = 0;
-    size_t len = 0;
-    int result = 0;
-
-    while ((result = hyperdex_ds_iterate_map_string_string_next(&iter, &k, &k_sz, &v, &v_sz)) > 0)
-    {
-        ++len;
-    }
-
-    if (result < 0)
-    {
-        error = error_message("server sent malformed map(string, string)");
-        return false;
-    }
-
-    hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_MAP_STRING_STRING, value, value_sz);
-    v8::Local<v8::Array> arr(v8::Array::New(len));
-    size_t idx = 0;
-
-    while ((result = hyperdex_ds_iterate_map_string_string_next(&iter, &k, &k_sz, &v, &v_sz)) > 0)
-    {
-        v8::Local<v8::Value> key;
-        v8::Local<v8::Value> val;
-
-        if (!build_string(k, k_sz, key, error) ||
-            !build_string(v, v_sz, val, error))
-        {
-            return false;
-        }
-
-        v8::Local<v8::Array> pair(v8::Array::New(2));
-        pair->Set(0, key);
-        pair->Set(1, val);
-        arr->Set(idx, pair);
-        ++idx;
-    }
-
-    retval = arr;
-    return true;
+Operation :: build_map_string_string(const char *value, size_t value_sz,
+                                     v8::Local<v8::Value> &retval,
+                                     v8::Local<v8::Value> &error)
+{
+	hyperdex_ds_iterator iter;
+	hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_MAP_STRING_STRING, value, value_sz);
+	const char *k = NULL;
+	const char *v = NULL;
+	size_t k_sz = 0;
+	size_t v_sz = 0;
+	size_t len = 0;
+	int result = 0;
+	while ((result = hyperdex_ds_iterate_map_string_string_next(&iter, &k, &k_sz, &v, &v_sz)) > 0)
+	{
+		++len;
+	}
+	if (result < 0)
+	{
+		error = error_message("server sent malformed map(string, string)");
+		return false;
+	}
+	hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_MAP_STRING_STRING, value, value_sz);
+	v8::Local<v8::Array> arr(v8::Array::New(len));
+	size_t idx = 0;
+	while ((result = hyperdex_ds_iterate_map_string_string_next(&iter, &k, &k_sz, &v, &v_sz)) > 0)
+	{
+		v8::Local<v8::Value> key;
+		v8::Local<v8::Value> val;
+		if (!build_string(k, k_sz, key, error) ||
+		    !build_string(v, v_sz, val, error))
+		{
+			return false;
+		}
+		v8::Local<v8::Array> pair(v8::Array::New(2));
+		pair->Set(0, key);
+		pair->Set(1, val);
+		arr->Set(idx, pair);
+		++idx;
+	}
+	retval = arr;
+	return true;
 }
 
 bool
-Operation :: build_map_string_int(const char* value, size_t value_sz,
-                                   v8::Local<v8::Value>& retval,
-                                   v8::Local<v8::Value>& error)
-{
-    hyperdex_ds_iterator iter;
-    hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_MAP_STRING_INT64, value, value_sz);
-    const char* k = NULL;
-    size_t k_sz = 0;
-    int64_t v;
-    size_t len = 0;
-    int result = 0;
-
-    while ((result = hyperdex_ds_iterate_map_string_int_next(&iter, &k, &k_sz, &v)) > 0)
-    {
-        ++len;
-    }
-
-    if (result < 0)
-    {
-        error = error_message("server sent malformed map(string, int)");
-        return false;
-    }
-
-    hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_MAP_STRING_INT64, value, value_sz);
-    v8::Local<v8::Array> arr(v8::Array::New(len));
-    size_t idx = 0;
-
-    while ((result = hyperdex_ds_iterate_map_string_int_next(&iter, &k, &k_sz, &v)) > 0)
-    {
-        v8::Local<v8::Value> key;
-        v8::Local<v8::Value> val(v8::Integer::New(v));
-
-        if (!build_string(k, k_sz, key, error))
-        {
-            return false;
-        }
-
-        v8::Local<v8::Array> pair(v8::Array::New(2));
-        pair->Set(0, key);
-        pair->Set(1, val);
-        arr->Set(idx, pair);
-        ++idx;
-    }
-
-    retval = arr;
-    return true;
+Operation :: build_map_string_int(const char *value, size_t value_sz,
+                                  v8::Local<v8::Value> &retval,
+                                  v8::Local<v8::Value> &error)
+{
+	hyperdex_ds_iterator iter;
+	hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_MAP_STRING_INT64, value, value_sz);
+	const char *k = NULL;
+	size_t k_sz = 0;
+	int64_t v;
+	size_t len = 0;
+	int result = 0;
+	while ((result = hyperdex_ds_iterate_map_string_int_next(&iter, &k, &k_sz, &v)) > 0)
+	{
+		++len;
+	}
+	if (result < 0)
+	{
+		error = error_message("server sent malformed map(string, int)");
+		return false;
+	}
+	hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_MAP_STRING_INT64, value, value_sz);
+	v8::Local<v8::Array> arr(v8::Array::New(len));
+	size_t idx = 0;
+	while ((result = hyperdex_ds_iterate_map_string_int_next(&iter, &k, &k_sz, &v)) > 0)
+	{
+		v8::Local<v8::Value> key;
+		v8::Local<v8::Value> val(v8::Integer::New(v));
+		if (!build_string(k, k_sz, key, error))
+		{
+			return false;
+		}
+		v8::Local<v8::Array> pair(v8::Array::New(2));
+		pair->Set(0, key);
+		pair->Set(1, val);
+		arr->Set(idx, pair);
+		++idx;
+	}
+	retval = arr;
+	return true;
 }
 
 bool
-Operation :: build_map_string_float(const char* value, size_t value_sz,
-                                     v8::Local<v8::Value>& retval,
-                                     v8::Local<v8::Value>& error)
-{
-    hyperdex_ds_iterator iter;
-    hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_MAP_STRING_FLOAT, value, value_sz);
-    const char* k = NULL;
-    size_t k_sz = 0;
-    double v;
-    size_t len = 0;
-    int result = 0;
-
-    while ((result = hyperdex_ds_iterate_map_string_float_next(&iter, &k, &k_sz, &v)) > 0)
-    {
-        ++len;
-    }
-
-    if (result < 0)
-    {
-        error = error_message("server sent malformed map(string, float)");
-        return false;
-    }
-
-    hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_MAP_STRING_FLOAT, value, value_sz);
-    v8::Local<v8::Array> arr(v8::Array::New(len));
-    size_t idx = 0;
-
-    while ((result = hyperdex_ds_iterate_map_string_float_next(&iter, &k, &k_sz, &v)) > 0)
-    {
-        v8::Local<v8::Value> key;
-        v8::Local<v8::Value> val(v8::Number::New(v));
-
-        if (!build_string(k, k_sz, key, error))
-        {
-            return false;
-        }
-
-        v8::Local<v8::Array> pair(v8::Array::New(2));
-        pair->Set(0, key);
-        pair->Set(1, val);
-        arr->Set(idx, pair);
-        ++idx;
-    }
-
-    retval = arr;
-    return true;
+Operation :: build_map_string_float(const char *value, size_t value_sz,
+                                    v8::Local<v8::Value> &retval,
+                                    v8::Local<v8::Value> &error)
+{
+	hyperdex_ds_iterator iter;
+	hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_MAP_STRING_FLOAT, value, value_sz);
+	const char *k = NULL;
+	size_t k_sz = 0;
+	double v;
+	size_t len = 0;
+	int result = 0;
+	while ((result = hyperdex_ds_iterate_map_string_float_next(&iter, &k, &k_sz, &v)) > 0)
+	{
+		++len;
+	}
+	if (result < 0)
+	{
+		error = error_message("server sent malformed map(string, float)");
+		return false;
+	}
+	hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_MAP_STRING_FLOAT, value, value_sz);
+	v8::Local<v8::Array> arr(v8::Array::New(len));
+	size_t idx = 0;
+	while ((result = hyperdex_ds_iterate_map_string_float_next(&iter, &k, &k_sz, &v)) > 0)
+	{
+		v8::Local<v8::Value> key;
+		v8::Local<v8::Value> val(v8::Number::New(v));
+		if (!build_string(k, k_sz, key, error))
+		{
+			return false;
+		}
+		v8::Local<v8::Array> pair(v8::Array::New(2));
+		pair->Set(0, key);
+		pair->Set(1, val);
+		arr->Set(idx, pair);
+		++idx;
+	}
+	retval = arr;
+	return true;
 }
 
 bool
-Operation :: build_map_int_string(const char* value, size_t value_sz,
-                                  v8::Local<v8::Value>& retval,
-                                  v8::Local<v8::Value>& error)
-{
-    hyperdex_ds_iterator iter;
-    hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_MAP_INT64_STRING, value, value_sz);
-    int64_t k;
-    const char* v = NULL;
-    size_t v_sz = 0;
-    size_t len = 0;
-    int result = 0;
-
-    while ((result = hyperdex_ds_iterate_map_int_string_next(&iter, &k, &v, &v_sz)) > 0)
-    {
-        ++len;
-    }
-
-    if (result < 0)
-    {
-        error = error_message("server sent malformed map(int, string)");
-        return false;
-    }
-
-    hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_MAP_INT64_STRING, value, value_sz);
-    v8::Local<v8::Array> arr(v8::Array::New(len));
-    size_t idx = 0;
-
-    while ((result = hyperdex_ds_iterate_map_int_string_next(&iter, &k, &v, &v_sz)) > 0)
-    {
-        v8::Local<v8::Value> key(v8::Integer::New(k));
-        v8::Local<v8::Value> val;
-
-        if (!build_string(v, v_sz, val, error))
-        {
-            return false;
-        }
-
-        v8::Local<v8::Array> pair(v8::Array::New(2));
-        pair->Set(0, key);
-        pair->Set(1, val);
-        arr->Set(idx, pair);
-        ++idx;
-    }
-
-    retval = arr;
-    return true;
+Operation :: build_map_int_string(const char *value, size_t value_sz,
+                                  v8::Local<v8::Value> &retval,
+                                  v8::Local<v8::Value> &error)
+{
+	hyperdex_ds_iterator iter;
+	hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_MAP_INT64_STRING, value, value_sz);
+	int64_t k;
+	const char *v = NULL;
+	size_t v_sz = 0;
+	size_t len = 0;
+	int result = 0;
+	while ((result = hyperdex_ds_iterate_map_int_string_next(&iter, &k, &v, &v_sz)) > 0)
+	{
+		++len;
+	}
+	if (result < 0)
+	{
+		error = error_message("server sent malformed map(int, string)");
+		return false;
+	}
+	hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_MAP_INT64_STRING, value, value_sz);
+	v8::Local<v8::Array> arr(v8::Array::New(len));
+	size_t idx = 0;
+	while ((result = hyperdex_ds_iterate_map_int_string_next(&iter, &k, &v, &v_sz)) > 0)
+	{
+		v8::Local<v8::Value> key(v8::Integer::New(k));
+		v8::Local<v8::Value> val;
+		if (!build_string(v, v_sz, val, error))
+		{
+			return false;
+		}
+		v8::Local<v8::Array> pair(v8::Array::New(2));
+		pair->Set(0, key);
+		pair->Set(1, val);
+		arr->Set(idx, pair);
+		++idx;
+	}
+	retval = arr;
+	return true;
 }
 
 bool
-Operation :: build_map_int_int(const char* value, size_t value_sz,
-                               v8::Local<v8::Value>& retval,
-                               v8::Local<v8::Value>& error)
-{
-    hyperdex_ds_iterator iter;
-    hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_MAP_INT64_INT64, value, value_sz);
-    int64_t k;
-    int64_t v;
-    size_t len = 0;
-    int result = 0;
-
-    while ((result = hyperdex_ds_iterate_map_int_int_next(&iter, &k, &v)) > 0)
-    {
-        ++len;
-    }
-
-    if (result < 0)
-    {
-        error = error_message("server sent malformed map(int, int)");
-        return false;
-    }
-
-    hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_MAP_INT64_INT64, value, value_sz);
-    v8::Local<v8::Array> arr(v8::Array::New(len));
-    size_t idx = 0;
-
-    while ((result = hyperdex_ds_iterate_map_int_int_next(&iter, &k, &v)) > 0)
-    {
-        v8::Local<v8::Value> key(v8::Integer::New(k));
-        v8::Local<v8::Value> val(v8::Integer::New(v));
-        v8::Local<v8::Array> pair(v8::Array::New(2));
-        pair->Set(0, key);
-        pair->Set(1, val);
-        arr->Set(idx, pair);
-        ++idx;
-    }
-
-    retval = arr;
-    return true;
+Operation :: build_map_int_int(const char *value, size_t value_sz,
+                               v8::Local<v8::Value> &retval,
+                               v8::Local<v8::Value> &error)
+{
+	hyperdex_ds_iterator iter;
+	hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_MAP_INT64_INT64, value, value_sz);
+	int64_t k;
+	int64_t v;
+	size_t len = 0;
+	int result = 0;
+	while ((result = hyperdex_ds_iterate_map_int_int_next(&iter, &k, &v)) > 0)
+	{
+		++len;
+	}
+	if (result < 0)
+	{
+		error = error_message("server sent malformed map(int, int)");
+		return false;
+	}
+	hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_MAP_INT64_INT64, value, value_sz);
+	v8::Local<v8::Array> arr(v8::Array::New(len));
+	size_t idx = 0;
+	while ((result = hyperdex_ds_iterate_map_int_int_next(&iter, &k, &v)) > 0)
+	{
+		v8::Local<v8::Value> key(v8::Integer::New(k));
+		v8::Local<v8::Value> val(v8::Integer::New(v));
+		v8::Local<v8::Array> pair(v8::Array::New(2));
+		pair->Set(0, key);
+		pair->Set(1, val);
+		arr->Set(idx, pair);
+		++idx;
+	}
+	retval = arr;
+	return true;
 }
 
 bool
-Operation :: build_map_int_float(const char* value, size_t value_sz,
-                                 v8::Local<v8::Value>& retval,
-                                 v8::Local<v8::Value>& error)
-{
-    hyperdex_ds_iterator iter;
-    hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_MAP_INT64_FLOAT, value, value_sz);
-    int64_t k;
-    double v;
-    size_t len = 0;
-    int result = 0;
-
-    while ((result = hyperdex_ds_iterate_map_int_float_next(&iter, &k, &v)) > 0)
-    {
-        ++len;
-    }
-
-    if (result < 0)
-    {
-        error = error_message("server sent malformed map(int, float)");
-        return false;
-    }
-
-    hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_MAP_INT64_FLOAT, value, value_sz);
-    v8::Local<v8::Array> arr(v8::Array::New(len));
-    size_t idx = 0;
-
-    while ((result = hyperdex_ds_iterate_map_int_float_next(&iter, &k, &v)) > 0)
-    {
-        v8::Local<v8::Value> key(v8::Integer::New(k));
-        v8::Local<v8::Value> val(v8::Number::New(v));
-        v8::Local<v8::Array> pair(v8::Array::New(2));
-        pair->Set(0, key);
-        pair->Set(1, val);
-        arr->Set(idx, pair);
-        ++idx;
-    }
-
-    retval = arr;
-    return true;
+Operation :: build_map_int_float(const char *value, size_t value_sz,
+                                 v8::Local<v8::Value> &retval,
+                                 v8::Local<v8::Value> &error)
+{
+	hyperdex_ds_iterator iter;
+	hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_MAP_INT64_FLOAT, value, value_sz);
+	int64_t k;
+	double v;
+	size_t len = 0;
+	int result = 0;
+	while ((result = hyperdex_ds_iterate_map_int_float_next(&iter, &k, &v)) > 0)
+	{
+		++len;
+	}
+	if (result < 0)
+	{
+		error = error_message("server sent malformed map(int, float)");
+		return false;
+	}
+	hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_MAP_INT64_FLOAT, value, value_sz);
+	v8::Local<v8::Array> arr(v8::Array::New(len));
+	size_t idx = 0;
+	while ((result = hyperdex_ds_iterate_map_int_float_next(&iter, &k, &v)) > 0)
+	{
+		v8::Local<v8::Value> key(v8::Integer::New(k));
+		v8::Local<v8::Value> val(v8::Number::New(v));
+		v8::Local<v8::Array> pair(v8::Array::New(2));
+		pair->Set(0, key);
+		pair->Set(1, val);
+		arr->Set(idx, pair);
+		++idx;
+	}
+	retval = arr;
+	return true;
 }
 
 bool
-Operation :: build_map_float_string(const char* value, size_t value_sz,
-                                    v8::Local<v8::Value>& retval,
-                                    v8::Local<v8::Value>& error)
-{
-    hyperdex_ds_iterator iter;
-    hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_MAP_FLOAT_STRING, value, value_sz);
-    double k;
-    const char* v = NULL;
-    size_t v_sz = 0;
-    size_t len = 0;
-    int result = 0;
-
-    while ((result = hyperdex_ds_iterate_map_float_string_next(&iter, &k, &v, &v_sz)) > 0)
-    {
-        ++len;
-    }
-
-    if (result < 0)
-    {
-        error = error_message("server sent malformed map(float, string)");
-        return false;
-    }
-
-    hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_MAP_FLOAT_STRING, value, value_sz);
-    v8::Local<v8::Array> arr(v8::Array::New(len));
-    size_t idx = 0;
-
-    while ((result = hyperdex_ds_iterate_map_float_string_next(&iter, &k, &v, &v_sz)) > 0)
-    {
-        v8::Local<v8::Value> key(v8::Number::New(k));
-        v8::Local<v8::Value> val;
-
-        if (!build_string(v, v_sz, val, error))
-        {
-            return false;
-        }
-
-        v8::Local<v8::Array> pair(v8::Array::New(2));
-        pair->Set(0, key);
-        pair->Set(1, val);
-        arr->Set(idx, pair);
-        ++idx;
-    }
-
-    retval = arr;
-    return true;
+Operation :: build_map_float_string(const char *value, size_t value_sz,
+                                    v8::Local<v8::Value> &retval,
+                                    v8::Local<v8::Value> &error)
+{
+	hyperdex_ds_iterator iter;
+	hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_MAP_FLOAT_STRING, value, value_sz);
+	double k;
+	const char *v = NULL;
+	size_t v_sz = 0;
+	size_t len = 0;
+	int result = 0;
+	while ((result = hyperdex_ds_iterate_map_float_string_next(&iter, &k, &v, &v_sz)) > 0)
+	{
+		++len;
+	}
+	if (result < 0)
+	{
+		error = error_message("server sent malformed map(float, string)");
+		return false;
+	}
+	hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_MAP_FLOAT_STRING, value, value_sz);
+	v8::Local<v8::Array> arr(v8::Array::New(len));
+	size_t idx = 0;
+	while ((result = hyperdex_ds_iterate_map_float_string_next(&iter, &k, &v, &v_sz)) > 0)
+	{
+		v8::Local<v8::Value> key(v8::Number::New(k));
+		v8::Local<v8::Value> val;
+		if (!build_string(v, v_sz, val, error))
+		{
+			return false;
+		}
+		v8::Local<v8::Array> pair(v8::Array::New(2));
+		pair->Set(0, key);
+		pair->Set(1, val);
+		arr->Set(idx, pair);
+		++idx;
+	}
+	retval = arr;
+	return true;
 }
 
 bool
-Operation :: build_map_float_int(const char* value, size_t value_sz,
-                                 v8::Local<v8::Value>& retval,
-                                 v8::Local<v8::Value>& error)
-{
-    hyperdex_ds_iterator iter;
-    hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_MAP_FLOAT_INT64, value, value_sz);
-    double k;
-    int64_t v;
-    size_t len = 0;
-    int result = 0;
-
-    while ((result = hyperdex_ds_iterate_map_float_int_next(&iter, &k, &v)) > 0)
-    {
-        ++len;
-    }
-
-    if (result < 0)
-    {
-        error = error_message("server sent malformed map(float, int)");
-        return false;
-    }
-
-    hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_MAP_FLOAT_INT64, value, value_sz);
-    v8::Local<v8::Array> arr(v8::Array::New(len));
-    size_t idx = 0;
-
-    while ((result = hyperdex_ds_iterate_map_float_int_next(&iter, &k, &v)) > 0)
-    {
-        v8::Local<v8::Value> key(v8::Number::New(k));
-        v8::Local<v8::Value> val(v8::Integer::New(v));
-        v8::Local<v8::Array> pair(v8::Array::New(2));
-        pair->Set(0, key);
-        pair->Set(1, val);
-        arr->Set(idx, pair);
-        ++idx;
-    }
-
-    retval = arr;
-    return true;
+Operation :: build_map_float_int(const char *value, size_t value_sz,
+                                 v8::Local<v8::Value> &retval,
+                                 v8::Local<v8::Value> &error)
+{
+	hyperdex_ds_iterator iter;
+	hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_MAP_FLOAT_INT64, value, value_sz);
+	double k;
+	int64_t v;
+	size_t len = 0;
+	int result = 0;
+	while ((result = hyperdex_ds_iterate_map_float_int_next(&iter, &k, &v)) > 0)
+	{
+		++len;
+	}
+	if (result < 0)
+	{
+		error = error_message("server sent malformed map(float, int)");
+		return false;
+	}
+	hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_MAP_FLOAT_INT64, value, value_sz);
+	v8::Local<v8::Array> arr(v8::Array::New(len));
+	size_t idx = 0;
+	while ((result = hyperdex_ds_iterate_map_float_int_next(&iter, &k, &v)) > 0)
+	{
+		v8::Local<v8::Value> key(v8::Number::New(k));
+		v8::Local<v8::Value> val(v8::Integer::New(v));
+		v8::Local<v8::Array> pair(v8::Array::New(2));
+		pair->Set(0, key);
+		pair->Set(1, val);
+		arr->Set(idx, pair);
+		++idx;
+	}
+	retval = arr;
+	return true;
 }
 
 bool
-Operation :: build_map_float_float(const char* value, size_t value_sz,
-                                   v8::Local<v8::Value>& retval,
-                                   v8::Local<v8::Value>& error)
-{
-    hyperdex_ds_iterator iter;
-    hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_MAP_FLOAT_FLOAT, value, value_sz);
-    double k;
-    double v;
-    size_t len = 0;
-    int result = 0;
-
-    while ((result = hyperdex_ds_iterate_map_float_float_next(&iter, &k, &v)) > 0)
-    {
-        ++len;
-    }
-
-    if (result < 0)
-    {
-        error = error_message("server sent malformed map(float, float)");
-        return false;
-    }
-
-    hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_MAP_FLOAT_FLOAT, value, value_sz);
-    v8::Local<v8::Array> arr(v8::Array::New(len));
-    size_t idx = 0;
-
-    while ((result = hyperdex_ds_iterate_map_float_float_next(&iter, &k, &v)) > 0)
-    {
-        v8::Local<v8::Value> key(v8::Number::New(k));
-        v8::Local<v8::Value> val(v8::Number::New(v));
-        v8::Local<v8::Array> pair(v8::Array::New(2));
-        pair->Set(0, key);
-        pair->Set(1, val);
-        arr->Set(idx, pair);
-        ++idx;
-    }
-
-    retval = arr;
-    return true;
+Operation :: build_map_float_float(const char *value, size_t value_sz,
+                                   v8::Local<v8::Value> &retval,
+                                   v8::Local<v8::Value> &error)
+{
+	hyperdex_ds_iterator iter;
+	hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_MAP_FLOAT_FLOAT, value, value_sz);
+	double k;
+	double v;
+	size_t len = 0;
+	int result = 0;
+	while ((result = hyperdex_ds_iterate_map_float_float_next(&iter, &k, &v)) > 0)
+	{
+		++len;
+	}
+	if (result < 0)
+	{
+		error = error_message("server sent malformed map(float, float)");
+		return false;
+	}
+	hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_MAP_FLOAT_FLOAT, value, value_sz);
+	v8::Local<v8::Array> arr(v8::Array::New(len));
+	size_t idx = 0;
+	while ((result = hyperdex_ds_iterate_map_float_float_next(&iter, &k, &v)) > 0)
+	{
+		v8::Local<v8::Value> key(v8::Number::New(k));
+		v8::Local<v8::Value> val(v8::Number::New(v));
+		v8::Local<v8::Array> pair(v8::Array::New(2));
+		pair->Set(0, key);
+		pair->Set(1, val);
+		arr->Set(idx, pair);
+		++idx;
+	}
+	retval = arr;
+	return true;
 }
 
 bool
-Operation :: build_attribute(const hyperdex_client_attribute* attr,
-                             v8::Local<v8::Value>& retval,
-                             v8::Local<v8::Value>& error)
-{
-    switch (attr->datatype)
-    {
-        case HYPERDATATYPE_STRING:
-            return build_string(attr->value, attr->value_sz, retval, error);
-        case HYPERDATATYPE_INT64:
-            return build_int(attr->value, attr->value_sz, retval, error);
-        case HYPERDATATYPE_FLOAT:
-            return build_float(attr->value, attr->value_sz, retval, error);
-        case HYPERDATATYPE_DOCUMENT:
-            return build_document(attr->value, attr->value_sz, retval, error);
-        case HYPERDATATYPE_LIST_STRING:
-            return build_list_string(attr->value, attr->value_sz, retval, error);
-        case HYPERDATATYPE_LIST_INT64:
-            return build_list_int(attr->value, attr->value_sz, retval, error);
-        case HYPERDATATYPE_LIST_FLOAT:
-            return build_list_float(attr->value, attr->value_sz, retval, error);
-        case HYPERDATATYPE_SET_STRING:
-            return build_set_string(attr->value, attr->value_sz, retval, error);
-        case HYPERDATATYPE_SET_INT64:
-            return build_set_int(attr->value, attr->value_sz, retval, error);
-        case HYPERDATATYPE_SET_FLOAT:
-            return build_set_float(attr->value, attr->value_sz, retval, error);
-        case HYPERDATATYPE_MAP_STRING_STRING:
-            return build_map_string_string(attr->value, attr->value_sz, retval, error);
-        case HYPERDATATYPE_MAP_STRING_INT64:
-            return build_map_string_int(attr->value, attr->value_sz, retval, error);
-        case HYPERDATATYPE_MAP_STRING_FLOAT:
-            return build_map_string_float(attr->value, attr->value_sz, retval, error);
-        case HYPERDATATYPE_MAP_INT64_STRING:
-            return build_map_int_string(attr->value, attr->value_sz, retval, error);
-        case HYPERDATATYPE_MAP_INT64_INT64:
-            return build_map_int_int(attr->value, attr->value_sz, retval, error);
-        case HYPERDATATYPE_MAP_INT64_FLOAT:
-            return build_map_int_float(attr->value, attr->value_sz, retval, error);
-        case HYPERDATATYPE_MAP_FLOAT_STRING:
-            return build_map_float_string(attr->value, attr->value_sz, retval, error);
-        case HYPERDATATYPE_MAP_FLOAT_INT64:
-            return build_map_float_int(attr->value, attr->value_sz, retval, error);
-        case HYPERDATATYPE_MAP_FLOAT_FLOAT:
-            return build_map_float_float(attr->value, attr->value_sz, retval, error);
-        case HYPERDATATYPE_GENERIC:
-        case HYPERDATATYPE_LIST_GENERIC:
-        case HYPERDATATYPE_SET_GENERIC:
-        case HYPERDATATYPE_MAP_GENERIC:
-        case HYPERDATATYPE_MAP_STRING_KEYONLY:
-        case HYPERDATATYPE_MAP_INT64_KEYONLY:
-        case HYPERDATATYPE_MAP_FLOAT_KEYONLY:
-        case HYPERDATATYPE_GARBAGE:
-        default:
-            error = this->error_message("server sent malformed attributes");
-            return false;
-    }
+Operation :: build_attribute(const hyperdex_client_attribute *attr,
+                             v8::Local<v8::Value> &retval,
+                             v8::Local<v8::Value> &error)
+{
+	switch (attr->datatype)
+	{
+	case HYPERDATATYPE_STRING:
+		return build_string(attr->value, attr->value_sz, retval, error);
+	case HYPERDATATYPE_INT64:
+		return build_int(attr->value, attr->value_sz, retval, error);
+	case HYPERDATATYPE_FLOAT:
+		return build_float(attr->value, attr->value_sz, retval, error);
+	case HYPERDATATYPE_DOCUMENT:
+		return build_document(attr->value, attr->value_sz, retval, error);
+	case HYPERDATATYPE_LIST_STRING:
+		return build_list_string(attr->value, attr->value_sz, retval, error);
+	case HYPERDATATYPE_LIST_INT64:
+		return build_list_int(attr->value, attr->value_sz, retval, error);
+	case HYPERDATATYPE_LIST_FLOAT:
+		return build_list_float(attr->value, attr->value_sz, retval, error);
+	case HYPERDATATYPE_SET_STRING:
+		return build_set_string(attr->value, attr->value_sz, retval, error);
+	case HYPERDATATYPE_SET_INT64:
+		return build_set_int(attr->value, attr->value_sz, retval, error);
+	case HYPERDATATYPE_SET_FLOAT:
+		return build_set_float(attr->value, attr->value_sz, retval, error);
+	case HYPERDATATYPE_MAP_STRING_STRING:
+		return build_map_string_string(attr->value, attr->value_sz, retval, error);
+	case HYPERDATATYPE_MAP_STRING_INT64:
+		return build_map_string_int(attr->value, attr->value_sz, retval, error);
+	case HYPERDATATYPE_MAP_STRING_FLOAT:
+		return build_map_string_float(attr->value, attr->value_sz, retval, error);
+	case HYPERDATATYPE_MAP_INT64_STRING:
+		return build_map_int_string(attr->value, attr->value_sz, retval, error);
+	case HYPERDATATYPE_MAP_INT64_INT64:
+		return build_map_int_int(attr->value, attr->value_sz, retval, error);
+	case HYPERDATATYPE_MAP_INT64_FLOAT:
+		return build_map_int_float(attr->value, attr->value_sz, retval, error);
+	case HYPERDATATYPE_MAP_FLOAT_STRING:
+		return build_map_float_string(attr->value, attr->value_sz, retval, error);
+	case HYPERDATATYPE_MAP_FLOAT_INT64:
+		return build_map_float_int(attr->value, attr->value_sz, retval, error);
+	case HYPERDATATYPE_MAP_FLOAT_FLOAT:
+		return build_map_float_float(attr->value, attr->value_sz, retval, error);
+	case HYPERDATATYPE_GENERIC:
+	case HYPERDATATYPE_LIST_GENERIC:
+	case HYPERDATATYPE_SET_GENERIC:
+	case HYPERDATATYPE_MAP_GENERIC:
+	case HYPERDATATYPE_MAP_STRING_KEYONLY:
+	case HYPERDATATYPE_MAP_INT64_KEYONLY:
+	case HYPERDATATYPE_MAP_FLOAT_KEYONLY:
+	case HYPERDATATYPE_GARBAGE:
+	default:
+		error = this->error_message("server sent malformed attributes");
+		return false;
+	}
 }
 
 void
-Operation :: build_attributes(v8::Local<v8::Value>& retval,
-                              v8::Local<v8::Value>& error)
-{
-    v8::Local<v8::Object> obj(v8::Object::New());
-
-    for (size_t i = 0; i < attrs_sz; ++i)
-    {
-        v8::Local<v8::Value> val;
-
-        if (!build_attribute(attrs + i, val, error))
-        {
-            retval = v8::Local<v8::Value>::New(v8::Undefined());
-            return;
-        }
-
-        obj->Set(v8::String::New(attrs[i].attr), val);
-    }
-
-    if (attrs)
-    {
-        hyperdex_client_destroy_attrs(attrs, attrs_sz);
-        attrs = NULL;
-        attrs_sz = 0;
-    }
-
-    retval = obj;
-    error = v8::Local<v8::Value>::New(v8::Undefined());
+Operation :: build_attributes(v8::Local<v8::Value> &retval,
+                              v8::Local<v8::Value> &error)
+{
+	v8::Local<v8::Object> obj(v8::Object::New());
+	for (size_t i = 0; i < attrs_sz; ++i)
+	{
+		v8::Local<v8::Value> val;
+		if (!build_attribute(attrs + i, val, error))
+		{
+			retval = v8::Local<v8::Value>::New(v8::Undefined());
+			return;
+		}
+		obj->Set(v8::String::New(attrs[i].attr), val);
+	}
+	if (attrs)
+	{
+		hyperdex_client_destroy_attrs(attrs, attrs_sz);
+		attrs = NULL;
+		attrs_sz = 0;
+	}
+	retval = obj;
+	error = v8::Local<v8::Value>::New(v8::Undefined());
 }
 
 void
 Operation :: encode_asynccall_status()
 {
-    v8::Local<v8::Value> retval;
-    v8::Local<v8::Value> error;
-
-    if (status == HYPERDEX_CLIENT_SUCCESS)
-    {
-        retval = v8::Local<v8::Value>::New(v8::True());
-        error = v8::Local<v8::Value>::New(v8::Undefined());
-    }
-    else if (status == HYPERDEX_CLIENT_NOTFOUND)
-    {
-        retval = v8::Local<v8::Value>::New(v8::Null());
-        error = v8::Local<v8::Value>::New(v8::Undefined());
-    }
-    else if (status == HYPERDEX_CLIENT_CMPFAIL)
-    {
-        retval = v8::Local<v8::Value>::New(v8::False());
-        error = v8::Local<v8::Value>::New(v8::Undefined());
-    }
-    else
-    {
-        retval = v8::Local<v8::Value>::New(v8::Undefined());
-        error = v8::Local<v8::Value>::New(this->error_from_status());
-    }
-
-    finished = true;
-    this->make_callback(error, retval);
+	v8::Local<v8::Value> retval;
+	v8::Local<v8::Value> error;
+	if (status == HYPERDEX_CLIENT_SUCCESS)
+	{
+		retval = v8::Local<v8::Value>::New(v8::True());
+		error = v8::Local<v8::Value>::New(v8::Undefined());
+	}
+	else if (status == HYPERDEX_CLIENT_NOTFOUND)
+	{
+		retval = v8::Local<v8::Value>::New(v8::Null());
+		error = v8::Local<v8::Value>::New(v8::Undefined());
+	}
+	else if (status == HYPERDEX_CLIENT_CMPFAIL)
+	{
+		retval = v8::Local<v8::Value>::New(v8::False());
+		error = v8::Local<v8::Value>::New(v8::Undefined());
+	}
+	else
+	{
+		retval = v8::Local<v8::Value>::New(v8::Undefined());
+		error = v8::Local<v8::Value>::New(this->error_from_status());
+	}
+	finished = true;
+	this->make_callback(error, retval);
 }
 
 void
 Operation :: encode_asynccall_status_attributes()
 {
-    v8::Local<v8::Value> retval;
-    v8::Local<v8::Value> error;
-
-    if (status == HYPERDEX_CLIENT_SUCCESS)
-    {
-        this->build_attributes(retval, error);
-    }
-    else if (status == HYPERDEX_CLIENT_NOTFOUND)
-    {
-        retval = v8::Local<v8::Value>::New(v8::Null());
-        error = v8::Local<v8::Value>::New(v8::Undefined());
-    }
-    else if (status == HYPERDEX_CLIENT_CMPFAIL)
-    {
-        retval = v8::Local<v8::Value>::New(v8::False());
-        error = v8::Local<v8::Value>::New(v8::Undefined());
-    }
-    else
-    {
-        retval = v8::Local<v8::Value>::New(v8::Undefined());
-        error = v8::Local<v8::Value>::New(this->error_from_status());
-    }
-
-    finished = true;
-    this->make_callback(error, retval);
+	v8::Local<v8::Value> retval;
+	v8::Local<v8::Value> error;
+	if (status == HYPERDEX_CLIENT_SUCCESS)
+	{
+		this->build_attributes(retval, error);
+	}
+	else if (status == HYPERDEX_CLIENT_NOTFOUND)
+	{
+		retval = v8::Local<v8::Value>::New(v8::Null());
+		error = v8::Local<v8::Value>::New(v8::Undefined());
+	}
+	else if (status == HYPERDEX_CLIENT_CMPFAIL)
+	{
+		retval = v8::Local<v8::Value>::New(v8::False());
+		error = v8::Local<v8::Value>::New(v8::Undefined());
+	}
+	else
+	{
+		retval = v8::Local<v8::Value>::New(v8::Undefined());
+		error = v8::Local<v8::Value>::New(this->error_from_status());
+	}
+	finished = true;
+	this->make_callback(error, retval);
 }
 
 void
 Operation :: encode_asynccall_status_count()
 {
-    v8::Local<v8::Value> retval;
-    v8::Local<v8::Value> error;
-
-    if (status == HYPERDEX_CLIENT_SUCCESS)
-    {
-        retval = v8::Local<v8::Value>::New(v8::Integer::New(count));
-        error = v8::Local<v8::Value>::New(v8::Undefined());
-    }
-    else if (status == HYPERDEX_CLIENT_NOTFOUND)
-    {
-        retval = v8::Local<v8::Value>::New(v8::Null());
-        error = v8::Local<v8::Value>::New(v8::Undefined());
-    }
-    else if (status == HYPERDEX_CLIENT_CMPFAIL)
-    {
-        retval = v8::Local<v8::Value>::New(v8::False());
-        error = v8::Local<v8::Value>::New(v8::Undefined());
-    }
-    else
-    {
-        retval = v8::Local<v8::Value>::New(v8::Undefined());
-        error = v8::Local<v8::Value>::New(this->error_from_status());
-    }
-
-    finished = true;
-    this->make_callback(error, retval);
+	v8::Local<v8::Value> retval;
+	v8::Local<v8::Value> error;
+	if (status == HYPERDEX_CLIENT_SUCCESS)
+	{
+		retval = v8::Local<v8::Value>::New(v8::Integer::New(count));
+		error = v8::Local<v8::Value>::New(v8::Undefined());
+	}
+	else if (status == HYPERDEX_CLIENT_NOTFOUND)
+	{
+		retval = v8::Local<v8::Value>::New(v8::Null());
+		error = v8::Local<v8::Value>::New(v8::Undefined());
+	}
+	else if (status == HYPERDEX_CLIENT_CMPFAIL)
+	{
+		retval = v8::Local<v8::Value>::New(v8::False());
+		error = v8::Local<v8::Value>::New(v8::Undefined());
+	}
+	else
+	{
+		retval = v8::Local<v8::Value>::New(v8::Undefined());
+		error = v8::Local<v8::Value>::New(this->error_from_status());
+	}
+	finished = true;
+	this->make_callback(error, retval);
 }
 
 void
 Operation :: encode_asynccall_status_description()
 {
-    v8::Local<v8::Value> retval;
-    v8::Local<v8::Value> error;
-
-    if (status == HYPERDEX_CLIENT_SUCCESS)
-    {
-        retval = v8::Local<v8::Value>::New(v8::String::New(description));
-        error = v8::Local<v8::Value>::New(v8::Undefined());
-    }
-    else if (status == HYPERDEX_CLIENT_NOTFOUND)
-    {
-        retval = v8::Local<v8::Value>::New(v8::Null());
-        error = v8::Local<v8::Value>::New(v8::Undefined());
-    }
-    else if (status == HYPERDEX_CLIENT_CMPFAIL)
-    {
-        retval = v8::Local<v8::Value>::New(v8::False());
-        error = v8::Local<v8::Value>::New(v8::Undefined());
-    }
-    else
-    {
-        retval = v8::Local<v8::Value>::New(v8::Undefined());
-        error = v8::Local<v8::Value>::New(this->error_from_status());
-    }
-
-    finished = true;
-    this->make_callback(error, retval);
+	v8::Local<v8::Value> retval;
+	v8::Local<v8::Value> error;
+	if (status == HYPERDEX_CLIENT_SUCCESS)
+	{
+		retval = v8::Local<v8::Value>::New(v8::String::New(description));
+		error = v8::Local<v8::Value>::New(v8::Undefined());
+	}
+	else if (status == HYPERDEX_CLIENT_NOTFOUND)
+	{
+		retval = v8::Local<v8::Value>::New(v8::Null());
+		error = v8::Local<v8::Value>::New(v8::Undefined());
+	}
+	else if (status == HYPERDEX_CLIENT_CMPFAIL)
+	{
+		retval = v8::Local<v8::Value>::New(v8::False());
+		error = v8::Local<v8::Value>::New(v8::Undefined());
+	}
+	else
+	{
+		retval = v8::Local<v8::Value>::New(v8::Undefined());
+		error = v8::Local<v8::Value>::New(this->error_from_status());
+	}
+	finished = true;
+	this->make_callback(error, retval);
 }
 
 void
 Operation :: encode_iterator_status_attributes()
 {
-    v8::Local<v8::Value> retval;
-    v8::Local<v8::Value> error;
-
-    if (status == HYPERDEX_CLIENT_SEARCHDONE)
-    {
-        finished = true;
-        this->make_callback_done();
-        return;
-    }
-    else if (status == HYPERDEX_CLIENT_SUCCESS)
-    {
-        this->build_attributes(retval, error);
-    }
-    else if (status == HYPERDEX_CLIENT_NOTFOUND)
-    {
-        retval = v8::Local<v8::Value>::New(v8::Null());
-        error = v8::Local<v8::Value>::New(v8::Undefined());
-    }
-    else if (status == HYPERDEX_CLIENT_CMPFAIL)
-    {
-        retval = v8::Local<v8::Value>::New(v8::False());
-        error = v8::Local<v8::Value>::New(v8::Undefined());
-    }
-    else
-    {
-        retval = v8::Local<v8::Value>::New(v8::Undefined());
-        error = v8::Local<v8::Value>::New(this->error_from_status());
-    }
-
-    this->make_callback(error, retval);
+	v8::Local<v8::Value> retval;
+	v8::Local<v8::Value> error;
+	if (status == HYPERDEX_CLIENT_SEARCHDONE)
+	{
+		finished = true;
+		this->make_callback_done();
+		return;
+	}
+	else if (status == HYPERDEX_CLIENT_SUCCESS)
+	{
+		this->build_attributes(retval, error);
+	}
+	else if (status == HYPERDEX_CLIENT_NOTFOUND)
+	{
+		retval = v8::Local<v8::Value>::New(v8::Null());
+		error = v8::Local<v8::Value>::New(v8::Undefined());
+	}
+	else if (status == HYPERDEX_CLIENT_CMPFAIL)
+	{
+		retval = v8::Local<v8::Value>::New(v8::False());
+		error = v8::Local<v8::Value>::New(v8::Undefined());
+	}
+	else
+	{
+		retval = v8::Local<v8::Value>::New(v8::Undefined());
+		error = v8::Local<v8::Value>::New(this->error_from_status());
+	}
+	this->make_callback(error, retval);
 }
 
 void
-Operation :: make_callback(v8::Handle<v8::Value>& first,
-                           v8::Handle<v8::Value>& second)
+Operation :: make_callback(v8::Handle<v8::Value> &first,
+                           v8::Handle<v8::Value> &second)
 {
-    v8::Local<v8::Function> callback = v8::Local<v8::Object>::New(m_callback)->Get(v8::String::NewSymbol("callback")).As<v8::Function>();
-    v8::Handle<v8::Value> argv[] = { first, second };
-    node::MakeCallback(v8::Context::GetCurrent()->Global(), callback, 2, argv);
+	v8::Local<v8::Function> callback = v8::Local<v8::Object>::New(m_callback)->Get(v8::String::NewSymbol("callback")).As<v8::Function>();
+	v8::Handle<v8::Value> argv[] = { first, second };
+	node::MakeCallback(v8::Context::GetCurrent()->Global(), callback, 2, argv);
 }
 
 void
 Operation :: make_callback_done()
 {
-    assert(m_has_callback_done);
-    v8::Local<v8::Function> callback = v8::Local<v8::Object>::New(m_callback_done)->Get(v8::String::NewSymbol("callback")).As<v8::Function>();
-    v8::Handle<v8::Value> argv[] = {};
-    node::MakeCallback(v8::Context::GetCurrent()->Global(), callback, 0, argv);
+	assert(m_has_callback_done);
+	v8::Local<v8::Function> callback = v8::Local<v8::Object>::New(m_callback_done)->Get(v8::String::NewSymbol("callback")).As<v8::Function>();
+	v8::Handle<v8::Value> argv[] = {};
+	node::MakeCallback(v8::Context::GetCurrent()->Global(), callback, 0, argv);
 }
 
 v8::Local<v8::Value>
-Operation :: error_from_status(hyperdex_client* client,
+Operation :: error_from_status(hyperdex_client *client,
                                hyperdex_client_returncode status)
 {
-    v8::Local<v8::Object> obj(v8::Object::New());
-    obj->Set(v8::String::New("msg"),
-             v8::String::New(hyperdex_client_error_message(client)));
-    obj->Set(v8::String::New("sym"),
-             v8::String::New(hyperdex_client_returncode_to_string(status)));
-    return obj;
+	v8::Local<v8::Object> obj(v8::Object::New());
+	obj->Set(v8::String::New("msg"),
+	         v8::String::New(hyperdex_client_error_message(client)));
+	obj->Set(v8::String::New("sym"),
+	         v8::String::New(hyperdex_client_returncode_to_string(status)));
+	return obj;
 }
 
 v8::Local<v8::Value>
 Operation :: error_from_status()
 {
-    return Operation::error_from_status(client->client(), status);
+	return Operation::error_from_status(client->client(), status);
 }
 
 v8::Local<v8::Value>
-Operation :: error_message(const char* msg)
+Operation :: error_message(const char *msg)
 {
-    v8::Local<v8::Object> obj(v8::Object::New());
-    obj->Set(v8::String::New("msg"), v8::String::New(msg));
-    return obj;
+	v8::Local<v8::Object> obj(v8::Object::New());
+	obj->Set(v8::String::New("msg"), v8::String::New(msg));
+	return obj;
 }
 
 v8::Local<v8::Value>
 Operation :: error_out_of_memory()
 {
-    return error_message("out of memory");
+	return error_message("out of memory");
 }
 
 void
-Operation :: callback_error(v8::Handle<v8::Value>& err)
+Operation :: callback_error(v8::Handle<v8::Value> &err)
 {
-    v8::Local<v8::Value> X(v8::Local<v8::Value>::New(v8::Undefined()));
-    make_callback(err, X);
+	v8::Local<v8::Value> X(v8::Local<v8::Value>::New(v8::Undefined()));
+	make_callback(err, X);
 }
 
 void
 Operation :: callback_error_from_status()
 {
-    v8::Local<v8::Value> err
-        = v8::Local<v8::Value>::New(this->error_from_status());
-    callback_error(err);
+	v8::Local<v8::Value> err
+	    = v8::Local<v8::Value>::New(this->error_from_status());
+	callback_error(err);
 }
 
 void
-Operation :: callback_error_message(const char* msg)
+Operation :: callback_error_message(const char *msg)
 {
-    v8::Local<v8::Value> err
-        = v8::Local<v8::Value>::New(this->error_message(msg));
-    callback_error(err);
+	v8::Local<v8::Value> err
+	    = v8::Local<v8::Value>::New(this->error_message(msg));
+	callback_error(err);
 }
 
 void
 Operation :: callback_error_out_of_memory()
 {
-    v8::Local<v8::Value> err
-        = v8::Local<v8::Value>::New(this->error_out_of_memory());
-    callback_error(err);
+	v8::Local<v8::Value> err
+	    = v8::Local<v8::Value>::New(this->error_out_of_memory());
+	callback_error(err);
 }
 
 void
 Init(v8::Handle<v8::Object> target)
 {
-    HyperDexClient::Init(target);
+	HyperDexClient::Init(target);
 }
 
 } // namespace nodejs
diff --git a/bindings/node.js/client.declarations.cc b/bindings/node.js/client.declarations.cc
index 4585bdfb0..3073b5067 100644
--- a/bindings/node.js/client.declarations.cc
+++ b/bindings/node.js/client.declarations.cc
@@ -28,142 +28,142 @@
 
 #ifdef HYPERDEX_NODE_INCLUDED_CLIENT_CC
 
-static v8::Handle<v8::Value> asynccall__spacename_key__status_attributes(int64_t (*f)(struct hyperdex_client* client, const char* space, const char* key, size_t key_sz, enum hyperdex_client_returncode* status, const struct hyperdex_client_attribute** attrs, size_t* attrs_sz), const v8::Arguments& args);
-static v8::Handle<v8::Value> asynccall__spacename_key_attributenames__status_attributes(int64_t (*f)(struct hyperdex_client* client, const char* space, const char* key, size_t key_sz, const char** attrnames, size_t attrnames_sz, enum hyperdex_client_returncode* status, const struct hyperdex_client_attribute** attrs, size_t* attrs_sz), const v8::Arguments& args);
-static v8::Handle<v8::Value> asynccall__spacename_key_attributes__status(int64_t (*f)(struct hyperdex_client* client, const char* space, const char* key, size_t key_sz, const struct hyperdex_client_attribute* attrs, size_t attrs_sz, enum hyperdex_client_returncode* status), const v8::Arguments& args);
-static v8::Handle<v8::Value> asynccall__spacename_key_predicates_attributes__status(int64_t (*f)(struct hyperdex_client* client, const char* space, const char* key, size_t key_sz, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, const struct hyperdex_client_attribute* attrs, size_t attrs_sz, enum hyperdex_client_returncode* status), const v8::Arguments& args);
-static v8::Handle<v8::Value> asynccall__spacename_predicates_attributes__status_count(int64_t (*f)(struct hyperdex_client* client, const char* space, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, const struct hyperdex_client_attribute* attrs, size_t attrs_sz, enum hyperdex_client_returncode* status, uint64_t* count), const v8::Arguments& args);
-static v8::Handle<v8::Value> asynccall__spacename_key__status(int64_t (*f)(struct hyperdex_client* client, const char* space, const char* key, size_t key_sz, enum hyperdex_client_returncode* status), const v8::Arguments& args);
-static v8::Handle<v8::Value> asynccall__spacename_key_predicates__status(int64_t (*f)(struct hyperdex_client* client, const char* space, const char* key, size_t key_sz, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, enum hyperdex_client_returncode* status), const v8::Arguments& args);
-static v8::Handle<v8::Value> asynccall__spacename_predicates__status_count(int64_t (*f)(struct hyperdex_client* client, const char* space, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, enum hyperdex_client_returncode* status, uint64_t* count), const v8::Arguments& args);
-static v8::Handle<v8::Value> asynccall__spacename_key_mapattributes__status(int64_t (*f)(struct hyperdex_client* client, const char* space, const char* key, size_t key_sz, const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz, enum hyperdex_client_returncode* status), const v8::Arguments& args);
-static v8::Handle<v8::Value> asynccall__spacename_key_predicates_mapattributes__status(int64_t (*f)(struct hyperdex_client* client, const char* space, const char* key, size_t key_sz, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz, enum hyperdex_client_returncode* status), const v8::Arguments& args);
-static v8::Handle<v8::Value> asynccall__spacename_predicates_mapattributes__status_count(int64_t (*f)(struct hyperdex_client* client, const char* space, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz, enum hyperdex_client_returncode* status, uint64_t* count), const v8::Arguments& args);
-static v8::Handle<v8::Value> iterator__spacename_predicates__status_attributes(int64_t (*f)(struct hyperdex_client* client, const char* space, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, enum hyperdex_client_returncode* status, const struct hyperdex_client_attribute** attrs, size_t* attrs_sz), const v8::Arguments& args);
-static v8::Handle<v8::Value> asynccall__spacename_predicates__status_description(int64_t (*f)(struct hyperdex_client* client, const char* space, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, enum hyperdex_client_returncode* status, const char** description), const v8::Arguments& args);
-static v8::Handle<v8::Value> iterator__spacename_predicates_sortby_limit_maxmin__status_attributes(int64_t (*f)(struct hyperdex_client* client, const char* space, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, const char* sort_by, uint64_t limit, int maxmin, enum hyperdex_client_returncode* status, const struct hyperdex_client_attribute** attrs, size_t* attrs_sz), const v8::Arguments& args);
+static v8::Handle<v8::Value> asynccall__spacename_key__status_attributes(int64_t (*f)(struct hyperdex_client *client, const char *space, const char *key, size_t key_sz, enum hyperdex_client_returncode *status, const struct hyperdex_client_attribute **attrs, size_t *attrs_sz), const v8::Arguments &args);
+static v8::Handle<v8::Value> asynccall__spacename_key_attributenames__status_attributes(int64_t (*f)(struct hyperdex_client *client, const char *space, const char *key, size_t key_sz, const char **attrnames, size_t attrnames_sz, enum hyperdex_client_returncode *status, const struct hyperdex_client_attribute **attrs, size_t *attrs_sz), const v8::Arguments &args);
+static v8::Handle<v8::Value> asynccall__spacename_key_attributes__status(int64_t (*f)(struct hyperdex_client *client, const char *space, const char *key, size_t key_sz, const struct hyperdex_client_attribute *attrs, size_t attrs_sz, enum hyperdex_client_returncode *status), const v8::Arguments &args);
+static v8::Handle<v8::Value> asynccall__spacename_key_predicates_attributes__status(int64_t (*f)(struct hyperdex_client *client, const char *space, const char *key, size_t key_sz, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, const struct hyperdex_client_attribute *attrs, size_t attrs_sz, enum hyperdex_client_returncode *status), const v8::Arguments &args);
+static v8::Handle<v8::Value> asynccall__spacename_predicates_attributes__status_count(int64_t (*f)(struct hyperdex_client *client, const char *space, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, const struct hyperdex_client_attribute *attrs, size_t attrs_sz, enum hyperdex_client_returncode *status, uint64_t *count), const v8::Arguments &args);
+static v8::Handle<v8::Value> asynccall__spacename_key__status(int64_t (*f)(struct hyperdex_client *client, const char *space, const char *key, size_t key_sz, enum hyperdex_client_returncode *status), const v8::Arguments &args);
+static v8::Handle<v8::Value> asynccall__spacename_key_predicates__status(int64_t (*f)(struct hyperdex_client *client, const char *space, const char *key, size_t key_sz, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, enum hyperdex_client_returncode *status), const v8::Arguments &args);
+static v8::Handle<v8::Value> asynccall__spacename_predicates__status_count(int64_t (*f)(struct hyperdex_client *client, const char *space, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, enum hyperdex_client_returncode *status, uint64_t *count), const v8::Arguments &args);
+static v8::Handle<v8::Value> asynccall__spacename_key_mapattributes__status(int64_t (*f)(struct hyperdex_client *client, const char *space, const char *key, size_t key_sz, const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz, enum hyperdex_client_returncode *status), const v8::Arguments &args);
+static v8::Handle<v8::Value> asynccall__spacename_key_predicates_mapattributes__status(int64_t (*f)(struct hyperdex_client *client, const char *space, const char *key, size_t key_sz, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz, enum hyperdex_client_returncode *status), const v8::Arguments &args);
+static v8::Handle<v8::Value> asynccall__spacename_predicates_mapattributes__status_count(int64_t (*f)(struct hyperdex_client *client, const char *space, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz, enum hyperdex_client_returncode *status, uint64_t *count), const v8::Arguments &args);
+static v8::Handle<v8::Value> iterator__spacename_predicates__status_attributes(int64_t (*f)(struct hyperdex_client *client, const char *space, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, enum hyperdex_client_returncode *status, const struct hyperdex_client_attribute **attrs, size_t *attrs_sz), const v8::Arguments &args);
+static v8::Handle<v8::Value> asynccall__spacename_predicates__status_description(int64_t (*f)(struct hyperdex_client *client, const char *space, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, enum hyperdex_client_returncode *status, const char **description), const v8::Arguments &args);
+static v8::Handle<v8::Value> iterator__spacename_predicates_sortby_limit_maxmin__status_attributes(int64_t (*f)(struct hyperdex_client *client, const char *space, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, const char *sort_by, uint64_t limit, int maxmin, enum hyperdex_client_returncode *status, const struct hyperdex_client_attribute **attrs, size_t *attrs_sz), const v8::Arguments &args);
 
-static v8::Handle<v8::Value> get(const v8::Arguments& args);
-static v8::Handle<v8::Value> get_partial(const v8::Arguments& args);
-static v8::Handle<v8::Value> put(const v8::Arguments& args);
-static v8::Handle<v8::Value> cond_put(const v8::Arguments& args);
-static v8::Handle<v8::Value> cond_put_or_create(const v8::Arguments& args);
-static v8::Handle<v8::Value> group_put(const v8::Arguments& args);
-static v8::Handle<v8::Value> put_if_not_exist(const v8::Arguments& args);
-static v8::Handle<v8::Value> del(const v8::Arguments& args);
-static v8::Handle<v8::Value> cond_del(const v8::Arguments& args);
-static v8::Handle<v8::Value> group_del(const v8::Arguments& args);
-static v8::Handle<v8::Value> atomic_add(const v8::Arguments& args);
-static v8::Handle<v8::Value> cond_atomic_add(const v8::Arguments& args);
-static v8::Handle<v8::Value> group_atomic_add(const v8::Arguments& args);
-static v8::Handle<v8::Value> atomic_sub(const v8::Arguments& args);
-static v8::Handle<v8::Value> cond_atomic_sub(const v8::Arguments& args);
-static v8::Handle<v8::Value> group_atomic_sub(const v8::Arguments& args);
-static v8::Handle<v8::Value> atomic_mul(const v8::Arguments& args);
-static v8::Handle<v8::Value> cond_atomic_mul(const v8::Arguments& args);
-static v8::Handle<v8::Value> group_atomic_mul(const v8::Arguments& args);
-static v8::Handle<v8::Value> atomic_div(const v8::Arguments& args);
-static v8::Handle<v8::Value> cond_atomic_div(const v8::Arguments& args);
-static v8::Handle<v8::Value> group_atomic_div(const v8::Arguments& args);
-static v8::Handle<v8::Value> atomic_mod(const v8::Arguments& args);
-static v8::Handle<v8::Value> cond_atomic_mod(const v8::Arguments& args);
-static v8::Handle<v8::Value> group_atomic_mod(const v8::Arguments& args);
-static v8::Handle<v8::Value> atomic_and(const v8::Arguments& args);
-static v8::Handle<v8::Value> cond_atomic_and(const v8::Arguments& args);
-static v8::Handle<v8::Value> group_atomic_and(const v8::Arguments& args);
-static v8::Handle<v8::Value> atomic_or(const v8::Arguments& args);
-static v8::Handle<v8::Value> cond_atomic_or(const v8::Arguments& args);
-static v8::Handle<v8::Value> group_atomic_or(const v8::Arguments& args);
-static v8::Handle<v8::Value> atomic_xor(const v8::Arguments& args);
-static v8::Handle<v8::Value> cond_atomic_xor(const v8::Arguments& args);
-static v8::Handle<v8::Value> group_atomic_xor(const v8::Arguments& args);
-static v8::Handle<v8::Value> atomic_min(const v8::Arguments& args);
-static v8::Handle<v8::Value> cond_atomic_min(const v8::Arguments& args);
-static v8::Handle<v8::Value> group_atomic_min(const v8::Arguments& args);
-static v8::Handle<v8::Value> atomic_max(const v8::Arguments& args);
-static v8::Handle<v8::Value> cond_atomic_max(const v8::Arguments& args);
-static v8::Handle<v8::Value> group_atomic_max(const v8::Arguments& args);
-static v8::Handle<v8::Value> string_prepend(const v8::Arguments& args);
-static v8::Handle<v8::Value> cond_string_prepend(const v8::Arguments& args);
-static v8::Handle<v8::Value> group_string_prepend(const v8::Arguments& args);
-static v8::Handle<v8::Value> string_append(const v8::Arguments& args);
-static v8::Handle<v8::Value> cond_string_append(const v8::Arguments& args);
-static v8::Handle<v8::Value> group_string_append(const v8::Arguments& args);
-static v8::Handle<v8::Value> string_ltrim(const v8::Arguments& args);
-static v8::Handle<v8::Value> cond_string_ltrim(const v8::Arguments& args);
-static v8::Handle<v8::Value> group_string_ltrim(const v8::Arguments& args);
-static v8::Handle<v8::Value> string_rtrim(const v8::Arguments& args);
-static v8::Handle<v8::Value> cond_string_rtrim(const v8::Arguments& args);
-static v8::Handle<v8::Value> group_string_rtrim(const v8::Arguments& args);
-static v8::Handle<v8::Value> list_lpush(const v8::Arguments& args);
-static v8::Handle<v8::Value> cond_list_lpush(const v8::Arguments& args);
-static v8::Handle<v8::Value> group_list_lpush(const v8::Arguments& args);
-static v8::Handle<v8::Value> list_rpush(const v8::Arguments& args);
-static v8::Handle<v8::Value> cond_list_rpush(const v8::Arguments& args);
-static v8::Handle<v8::Value> group_list_rpush(const v8::Arguments& args);
-static v8::Handle<v8::Value> set_add(const v8::Arguments& args);
-static v8::Handle<v8::Value> cond_set_add(const v8::Arguments& args);
-static v8::Handle<v8::Value> group_set_add(const v8::Arguments& args);
-static v8::Handle<v8::Value> set_remove(const v8::Arguments& args);
-static v8::Handle<v8::Value> cond_set_remove(const v8::Arguments& args);
-static v8::Handle<v8::Value> group_set_remove(const v8::Arguments& args);
-static v8::Handle<v8::Value> set_intersect(const v8::Arguments& args);
-static v8::Handle<v8::Value> cond_set_intersect(const v8::Arguments& args);
-static v8::Handle<v8::Value> group_set_intersect(const v8::Arguments& args);
-static v8::Handle<v8::Value> set_union(const v8::Arguments& args);
-static v8::Handle<v8::Value> cond_set_union(const v8::Arguments& args);
-static v8::Handle<v8::Value> group_set_union(const v8::Arguments& args);
-static v8::Handle<v8::Value> document_rename(const v8::Arguments& args);
-static v8::Handle<v8::Value> cond_document_rename(const v8::Arguments& args);
-static v8::Handle<v8::Value> group_document_rename(const v8::Arguments& args);
-static v8::Handle<v8::Value> document_unset(const v8::Arguments& args);
-static v8::Handle<v8::Value> cond_document_unset(const v8::Arguments& args);
-static v8::Handle<v8::Value> group_document_unset(const v8::Arguments& args);
-static v8::Handle<v8::Value> map_add(const v8::Arguments& args);
-static v8::Handle<v8::Value> cond_map_add(const v8::Arguments& args);
-static v8::Handle<v8::Value> group_map_add(const v8::Arguments& args);
-static v8::Handle<v8::Value> map_remove(const v8::Arguments& args);
-static v8::Handle<v8::Value> cond_map_remove(const v8::Arguments& args);
-static v8::Handle<v8::Value> group_map_remove(const v8::Arguments& args);
-static v8::Handle<v8::Value> map_atomic_add(const v8::Arguments& args);
-static v8::Handle<v8::Value> cond_map_atomic_add(const v8::Arguments& args);
-static v8::Handle<v8::Value> group_map_atomic_add(const v8::Arguments& args);
-static v8::Handle<v8::Value> map_atomic_sub(const v8::Arguments& args);
-static v8::Handle<v8::Value> cond_map_atomic_sub(const v8::Arguments& args);
-static v8::Handle<v8::Value> group_map_atomic_sub(const v8::Arguments& args);
-static v8::Handle<v8::Value> map_atomic_mul(const v8::Arguments& args);
-static v8::Handle<v8::Value> cond_map_atomic_mul(const v8::Arguments& args);
-static v8::Handle<v8::Value> group_map_atomic_mul(const v8::Arguments& args);
-static v8::Handle<v8::Value> map_atomic_div(const v8::Arguments& args);
-static v8::Handle<v8::Value> cond_map_atomic_div(const v8::Arguments& args);
-static v8::Handle<v8::Value> group_map_atomic_div(const v8::Arguments& args);
-static v8::Handle<v8::Value> map_atomic_mod(const v8::Arguments& args);
-static v8::Handle<v8::Value> cond_map_atomic_mod(const v8::Arguments& args);
-static v8::Handle<v8::Value> group_map_atomic_mod(const v8::Arguments& args);
-static v8::Handle<v8::Value> map_atomic_and(const v8::Arguments& args);
-static v8::Handle<v8::Value> cond_map_atomic_and(const v8::Arguments& args);
-static v8::Handle<v8::Value> group_map_atomic_and(const v8::Arguments& args);
-static v8::Handle<v8::Value> map_atomic_or(const v8::Arguments& args);
-static v8::Handle<v8::Value> cond_map_atomic_or(const v8::Arguments& args);
-static v8::Handle<v8::Value> group_map_atomic_or(const v8::Arguments& args);
-static v8::Handle<v8::Value> map_atomic_xor(const v8::Arguments& args);
-static v8::Handle<v8::Value> cond_map_atomic_xor(const v8::Arguments& args);
-static v8::Handle<v8::Value> group_map_atomic_xor(const v8::Arguments& args);
-static v8::Handle<v8::Value> map_string_prepend(const v8::Arguments& args);
-static v8::Handle<v8::Value> cond_map_string_prepend(const v8::Arguments& args);
-static v8::Handle<v8::Value> group_map_string_prepend(const v8::Arguments& args);
-static v8::Handle<v8::Value> map_string_append(const v8::Arguments& args);
-static v8::Handle<v8::Value> cond_map_string_append(const v8::Arguments& args);
-static v8::Handle<v8::Value> group_map_string_append(const v8::Arguments& args);
-static v8::Handle<v8::Value> map_atomic_min(const v8::Arguments& args);
-static v8::Handle<v8::Value> cond_map_atomic_min(const v8::Arguments& args);
-static v8::Handle<v8::Value> group_map_atomic_min(const v8::Arguments& args);
-static v8::Handle<v8::Value> map_atomic_max(const v8::Arguments& args);
-static v8::Handle<v8::Value> cond_map_atomic_max(const v8::Arguments& args);
-static v8::Handle<v8::Value> group_map_atomic_max(const v8::Arguments& args);
-static v8::Handle<v8::Value> search(const v8::Arguments& args);
-static v8::Handle<v8::Value> search_describe(const v8::Arguments& args);
-static v8::Handle<v8::Value> sorted_search(const v8::Arguments& args);
-static v8::Handle<v8::Value> count(const v8::Arguments& args);
+static v8::Handle<v8::Value> get(const v8::Arguments &args);
+static v8::Handle<v8::Value> get_partial(const v8::Arguments &args);
+static v8::Handle<v8::Value> put(const v8::Arguments &args);
+static v8::Handle<v8::Value> cond_put(const v8::Arguments &args);
+static v8::Handle<v8::Value> cond_put_or_create(const v8::Arguments &args);
+static v8::Handle<v8::Value> group_put(const v8::Arguments &args);
+static v8::Handle<v8::Value> put_if_not_exist(const v8::Arguments &args);
+static v8::Handle<v8::Value> del(const v8::Arguments &args);
+static v8::Handle<v8::Value> cond_del(const v8::Arguments &args);
+static v8::Handle<v8::Value> group_del(const v8::Arguments &args);
+static v8::Handle<v8::Value> atomic_add(const v8::Arguments &args);
+static v8::Handle<v8::Value> cond_atomic_add(const v8::Arguments &args);
+static v8::Handle<v8::Value> group_atomic_add(const v8::Arguments &args);
+static v8::Handle<v8::Value> atomic_sub(const v8::Arguments &args);
+static v8::Handle<v8::Value> cond_atomic_sub(const v8::Arguments &args);
+static v8::Handle<v8::Value> group_atomic_sub(const v8::Arguments &args);
+static v8::Handle<v8::Value> atomic_mul(const v8::Arguments &args);
+static v8::Handle<v8::Value> cond_atomic_mul(const v8::Arguments &args);
+static v8::Handle<v8::Value> group_atomic_mul(const v8::Arguments &args);
+static v8::Handle<v8::Value> atomic_div(const v8::Arguments &args);
+static v8::Handle<v8::Value> cond_atomic_div(const v8::Arguments &args);
+static v8::Handle<v8::Value> group_atomic_div(const v8::Arguments &args);
+static v8::Handle<v8::Value> atomic_mod(const v8::Arguments &args);
+static v8::Handle<v8::Value> cond_atomic_mod(const v8::Arguments &args);
+static v8::Handle<v8::Value> group_atomic_mod(const v8::Arguments &args);
+static v8::Handle<v8::Value> atomic_and(const v8::Arguments &args);
+static v8::Handle<v8::Value> cond_atomic_and(const v8::Arguments &args);
+static v8::Handle<v8::Value> group_atomic_and(const v8::Arguments &args);
+static v8::Handle<v8::Value> atomic_or(const v8::Arguments &args);
+static v8::Handle<v8::Value> cond_atomic_or(const v8::Arguments &args);
+static v8::Handle<v8::Value> group_atomic_or(const v8::Arguments &args);
+static v8::Handle<v8::Value> atomic_xor(const v8::Arguments &args);
+static v8::Handle<v8::Value> cond_atomic_xor(const v8::Arguments &args);
+static v8::Handle<v8::Value> group_atomic_xor(const v8::Arguments &args);
+static v8::Handle<v8::Value> atomic_min(const v8::Arguments &args);
+static v8::Handle<v8::Value> cond_atomic_min(const v8::Arguments &args);
+static v8::Handle<v8::Value> group_atomic_min(const v8::Arguments &args);
+static v8::Handle<v8::Value> atomic_max(const v8::Arguments &args);
+static v8::Handle<v8::Value> cond_atomic_max(const v8::Arguments &args);
+static v8::Handle<v8::Value> group_atomic_max(const v8::Arguments &args);
+static v8::Handle<v8::Value> string_prepend(const v8::Arguments &args);
+static v8::Handle<v8::Value> cond_string_prepend(const v8::Arguments &args);
+static v8::Handle<v8::Value> group_string_prepend(const v8::Arguments &args);
+static v8::Handle<v8::Value> string_append(const v8::Arguments &args);
+static v8::Handle<v8::Value> cond_string_append(const v8::Arguments &args);
+static v8::Handle<v8::Value> group_string_append(const v8::Arguments &args);
+static v8::Handle<v8::Value> string_ltrim(const v8::Arguments &args);
+static v8::Handle<v8::Value> cond_string_ltrim(const v8::Arguments &args);
+static v8::Handle<v8::Value> group_string_ltrim(const v8::Arguments &args);
+static v8::Handle<v8::Value> string_rtrim(const v8::Arguments &args);
+static v8::Handle<v8::Value> cond_string_rtrim(const v8::Arguments &args);
+static v8::Handle<v8::Value> group_string_rtrim(const v8::Arguments &args);
+static v8::Handle<v8::Value> list_lpush(const v8::Arguments &args);
+static v8::Handle<v8::Value> cond_list_lpush(const v8::Arguments &args);
+static v8::Handle<v8::Value> group_list_lpush(const v8::Arguments &args);
+static v8::Handle<v8::Value> list_rpush(const v8::Arguments &args);
+static v8::Handle<v8::Value> cond_list_rpush(const v8::Arguments &args);
+static v8::Handle<v8::Value> group_list_rpush(const v8::Arguments &args);
+static v8::Handle<v8::Value> set_add(const v8::Arguments &args);
+static v8::Handle<v8::Value> cond_set_add(const v8::Arguments &args);
+static v8::Handle<v8::Value> group_set_add(const v8::Arguments &args);
+static v8::Handle<v8::Value> set_remove(const v8::Arguments &args);
+static v8::Handle<v8::Value> cond_set_remove(const v8::Arguments &args);
+static v8::Handle<v8::Value> group_set_remove(const v8::Arguments &args);
+static v8::Handle<v8::Value> set_intersect(const v8::Arguments &args);
+static v8::Handle<v8::Value> cond_set_intersect(const v8::Arguments &args);
+static v8::Handle<v8::Value> group_set_intersect(const v8::Arguments &args);
+static v8::Handle<v8::Value> set_union(const v8::Arguments &args);
+static v8::Handle<v8::Value> cond_set_union(const v8::Arguments &args);
+static v8::Handle<v8::Value> group_set_union(const v8::Arguments &args);
+static v8::Handle<v8::Value> document_rename(const v8::Arguments &args);
+static v8::Handle<v8::Value> cond_document_rename(const v8::Arguments &args);
+static v8::Handle<v8::Value> group_document_rename(const v8::Arguments &args);
+static v8::Handle<v8::Value> document_unset(const v8::Arguments &args);
+static v8::Handle<v8::Value> cond_document_unset(const v8::Arguments &args);
+static v8::Handle<v8::Value> group_document_unset(const v8::Arguments &args);
+static v8::Handle<v8::Value> map_add(const v8::Arguments &args);
+static v8::Handle<v8::Value> cond_map_add(const v8::Arguments &args);
+static v8::Handle<v8::Value> group_map_add(const v8::Arguments &args);
+static v8::Handle<v8::Value> map_remove(const v8::Arguments &args);
+static v8::Handle<v8::Value> cond_map_remove(const v8::Arguments &args);
+static v8::Handle<v8::Value> group_map_remove(const v8::Arguments &args);
+static v8::Handle<v8::Value> map_atomic_add(const v8::Arguments &args);
+static v8::Handle<v8::Value> cond_map_atomic_add(const v8::Arguments &args);
+static v8::Handle<v8::Value> group_map_atomic_add(const v8::Arguments &args);
+static v8::Handle<v8::Value> map_atomic_sub(const v8::Arguments &args);
+static v8::Handle<v8::Value> cond_map_atomic_sub(const v8::Arguments &args);
+static v8::Handle<v8::Value> group_map_atomic_sub(const v8::Arguments &args);
+static v8::Handle<v8::Value> map_atomic_mul(const v8::Arguments &args);
+static v8::Handle<v8::Value> cond_map_atomic_mul(const v8::Arguments &args);
+static v8::Handle<v8::Value> group_map_atomic_mul(const v8::Arguments &args);
+static v8::Handle<v8::Value> map_atomic_div(const v8::Arguments &args);
+static v8::Handle<v8::Value> cond_map_atomic_div(const v8::Arguments &args);
+static v8::Handle<v8::Value> group_map_atomic_div(const v8::Arguments &args);
+static v8::Handle<v8::Value> map_atomic_mod(const v8::Arguments &args);
+static v8::Handle<v8::Value> cond_map_atomic_mod(const v8::Arguments &args);
+static v8::Handle<v8::Value> group_map_atomic_mod(const v8::Arguments &args);
+static v8::Handle<v8::Value> map_atomic_and(const v8::Arguments &args);
+static v8::Handle<v8::Value> cond_map_atomic_and(const v8::Arguments &args);
+static v8::Handle<v8::Value> group_map_atomic_and(const v8::Arguments &args);
+static v8::Handle<v8::Value> map_atomic_or(const v8::Arguments &args);
+static v8::Handle<v8::Value> cond_map_atomic_or(const v8::Arguments &args);
+static v8::Handle<v8::Value> group_map_atomic_or(const v8::Arguments &args);
+static v8::Handle<v8::Value> map_atomic_xor(const v8::Arguments &args);
+static v8::Handle<v8::Value> cond_map_atomic_xor(const v8::Arguments &args);
+static v8::Handle<v8::Value> group_map_atomic_xor(const v8::Arguments &args);
+static v8::Handle<v8::Value> map_string_prepend(const v8::Arguments &args);
+static v8::Handle<v8::Value> cond_map_string_prepend(const v8::Arguments &args);
+static v8::Handle<v8::Value> group_map_string_prepend(const v8::Arguments &args);
+static v8::Handle<v8::Value> map_string_append(const v8::Arguments &args);
+static v8::Handle<v8::Value> cond_map_string_append(const v8::Arguments &args);
+static v8::Handle<v8::Value> group_map_string_append(const v8::Arguments &args);
+static v8::Handle<v8::Value> map_atomic_min(const v8::Arguments &args);
+static v8::Handle<v8::Value> cond_map_atomic_min(const v8::Arguments &args);
+static v8::Handle<v8::Value> group_map_atomic_min(const v8::Arguments &args);
+static v8::Handle<v8::Value> map_atomic_max(const v8::Arguments &args);
+static v8::Handle<v8::Value> cond_map_atomic_max(const v8::Arguments &args);
+static v8::Handle<v8::Value> group_map_atomic_max(const v8::Arguments &args);
+static v8::Handle<v8::Value> search(const v8::Arguments &args);
+static v8::Handle<v8::Value> search_describe(const v8::Arguments &args);
+static v8::Handle<v8::Value> sorted_search(const v8::Arguments &args);
+static v8::Handle<v8::Value> count(const v8::Arguments &args);
 
 #endif // HYPERDEX_NODE_INCLUDED_CLIENT_CC
diff --git a/bindings/node.js/client.definitions.cc b/bindings/node.js/client.definitions.cc
index 92dd1e602..1e9f0e34f 100644
--- a/bindings/node.js/client.definitions.cc
+++ b/bindings/node.js/client.definitions.cc
@@ -29,1437 +29,1353 @@
 #ifdef HYPERDEX_NODE_INCLUDED_CLIENT_CC
 
 v8::Handle<v8::Value>
-HyperDexClient :: asynccall__spacename_key__status_attributes(int64_t (*f)(struct hyperdex_client* client, const char* space, const char* key, size_t key_sz, enum hyperdex_client_returncode* status, const struct hyperdex_client_attribute** attrs, size_t* attrs_sz), const v8::Arguments& args)
-{
-    v8::HandleScope scope;
-    v8::Local<v8::Object> client_obj = args.This();
-    HyperDexClient* client = node::ObjectWrap::Unwrap<HyperDexClient>(client_obj);
-    e::intrusive_ptr<Operation> op(new Operation(client_obj, client));
-    const size_t base_args_sz = 2;
-    const bool bDoAuth = ((size_t)args.Length() > base_args_sz + 1);
-    const size_t i_Func = bDoAuth ? base_args_sz + 1 : base_args_sz;
-    v8::Local<v8::Function> func = args[i_Func].As<v8::Function>();
-
-    if (func.IsEmpty() || !func->IsFunction())
-    {
-        v8::ThrowException(v8::String::New("Callback must be a function"));
-        return scope.Close(v8::Undefined());
-    }
-
-    if (!op->set_callback(func)) { return scope.Close(v8::Undefined()); }
-
-    const char* in_space;
-    v8::Local<v8::Value> spacename = args[0];
-    if (!op->convert_spacename(spacename, &in_space)) return scope.Close(v8::Undefined());
-    const char* in_key;
-    size_t in_key_sz;
-    v8::Local<v8::Value> key = args[1];
-    if (!op->convert_key(key, &in_key, &in_key_sz)) return scope.Close(v8::Undefined());
-    if (bDoAuth)
-    {
-        v8::Handle<v8::Value> M = args[base_args_sz];
-        if (!op->set_auth_context(M)) { return scope.Close(v8::Undefined()); }
-    }
-
-    op->reqid = f(client->client(), in_space, in_key, in_key_sz, &op->status, &op->attrs, &op->attrs_sz);
-
-    if (bDoAuth) op->clear_auth_context();
-    if (op->reqid < 0)
-    {
-        op->callback_error_from_status();
-        return scope.Close(v8::Undefined());
-    }
-
-    op->encode_return = &Operation::encode_asynccall_status_attributes;
-    client->add(op->reqid, op);
-    return scope.Close(v8::Undefined());
-}
-
-v8::Handle<v8::Value>
-HyperDexClient :: asynccall__spacename_key_attributenames__status_attributes(int64_t (*f)(struct hyperdex_client* client, const char* space, const char* key, size_t key_sz, const char** attrnames, size_t attrnames_sz, enum hyperdex_client_returncode* status, const struct hyperdex_client_attribute** attrs, size_t* attrs_sz), const v8::Arguments& args)
-{
-    v8::HandleScope scope;
-    v8::Local<v8::Object> client_obj = args.This();
-    HyperDexClient* client = node::ObjectWrap::Unwrap<HyperDexClient>(client_obj);
-    e::intrusive_ptr<Operation> op(new Operation(client_obj, client));
-    const size_t base_args_sz = 3;
-    const bool bDoAuth = ((size_t)args.Length() > base_args_sz + 1);
-    const size_t i_Func = bDoAuth ? base_args_sz + 1 : base_args_sz;
-    v8::Local<v8::Function> func = args[i_Func].As<v8::Function>();
-
-    if (func.IsEmpty() || !func->IsFunction())
-    {
-        v8::ThrowException(v8::String::New("Callback must be a function"));
-        return scope.Close(v8::Undefined());
-    }
-
-    if (!op->set_callback(func)) { return scope.Close(v8::Undefined()); }
-
-    const char* in_space;
-    v8::Local<v8::Value> spacename = args[0];
-    if (!op->convert_spacename(spacename, &in_space)) return scope.Close(v8::Undefined());
-    const char* in_key;
-    size_t in_key_sz;
-    v8::Local<v8::Value> key = args[1];
-    if (!op->convert_key(key, &in_key, &in_key_sz)) return scope.Close(v8::Undefined());
-    const char** in_attrnames;
-    size_t in_attrnames_sz;
-    v8::Local<v8::Value> attributenames = args[2];
-    if (!op->convert_attributenames(attributenames, &in_attrnames, &in_attrnames_sz)) return scope.Close(v8::Undefined());
-    if (bDoAuth)
-    {
-        v8::Handle<v8::Value> M = args[base_args_sz];
-        if (!op->set_auth_context(M)) { return scope.Close(v8::Undefined()); }
-    }
-
-    op->reqid = f(client->client(), in_space, in_key, in_key_sz, in_attrnames, in_attrnames_sz, &op->status, &op->attrs, &op->attrs_sz);
-
-    if (bDoAuth) op->clear_auth_context();
-    if (op->reqid < 0)
-    {
-        op->callback_error_from_status();
-        return scope.Close(v8::Undefined());
-    }
-
-    op->encode_return = &Operation::encode_asynccall_status_attributes;
-    client->add(op->reqid, op);
-    return scope.Close(v8::Undefined());
-}
-
-v8::Handle<v8::Value>
-HyperDexClient :: asynccall__spacename_key_attributes__status(int64_t (*f)(struct hyperdex_client* client, const char* space, const char* key, size_t key_sz, const struct hyperdex_client_attribute* attrs, size_t attrs_sz, enum hyperdex_client_returncode* status), const v8::Arguments& args)
-{
-    v8::HandleScope scope;
-    v8::Local<v8::Object> client_obj = args.This();
-    HyperDexClient* client = node::ObjectWrap::Unwrap<HyperDexClient>(client_obj);
-    e::intrusive_ptr<Operation> op(new Operation(client_obj, client));
-    const size_t base_args_sz = 3;
-    const bool bDoAuth = ((size_t)args.Length() > base_args_sz + 1);
-    const size_t i_Func = bDoAuth ? base_args_sz + 1 : base_args_sz;
-    v8::Local<v8::Function> func = args[i_Func].As<v8::Function>();
-
-    if (func.IsEmpty() || !func->IsFunction())
-    {
-        v8::ThrowException(v8::String::New("Callback must be a function"));
-        return scope.Close(v8::Undefined());
-    }
-
-    if (!op->set_callback(func)) { return scope.Close(v8::Undefined()); }
-
-    const char* in_space;
-    v8::Local<v8::Value> spacename = args[0];
-    if (!op->convert_spacename(spacename, &in_space)) return scope.Close(v8::Undefined());
-    const char* in_key;
-    size_t in_key_sz;
-    v8::Local<v8::Value> key = args[1];
-    if (!op->convert_key(key, &in_key, &in_key_sz)) return scope.Close(v8::Undefined());
-    const struct hyperdex_client_attribute* in_attrs;
-    size_t in_attrs_sz;
-    v8::Local<v8::Value> attributes = args[2];
-    if (!op->convert_attributes(attributes, &in_attrs, &in_attrs_sz)) return scope.Close(v8::Undefined());
-    if (bDoAuth)
-    {
-        v8::Handle<v8::Value> M = args[base_args_sz];
-        if (!op->set_auth_context(M)) { return scope.Close(v8::Undefined()); }
-    }
-
-    op->reqid = f(client->client(), in_space, in_key, in_key_sz, in_attrs, in_attrs_sz, &op->status);
-
-    if (bDoAuth) op->clear_auth_context();
-    if (op->reqid < 0)
-    {
-        op->callback_error_from_status();
-        return scope.Close(v8::Undefined());
-    }
-
-    op->encode_return = &Operation::encode_asynccall_status;
-    client->add(op->reqid, op);
-    return scope.Close(v8::Undefined());
-}
-
-v8::Handle<v8::Value>
-HyperDexClient :: asynccall__spacename_key_predicates_attributes__status(int64_t (*f)(struct hyperdex_client* client, const char* space, const char* key, size_t key_sz, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, const struct hyperdex_client_attribute* attrs, size_t attrs_sz, enum hyperdex_client_returncode* status), const v8::Arguments& args)
-{
-    v8::HandleScope scope;
-    v8::Local<v8::Object> client_obj = args.This();
-    HyperDexClient* client = node::ObjectWrap::Unwrap<HyperDexClient>(client_obj);
-    e::intrusive_ptr<Operation> op(new Operation(client_obj, client));
-    const size_t base_args_sz = 4;
-    const bool bDoAuth = ((size_t)args.Length() > base_args_sz + 1);
-    const size_t i_Func = bDoAuth ? base_args_sz + 1 : base_args_sz;
-    v8::Local<v8::Function> func = args[i_Func].As<v8::Function>();
-
-    if (func.IsEmpty() || !func->IsFunction())
-    {
-        v8::ThrowException(v8::String::New("Callback must be a function"));
-        return scope.Close(v8::Undefined());
-    }
-
-    if (!op->set_callback(func)) { return scope.Close(v8::Undefined()); }
-
-    const char* in_space;
-    v8::Local<v8::Value> spacename = args[0];
-    if (!op->convert_spacename(spacename, &in_space)) return scope.Close(v8::Undefined());
-    const char* in_key;
-    size_t in_key_sz;
-    v8::Local<v8::Value> key = args[1];
-    if (!op->convert_key(key, &in_key, &in_key_sz)) return scope.Close(v8::Undefined());
-    const struct hyperdex_client_attribute_check* in_checks;
-    size_t in_checks_sz;
-    v8::Local<v8::Value> predicates = args[2];
-    if (!op->convert_predicates(predicates, &in_checks, &in_checks_sz)) return scope.Close(v8::Undefined());
-    const struct hyperdex_client_attribute* in_attrs;
-    size_t in_attrs_sz;
-    v8::Local<v8::Value> attributes = args[3];
-    if (!op->convert_attributes(attributes, &in_attrs, &in_attrs_sz)) return scope.Close(v8::Undefined());
-    if (bDoAuth)
-    {
-        v8::Handle<v8::Value> M = args[base_args_sz];
-        if (!op->set_auth_context(M)) { return scope.Close(v8::Undefined()); }
-    }
-
-    op->reqid = f(client->client(), in_space, in_key, in_key_sz, in_checks, in_checks_sz, in_attrs, in_attrs_sz, &op->status);
-
-    if (bDoAuth) op->clear_auth_context();
-    if (op->reqid < 0)
-    {
-        op->callback_error_from_status();
-        return scope.Close(v8::Undefined());
-    }
-
-    op->encode_return = &Operation::encode_asynccall_status;
-    client->add(op->reqid, op);
-    return scope.Close(v8::Undefined());
-}
-
-v8::Handle<v8::Value>
-HyperDexClient :: asynccall__spacename_predicates_attributes__status_count(int64_t (*f)(struct hyperdex_client* client, const char* space, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, const struct hyperdex_client_attribute* attrs, size_t attrs_sz, enum hyperdex_client_returncode* status, uint64_t* count), const v8::Arguments& args)
-{
-    v8::HandleScope scope;
-    v8::Local<v8::Object> client_obj = args.This();
-    HyperDexClient* client = node::ObjectWrap::Unwrap<HyperDexClient>(client_obj);
-    e::intrusive_ptr<Operation> op(new Operation(client_obj, client));
-    const size_t base_args_sz = 3;
-    const bool bDoAuth = ((size_t)args.Length() > base_args_sz + 1);
-    const size_t i_Func = bDoAuth ? base_args_sz + 1 : base_args_sz;
-    v8::Local<v8::Function> func = args[i_Func].As<v8::Function>();
-
-    if (func.IsEmpty() || !func->IsFunction())
-    {
-        v8::ThrowException(v8::String::New("Callback must be a function"));
-        return scope.Close(v8::Undefined());
-    }
-
-    if (!op->set_callback(func)) { return scope.Close(v8::Undefined()); }
-
-    const char* in_space;
-    v8::Local<v8::Value> spacename = args[0];
-    if (!op->convert_spacename(spacename, &in_space)) return scope.Close(v8::Undefined());
-    const struct hyperdex_client_attribute_check* in_checks;
-    size_t in_checks_sz;
-    v8::Local<v8::Value> predicates = args[1];
-    if (!op->convert_predicates(predicates, &in_checks, &in_checks_sz)) return scope.Close(v8::Undefined());
-    const struct hyperdex_client_attribute* in_attrs;
-    size_t in_attrs_sz;
-    v8::Local<v8::Value> attributes = args[2];
-    if (!op->convert_attributes(attributes, &in_attrs, &in_attrs_sz)) return scope.Close(v8::Undefined());
-    if (bDoAuth)
-    {
-        v8::Handle<v8::Value> M = args[base_args_sz];
-        if (!op->set_auth_context(M)) { return scope.Close(v8::Undefined()); }
-    }
-
-    op->reqid = f(client->client(), in_space, in_checks, in_checks_sz, in_attrs, in_attrs_sz, &op->status, &op->count);
-
-    if (bDoAuth) op->clear_auth_context();
-    if (op->reqid < 0)
-    {
-        op->callback_error_from_status();
-        return scope.Close(v8::Undefined());
-    }
-
-    op->encode_return = &Operation::encode_asynccall_status_count;
-    client->add(op->reqid, op);
-    return scope.Close(v8::Undefined());
-}
-
-v8::Handle<v8::Value>
-HyperDexClient :: asynccall__spacename_key__status(int64_t (*f)(struct hyperdex_client* client, const char* space, const char* key, size_t key_sz, enum hyperdex_client_returncode* status), const v8::Arguments& args)
-{
-    v8::HandleScope scope;
-    v8::Local<v8::Object> client_obj = args.This();
-    HyperDexClient* client = node::ObjectWrap::Unwrap<HyperDexClient>(client_obj);
-    e::intrusive_ptr<Operation> op(new Operation(client_obj, client));
-    const size_t base_args_sz = 2;
-    const bool bDoAuth = ((size_t)args.Length() > base_args_sz + 1);
-    const size_t i_Func = bDoAuth ? base_args_sz + 1 : base_args_sz;
-    v8::Local<v8::Function> func = args[i_Func].As<v8::Function>();
-
-    if (func.IsEmpty() || !func->IsFunction())
-    {
-        v8::ThrowException(v8::String::New("Callback must be a function"));
-        return scope.Close(v8::Undefined());
-    }
-
-    if (!op->set_callback(func)) { return scope.Close(v8::Undefined()); }
-
-    const char* in_space;
-    v8::Local<v8::Value> spacename = args[0];
-    if (!op->convert_spacename(spacename, &in_space)) return scope.Close(v8::Undefined());
-    const char* in_key;
-    size_t in_key_sz;
-    v8::Local<v8::Value> key = args[1];
-    if (!op->convert_key(key, &in_key, &in_key_sz)) return scope.Close(v8::Undefined());
-    if (bDoAuth)
-    {
-        v8::Handle<v8::Value> M = args[base_args_sz];
-        if (!op->set_auth_context(M)) { return scope.Close(v8::Undefined()); }
-    }
-
-    op->reqid = f(client->client(), in_space, in_key, in_key_sz, &op->status);
-
-    if (bDoAuth) op->clear_auth_context();
-    if (op->reqid < 0)
-    {
-        op->callback_error_from_status();
-        return scope.Close(v8::Undefined());
-    }
-
-    op->encode_return = &Operation::encode_asynccall_status;
-    client->add(op->reqid, op);
-    return scope.Close(v8::Undefined());
-}
-
-v8::Handle<v8::Value>
-HyperDexClient :: asynccall__spacename_key_predicates__status(int64_t (*f)(struct hyperdex_client* client, const char* space, const char* key, size_t key_sz, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, enum hyperdex_client_returncode* status), const v8::Arguments& args)
-{
-    v8::HandleScope scope;
-    v8::Local<v8::Object> client_obj = args.This();
-    HyperDexClient* client = node::ObjectWrap::Unwrap<HyperDexClient>(client_obj);
-    e::intrusive_ptr<Operation> op(new Operation(client_obj, client));
-    const size_t base_args_sz = 3;
-    const bool bDoAuth = ((size_t)args.Length() > base_args_sz + 1);
-    const size_t i_Func = bDoAuth ? base_args_sz + 1 : base_args_sz;
-    v8::Local<v8::Function> func = args[i_Func].As<v8::Function>();
-
-    if (func.IsEmpty() || !func->IsFunction())
-    {
-        v8::ThrowException(v8::String::New("Callback must be a function"));
-        return scope.Close(v8::Undefined());
-    }
-
-    if (!op->set_callback(func)) { return scope.Close(v8::Undefined()); }
-
-    const char* in_space;
-    v8::Local<v8::Value> spacename = args[0];
-    if (!op->convert_spacename(spacename, &in_space)) return scope.Close(v8::Undefined());
-    const char* in_key;
-    size_t in_key_sz;
-    v8::Local<v8::Value> key = args[1];
-    if (!op->convert_key(key, &in_key, &in_key_sz)) return scope.Close(v8::Undefined());
-    const struct hyperdex_client_attribute_check* in_checks;
-    size_t in_checks_sz;
-    v8::Local<v8::Value> predicates = args[2];
-    if (!op->convert_predicates(predicates, &in_checks, &in_checks_sz)) return scope.Close(v8::Undefined());
-    if (bDoAuth)
-    {
-        v8::Handle<v8::Value> M = args[base_args_sz];
-        if (!op->set_auth_context(M)) { return scope.Close(v8::Undefined()); }
-    }
-
-    op->reqid = f(client->client(), in_space, in_key, in_key_sz, in_checks, in_checks_sz, &op->status);
-
-    if (bDoAuth) op->clear_auth_context();
-    if (op->reqid < 0)
-    {
-        op->callback_error_from_status();
-        return scope.Close(v8::Undefined());
-    }
-
-    op->encode_return = &Operation::encode_asynccall_status;
-    client->add(op->reqid, op);
-    return scope.Close(v8::Undefined());
-}
-
-v8::Handle<v8::Value>
-HyperDexClient :: asynccall__spacename_predicates__status_count(int64_t (*f)(struct hyperdex_client* client, const char* space, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, enum hyperdex_client_returncode* status, uint64_t* count), const v8::Arguments& args)
-{
-    v8::HandleScope scope;
-    v8::Local<v8::Object> client_obj = args.This();
-    HyperDexClient* client = node::ObjectWrap::Unwrap<HyperDexClient>(client_obj);
-    e::intrusive_ptr<Operation> op(new Operation(client_obj, client));
-    const size_t base_args_sz = 2;
-    const bool bDoAuth = ((size_t)args.Length() > base_args_sz + 1);
-    const size_t i_Func = bDoAuth ? base_args_sz + 1 : base_args_sz;
-    v8::Local<v8::Function> func = args[i_Func].As<v8::Function>();
-
-    if (func.IsEmpty() || !func->IsFunction())
-    {
-        v8::ThrowException(v8::String::New("Callback must be a function"));
-        return scope.Close(v8::Undefined());
-    }
-
-    if (!op->set_callback(func)) { return scope.Close(v8::Undefined()); }
-
-    const char* in_space;
-    v8::Local<v8::Value> spacename = args[0];
-    if (!op->convert_spacename(spacename, &in_space)) return scope.Close(v8::Undefined());
-    const struct hyperdex_client_attribute_check* in_checks;
-    size_t in_checks_sz;
-    v8::Local<v8::Value> predicates = args[1];
-    if (!op->convert_predicates(predicates, &in_checks, &in_checks_sz)) return scope.Close(v8::Undefined());
-    if (bDoAuth)
-    {
-        v8::Handle<v8::Value> M = args[base_args_sz];
-        if (!op->set_auth_context(M)) { return scope.Close(v8::Undefined()); }
-    }
-
-    op->reqid = f(client->client(), in_space, in_checks, in_checks_sz, &op->status, &op->count);
-
-    if (bDoAuth) op->clear_auth_context();
-    if (op->reqid < 0)
-    {
-        op->callback_error_from_status();
-        return scope.Close(v8::Undefined());
-    }
-
-    op->encode_return = &Operation::encode_asynccall_status_count;
-    client->add(op->reqid, op);
-    return scope.Close(v8::Undefined());
-}
-
-v8::Handle<v8::Value>
-HyperDexClient :: asynccall__spacename_key_mapattributes__status(int64_t (*f)(struct hyperdex_client* client, const char* space, const char* key, size_t key_sz, const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz, enum hyperdex_client_returncode* status), const v8::Arguments& args)
-{
-    v8::HandleScope scope;
-    v8::Local<v8::Object> client_obj = args.This();
-    HyperDexClient* client = node::ObjectWrap::Unwrap<HyperDexClient>(client_obj);
-    e::intrusive_ptr<Operation> op(new Operation(client_obj, client));
-    const size_t base_args_sz = 3;
-    const bool bDoAuth = ((size_t)args.Length() > base_args_sz + 1);
-    const size_t i_Func = bDoAuth ? base_args_sz + 1 : base_args_sz;
-    v8::Local<v8::Function> func = args[i_Func].As<v8::Function>();
-
-    if (func.IsEmpty() || !func->IsFunction())
-    {
-        v8::ThrowException(v8::String::New("Callback must be a function"));
-        return scope.Close(v8::Undefined());
-    }
-
-    if (!op->set_callback(func)) { return scope.Close(v8::Undefined()); }
-
-    const char* in_space;
-    v8::Local<v8::Value> spacename = args[0];
-    if (!op->convert_spacename(spacename, &in_space)) return scope.Close(v8::Undefined());
-    const char* in_key;
-    size_t in_key_sz;
-    v8::Local<v8::Value> key = args[1];
-    if (!op->convert_key(key, &in_key, &in_key_sz)) return scope.Close(v8::Undefined());
-    const struct hyperdex_client_map_attribute* in_mapattrs;
-    size_t in_mapattrs_sz;
-    v8::Local<v8::Value> mapattributes = args[2];
-    if (!op->convert_mapattributes(mapattributes, &in_mapattrs, &in_mapattrs_sz)) return scope.Close(v8::Undefined());
-    if (bDoAuth)
-    {
-        v8::Handle<v8::Value> M = args[base_args_sz];
-        if (!op->set_auth_context(M)) { return scope.Close(v8::Undefined()); }
-    }
-
-    op->reqid = f(client->client(), in_space, in_key, in_key_sz, in_mapattrs, in_mapattrs_sz, &op->status);
-
-    if (bDoAuth) op->clear_auth_context();
-    if (op->reqid < 0)
-    {
-        op->callback_error_from_status();
-        return scope.Close(v8::Undefined());
-    }
-
-    op->encode_return = &Operation::encode_asynccall_status;
-    client->add(op->reqid, op);
-    return scope.Close(v8::Undefined());
-}
-
-v8::Handle<v8::Value>
-HyperDexClient :: asynccall__spacename_key_predicates_mapattributes__status(int64_t (*f)(struct hyperdex_client* client, const char* space, const char* key, size_t key_sz, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz, enum hyperdex_client_returncode* status), const v8::Arguments& args)
-{
-    v8::HandleScope scope;
-    v8::Local<v8::Object> client_obj = args.This();
-    HyperDexClient* client = node::ObjectWrap::Unwrap<HyperDexClient>(client_obj);
-    e::intrusive_ptr<Operation> op(new Operation(client_obj, client));
-    const size_t base_args_sz = 4;
-    const bool bDoAuth = ((size_t)args.Length() > base_args_sz + 1);
-    const size_t i_Func = bDoAuth ? base_args_sz + 1 : base_args_sz;
-    v8::Local<v8::Function> func = args[i_Func].As<v8::Function>();
-
-    if (func.IsEmpty() || !func->IsFunction())
-    {
-        v8::ThrowException(v8::String::New("Callback must be a function"));
-        return scope.Close(v8::Undefined());
-    }
-
-    if (!op->set_callback(func)) { return scope.Close(v8::Undefined()); }
-
-    const char* in_space;
-    v8::Local<v8::Value> spacename = args[0];
-    if (!op->convert_spacename(spacename, &in_space)) return scope.Close(v8::Undefined());
-    const char* in_key;
-    size_t in_key_sz;
-    v8::Local<v8::Value> key = args[1];
-    if (!op->convert_key(key, &in_key, &in_key_sz)) return scope.Close(v8::Undefined());
-    const struct hyperdex_client_attribute_check* in_checks;
-    size_t in_checks_sz;
-    v8::Local<v8::Value> predicates = args[2];
-    if (!op->convert_predicates(predicates, &in_checks, &in_checks_sz)) return scope.Close(v8::Undefined());
-    const struct hyperdex_client_map_attribute* in_mapattrs;
-    size_t in_mapattrs_sz;
-    v8::Local<v8::Value> mapattributes = args[3];
-    if (!op->convert_mapattributes(mapattributes, &in_mapattrs, &in_mapattrs_sz)) return scope.Close(v8::Undefined());
-    if (bDoAuth)
-    {
-        v8::Handle<v8::Value> M = args[base_args_sz];
-        if (!op->set_auth_context(M)) { return scope.Close(v8::Undefined()); }
-    }
-
-    op->reqid = f(client->client(), in_space, in_key, in_key_sz, in_checks, in_checks_sz, in_mapattrs, in_mapattrs_sz, &op->status);
-
-    if (bDoAuth) op->clear_auth_context();
-    if (op->reqid < 0)
-    {
-        op->callback_error_from_status();
-        return scope.Close(v8::Undefined());
-    }
-
-    op->encode_return = &Operation::encode_asynccall_status;
-    client->add(op->reqid, op);
-    return scope.Close(v8::Undefined());
-}
-
-v8::Handle<v8::Value>
-HyperDexClient :: asynccall__spacename_predicates_mapattributes__status_count(int64_t (*f)(struct hyperdex_client* client, const char* space, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz, enum hyperdex_client_returncode* status, uint64_t* count), const v8::Arguments& args)
-{
-    v8::HandleScope scope;
-    v8::Local<v8::Object> client_obj = args.This();
-    HyperDexClient* client = node::ObjectWrap::Unwrap<HyperDexClient>(client_obj);
-    e::intrusive_ptr<Operation> op(new Operation(client_obj, client));
-    const size_t base_args_sz = 3;
-    const bool bDoAuth = ((size_t)args.Length() > base_args_sz + 1);
-    const size_t i_Func = bDoAuth ? base_args_sz + 1 : base_args_sz;
-    v8::Local<v8::Function> func = args[i_Func].As<v8::Function>();
-
-    if (func.IsEmpty() || !func->IsFunction())
-    {
-        v8::ThrowException(v8::String::New("Callback must be a function"));
-        return scope.Close(v8::Undefined());
-    }
-
-    if (!op->set_callback(func)) { return scope.Close(v8::Undefined()); }
-
-    const char* in_space;
-    v8::Local<v8::Value> spacename = args[0];
-    if (!op->convert_spacename(spacename, &in_space)) return scope.Close(v8::Undefined());
-    const struct hyperdex_client_attribute_check* in_checks;
-    size_t in_checks_sz;
-    v8::Local<v8::Value> predicates = args[1];
-    if (!op->convert_predicates(predicates, &in_checks, &in_checks_sz)) return scope.Close(v8::Undefined());
-    const struct hyperdex_client_map_attribute* in_mapattrs;
-    size_t in_mapattrs_sz;
-    v8::Local<v8::Value> mapattributes = args[2];
-    if (!op->convert_mapattributes(mapattributes, &in_mapattrs, &in_mapattrs_sz)) return scope.Close(v8::Undefined());
-    if (bDoAuth)
-    {
-        v8::Handle<v8::Value> M = args[base_args_sz];
-        if (!op->set_auth_context(M)) { return scope.Close(v8::Undefined()); }
-    }
-
-    op->reqid = f(client->client(), in_space, in_checks, in_checks_sz, in_mapattrs, in_mapattrs_sz, &op->status, &op->count);
-
-    if (bDoAuth) op->clear_auth_context();
-    if (op->reqid < 0)
-    {
-        op->callback_error_from_status();
-        return scope.Close(v8::Undefined());
-    }
-
-    op->encode_return = &Operation::encode_asynccall_status_count;
-    client->add(op->reqid, op);
-    return scope.Close(v8::Undefined());
-}
-
-v8::Handle<v8::Value>
-HyperDexClient :: iterator__spacename_predicates__status_attributes(int64_t (*f)(struct hyperdex_client* client, const char* space, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, enum hyperdex_client_returncode* status, const struct hyperdex_client_attribute** attrs, size_t* attrs_sz), const v8::Arguments& args)
-{
-    v8::HandleScope scope;
-    v8::Local<v8::Object> client_obj = args.This();
-    HyperDexClient* client = node::ObjectWrap::Unwrap<HyperDexClient>(client_obj);
-    e::intrusive_ptr<Operation> op(new Operation(client_obj, client));
-    v8::Local<v8::Function> func = args[2].As<v8::Function>();
-
-    if (func.IsEmpty() || !func->IsFunction())
-    {
-        v8::ThrowException(v8::String::New("Callback must be a function"));
-        return scope.Close(v8::Undefined());
-    }
-
-    v8::Local<v8::Function> done = args[3].As<v8::Function>();
-
-    if (done.IsEmpty() || !done->IsFunction())
-    {
-        v8::ThrowException(v8::String::New("Callback must be a function"));
-        return scope.Close(v8::Undefined());
-    }
-
-    if (!op->set_callback(func, done)) { return scope.Close(v8::Undefined()); }
-    const char* in_space;
-    v8::Local<v8::Value> spacename = args[0];
-    if (!op->convert_spacename(spacename, &in_space)) return scope.Close(v8::Undefined());
-    const struct hyperdex_client_attribute_check* in_checks;
-    size_t in_checks_sz;
-    v8::Local<v8::Value> predicates = args[1];
-    if (!op->convert_predicates(predicates, &in_checks, &in_checks_sz)) return scope.Close(v8::Undefined());
-    op->reqid = f(client->client(), in_space, in_checks, in_checks_sz, &op->status, &op->attrs, &op->attrs_sz);
-
-    if (op->reqid < 0)
-    {
-        op->callback_error_from_status();
-        return scope.Close(v8::Undefined());
-    }
-
-    op->encode_return = &Operation::encode_iterator_status_attributes;
-    client->add(op->reqid, op);
-    return scope.Close(v8::Undefined());
-}
-
-v8::Handle<v8::Value>
-HyperDexClient :: asynccall__spacename_predicates__status_description(int64_t (*f)(struct hyperdex_client* client, const char* space, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, enum hyperdex_client_returncode* status, const char** description), const v8::Arguments& args)
-{
-    v8::HandleScope scope;
-    v8::Local<v8::Object> client_obj = args.This();
-    HyperDexClient* client = node::ObjectWrap::Unwrap<HyperDexClient>(client_obj);
-    e::intrusive_ptr<Operation> op(new Operation(client_obj, client));
-    const size_t base_args_sz = 2;
-    const bool bDoAuth = ((size_t)args.Length() > base_args_sz + 1);
-    const size_t i_Func = bDoAuth ? base_args_sz + 1 : base_args_sz;
-    v8::Local<v8::Function> func = args[i_Func].As<v8::Function>();
-
-    if (func.IsEmpty() || !func->IsFunction())
-    {
-        v8::ThrowException(v8::String::New("Callback must be a function"));
-        return scope.Close(v8::Undefined());
-    }
-
-    if (!op->set_callback(func)) { return scope.Close(v8::Undefined()); }
-
-    const char* in_space;
-    v8::Local<v8::Value> spacename = args[0];
-    if (!op->convert_spacename(spacename, &in_space)) return scope.Close(v8::Undefined());
-    const struct hyperdex_client_attribute_check* in_checks;
-    size_t in_checks_sz;
-    v8::Local<v8::Value> predicates = args[1];
-    if (!op->convert_predicates(predicates, &in_checks, &in_checks_sz)) return scope.Close(v8::Undefined());
-    if (bDoAuth)
-    {
-        v8::Handle<v8::Value> M = args[base_args_sz];
-        if (!op->set_auth_context(M)) { return scope.Close(v8::Undefined()); }
-    }
-
-    op->reqid = f(client->client(), in_space, in_checks, in_checks_sz, &op->status, &op->description);
-
-    if (bDoAuth) op->clear_auth_context();
-    if (op->reqid < 0)
-    {
-        op->callback_error_from_status();
-        return scope.Close(v8::Undefined());
-    }
-
-    op->encode_return = &Operation::encode_asynccall_status_description;
-    client->add(op->reqid, op);
-    return scope.Close(v8::Undefined());
-}
-
+HyperDexClient :: asynccall__spacename_key__status_attributes(int64_t (*f)(struct hyperdex_client *client, const char *space, const char *key, size_t key_sz, enum hyperdex_client_returncode *status, const struct hyperdex_client_attribute **attrs, size_t *attrs_sz), const v8::Arguments &args)
+{
+	v8::HandleScope scope;
+	v8::Local<v8::Object> client_obj = args.This();
+	HyperDexClient *client = node::ObjectWrap::Unwrap<HyperDexClient>(client_obj);
+	e::intrusive_ptr<Operation> op(new Operation(client_obj, client));
+	const size_t base_args_sz = 2;
+	const bool bDoAuth = ((size_t)args.Length() > base_args_sz + 1);
+	const size_t i_Func = bDoAuth ? base_args_sz + 1 : base_args_sz;
+	v8::Local<v8::Function> func = args[i_Func].As<v8::Function>();
+	if (func.IsEmpty() || !func->IsFunction())
+	{
+		v8::ThrowException(v8::String::New("Callback must be a function"));
+		return scope.Close(v8::Undefined());
+	}
+	if (!op->set_callback(func)) { return scope.Close(v8::Undefined()); }
+	const char *in_space;
+	v8::Local<v8::Value> spacename = args[0];
+	if (!op->convert_spacename(spacename, &in_space)) return scope.Close(v8::Undefined());
+	const char *in_key;
+	size_t in_key_sz;
+	v8::Local<v8::Value> key = args[1];
+	if (!op->convert_key(key, &in_key, &in_key_sz)) return scope.Close(v8::Undefined());
+	if (bDoAuth)
+	{
+		v8::Handle<v8::Value> M = args[base_args_sz];
+		if (!op->set_auth_context(M)) { return scope.Close(v8::Undefined()); }
+	}
+	op->reqid = f(client->client(), in_space, in_key, in_key_sz, &op->status, &op->attrs, &op->attrs_sz);
+	if (bDoAuth) op->clear_auth_context();
+	if (op->reqid < 0)
+	{
+		op->callback_error_from_status();
+		return scope.Close(v8::Undefined());
+	}
+	op->encode_return = &Operation::encode_asynccall_status_attributes;
+	client->add(op->reqid, op);
+	return scope.Close(v8::Undefined());
+}
+
+v8::Handle<v8::Value>
+HyperDexClient :: asynccall__spacename_key_attributenames__status_attributes(int64_t (*f)(struct hyperdex_client *client, const char *space, const char *key, size_t key_sz, const char **attrnames, size_t attrnames_sz, enum hyperdex_client_returncode *status, const struct hyperdex_client_attribute **attrs, size_t *attrs_sz), const v8::Arguments &args)
+{
+	v8::HandleScope scope;
+	v8::Local<v8::Object> client_obj = args.This();
+	HyperDexClient *client = node::ObjectWrap::Unwrap<HyperDexClient>(client_obj);
+	e::intrusive_ptr<Operation> op(new Operation(client_obj, client));
+	const size_t base_args_sz = 3;
+	const bool bDoAuth = ((size_t)args.Length() > base_args_sz + 1);
+	const size_t i_Func = bDoAuth ? base_args_sz + 1 : base_args_sz;
+	v8::Local<v8::Function> func = args[i_Func].As<v8::Function>();
+	if (func.IsEmpty() || !func->IsFunction())
+	{
+		v8::ThrowException(v8::String::New("Callback must be a function"));
+		return scope.Close(v8::Undefined());
+	}
+	if (!op->set_callback(func)) { return scope.Close(v8::Undefined()); }
+	const char *in_space;
+	v8::Local<v8::Value> spacename = args[0];
+	if (!op->convert_spacename(spacename, &in_space)) return scope.Close(v8::Undefined());
+	const char *in_key;
+	size_t in_key_sz;
+	v8::Local<v8::Value> key = args[1];
+	if (!op->convert_key(key, &in_key, &in_key_sz)) return scope.Close(v8::Undefined());
+	const char **in_attrnames;
+	size_t in_attrnames_sz;
+	v8::Local<v8::Value> attributenames = args[2];
+	if (!op->convert_attributenames(attributenames, &in_attrnames, &in_attrnames_sz)) return scope.Close(v8::Undefined());
+	if (bDoAuth)
+	{
+		v8::Handle<v8::Value> M = args[base_args_sz];
+		if (!op->set_auth_context(M)) { return scope.Close(v8::Undefined()); }
+	}
+	op->reqid = f(client->client(), in_space, in_key, in_key_sz, in_attrnames, in_attrnames_sz, &op->status, &op->attrs, &op->attrs_sz);
+	if (bDoAuth) op->clear_auth_context();
+	if (op->reqid < 0)
+	{
+		op->callback_error_from_status();
+		return scope.Close(v8::Undefined());
+	}
+	op->encode_return = &Operation::encode_asynccall_status_attributes;
+	client->add(op->reqid, op);
+	return scope.Close(v8::Undefined());
+}
+
+v8::Handle<v8::Value>
+HyperDexClient :: asynccall__spacename_key_attributes__status(int64_t (*f)(struct hyperdex_client *client, const char *space, const char *key, size_t key_sz, const struct hyperdex_client_attribute *attrs, size_t attrs_sz, enum hyperdex_client_returncode *status), const v8::Arguments &args)
+{
+	v8::HandleScope scope;
+	v8::Local<v8::Object> client_obj = args.This();
+	HyperDexClient *client = node::ObjectWrap::Unwrap<HyperDexClient>(client_obj);
+	e::intrusive_ptr<Operation> op(new Operation(client_obj, client));
+	const size_t base_args_sz = 3;
+	const bool bDoAuth = ((size_t)args.Length() > base_args_sz + 1);
+	const size_t i_Func = bDoAuth ? base_args_sz + 1 : base_args_sz;
+	v8::Local<v8::Function> func = args[i_Func].As<v8::Function>();
+	if (func.IsEmpty() || !func->IsFunction())
+	{
+		v8::ThrowException(v8::String::New("Callback must be a function"));
+		return scope.Close(v8::Undefined());
+	}
+	if (!op->set_callback(func)) { return scope.Close(v8::Undefined()); }
+	const char *in_space;
+	v8::Local<v8::Value> spacename = args[0];
+	if (!op->convert_spacename(spacename, &in_space)) return scope.Close(v8::Undefined());
+	const char *in_key;
+	size_t in_key_sz;
+	v8::Local<v8::Value> key = args[1];
+	if (!op->convert_key(key, &in_key, &in_key_sz)) return scope.Close(v8::Undefined());
+	const struct hyperdex_client_attribute *in_attrs;
+	size_t in_attrs_sz;
+	v8::Local<v8::Value> attributes = args[2];
+	if (!op->convert_attributes(attributes, &in_attrs, &in_attrs_sz)) return scope.Close(v8::Undefined());
+	if (bDoAuth)
+	{
+		v8::Handle<v8::Value> M = args[base_args_sz];
+		if (!op->set_auth_context(M)) { return scope.Close(v8::Undefined()); }
+	}
+	op->reqid = f(client->client(), in_space, in_key, in_key_sz, in_attrs, in_attrs_sz, &op->status);
+	if (bDoAuth) op->clear_auth_context();
+	if (op->reqid < 0)
+	{
+		op->callback_error_from_status();
+		return scope.Close(v8::Undefined());
+	}
+	op->encode_return = &Operation::encode_asynccall_status;
+	client->add(op->reqid, op);
+	return scope.Close(v8::Undefined());
+}
+
+v8::Handle<v8::Value>
+HyperDexClient :: asynccall__spacename_key_predicates_attributes__status(int64_t (*f)(struct hyperdex_client *client, const char *space, const char *key, size_t key_sz, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, const struct hyperdex_client_attribute *attrs, size_t attrs_sz, enum hyperdex_client_returncode *status), const v8::Arguments &args)
+{
+	v8::HandleScope scope;
+	v8::Local<v8::Object> client_obj = args.This();
+	HyperDexClient *client = node::ObjectWrap::Unwrap<HyperDexClient>(client_obj);
+	e::intrusive_ptr<Operation> op(new Operation(client_obj, client));
+	const size_t base_args_sz = 4;
+	const bool bDoAuth = ((size_t)args.Length() > base_args_sz + 1);
+	const size_t i_Func = bDoAuth ? base_args_sz + 1 : base_args_sz;
+	v8::Local<v8::Function> func = args[i_Func].As<v8::Function>();
+	if (func.IsEmpty() || !func->IsFunction())
+	{
+		v8::ThrowException(v8::String::New("Callback must be a function"));
+		return scope.Close(v8::Undefined());
+	}
+	if (!op->set_callback(func)) { return scope.Close(v8::Undefined()); }
+	const char *in_space;
+	v8::Local<v8::Value> spacename = args[0];
+	if (!op->convert_spacename(spacename, &in_space)) return scope.Close(v8::Undefined());
+	const char *in_key;
+	size_t in_key_sz;
+	v8::Local<v8::Value> key = args[1];
+	if (!op->convert_key(key, &in_key, &in_key_sz)) return scope.Close(v8::Undefined());
+	const struct hyperdex_client_attribute_check *in_checks;
+	size_t in_checks_sz;
+	v8::Local<v8::Value> predicates = args[2];
+	if (!op->convert_predicates(predicates, &in_checks, &in_checks_sz)) return scope.Close(v8::Undefined());
+	const struct hyperdex_client_attribute *in_attrs;
+	size_t in_attrs_sz;
+	v8::Local<v8::Value> attributes = args[3];
+	if (!op->convert_attributes(attributes, &in_attrs, &in_attrs_sz)) return scope.Close(v8::Undefined());
+	if (bDoAuth)
+	{
+		v8::Handle<v8::Value> M = args[base_args_sz];
+		if (!op->set_auth_context(M)) { return scope.Close(v8::Undefined()); }
+	}
+	op->reqid = f(client->client(), in_space, in_key, in_key_sz, in_checks, in_checks_sz, in_attrs, in_attrs_sz, &op->status);
+	if (bDoAuth) op->clear_auth_context();
+	if (op->reqid < 0)
+	{
+		op->callback_error_from_status();
+		return scope.Close(v8::Undefined());
+	}
+	op->encode_return = &Operation::encode_asynccall_status;
+	client->add(op->reqid, op);
+	return scope.Close(v8::Undefined());
+}
+
+v8::Handle<v8::Value>
+HyperDexClient :: asynccall__spacename_predicates_attributes__status_count(int64_t (*f)(struct hyperdex_client *client, const char *space, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, const struct hyperdex_client_attribute *attrs, size_t attrs_sz, enum hyperdex_client_returncode *status, uint64_t *count), const v8::Arguments &args)
+{
+	v8::HandleScope scope;
+	v8::Local<v8::Object> client_obj = args.This();
+	HyperDexClient *client = node::ObjectWrap::Unwrap<HyperDexClient>(client_obj);
+	e::intrusive_ptr<Operation> op(new Operation(client_obj, client));
+	const size_t base_args_sz = 3;
+	const bool bDoAuth = ((size_t)args.Length() > base_args_sz + 1);
+	const size_t i_Func = bDoAuth ? base_args_sz + 1 : base_args_sz;
+	v8::Local<v8::Function> func = args[i_Func].As<v8::Function>();
+	if (func.IsEmpty() || !func->IsFunction())
+	{
+		v8::ThrowException(v8::String::New("Callback must be a function"));
+		return scope.Close(v8::Undefined());
+	}
+	if (!op->set_callback(func)) { return scope.Close(v8::Undefined()); }
+	const char *in_space;
+	v8::Local<v8::Value> spacename = args[0];
+	if (!op->convert_spacename(spacename, &in_space)) return scope.Close(v8::Undefined());
+	const struct hyperdex_client_attribute_check *in_checks;
+	size_t in_checks_sz;
+	v8::Local<v8::Value> predicates = args[1];
+	if (!op->convert_predicates(predicates, &in_checks, &in_checks_sz)) return scope.Close(v8::Undefined());
+	const struct hyperdex_client_attribute *in_attrs;
+	size_t in_attrs_sz;
+	v8::Local<v8::Value> attributes = args[2];
+	if (!op->convert_attributes(attributes, &in_attrs, &in_attrs_sz)) return scope.Close(v8::Undefined());
+	if (bDoAuth)
+	{
+		v8::Handle<v8::Value> M = args[base_args_sz];
+		if (!op->set_auth_context(M)) { return scope.Close(v8::Undefined()); }
+	}
+	op->reqid = f(client->client(), in_space, in_checks, in_checks_sz, in_attrs, in_attrs_sz, &op->status, &op->count);
+	if (bDoAuth) op->clear_auth_context();
+	if (op->reqid < 0)
+	{
+		op->callback_error_from_status();
+		return scope.Close(v8::Undefined());
+	}
+	op->encode_return = &Operation::encode_asynccall_status_count;
+	client->add(op->reqid, op);
+	return scope.Close(v8::Undefined());
+}
+
+v8::Handle<v8::Value>
+HyperDexClient :: asynccall__spacename_key__status(int64_t (*f)(struct hyperdex_client *client, const char *space, const char *key, size_t key_sz, enum hyperdex_client_returncode *status), const v8::Arguments &args)
+{
+	v8::HandleScope scope;
+	v8::Local<v8::Object> client_obj = args.This();
+	HyperDexClient *client = node::ObjectWrap::Unwrap<HyperDexClient>(client_obj);
+	e::intrusive_ptr<Operation> op(new Operation(client_obj, client));
+	const size_t base_args_sz = 2;
+	const bool bDoAuth = ((size_t)args.Length() > base_args_sz + 1);
+	const size_t i_Func = bDoAuth ? base_args_sz + 1 : base_args_sz;
+	v8::Local<v8::Function> func = args[i_Func].As<v8::Function>();
+	if (func.IsEmpty() || !func->IsFunction())
+	{
+		v8::ThrowException(v8::String::New("Callback must be a function"));
+		return scope.Close(v8::Undefined());
+	}
+	if (!op->set_callback(func)) { return scope.Close(v8::Undefined()); }
+	const char *in_space;
+	v8::Local<v8::Value> spacename = args[0];
+	if (!op->convert_spacename(spacename, &in_space)) return scope.Close(v8::Undefined());
+	const char *in_key;
+	size_t in_key_sz;
+	v8::Local<v8::Value> key = args[1];
+	if (!op->convert_key(key, &in_key, &in_key_sz)) return scope.Close(v8::Undefined());
+	if (bDoAuth)
+	{
+		v8::Handle<v8::Value> M = args[base_args_sz];
+		if (!op->set_auth_context(M)) { return scope.Close(v8::Undefined()); }
+	}
+	op->reqid = f(client->client(), in_space, in_key, in_key_sz, &op->status);
+	if (bDoAuth) op->clear_auth_context();
+	if (op->reqid < 0)
+	{
+		op->callback_error_from_status();
+		return scope.Close(v8::Undefined());
+	}
+	op->encode_return = &Operation::encode_asynccall_status;
+	client->add(op->reqid, op);
+	return scope.Close(v8::Undefined());
+}
+
+v8::Handle<v8::Value>
+HyperDexClient :: asynccall__spacename_key_predicates__status(int64_t (*f)(struct hyperdex_client *client, const char *space, const char *key, size_t key_sz, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, enum hyperdex_client_returncode *status), const v8::Arguments &args)
+{
+	v8::HandleScope scope;
+	v8::Local<v8::Object> client_obj = args.This();
+	HyperDexClient *client = node::ObjectWrap::Unwrap<HyperDexClient>(client_obj);
+	e::intrusive_ptr<Operation> op(new Operation(client_obj, client));
+	const size_t base_args_sz = 3;
+	const bool bDoAuth = ((size_t)args.Length() > base_args_sz + 1);
+	const size_t i_Func = bDoAuth ? base_args_sz + 1 : base_args_sz;
+	v8::Local<v8::Function> func = args[i_Func].As<v8::Function>();
+	if (func.IsEmpty() || !func->IsFunction())
+	{
+		v8::ThrowException(v8::String::New("Callback must be a function"));
+		return scope.Close(v8::Undefined());
+	}
+	if (!op->set_callback(func)) { return scope.Close(v8::Undefined()); }
+	const char *in_space;
+	v8::Local<v8::Value> spacename = args[0];
+	if (!op->convert_spacename(spacename, &in_space)) return scope.Close(v8::Undefined());
+	const char *in_key;
+	size_t in_key_sz;
+	v8::Local<v8::Value> key = args[1];
+	if (!op->convert_key(key, &in_key, &in_key_sz)) return scope.Close(v8::Undefined());
+	const struct hyperdex_client_attribute_check *in_checks;
+	size_t in_checks_sz;
+	v8::Local<v8::Value> predicates = args[2];
+	if (!op->convert_predicates(predicates, &in_checks, &in_checks_sz)) return scope.Close(v8::Undefined());
+	if (bDoAuth)
+	{
+		v8::Handle<v8::Value> M = args[base_args_sz];
+		if (!op->set_auth_context(M)) { return scope.Close(v8::Undefined()); }
+	}
+	op->reqid = f(client->client(), in_space, in_key, in_key_sz, in_checks, in_checks_sz, &op->status);
+	if (bDoAuth) op->clear_auth_context();
+	if (op->reqid < 0)
+	{
+		op->callback_error_from_status();
+		return scope.Close(v8::Undefined());
+	}
+	op->encode_return = &Operation::encode_asynccall_status;
+	client->add(op->reqid, op);
+	return scope.Close(v8::Undefined());
+}
+
+v8::Handle<v8::Value>
+HyperDexClient :: asynccall__spacename_predicates__status_count(int64_t (*f)(struct hyperdex_client *client, const char *space, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, enum hyperdex_client_returncode *status, uint64_t *count), const v8::Arguments &args)
+{
+	v8::HandleScope scope;
+	v8::Local<v8::Object> client_obj = args.This();
+	HyperDexClient *client = node::ObjectWrap::Unwrap<HyperDexClient>(client_obj);
+	e::intrusive_ptr<Operation> op(new Operation(client_obj, client));
+	const size_t base_args_sz = 2;
+	const bool bDoAuth = ((size_t)args.Length() > base_args_sz + 1);
+	const size_t i_Func = bDoAuth ? base_args_sz + 1 : base_args_sz;
+	v8::Local<v8::Function> func = args[i_Func].As<v8::Function>();
+	if (func.IsEmpty() || !func->IsFunction())
+	{
+		v8::ThrowException(v8::String::New("Callback must be a function"));
+		return scope.Close(v8::Undefined());
+	}
+	if (!op->set_callback(func)) { return scope.Close(v8::Undefined()); }
+	const char *in_space;
+	v8::Local<v8::Value> spacename = args[0];
+	if (!op->convert_spacename(spacename, &in_space)) return scope.Close(v8::Undefined());
+	const struct hyperdex_client_attribute_check *in_checks;
+	size_t in_checks_sz;
+	v8::Local<v8::Value> predicates = args[1];
+	if (!op->convert_predicates(predicates, &in_checks, &in_checks_sz)) return scope.Close(v8::Undefined());
+	if (bDoAuth)
+	{
+		v8::Handle<v8::Value> M = args[base_args_sz];
+		if (!op->set_auth_context(M)) { return scope.Close(v8::Undefined()); }
+	}
+	op->reqid = f(client->client(), in_space, in_checks, in_checks_sz, &op->status, &op->count);
+	if (bDoAuth) op->clear_auth_context();
+	if (op->reqid < 0)
+	{
+		op->callback_error_from_status();
+		return scope.Close(v8::Undefined());
+	}
+	op->encode_return = &Operation::encode_asynccall_status_count;
+	client->add(op->reqid, op);
+	return scope.Close(v8::Undefined());
+}
+
+v8::Handle<v8::Value>
+HyperDexClient :: asynccall__spacename_key_mapattributes__status(int64_t (*f)(struct hyperdex_client *client, const char *space, const char *key, size_t key_sz, const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz, enum hyperdex_client_returncode *status), const v8::Arguments &args)
+{
+	v8::HandleScope scope;
+	v8::Local<v8::Object> client_obj = args.This();
+	HyperDexClient *client = node::ObjectWrap::Unwrap<HyperDexClient>(client_obj);
+	e::intrusive_ptr<Operation> op(new Operation(client_obj, client));
+	const size_t base_args_sz = 3;
+	const bool bDoAuth = ((size_t)args.Length() > base_args_sz + 1);
+	const size_t i_Func = bDoAuth ? base_args_sz + 1 : base_args_sz;
+	v8::Local<v8::Function> func = args[i_Func].As<v8::Function>();
+	if (func.IsEmpty() || !func->IsFunction())
+	{
+		v8::ThrowException(v8::String::New("Callback must be a function"));
+		return scope.Close(v8::Undefined());
+	}
+	if (!op->set_callback(func)) { return scope.Close(v8::Undefined()); }
+	const char *in_space;
+	v8::Local<v8::Value> spacename = args[0];
+	if (!op->convert_spacename(spacename, &in_space)) return scope.Close(v8::Undefined());
+	const char *in_key;
+	size_t in_key_sz;
+	v8::Local<v8::Value> key = args[1];
+	if (!op->convert_key(key, &in_key, &in_key_sz)) return scope.Close(v8::Undefined());
+	const struct hyperdex_client_map_attribute *in_mapattrs;
+	size_t in_mapattrs_sz;
+	v8::Local<v8::Value> mapattributes = args[2];
+	if (!op->convert_mapattributes(mapattributes, &in_mapattrs, &in_mapattrs_sz)) return scope.Close(v8::Undefined());
+	if (bDoAuth)
+	{
+		v8::Handle<v8::Value> M = args[base_args_sz];
+		if (!op->set_auth_context(M)) { return scope.Close(v8::Undefined()); }
+	}
+	op->reqid = f(client->client(), in_space, in_key, in_key_sz, in_mapattrs, in_mapattrs_sz, &op->status);
+	if (bDoAuth) op->clear_auth_context();
+	if (op->reqid < 0)
+	{
+		op->callback_error_from_status();
+		return scope.Close(v8::Undefined());
+	}
+	op->encode_return = &Operation::encode_asynccall_status;
+	client->add(op->reqid, op);
+	return scope.Close(v8::Undefined());
+}
+
+v8::Handle<v8::Value>
+HyperDexClient :: asynccall__spacename_key_predicates_mapattributes__status(int64_t (*f)(struct hyperdex_client *client, const char *space, const char *key, size_t key_sz, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz, enum hyperdex_client_returncode *status), const v8::Arguments &args)
+{
+	v8::HandleScope scope;
+	v8::Local<v8::Object> client_obj = args.This();
+	HyperDexClient *client = node::ObjectWrap::Unwrap<HyperDexClient>(client_obj);
+	e::intrusive_ptr<Operation> op(new Operation(client_obj, client));
+	const size_t base_args_sz = 4;
+	const bool bDoAuth = ((size_t)args.Length() > base_args_sz + 1);
+	const size_t i_Func = bDoAuth ? base_args_sz + 1 : base_args_sz;
+	v8::Local<v8::Function> func = args[i_Func].As<v8::Function>();
+	if (func.IsEmpty() || !func->IsFunction())
+	{
+		v8::ThrowException(v8::String::New("Callback must be a function"));
+		return scope.Close(v8::Undefined());
+	}
+	if (!op->set_callback(func)) { return scope.Close(v8::Undefined()); }
+	const char *in_space;
+	v8::Local<v8::Value> spacename = args[0];
+	if (!op->convert_spacename(spacename, &in_space)) return scope.Close(v8::Undefined());
+	const char *in_key;
+	size_t in_key_sz;
+	v8::Local<v8::Value> key = args[1];
+	if (!op->convert_key(key, &in_key, &in_key_sz)) return scope.Close(v8::Undefined());
+	const struct hyperdex_client_attribute_check *in_checks;
+	size_t in_checks_sz;
+	v8::Local<v8::Value> predicates = args[2];
+	if (!op->convert_predicates(predicates, &in_checks, &in_checks_sz)) return scope.Close(v8::Undefined());
+	const struct hyperdex_client_map_attribute *in_mapattrs;
+	size_t in_mapattrs_sz;
+	v8::Local<v8::Value> mapattributes = args[3];
+	if (!op->convert_mapattributes(mapattributes, &in_mapattrs, &in_mapattrs_sz)) return scope.Close(v8::Undefined());
+	if (bDoAuth)
+	{
+		v8::Handle<v8::Value> M = args[base_args_sz];
+		if (!op->set_auth_context(M)) { return scope.Close(v8::Undefined()); }
+	}
+	op->reqid = f(client->client(), in_space, in_key, in_key_sz, in_checks, in_checks_sz, in_mapattrs, in_mapattrs_sz, &op->status);
+	if (bDoAuth) op->clear_auth_context();
+	if (op->reqid < 0)
+	{
+		op->callback_error_from_status();
+		return scope.Close(v8::Undefined());
+	}
+	op->encode_return = &Operation::encode_asynccall_status;
+	client->add(op->reqid, op);
+	return scope.Close(v8::Undefined());
+}
+
+v8::Handle<v8::Value>
+HyperDexClient :: asynccall__spacename_predicates_mapattributes__status_count(int64_t (*f)(struct hyperdex_client *client, const char *space, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz, enum hyperdex_client_returncode *status, uint64_t *count), const v8::Arguments &args)
+{
+	v8::HandleScope scope;
+	v8::Local<v8::Object> client_obj = args.This();
+	HyperDexClient *client = node::ObjectWrap::Unwrap<HyperDexClient>(client_obj);
+	e::intrusive_ptr<Operation> op(new Operation(client_obj, client));
+	const size_t base_args_sz = 3;
+	const bool bDoAuth = ((size_t)args.Length() > base_args_sz + 1);
+	const size_t i_Func = bDoAuth ? base_args_sz + 1 : base_args_sz;
+	v8::Local<v8::Function> func = args[i_Func].As<v8::Function>();
+	if (func.IsEmpty() || !func->IsFunction())
+	{
+		v8::ThrowException(v8::String::New("Callback must be a function"));
+		return scope.Close(v8::Undefined());
+	}
+	if (!op->set_callback(func)) { return scope.Close(v8::Undefined()); }
+	const char *in_space;
+	v8::Local<v8::Value> spacename = args[0];
+	if (!op->convert_spacename(spacename, &in_space)) return scope.Close(v8::Undefined());
+	const struct hyperdex_client_attribute_check *in_checks;
+	size_t in_checks_sz;
+	v8::Local<v8::Value> predicates = args[1];
+	if (!op->convert_predicates(predicates, &in_checks, &in_checks_sz)) return scope.Close(v8::Undefined());
+	const struct hyperdex_client_map_attribute *in_mapattrs;
+	size_t in_mapattrs_sz;
+	v8::Local<v8::Value> mapattributes = args[2];
+	if (!op->convert_mapattributes(mapattributes, &in_mapattrs, &in_mapattrs_sz)) return scope.Close(v8::Undefined());
+	if (bDoAuth)
+	{
+		v8::Handle<v8::Value> M = args[base_args_sz];
+		if (!op->set_auth_context(M)) { return scope.Close(v8::Undefined()); }
+	}
+	op->reqid = f(client->client(), in_space, in_checks, in_checks_sz, in_mapattrs, in_mapattrs_sz, &op->status, &op->count);
+	if (bDoAuth) op->clear_auth_context();
+	if (op->reqid < 0)
+	{
+		op->callback_error_from_status();
+		return scope.Close(v8::Undefined());
+	}
+	op->encode_return = &Operation::encode_asynccall_status_count;
+	client->add(op->reqid, op);
+	return scope.Close(v8::Undefined());
+}
+
+v8::Handle<v8::Value>
+HyperDexClient :: iterator__spacename_predicates__status_attributes(int64_t (*f)(struct hyperdex_client *client, const char *space, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, enum hyperdex_client_returncode *status, const struct hyperdex_client_attribute **attrs, size_t *attrs_sz), const v8::Arguments &args)
+{
+	v8::HandleScope scope;
+	v8::Local<v8::Object> client_obj = args.This();
+	HyperDexClient *client = node::ObjectWrap::Unwrap<HyperDexClient>(client_obj);
+	e::intrusive_ptr<Operation> op(new Operation(client_obj, client));
+	v8::Local<v8::Function> func = args[2].As<v8::Function>();
+	if (func.IsEmpty() || !func->IsFunction())
+	{
+		v8::ThrowException(v8::String::New("Callback must be a function"));
+		return scope.Close(v8::Undefined());
+	}
+	v8::Local<v8::Function> done = args[3].As<v8::Function>();
+	if (done.IsEmpty() || !done->IsFunction())
+	{
+		v8::ThrowException(v8::String::New("Callback must be a function"));
+		return scope.Close(v8::Undefined());
+	}
+	if (!op->set_callback(func, done)) { return scope.Close(v8::Undefined()); }
+	const char *in_space;
+	v8::Local<v8::Value> spacename = args[0];
+	if (!op->convert_spacename(spacename, &in_space)) return scope.Close(v8::Undefined());
+	const struct hyperdex_client_attribute_check *in_checks;
+	size_t in_checks_sz;
+	v8::Local<v8::Value> predicates = args[1];
+	if (!op->convert_predicates(predicates, &in_checks, &in_checks_sz)) return scope.Close(v8::Undefined());
+	op->reqid = f(client->client(), in_space, in_checks, in_checks_sz, &op->status, &op->attrs, &op->attrs_sz);
+	if (op->reqid < 0)
+	{
+		op->callback_error_from_status();
+		return scope.Close(v8::Undefined());
+	}
+	op->encode_return = &Operation::encode_iterator_status_attributes;
+	client->add(op->reqid, op);
+	return scope.Close(v8::Undefined());
+}
+
+v8::Handle<v8::Value>
+HyperDexClient :: asynccall__spacename_predicates__status_description(int64_t (*f)(struct hyperdex_client *client, const char *space, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, enum hyperdex_client_returncode *status, const char **description), const v8::Arguments &args)
+{
+	v8::HandleScope scope;
+	v8::Local<v8::Object> client_obj = args.This();
+	HyperDexClient *client = node::ObjectWrap::Unwrap<HyperDexClient>(client_obj);
+	e::intrusive_ptr<Operation> op(new Operation(client_obj, client));
+	const size_t base_args_sz = 2;
+	const bool bDoAuth = ((size_t)args.Length() > base_args_sz + 1);
+	const size_t i_Func = bDoAuth ? base_args_sz + 1 : base_args_sz;
+	v8::Local<v8::Function> func = args[i_Func].As<v8::Function>();
+	if (func.IsEmpty() || !func->IsFunction())
+	{
+		v8::ThrowException(v8::String::New("Callback must be a function"));
+		return scope.Close(v8::Undefined());
+	}
+	if (!op->set_callback(func)) { return scope.Close(v8::Undefined()); }
+	const char *in_space;
+	v8::Local<v8::Value> spacename = args[0];
+	if (!op->convert_spacename(spacename, &in_space)) return scope.Close(v8::Undefined());
+	const struct hyperdex_client_attribute_check *in_checks;
+	size_t in_checks_sz;
+	v8::Local<v8::Value> predicates = args[1];
+	if (!op->convert_predicates(predicates, &in_checks, &in_checks_sz)) return scope.Close(v8::Undefined());
+	if (bDoAuth)
+	{
+		v8::Handle<v8::Value> M = args[base_args_sz];
+		if (!op->set_auth_context(M)) { return scope.Close(v8::Undefined()); }
+	}
+	op->reqid = f(client->client(), in_space, in_checks, in_checks_sz, &op->status, &op->description);
+	if (bDoAuth) op->clear_auth_context();
+	if (op->reqid < 0)
+	{
+		op->callback_error_from_status();
+		return scope.Close(v8::Undefined());
+	}
+	op->encode_return = &Operation::encode_asynccall_status_description;
+	client->add(op->reqid, op);
+	return scope.Close(v8::Undefined());
+}
+
 v8::Handle<v8::Value>
-HyperDexClient :: iterator__spacename_predicates_sortby_limit_maxmin__status_attributes(int64_t (*f)(struct hyperdex_client* client, const char* space, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, const char* sort_by, uint64_t limit, int maxmin, enum hyperdex_client_returncode* status, const struct hyperdex_client_attribute** attrs, size_t* attrs_sz), const v8::Arguments& args)
+HyperDexClient :: iterator__spacename_predicates_sortby_limit_maxmin__status_attributes(int64_t (*f)(struct hyperdex_client *client, const char *space, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, const char *sort_by, uint64_t limit, int maxmin, enum hyperdex_client_returncode *status, const struct hyperdex_client_attribute **attrs, size_t *attrs_sz), const v8::Arguments &args)
 {
-    v8::HandleScope scope;
-    v8::Local<v8::Object> client_obj = args.This();
-    HyperDexClient* client = node::ObjectWrap::Unwrap<HyperDexClient>(client_obj);
-    e::intrusive_ptr<Operation> op(new Operation(client_obj, client));
-    v8::Local<v8::Function> func = args[5].As<v8::Function>();
-
-    if (func.IsEmpty() || !func->IsFunction())
-    {
-        v8::ThrowException(v8::String::New("Callback must be a function"));
-        return scope.Close(v8::Undefined());
-    }
-
-    v8::Local<v8::Function> done = args[6].As<v8::Function>();
-
-    if (done.IsEmpty() || !done->IsFunction())
-    {
-        v8::ThrowException(v8::String::New("Callback must be a function"));
-        return scope.Close(v8::Undefined());
-    }
-
-    if (!op->set_callback(func, done)) { return scope.Close(v8::Undefined()); }
-    const char* in_space;
-    v8::Local<v8::Value> spacename = args[0];
-    if (!op->convert_spacename(spacename, &in_space)) return scope.Close(v8::Undefined());
-    const struct hyperdex_client_attribute_check* in_checks;
-    size_t in_checks_sz;
-    v8::Local<v8::Value> predicates = args[1];
-    if (!op->convert_predicates(predicates, &in_checks, &in_checks_sz)) return scope.Close(v8::Undefined());
-    const char* in_sort_by;
-    v8::Local<v8::Value> sortby = args[2];
-    if (!op->convert_sortby(sortby, &in_sort_by)) return scope.Close(v8::Undefined());
-    uint64_t in_limit;
-    v8::Local<v8::Value> limit = args[3];
-    if (!op->convert_limit(limit, &in_limit)) return scope.Close(v8::Undefined());
-    int in_maxmin;
-    v8::Local<v8::Value> maxmin = args[4];
-    if (!op->convert_maxmin(maxmin, &in_maxmin)) return scope.Close(v8::Undefined());
-    op->reqid = f(client->client(), in_space, in_checks, in_checks_sz, in_sort_by, in_limit, in_maxmin, &op->status, &op->attrs, &op->attrs_sz);
-
-    if (op->reqid < 0)
-    {
-        op->callback_error_from_status();
-        return scope.Close(v8::Undefined());
-    }
-
-    op->encode_return = &Operation::encode_iterator_status_attributes;
-    client->add(op->reqid, op);
-    return scope.Close(v8::Undefined());
+	v8::HandleScope scope;
+	v8::Local<v8::Object> client_obj = args.This();
+	HyperDexClient *client = node::ObjectWrap::Unwrap<HyperDexClient>(client_obj);
+	e::intrusive_ptr<Operation> op(new Operation(client_obj, client));
+	v8::Local<v8::Function> func = args[5].As<v8::Function>();
+	if (func.IsEmpty() || !func->IsFunction())
+	{
+		v8::ThrowException(v8::String::New("Callback must be a function"));
+		return scope.Close(v8::Undefined());
+	}
+	v8::Local<v8::Function> done = args[6].As<v8::Function>();
+	if (done.IsEmpty() || !done->IsFunction())
+	{
+		v8::ThrowException(v8::String::New("Callback must be a function"));
+		return scope.Close(v8::Undefined());
+	}
+	if (!op->set_callback(func, done)) { return scope.Close(v8::Undefined()); }
+	const char *in_space;
+	v8::Local<v8::Value> spacename = args[0];
+	if (!op->convert_spacename(spacename, &in_space)) return scope.Close(v8::Undefined());
+	const struct hyperdex_client_attribute_check *in_checks;
+	size_t in_checks_sz;
+	v8::Local<v8::Value> predicates = args[1];
+	if (!op->convert_predicates(predicates, &in_checks, &in_checks_sz)) return scope.Close(v8::Undefined());
+	const char *in_sort_by;
+	v8::Local<v8::Value> sortby = args[2];
+	if (!op->convert_sortby(sortby, &in_sort_by)) return scope.Close(v8::Undefined());
+	uint64_t in_limit;
+	v8::Local<v8::Value> limit = args[3];
+	if (!op->convert_limit(limit, &in_limit)) return scope.Close(v8::Undefined());
+	int in_maxmin;
+	v8::Local<v8::Value> maxmin = args[4];
+	if (!op->convert_maxmin(maxmin, &in_maxmin)) return scope.Close(v8::Undefined());
+	op->reqid = f(client->client(), in_space, in_checks, in_checks_sz, in_sort_by, in_limit, in_maxmin, &op->status, &op->attrs, &op->attrs_sz);
+	if (op->reqid < 0)
+	{
+		op->callback_error_from_status();
+		return scope.Close(v8::Undefined());
+	}
+	op->encode_return = &Operation::encode_iterator_status_attributes;
+	client->add(op->reqid, op);
+	return scope.Close(v8::Undefined());
 }
 
 
 v8::Handle<v8::Value>
-HyperDexClient :: get(const v8::Arguments& args)
+HyperDexClient :: get(const v8::Arguments &args)
 {
-    return asynccall__spacename_key__status_attributes(hyperdex_client_get, args);
+	return asynccall__spacename_key__status_attributes(hyperdex_client_get, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: get_partial(const v8::Arguments& args)
+HyperDexClient :: get_partial(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_attributenames__status_attributes(hyperdex_client_get_partial, args);
+	return asynccall__spacename_key_attributenames__status_attributes(hyperdex_client_get_partial, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: put(const v8::Arguments& args)
+HyperDexClient :: put(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_attributes__status(hyperdex_client_put, args);
+	return asynccall__spacename_key_attributes__status(hyperdex_client_put, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: cond_put(const v8::Arguments& args)
+HyperDexClient :: cond_put(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_put, args);
+	return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_put, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: cond_put_or_create(const v8::Arguments& args)
+HyperDexClient :: cond_put_or_create(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_put_or_create, args);
+	return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_put_or_create, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: group_put(const v8::Arguments& args)
+HyperDexClient :: group_put(const v8::Arguments &args)
 {
-    return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_put, args);
+	return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_put, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: put_if_not_exist(const v8::Arguments& args)
+HyperDexClient :: put_if_not_exist(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_attributes__status(hyperdex_client_put_if_not_exist, args);
+	return asynccall__spacename_key_attributes__status(hyperdex_client_put_if_not_exist, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: del(const v8::Arguments& args)
+HyperDexClient :: del(const v8::Arguments &args)
 {
-    return asynccall__spacename_key__status(hyperdex_client_del, args);
+	return asynccall__spacename_key__status(hyperdex_client_del, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: cond_del(const v8::Arguments& args)
+HyperDexClient :: cond_del(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_predicates__status(hyperdex_client_cond_del, args);
+	return asynccall__spacename_key_predicates__status(hyperdex_client_cond_del, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: group_del(const v8::Arguments& args)
+HyperDexClient :: group_del(const v8::Arguments &args)
 {
-    return asynccall__spacename_predicates__status_count(hyperdex_client_group_del, args);
+	return asynccall__spacename_predicates__status_count(hyperdex_client_group_del, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: atomic_add(const v8::Arguments& args)
+HyperDexClient :: atomic_add(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_attributes__status(hyperdex_client_atomic_add, args);
+	return asynccall__spacename_key_attributes__status(hyperdex_client_atomic_add, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: cond_atomic_add(const v8::Arguments& args)
+HyperDexClient :: cond_atomic_add(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_atomic_add, args);
+	return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_atomic_add, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: group_atomic_add(const v8::Arguments& args)
+HyperDexClient :: group_atomic_add(const v8::Arguments &args)
 {
-    return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_atomic_add, args);
+	return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_atomic_add, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: atomic_sub(const v8::Arguments& args)
+HyperDexClient :: atomic_sub(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_attributes__status(hyperdex_client_atomic_sub, args);
+	return asynccall__spacename_key_attributes__status(hyperdex_client_atomic_sub, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: cond_atomic_sub(const v8::Arguments& args)
+HyperDexClient :: cond_atomic_sub(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_atomic_sub, args);
+	return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_atomic_sub, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: group_atomic_sub(const v8::Arguments& args)
+HyperDexClient :: group_atomic_sub(const v8::Arguments &args)
 {
-    return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_atomic_sub, args);
+	return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_atomic_sub, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: atomic_mul(const v8::Arguments& args)
+HyperDexClient :: atomic_mul(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_attributes__status(hyperdex_client_atomic_mul, args);
+	return asynccall__spacename_key_attributes__status(hyperdex_client_atomic_mul, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: cond_atomic_mul(const v8::Arguments& args)
+HyperDexClient :: cond_atomic_mul(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_atomic_mul, args);
+	return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_atomic_mul, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: group_atomic_mul(const v8::Arguments& args)
+HyperDexClient :: group_atomic_mul(const v8::Arguments &args)
 {
-    return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_atomic_mul, args);
+	return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_atomic_mul, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: atomic_div(const v8::Arguments& args)
+HyperDexClient :: atomic_div(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_attributes__status(hyperdex_client_atomic_div, args);
+	return asynccall__spacename_key_attributes__status(hyperdex_client_atomic_div, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: cond_atomic_div(const v8::Arguments& args)
+HyperDexClient :: cond_atomic_div(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_atomic_div, args);
+	return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_atomic_div, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: group_atomic_div(const v8::Arguments& args)
+HyperDexClient :: group_atomic_div(const v8::Arguments &args)
 {
-    return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_atomic_div, args);
+	return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_atomic_div, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: atomic_mod(const v8::Arguments& args)
+HyperDexClient :: atomic_mod(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_attributes__status(hyperdex_client_atomic_mod, args);
+	return asynccall__spacename_key_attributes__status(hyperdex_client_atomic_mod, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: cond_atomic_mod(const v8::Arguments& args)
+HyperDexClient :: cond_atomic_mod(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_atomic_mod, args);
+	return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_atomic_mod, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: group_atomic_mod(const v8::Arguments& args)
+HyperDexClient :: group_atomic_mod(const v8::Arguments &args)
 {
-    return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_atomic_mod, args);
+	return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_atomic_mod, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: atomic_and(const v8::Arguments& args)
+HyperDexClient :: atomic_and(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_attributes__status(hyperdex_client_atomic_and, args);
+	return asynccall__spacename_key_attributes__status(hyperdex_client_atomic_and, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: cond_atomic_and(const v8::Arguments& args)
+HyperDexClient :: cond_atomic_and(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_atomic_and, args);
+	return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_atomic_and, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: group_atomic_and(const v8::Arguments& args)
+HyperDexClient :: group_atomic_and(const v8::Arguments &args)
 {
-    return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_atomic_and, args);
+	return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_atomic_and, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: atomic_or(const v8::Arguments& args)
+HyperDexClient :: atomic_or(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_attributes__status(hyperdex_client_atomic_or, args);
+	return asynccall__spacename_key_attributes__status(hyperdex_client_atomic_or, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: cond_atomic_or(const v8::Arguments& args)
+HyperDexClient :: cond_atomic_or(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_atomic_or, args);
+	return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_atomic_or, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: group_atomic_or(const v8::Arguments& args)
+HyperDexClient :: group_atomic_or(const v8::Arguments &args)
 {
-    return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_atomic_or, args);
+	return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_atomic_or, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: atomic_xor(const v8::Arguments& args)
+HyperDexClient :: atomic_xor(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_attributes__status(hyperdex_client_atomic_xor, args);
+	return asynccall__spacename_key_attributes__status(hyperdex_client_atomic_xor, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: cond_atomic_xor(const v8::Arguments& args)
+HyperDexClient :: cond_atomic_xor(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_atomic_xor, args);
+	return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_atomic_xor, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: group_atomic_xor(const v8::Arguments& args)
+HyperDexClient :: group_atomic_xor(const v8::Arguments &args)
 {
-    return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_atomic_xor, args);
+	return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_atomic_xor, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: atomic_min(const v8::Arguments& args)
+HyperDexClient :: atomic_min(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_attributes__status(hyperdex_client_atomic_min, args);
+	return asynccall__spacename_key_attributes__status(hyperdex_client_atomic_min, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: cond_atomic_min(const v8::Arguments& args)
+HyperDexClient :: cond_atomic_min(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_atomic_min, args);
+	return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_atomic_min, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: group_atomic_min(const v8::Arguments& args)
+HyperDexClient :: group_atomic_min(const v8::Arguments &args)
 {
-    return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_atomic_min, args);
+	return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_atomic_min, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: atomic_max(const v8::Arguments& args)
+HyperDexClient :: atomic_max(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_attributes__status(hyperdex_client_atomic_max, args);
+	return asynccall__spacename_key_attributes__status(hyperdex_client_atomic_max, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: cond_atomic_max(const v8::Arguments& args)
+HyperDexClient :: cond_atomic_max(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_atomic_max, args);
+	return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_atomic_max, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: group_atomic_max(const v8::Arguments& args)
+HyperDexClient :: group_atomic_max(const v8::Arguments &args)
 {
-    return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_atomic_max, args);
+	return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_atomic_max, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: string_prepend(const v8::Arguments& args)
+HyperDexClient :: string_prepend(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_attributes__status(hyperdex_client_string_prepend, args);
+	return asynccall__spacename_key_attributes__status(hyperdex_client_string_prepend, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: cond_string_prepend(const v8::Arguments& args)
+HyperDexClient :: cond_string_prepend(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_string_prepend, args);
+	return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_string_prepend, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: group_string_prepend(const v8::Arguments& args)
+HyperDexClient :: group_string_prepend(const v8::Arguments &args)
 {
-    return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_string_prepend, args);
+	return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_string_prepend, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: string_append(const v8::Arguments& args)
+HyperDexClient :: string_append(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_attributes__status(hyperdex_client_string_append, args);
+	return asynccall__spacename_key_attributes__status(hyperdex_client_string_append, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: cond_string_append(const v8::Arguments& args)
+HyperDexClient :: cond_string_append(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_string_append, args);
+	return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_string_append, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: group_string_append(const v8::Arguments& args)
+HyperDexClient :: group_string_append(const v8::Arguments &args)
 {
-    return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_string_append, args);
+	return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_string_append, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: string_ltrim(const v8::Arguments& args)
+HyperDexClient :: string_ltrim(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_attributes__status(hyperdex_client_string_ltrim, args);
+	return asynccall__spacename_key_attributes__status(hyperdex_client_string_ltrim, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: cond_string_ltrim(const v8::Arguments& args)
+HyperDexClient :: cond_string_ltrim(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_string_ltrim, args);
+	return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_string_ltrim, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: group_string_ltrim(const v8::Arguments& args)
+HyperDexClient :: group_string_ltrim(const v8::Arguments &args)
 {
-    return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_string_ltrim, args);
+	return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_string_ltrim, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: string_rtrim(const v8::Arguments& args)
+HyperDexClient :: string_rtrim(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_attributes__status(hyperdex_client_string_rtrim, args);
+	return asynccall__spacename_key_attributes__status(hyperdex_client_string_rtrim, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: cond_string_rtrim(const v8::Arguments& args)
+HyperDexClient :: cond_string_rtrim(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_string_rtrim, args);
+	return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_string_rtrim, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: group_string_rtrim(const v8::Arguments& args)
+HyperDexClient :: group_string_rtrim(const v8::Arguments &args)
 {
-    return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_string_rtrim, args);
+	return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_string_rtrim, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: list_lpush(const v8::Arguments& args)
+HyperDexClient :: list_lpush(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_attributes__status(hyperdex_client_list_lpush, args);
+	return asynccall__spacename_key_attributes__status(hyperdex_client_list_lpush, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: cond_list_lpush(const v8::Arguments& args)
+HyperDexClient :: cond_list_lpush(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_list_lpush, args);
+	return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_list_lpush, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: group_list_lpush(const v8::Arguments& args)
+HyperDexClient :: group_list_lpush(const v8::Arguments &args)
 {
-    return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_list_lpush, args);
+	return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_list_lpush, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: list_rpush(const v8::Arguments& args)
+HyperDexClient :: list_rpush(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_attributes__status(hyperdex_client_list_rpush, args);
+	return asynccall__spacename_key_attributes__status(hyperdex_client_list_rpush, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: cond_list_rpush(const v8::Arguments& args)
+HyperDexClient :: cond_list_rpush(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_list_rpush, args);
+	return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_list_rpush, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: group_list_rpush(const v8::Arguments& args)
+HyperDexClient :: group_list_rpush(const v8::Arguments &args)
 {
-    return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_list_rpush, args);
+	return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_list_rpush, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: set_add(const v8::Arguments& args)
+HyperDexClient :: set_add(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_attributes__status(hyperdex_client_set_add, args);
+	return asynccall__spacename_key_attributes__status(hyperdex_client_set_add, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: cond_set_add(const v8::Arguments& args)
+HyperDexClient :: cond_set_add(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_set_add, args);
+	return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_set_add, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: group_set_add(const v8::Arguments& args)
+HyperDexClient :: group_set_add(const v8::Arguments &args)
 {
-    return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_set_add, args);
+	return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_set_add, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: set_remove(const v8::Arguments& args)
+HyperDexClient :: set_remove(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_attributes__status(hyperdex_client_set_remove, args);
+	return asynccall__spacename_key_attributes__status(hyperdex_client_set_remove, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: cond_set_remove(const v8::Arguments& args)
+HyperDexClient :: cond_set_remove(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_set_remove, args);
+	return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_set_remove, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: group_set_remove(const v8::Arguments& args)
+HyperDexClient :: group_set_remove(const v8::Arguments &args)
 {
-    return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_set_remove, args);
+	return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_set_remove, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: set_intersect(const v8::Arguments& args)
+HyperDexClient :: set_intersect(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_attributes__status(hyperdex_client_set_intersect, args);
+	return asynccall__spacename_key_attributes__status(hyperdex_client_set_intersect, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: cond_set_intersect(const v8::Arguments& args)
+HyperDexClient :: cond_set_intersect(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_set_intersect, args);
+	return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_set_intersect, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: group_set_intersect(const v8::Arguments& args)
+HyperDexClient :: group_set_intersect(const v8::Arguments &args)
 {
-    return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_set_intersect, args);
+	return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_set_intersect, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: set_union(const v8::Arguments& args)
+HyperDexClient :: set_union(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_attributes__status(hyperdex_client_set_union, args);
+	return asynccall__spacename_key_attributes__status(hyperdex_client_set_union, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: cond_set_union(const v8::Arguments& args)
+HyperDexClient :: cond_set_union(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_set_union, args);
+	return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_set_union, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: group_set_union(const v8::Arguments& args)
+HyperDexClient :: group_set_union(const v8::Arguments &args)
 {
-    return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_set_union, args);
+	return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_set_union, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: document_rename(const v8::Arguments& args)
+HyperDexClient :: document_rename(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_attributes__status(hyperdex_client_document_rename, args);
+	return asynccall__spacename_key_attributes__status(hyperdex_client_document_rename, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: cond_document_rename(const v8::Arguments& args)
+HyperDexClient :: cond_document_rename(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_document_rename, args);
+	return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_document_rename, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: group_document_rename(const v8::Arguments& args)
+HyperDexClient :: group_document_rename(const v8::Arguments &args)
 {
-    return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_document_rename, args);
+	return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_document_rename, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: document_unset(const v8::Arguments& args)
+HyperDexClient :: document_unset(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_attributes__status(hyperdex_client_document_unset, args);
+	return asynccall__spacename_key_attributes__status(hyperdex_client_document_unset, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: cond_document_unset(const v8::Arguments& args)
+HyperDexClient :: cond_document_unset(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_document_unset, args);
+	return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_document_unset, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: group_document_unset(const v8::Arguments& args)
+HyperDexClient :: group_document_unset(const v8::Arguments &args)
 {
-    return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_document_unset, args);
+	return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_document_unset, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: map_add(const v8::Arguments& args)
+HyperDexClient :: map_add(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_mapattributes__status(hyperdex_client_map_add, args);
+	return asynccall__spacename_key_mapattributes__status(hyperdex_client_map_add, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: cond_map_add(const v8::Arguments& args)
+HyperDexClient :: cond_map_add(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_add, args);
+	return asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_add, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: group_map_add(const v8::Arguments& args)
+HyperDexClient :: group_map_add(const v8::Arguments &args)
 {
-    return asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_add, args);
+	return asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_add, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: map_remove(const v8::Arguments& args)
+HyperDexClient :: map_remove(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_attributes__status(hyperdex_client_map_remove, args);
+	return asynccall__spacename_key_attributes__status(hyperdex_client_map_remove, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: cond_map_remove(const v8::Arguments& args)
+HyperDexClient :: cond_map_remove(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_map_remove, args);
+	return asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_map_remove, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: group_map_remove(const v8::Arguments& args)
+HyperDexClient :: group_map_remove(const v8::Arguments &args)
 {
-    return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_map_remove, args);
+	return asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_map_remove, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: map_atomic_add(const v8::Arguments& args)
+HyperDexClient :: map_atomic_add(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_mapattributes__status(hyperdex_client_map_atomic_add, args);
+	return asynccall__spacename_key_mapattributes__status(hyperdex_client_map_atomic_add, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: cond_map_atomic_add(const v8::Arguments& args)
+HyperDexClient :: cond_map_atomic_add(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_atomic_add, args);
+	return asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_atomic_add, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: group_map_atomic_add(const v8::Arguments& args)
+HyperDexClient :: group_map_atomic_add(const v8::Arguments &args)
 {
-    return asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_atomic_add, args);
+	return asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_atomic_add, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: map_atomic_sub(const v8::Arguments& args)
+HyperDexClient :: map_atomic_sub(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_mapattributes__status(hyperdex_client_map_atomic_sub, args);
+	return asynccall__spacename_key_mapattributes__status(hyperdex_client_map_atomic_sub, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: cond_map_atomic_sub(const v8::Arguments& args)
+HyperDexClient :: cond_map_atomic_sub(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_atomic_sub, args);
+	return asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_atomic_sub, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: group_map_atomic_sub(const v8::Arguments& args)
+HyperDexClient :: group_map_atomic_sub(const v8::Arguments &args)
 {
-    return asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_atomic_sub, args);
+	return asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_atomic_sub, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: map_atomic_mul(const v8::Arguments& args)
+HyperDexClient :: map_atomic_mul(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_mapattributes__status(hyperdex_client_map_atomic_mul, args);
+	return asynccall__spacename_key_mapattributes__status(hyperdex_client_map_atomic_mul, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: cond_map_atomic_mul(const v8::Arguments& args)
+HyperDexClient :: cond_map_atomic_mul(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_atomic_mul, args);
+	return asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_atomic_mul, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: group_map_atomic_mul(const v8::Arguments& args)
+HyperDexClient :: group_map_atomic_mul(const v8::Arguments &args)
 {
-    return asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_atomic_mul, args);
+	return asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_atomic_mul, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: map_atomic_div(const v8::Arguments& args)
+HyperDexClient :: map_atomic_div(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_mapattributes__status(hyperdex_client_map_atomic_div, args);
+	return asynccall__spacename_key_mapattributes__status(hyperdex_client_map_atomic_div, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: cond_map_atomic_div(const v8::Arguments& args)
+HyperDexClient :: cond_map_atomic_div(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_atomic_div, args);
+	return asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_atomic_div, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: group_map_atomic_div(const v8::Arguments& args)
+HyperDexClient :: group_map_atomic_div(const v8::Arguments &args)
 {
-    return asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_atomic_div, args);
+	return asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_atomic_div, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: map_atomic_mod(const v8::Arguments& args)
+HyperDexClient :: map_atomic_mod(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_mapattributes__status(hyperdex_client_map_atomic_mod, args);
+	return asynccall__spacename_key_mapattributes__status(hyperdex_client_map_atomic_mod, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: cond_map_atomic_mod(const v8::Arguments& args)
+HyperDexClient :: cond_map_atomic_mod(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_atomic_mod, args);
+	return asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_atomic_mod, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: group_map_atomic_mod(const v8::Arguments& args)
+HyperDexClient :: group_map_atomic_mod(const v8::Arguments &args)
 {
-    return asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_atomic_mod, args);
+	return asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_atomic_mod, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: map_atomic_and(const v8::Arguments& args)
+HyperDexClient :: map_atomic_and(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_mapattributes__status(hyperdex_client_map_atomic_and, args);
+	return asynccall__spacename_key_mapattributes__status(hyperdex_client_map_atomic_and, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: cond_map_atomic_and(const v8::Arguments& args)
+HyperDexClient :: cond_map_atomic_and(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_atomic_and, args);
+	return asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_atomic_and, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: group_map_atomic_and(const v8::Arguments& args)
+HyperDexClient :: group_map_atomic_and(const v8::Arguments &args)
 {
-    return asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_atomic_and, args);
+	return asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_atomic_and, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: map_atomic_or(const v8::Arguments& args)
+HyperDexClient :: map_atomic_or(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_mapattributes__status(hyperdex_client_map_atomic_or, args);
+	return asynccall__spacename_key_mapattributes__status(hyperdex_client_map_atomic_or, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: cond_map_atomic_or(const v8::Arguments& args)
+HyperDexClient :: cond_map_atomic_or(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_atomic_or, args);
+	return asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_atomic_or, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: group_map_atomic_or(const v8::Arguments& args)
+HyperDexClient :: group_map_atomic_or(const v8::Arguments &args)
 {
-    return asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_atomic_or, args);
+	return asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_atomic_or, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: map_atomic_xor(const v8::Arguments& args)
+HyperDexClient :: map_atomic_xor(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_mapattributes__status(hyperdex_client_map_atomic_xor, args);
+	return asynccall__spacename_key_mapattributes__status(hyperdex_client_map_atomic_xor, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: cond_map_atomic_xor(const v8::Arguments& args)
+HyperDexClient :: cond_map_atomic_xor(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_atomic_xor, args);
+	return asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_atomic_xor, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: group_map_atomic_xor(const v8::Arguments& args)
+HyperDexClient :: group_map_atomic_xor(const v8::Arguments &args)
 {
-    return asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_atomic_xor, args);
+	return asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_atomic_xor, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: map_string_prepend(const v8::Arguments& args)
+HyperDexClient :: map_string_prepend(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_mapattributes__status(hyperdex_client_map_string_prepend, args);
+	return asynccall__spacename_key_mapattributes__status(hyperdex_client_map_string_prepend, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: cond_map_string_prepend(const v8::Arguments& args)
+HyperDexClient :: cond_map_string_prepend(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_string_prepend, args);
+	return asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_string_prepend, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: group_map_string_prepend(const v8::Arguments& args)
+HyperDexClient :: group_map_string_prepend(const v8::Arguments &args)
 {
-    return asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_string_prepend, args);
+	return asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_string_prepend, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: map_string_append(const v8::Arguments& args)
+HyperDexClient :: map_string_append(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_mapattributes__status(hyperdex_client_map_string_append, args);
+	return asynccall__spacename_key_mapattributes__status(hyperdex_client_map_string_append, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: cond_map_string_append(const v8::Arguments& args)
+HyperDexClient :: cond_map_string_append(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_string_append, args);
+	return asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_string_append, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: group_map_string_append(const v8::Arguments& args)
+HyperDexClient :: group_map_string_append(const v8::Arguments &args)
 {
-    return asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_string_append, args);
+	return asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_string_append, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: map_atomic_min(const v8::Arguments& args)
+HyperDexClient :: map_atomic_min(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_mapattributes__status(hyperdex_client_map_atomic_min, args);
+	return asynccall__spacename_key_mapattributes__status(hyperdex_client_map_atomic_min, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: cond_map_atomic_min(const v8::Arguments& args)
+HyperDexClient :: cond_map_atomic_min(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_atomic_min, args);
+	return asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_atomic_min, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: group_map_atomic_min(const v8::Arguments& args)
+HyperDexClient :: group_map_atomic_min(const v8::Arguments &args)
 {
-    return asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_atomic_min, args);
+	return asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_atomic_min, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: map_atomic_max(const v8::Arguments& args)
+HyperDexClient :: map_atomic_max(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_mapattributes__status(hyperdex_client_map_atomic_max, args);
+	return asynccall__spacename_key_mapattributes__status(hyperdex_client_map_atomic_max, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: cond_map_atomic_max(const v8::Arguments& args)
+HyperDexClient :: cond_map_atomic_max(const v8::Arguments &args)
 {
-    return asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_atomic_max, args);
+	return asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_atomic_max, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: group_map_atomic_max(const v8::Arguments& args)
+HyperDexClient :: group_map_atomic_max(const v8::Arguments &args)
 {
-    return asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_atomic_max, args);
+	return asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_atomic_max, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: search(const v8::Arguments& args)
+HyperDexClient :: search(const v8::Arguments &args)
 {
-    return iterator__spacename_predicates__status_attributes(hyperdex_client_search, args);
+	return iterator__spacename_predicates__status_attributes(hyperdex_client_search, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: search_describe(const v8::Arguments& args)
+HyperDexClient :: search_describe(const v8::Arguments &args)
 {
-    return asynccall__spacename_predicates__status_description(hyperdex_client_search_describe, args);
+	return asynccall__spacename_predicates__status_description(hyperdex_client_search_describe, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: sorted_search(const v8::Arguments& args)
+HyperDexClient :: sorted_search(const v8::Arguments &args)
 {
-    return iterator__spacename_predicates_sortby_limit_maxmin__status_attributes(hyperdex_client_sorted_search, args);
+	return iterator__spacename_predicates_sortby_limit_maxmin__status_attributes(hyperdex_client_sorted_search, args);
 }
 
 v8::Handle<v8::Value>
-HyperDexClient :: count(const v8::Arguments& args)
+HyperDexClient :: count(const v8::Arguments &args)
 {
-    return asynccall__spacename_predicates__status_count(hyperdex_client_count, args);
+	return asynccall__spacename_predicates__status_count(hyperdex_client_count, args);
 }
 
 #endif // HYPERDEX_NODE_INCLUDED_CLIENT_CC
diff --git a/bindings/python/hyperdex/client.pyx b/bindings/python/hyperdex/client.pyx
index 6fa957fe8..3498dcc1e 100644
--- a/bindings/python/hyperdex/client.pyx
+++ b/bindings/python/hyperdex/client.pyx
@@ -314,6 +314,7 @@ cdef extern from "hyperdex/client.h":
     int64_t hyperdex_client_search_describe(hyperdex_client* client, const char* space, const hyperdex_client_attribute_check* checks, size_t checks_sz, hyperdex_client_returncode* status, const char** description)
     int64_t hyperdex_client_sorted_search(hyperdex_client* client, const char* space, const hyperdex_client_attribute_check* checks, size_t checks_sz, const char* sort_by, uint64_t limit, int maxmin, hyperdex_client_returncode* status, const hyperdex_client_attribute** attrs, size_t* attrs_sz)
     int64_t hyperdex_client_count(hyperdex_client* client, const char* space, const hyperdex_client_attribute_check* checks, size_t checks_sz, hyperdex_client_returncode* status, uint64_t* count)
+    int64_t hyperdex_client_sum(hyperdex_client* client, const char* space, const hyperdex_client_attribute_check* checks, size_t checks_sz,  const char* sum_key, hyperdex_client_returncode* status, uint64_t* count)
     # End Automatically Generated Prototypes
 
 
@@ -399,6 +400,7 @@ ctypedef int64_t asynccall__spacename_predicates_attributes__status_count_fptr(h
 ctypedef int64_t asynccall__spacename_key__status_fptr(hyperdex_client* client, const char* space, const char* key, size_t key_sz, hyperdex_client_returncode* status)
 ctypedef int64_t asynccall__spacename_key_predicates__status_fptr(hyperdex_client* client, const char* space, const char* key, size_t key_sz, const hyperdex_client_attribute_check* checks, size_t checks_sz, hyperdex_client_returncode* status)
 ctypedef int64_t asynccall__spacename_predicates__status_count_fptr(hyperdex_client* client, const char* space, const hyperdex_client_attribute_check* checks, size_t checks_sz, hyperdex_client_returncode* status, uint64_t* count)
+ctypedef int64_t asynccall__spacename_predicates__status_sum_fptr(hyperdex_client* client, const char* space, const hyperdex_client_attribute_check* checks, size_t checks_sz, const char* key, hyperdex_client_returncode* status, uint64_t* count)
 ctypedef int64_t asynccall__spacename_key_mapattributes__status_fptr(hyperdex_client* client, const char* space, const char* key, size_t key_sz, const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz, hyperdex_client_returncode* status)
 ctypedef int64_t asynccall__spacename_key_predicates_mapattributes__status_fptr(hyperdex_client* client, const char* space, const char* key, size_t key_sz, const hyperdex_client_attribute_check* checks, size_t checks_sz, const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz, hyperdex_client_returncode* status)
 ctypedef int64_t asynccall__spacename_predicates_mapattributes__status_count_fptr(hyperdex_client* client, const char* space, const hyperdex_client_attribute_check* checks, size_t checks_sz, const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz, hyperdex_client_returncode* status, uint64_t* count)
@@ -1506,6 +1508,9 @@ cdef class Client:
     cdef convert_sortby(self, hyperdex_ds_arena* arena, bytes sortby, const char** sortby_str):
         sortby_str[0] = sortby
 
+    cdef convert_sum_key(self, hyperdex_ds_arena* arena, bytes key, const char** sum_key_str):
+        sum_key_str[0] = key 
+
     cdef convert_limit(self, hyperdex_ds_arena* arena, long limit, uint64_t* count):
         count[0] = limit
 
@@ -1695,6 +1700,24 @@ cdef class Client:
         self.ops[d.reqid] = d
         return d
 
+    cdef asynccall__spacename_predicates__status_sum(self, asynccall__spacename_predicates__status_sum_fptr f, bytes spacename, dict predicates, bytes key, auth=None):
+        cdef Deferred d = Deferred(self)
+        cdef const char* in_space
+        cdef hyperdex_client_attribute_check* in_checks
+        cdef size_t in_checks_sz
+        cdef const char* in_sum_key 
+        self.convert_spacename(d.arena, spacename, &in_space);
+        self.convert_predicates(d.arena, predicates, &in_checks, &in_checks_sz);
+        self.convert_sum_key(d.arena, key, &in_sum_key);
+        self.set_auth_context(auth)
+        d.reqid = f(self.client, in_space, in_checks, in_checks_sz, in_sum_key, &d.status, &d.count);
+        self.clear_auth_context()
+        if d.reqid < 0:
+            raise HyperDexClientException(d.status, hyperdex_client_error_message(self.client))
+        d.encode_return = hyperdex_python_client_deferred_encode_status_count
+        self.ops[d.reqid] = d
+        return d
+
     cdef asynccall__spacename_key_mapattributes__status(self, asynccall__spacename_key_mapattributes__status_fptr f, bytes spacename, key, dict mapattributes, auth=None):
         cdef Deferred d = Deferred(self)
         cdef const char* in_space
@@ -2412,4 +2435,8 @@ cdef class Client:
         return self.asynccall__spacename_predicates__status_count(hyperdex_client_count, spacename, predicates, auth)
     def count(self, bytes spacename, dict predicates, auth=None):
         return self.async_count(spacename, predicates, auth).wait()
+    def async_sum(self, bytes spacename, dict predicates, bytes sum_key, auth=None):
+        return self.asynccall__spacename_predicates__status_sum(hyperdex_client_sum, spacename, predicates, sum_key, auth)
+    def sum(self, bytes spacename, dict predicates, bytes sum_key, auth=None):
+        return self.async_sum(spacename, predicates, sum_key, auth).wait()
     # End Automatically Generated Methods
diff --git a/bindings/ruby/client.c b/bindings/ruby/client.c
index 7cfe02bee..1c49fec74 100644
--- a/bindings/ruby/client.c
+++ b/bindings/ruby/client.c
@@ -63,1369 +63,1238 @@ static VALUE class_contains;
 void
 hyperdex_ruby_out_of_memory()
 {
-    rb_raise(rb_eNoMemError, "failed to allocate memory");
+	rb_raise(rb_eNoMemError, "failed to allocate memory");
 }
 
 static VALUE
 hyperdex_ruby_client_create_exception(enum hyperdex_client_returncode status,
-                                      const char* error_message)
+                                      const char *error_message)
 {
-    const char* symbol = hyperdex_client_returncode_to_string(status);
-    VALUE exception;
-    exception = rb_exc_new2(class_exception, error_message);
-    rb_iv_set(exception, "@status", rb_uint_new(status));
-    rb_iv_set(exception, "@symbol", rb_str_new2(symbol));
-    return exception;
+	const char *symbol = hyperdex_client_returncode_to_string(status);
+	VALUE exception;
+	exception = rb_exc_new2(class_exception, error_message);
+	rb_iv_set(exception, "@status", rb_uint_new(status));
+	rb_iv_set(exception, "@symbol", rb_str_new2(symbol));
+	return exception;
 }
 
 void
 hyperdex_ruby_client_throw_exception(enum hyperdex_client_returncode status,
-                                     const char* error_message)
+                                     const char *error_message)
 {
-    VALUE exception = hyperdex_ruby_client_create_exception(status, error_message);
-    rb_exc_raise(exception);
-    abort(); /* unreachable? */
+	VALUE exception = hyperdex_ruby_client_create_exception(status, error_message);
+	rb_exc_raise(exception);
+	abort(); /* unreachable? */
 }
 
 /******************************* Predicate class ******************************/
 
 struct hyperdex_ruby_client_predicate_inner
 {
-    VALUE v;
-    enum hyperpredicate predicate;
+	VALUE v;
+	enum hyperpredicate predicate;
 };
 
 struct hyperdex_ruby_client_predicate
 {
-    size_t num_checks;
-    struct hyperdex_ruby_client_predicate_inner checks[1];
+	size_t num_checks;
+	struct hyperdex_ruby_client_predicate_inner checks[1];
 };
 
 /********************************** Ruby -> C *********************************/
 
-static const char*
-hyperdex_ruby_client_convert_cstring(VALUE x, const char* error_message)
+static const char *
+hyperdex_ruby_client_convert_cstring(VALUE x, const char *error_message)
 {
-    if (TYPE(x) == T_SYMBOL)
-    {
-        return rb_id2name(SYM2ID(x));
-    }
-    else if (TYPE(x) == T_STRING)
-    {
-        return StringValueCStr(x);
-    }
-    else
-    {
-        rb_exc_raise(rb_exc_new2(rb_eTypeError, error_message));
-        abort(); /* unreachable? */
-    }
+	if (TYPE(x) == T_SYMBOL)
+	{
+		return rb_id2name(SYM2ID(x));
+	}
+	else if (TYPE(x) == T_STRING)
+	{
+		return StringValueCStr(x);
+	}
+	else
+	{
+		rb_exc_raise(rb_exc_new2(rb_eTypeError, error_message));
+		abort(); /* unreachable? */
+	}
 }
 
-typedef int (*elem_string_fptr)(void*, const char*, size_t, enum hyperdex_ds_returncode*);
-typedef int (*elem_int_fptr)(void*, int64_t, enum hyperdex_ds_returncode*);
-typedef int (*elem_float_fptr)(void*, double, enum hyperdex_ds_returncode*);
+typedef int (*elem_string_fptr)(void *, const char *, size_t, enum hyperdex_ds_returncode *);
+typedef int (*elem_int_fptr)(void *, int64_t, enum hyperdex_ds_returncode *);
+typedef int (*elem_float_fptr)(void *, double, enum hyperdex_ds_returncode *);
 
 #define HDRB_HANDLE_ELEM_ERROR(X, TYPE) \
-    switch (X) \
-    { \
-        case HYPERDEX_DS_NOMEM: \
-            hyperdex_ruby_out_of_memory(); \
-        case HYPERDEX_DS_MIXED_TYPES: \
-            rb_raise(rb_eTypeError, "Cannot add " TYPE " to a heterogenous container"); \
-        case HYPERDEX_DS_SUCCESS: \
-        case HYPERDEX_DS_STRING_TOO_LONG: \
-        case HYPERDEX_DS_WRONG_STATE: \
-        default: \
-            rb_raise(rb_eTypeError, "Cannot convert " TYPE " to a HyperDex type"); \
-    }
+	switch (X) \
+	{ \
+	case HYPERDEX_DS_NOMEM: \
+		hyperdex_ruby_out_of_memory(); \
+	case HYPERDEX_DS_MIXED_TYPES: \
+		rb_raise(rb_eTypeError, "Cannot add " TYPE " to a heterogenous container"); \
+	case HYPERDEX_DS_SUCCESS: \
+	case HYPERDEX_DS_STRING_TOO_LONG: \
+	case HYPERDEX_DS_WRONG_STATE: \
+	default: \
+		rb_raise(rb_eTypeError, "Cannot convert " TYPE " to a HyperDex type"); \
+	}
 
 static void
 hyperdex_ruby_client_convert_elem(VALUE e,
-                                  void* x,
+                                  void *x,
                                   elem_string_fptr f_string,
                                   elem_int_fptr f_int,
                                   elem_float_fptr f_float)
 {
-    enum hyperdex_ds_returncode error;
-    const char* tmp_str;
-    size_t tmp_str_sz;
-    int64_t tmp_i;
-    double tmp_d;
-
-    switch (TYPE(e))
-    {
-        case T_SYMBOL:
-            tmp_str = rb_id2name(SYM2ID(e));
-            tmp_str_sz = strlen(tmp_str);
-            if (f_string(x, tmp_str, tmp_str_sz, &error) < 0)
-            {
-                HDRB_HANDLE_ELEM_ERROR(error, "string");
-            }
-            break;
-        case T_STRING:
-            tmp_str = StringValuePtr(e);
-            tmp_str_sz = RSTRING_LEN(e);
-            if (f_string(x, tmp_str, tmp_str_sz, &error) < 0)
-            {
-                HDRB_HANDLE_ELEM_ERROR(error, "string");
-            }
-            break;
-        case T_FIXNUM:
-        case T_BIGNUM:
-            tmp_i = NUM2LL(e);
-            if (f_int(x, tmp_i, &error) < 0)
-            {
-                HDRB_HANDLE_ELEM_ERROR(error, "integer");
-            }
-            break;
-        case T_FLOAT:
-            tmp_d = NUM2DBL(e);
-            if (f_float(x, tmp_d, &error) < 0)
-            {
-                HDRB_HANDLE_ELEM_ERROR(error, "float");
-            }
-            break;
-        default:
-            rb_raise(rb_eTypeError, "Cannot convert object to a HyperDex container element");
-            break;
-    }
+	enum hyperdex_ds_returncode error;
+	const char *tmp_str;
+	size_t tmp_str_sz;
+	int64_t tmp_i;
+	double tmp_d;
+	switch (TYPE(e))
+	{
+	case T_SYMBOL:
+		tmp_str = rb_id2name(SYM2ID(e));
+		tmp_str_sz = strlen(tmp_str);
+		if (f_string(x, tmp_str, tmp_str_sz, &error) < 0)
+		{
+			HDRB_HANDLE_ELEM_ERROR(error, "string");
+		}
+		break;
+	case T_STRING:
+		tmp_str = StringValuePtr(e);
+		tmp_str_sz = RSTRING_LEN(e);
+		if (f_string(x, tmp_str, tmp_str_sz, &error) < 0)
+		{
+			HDRB_HANDLE_ELEM_ERROR(error, "string");
+		}
+		break;
+	case T_FIXNUM:
+	case T_BIGNUM:
+		tmp_i = NUM2LL(e);
+		if (f_int(x, tmp_i, &error) < 0)
+		{
+			HDRB_HANDLE_ELEM_ERROR(error, "integer");
+		}
+		break;
+	case T_FLOAT:
+		tmp_d = NUM2DBL(e);
+		if (f_float(x, tmp_d, &error) < 0)
+		{
+			HDRB_HANDLE_ELEM_ERROR(error, "float");
+		}
+		break;
+	default:
+		rb_raise(rb_eTypeError, "Cannot convert object to a HyperDex container element");
+		break;
+	}
 }
 
 static void
-hyperdex_ruby_client_convert_list(struct hyperdex_ds_arena* arena,
+hyperdex_ruby_client_convert_list(struct hyperdex_ds_arena *arena,
                                   VALUE x,
-                                  const char** value,
-                                  size_t* value_sz,
-                                  enum hyperdatatype* datatype)
+                                  const char **value,
+                                  size_t *value_sz,
+                                  enum hyperdatatype *datatype)
 {
-    struct hyperdex_ds_list* list;
-    enum hyperdex_ds_returncode error;
-    VALUE entry;
-    ssize_t i = 0;
-
-    list = hyperdex_ds_allocate_list(arena);
-
-    if (!list)
-    {
-        hyperdex_ruby_out_of_memory();
-    }
-
-    for (i = 0; i < RARRAY_LEN(x); ++i)
-    {
-        entry = rb_ary_entry(x, i);
-        hyperdex_ruby_client_convert_elem(entry, list,
-                (elem_string_fptr) hyperdex_ds_list_append_string,
-                (elem_int_fptr) hyperdex_ds_list_append_int,
-                (elem_float_fptr) hyperdex_ds_list_append_float);
-    }
-
-    if (hyperdex_ds_list_finalize(list, &error, value, value_sz, datatype) < 0)
-    {
-        hyperdex_ruby_out_of_memory();
-    }
+	struct hyperdex_ds_list *list;
+	enum hyperdex_ds_returncode error;
+	VALUE entry;
+	ssize_t i = 0;
+	list = hyperdex_ds_allocate_list(arena);
+	if (!list)
+	{
+		hyperdex_ruby_out_of_memory();
+	}
+	for (i = 0; i < RARRAY_LEN(x); ++i)
+	{
+		entry = rb_ary_entry(x, i);
+		hyperdex_ruby_client_convert_elem(entry, list,
+		                                  (elem_string_fptr) hyperdex_ds_list_append_string,
+		                                  (elem_int_fptr) hyperdex_ds_list_append_int,
+		                                  (elem_float_fptr) hyperdex_ds_list_append_float);
+	}
+	if (hyperdex_ds_list_finalize(list, &error, value, value_sz, datatype) < 0)
+	{
+		hyperdex_ruby_out_of_memory();
+	}
 }
 
 static void
-hyperdex_ruby_client_convert_set(struct hyperdex_ds_arena* arena,
+hyperdex_ruby_client_convert_set(struct hyperdex_ds_arena *arena,
                                  VALUE _x,
-                                 const char** value,
-                                 size_t* value_sz,
-                                 enum hyperdatatype* datatype)
+                                 const char **value,
+                                 size_t *value_sz,
+                                 enum hyperdatatype *datatype)
 {
-    struct hyperdex_ds_set* set;
-    enum hyperdex_ds_returncode error;
-    VALUE entry;
-    ssize_t i = 0;
-    VALUE x = rb_funcall(_x, rb_intern("to_a"), 0);
-
-    set = hyperdex_ds_allocate_set(arena);
-
-    if (!set)
-    {
-        hyperdex_ruby_out_of_memory();
-    }
-
-    for (i = 0; i < RARRAY_LEN(x); ++i)
-    {
-        entry = rb_ary_entry(x, i);
-        hyperdex_ruby_client_convert_elem(entry, set,
-                (elem_string_fptr) hyperdex_ds_set_insert_string,
-                (elem_int_fptr) hyperdex_ds_set_insert_int,
-                (elem_float_fptr) hyperdex_ds_set_insert_float);
-    }
-
-    if (hyperdex_ds_set_finalize(set, &error, value, value_sz, datatype) < 0)
-    {
-        hyperdex_ruby_out_of_memory();
-    }
+	struct hyperdex_ds_set *set;
+	enum hyperdex_ds_returncode error;
+	VALUE entry;
+	ssize_t i = 0;
+	VALUE x = rb_funcall(_x, rb_intern("to_a"), 0);
+	set = hyperdex_ds_allocate_set(arena);
+	if (!set)
+	{
+		hyperdex_ruby_out_of_memory();
+	}
+	for (i = 0; i < RARRAY_LEN(x); ++i)
+	{
+		entry = rb_ary_entry(x, i);
+		hyperdex_ruby_client_convert_elem(entry, set,
+		                                  (elem_string_fptr) hyperdex_ds_set_insert_string,
+		                                  (elem_int_fptr) hyperdex_ds_set_insert_int,
+		                                  (elem_float_fptr) hyperdex_ds_set_insert_float);
+	}
+	if (hyperdex_ds_set_finalize(set, &error, value, value_sz, datatype) < 0)
+	{
+		hyperdex_ruby_out_of_memory();
+	}
 }
 
 static void
-hyperdex_ruby_client_convert_map(struct hyperdex_ds_arena* arena,
+hyperdex_ruby_client_convert_map(struct hyperdex_ds_arena *arena,
                                  VALUE _x,
-                                 const char** value,
-                                 size_t* value_sz,
-                                 enum hyperdatatype* datatype)
+                                 const char **value,
+                                 size_t *value_sz,
+                                 enum hyperdatatype *datatype)
 {
-    struct hyperdex_ds_map* map;
-    enum hyperdex_ds_returncode error;
-    VALUE entry;
-    VALUE key;
-    VALUE val;
-    ssize_t i = 0;
-    VALUE x = rb_funcall(_x, rb_intern("to_a"), 0);
-
-    map = hyperdex_ds_allocate_map(arena);
-
-    if (!map)
-    {
-        hyperdex_ruby_out_of_memory();
-    }
-
-    for (i = 0; i < RARRAY_LEN(x); ++i)
-    {
-        entry = rb_ary_entry(x, i);
-        key = rb_ary_entry(entry, 0);
-        val = rb_ary_entry(entry, 1);
-        hyperdex_ruby_client_convert_elem(key, map,
-                (elem_string_fptr) hyperdex_ds_map_insert_key_string,
-                (elem_int_fptr) hyperdex_ds_map_insert_key_int,
-                (elem_float_fptr) hyperdex_ds_map_insert_key_float);
-        hyperdex_ruby_client_convert_elem(val, map,
-                (elem_string_fptr) hyperdex_ds_map_insert_val_string,
-                (elem_int_fptr) hyperdex_ds_map_insert_val_int,
-                (elem_float_fptr) hyperdex_ds_map_insert_val_float);
-    }
-
-    if (hyperdex_ds_map_finalize(map, &error, value, value_sz, datatype) < 0)
-    {
-        hyperdex_ruby_out_of_memory();
-    }
+	struct hyperdex_ds_map *map;
+	enum hyperdex_ds_returncode error;
+	VALUE entry;
+	VALUE key;
+	VALUE val;
+	ssize_t i = 0;
+	VALUE x = rb_funcall(_x, rb_intern("to_a"), 0);
+	map = hyperdex_ds_allocate_map(arena);
+	if (!map)
+	{
+		hyperdex_ruby_out_of_memory();
+	}
+	for (i = 0; i < RARRAY_LEN(x); ++i)
+	{
+		entry = rb_ary_entry(x, i);
+		key = rb_ary_entry(entry, 0);
+		val = rb_ary_entry(entry, 1);
+		hyperdex_ruby_client_convert_elem(key, map,
+		                                  (elem_string_fptr) hyperdex_ds_map_insert_key_string,
+		                                  (elem_int_fptr) hyperdex_ds_map_insert_key_int,
+		                                  (elem_float_fptr) hyperdex_ds_map_insert_key_float);
+		hyperdex_ruby_client_convert_elem(val, map,
+		                                  (elem_string_fptr) hyperdex_ds_map_insert_val_string,
+		                                  (elem_int_fptr) hyperdex_ds_map_insert_val_int,
+		                                  (elem_float_fptr) hyperdex_ds_map_insert_val_float);
+	}
+	if (hyperdex_ds_map_finalize(map, &error, value, value_sz, datatype) < 0)
+	{
+		hyperdex_ruby_out_of_memory();
+	}
 }
 
 static void
-hyperdex_ruby_client_convert_type(struct hyperdex_ds_arena* arena,
+hyperdex_ruby_client_convert_type(struct hyperdex_ds_arena *arena,
                                   VALUE x,
-                                  const char** value,
-                                  size_t* value_sz,
-                                  enum hyperdatatype* datatype)
+                                  const char **value,
+                                  size_t *value_sz,
+                                  enum hyperdatatype *datatype)
 {
-    enum hyperdex_ds_returncode error;
-    const char* tmp_str;
-    size_t tmp_str_sz;
-    int64_t tmp_i;
-    double tmp_d;
-
-    switch (TYPE(x))
-    {
-        case T_SYMBOL:
-            tmp_str = rb_id2name(SYM2ID(x));
-            tmp_str_sz = strlen(tmp_str);
-
-            if (hyperdex_ds_copy_string(arena, tmp_str, tmp_str_sz,
-                                        &error, value, value_sz) < 0)
-            {
-                hyperdex_ruby_out_of_memory();
-            }
-
-            *datatype = HYPERDATATYPE_STRING;
-            break;
-        case T_STRING:
-            tmp_str = StringValuePtr(x);
-            tmp_str_sz = RSTRING_LEN(x);
-
-            if (hyperdex_ds_copy_string(arena, tmp_str, tmp_str_sz,
-                                        &error, value, value_sz) < 0)
-            {
-                hyperdex_ruby_out_of_memory();
-            }
-
-            *datatype = HYPERDATATYPE_STRING;
-            break;
-        case T_FIXNUM:
-        case T_BIGNUM:
-            tmp_i = NUM2LL(x);
-
-            if (hyperdex_ds_copy_int(arena, tmp_i,
-                                     &error, value, value_sz) < 0)
-            {
-                hyperdex_ruby_out_of_memory();
-            }
-
-            *datatype = HYPERDATATYPE_INT64;
-            break;
-        case T_FLOAT:
-            tmp_d = NUM2DBL(x);
-
-            if (hyperdex_ds_copy_float(arena, tmp_d,
-                                       &error, value, value_sz) < 0)
-            {
-                hyperdex_ruby_out_of_memory();
-            }
-
-            *datatype = HYPERDATATYPE_FLOAT;
-            break;
-        case T_ARRAY:
-            hyperdex_ruby_client_convert_list(arena, x, value, value_sz, datatype);
-            break;
-        case T_HASH:
-            hyperdex_ruby_client_convert_map(arena, x, value, value_sz, datatype);
-            break;
-        case T_OBJECT:
-            if (!rb_obj_is_kind_of(x, Set) == Qtrue)
-            {
-                rb_raise(rb_eTypeError, "Cannot convert object to a HyperDex type");
-                break;
-            }
-
-            hyperdex_ruby_client_convert_set(arena, x, value, value_sz, datatype);
-            break;
-        default:
-            rb_raise(rb_eTypeError, "Cannot convert object to a HyperDex type");
-            break;
-    }
+	enum hyperdex_ds_returncode error;
+	const char *tmp_str;
+	size_t tmp_str_sz;
+	int64_t tmp_i;
+	double tmp_d;
+	switch (TYPE(x))
+	{
+	case T_SYMBOL:
+		tmp_str = rb_id2name(SYM2ID(x));
+		tmp_str_sz = strlen(tmp_str);
+		if (hyperdex_ds_copy_string(arena, tmp_str, tmp_str_sz,
+		                            &error, value, value_sz) < 0)
+		{
+			hyperdex_ruby_out_of_memory();
+		}
+		*datatype = HYPERDATATYPE_STRING;
+		break;
+	case T_STRING:
+		tmp_str = StringValuePtr(x);
+		tmp_str_sz = RSTRING_LEN(x);
+		if (hyperdex_ds_copy_string(arena, tmp_str, tmp_str_sz,
+		                            &error, value, value_sz) < 0)
+		{
+			hyperdex_ruby_out_of_memory();
+		}
+		*datatype = HYPERDATATYPE_STRING;
+		break;
+	case T_FIXNUM:
+	case T_BIGNUM:
+		tmp_i = NUM2LL(x);
+		if (hyperdex_ds_copy_int(arena, tmp_i,
+		                         &error, value, value_sz) < 0)
+		{
+			hyperdex_ruby_out_of_memory();
+		}
+		*datatype = HYPERDATATYPE_INT64;
+		break;
+	case T_FLOAT:
+		tmp_d = NUM2DBL(x);
+		if (hyperdex_ds_copy_float(arena, tmp_d,
+		                           &error, value, value_sz) < 0)
+		{
+			hyperdex_ruby_out_of_memory();
+		}
+		*datatype = HYPERDATATYPE_FLOAT;
+		break;
+	case T_ARRAY:
+		hyperdex_ruby_client_convert_list(arena, x, value, value_sz, datatype);
+		break;
+	case T_HASH:
+		hyperdex_ruby_client_convert_map(arena, x, value, value_sz, datatype);
+		break;
+	case T_OBJECT:
+		if (!rb_obj_is_kind_of(x, Set) == Qtrue)
+		{
+			rb_raise(rb_eTypeError, "Cannot convert object to a HyperDex type");
+			break;
+		}
+		hyperdex_ruby_client_convert_set(arena, x, value, value_sz, datatype);
+		break;
+	default:
+		rb_raise(rb_eTypeError, "Cannot convert object to a HyperDex type");
+		break;
+	}
 }
 
 static void
-hyperdex_ruby_client_convert_attributes(struct hyperdex_ds_arena* arena,
+hyperdex_ruby_client_convert_attributes(struct hyperdex_ds_arena *arena,
                                         VALUE x,
-                                        const struct hyperdex_client_attribute** _attrs,
-                                        size_t* _attrs_sz)
+                                        const struct hyperdex_client_attribute **_attrs,
+                                        size_t *_attrs_sz)
 {
-    VALUE hash_pairs = Qnil;
-    VALUE hash_pair = Qnil;
-    VALUE key = Qnil;
-    VALUE val = Qnil;
-    struct hyperdex_client_attribute* attrs;
-    size_t attrs_sz;
-    ssize_t i;
-
-    if (TYPE(x) != T_HASH)
-    {
-        rb_exc_raise(rb_exc_new2(rb_eTypeError, "Attributes must be specified as a hash"));
-        abort(); /* unreachable? */
-    }
-
-    hash_pairs = rb_funcall(x, rb_intern("to_a"), 0);
-    attrs_sz = RARRAY_LEN(hash_pairs);
-    attrs = hyperdex_ds_allocate_attribute(arena, attrs_sz);
-
-    if (!attrs)
-    {
-        hyperdex_ruby_out_of_memory();
-    }
-
-    *_attrs = attrs;
-    *_attrs_sz = attrs_sz;
-
-    for (i = 0; i < RARRAY_LEN(hash_pairs); ++i)
-    {
-        hash_pair = rb_ary_entry(hash_pairs, i);
-        key = rb_ary_entry(hash_pair, 0);
-        val = rb_ary_entry(hash_pair, 1);
-
-        attrs[i].attr = hyperdex_ruby_client_convert_cstring(key, "Attribute name must be a string or symbol");
-        hyperdex_ruby_client_convert_type(arena, val, &attrs[i].value, &attrs[i].value_sz, &attrs[i].datatype);
-    }
+	VALUE hash_pairs = Qnil;
+	VALUE hash_pair = Qnil;
+	VALUE key = Qnil;
+	VALUE val = Qnil;
+	struct hyperdex_client_attribute *attrs;
+	size_t attrs_sz;
+	ssize_t i;
+	if (TYPE(x) != T_HASH)
+	{
+		rb_exc_raise(rb_exc_new2(rb_eTypeError, "Attributes must be specified as a hash"));
+		abort(); /* unreachable? */
+	}
+	hash_pairs = rb_funcall(x, rb_intern("to_a"), 0);
+	attrs_sz = RARRAY_LEN(hash_pairs);
+	attrs = hyperdex_ds_allocate_attribute(arena, attrs_sz);
+	if (!attrs)
+	{
+		hyperdex_ruby_out_of_memory();
+	}
+	*_attrs = attrs;
+	*_attrs_sz = attrs_sz;
+	for (i = 0; i < RARRAY_LEN(hash_pairs); ++i)
+	{
+		hash_pair = rb_ary_entry(hash_pairs, i);
+		key = rb_ary_entry(hash_pair, 0);
+		val = rb_ary_entry(hash_pair, 1);
+		attrs[i].attr = hyperdex_ruby_client_convert_cstring(key, "Attribute name must be a string or symbol");
+		hyperdex_ruby_client_convert_type(arena, val, &attrs[i].value, &attrs[i].value_sz, &attrs[i].datatype);
+	}
 }
 
 static void
-hyperdex_ruby_client_convert_key(struct hyperdex_ds_arena* arena,
+hyperdex_ruby_client_convert_key(struct hyperdex_ds_arena *arena,
                                  VALUE x,
-                                 const char** key,
-                                 size_t* key_sz)
+                                 const char **key,
+                                 size_t *key_sz)
 {
-    enum hyperdatatype datatype;
-    hyperdex_ruby_client_convert_type(arena, x, key, key_sz, &datatype);
+	enum hyperdatatype datatype;
+	hyperdex_ruby_client_convert_type(arena, x, key, key_sz, &datatype);
 }
 
 static void
-hyperdex_ruby_client_convert_limit(struct hyperdex_ds_arena* arena,
+hyperdex_ruby_client_convert_limit(struct hyperdex_ds_arena *arena,
                                    VALUE x,
-                                   uint64_t* limit)
+                                   uint64_t *limit)
 {
-    *limit = rb_num2ulong(x);
-    (void) arena;
+	*limit = rb_num2ulong(x);
+	(void) arena;
 }
 
 static void
-hyperdex_ruby_client_convert_mapattributes(struct hyperdex_ds_arena* arena,
+hyperdex_ruby_client_convert_mapattributes(struct hyperdex_ds_arena *arena,
                                            VALUE x,
-                                           const struct hyperdex_client_map_attribute** _mapattrs,
-                                           size_t* _mapattrs_sz)
+                                           const struct hyperdex_client_map_attribute **_mapattrs,
+                                           size_t *_mapattrs_sz)
 {
-    VALUE outer_pairs = Qnil;
-    VALUE outer_pair = Qnil;
-    VALUE inner_pairs = Qnil;
-    VALUE inner_pair = Qnil;
-    VALUE attr = Qnil;
-    VALUE key = Qnil;
-    VALUE val = Qnil;
-    struct hyperdex_client_map_attribute* mapattrs = NULL;
-    size_t mapattrs_sz = 0;
-    size_t mapattrs_idx = 0;
-    ssize_t i = 0;
-    size_t j = 0;
-
-    if (TYPE(x) != T_HASH)
-    {
-        rb_exc_raise(rb_exc_new2(rb_eTypeError, "Map attributes must be specified as a hash"));
-        abort(); /* unreachable? */
-    }
-
-    outer_pairs = rb_funcall(x, rb_intern("to_a"), 0);
-
-    for (i = 0; i < RARRAY_LEN(outer_pairs); ++i)
-    {
-        outer_pair = rb_ary_entry(outer_pairs, i);
-        inner_pairs = rb_ary_entry(outer_pair, 1);
-
-        if (TYPE(inner_pairs) != T_HASH)
-        {
-            rb_exc_raise(rb_exc_new2(rb_eTypeError, "Map attributes must be specified as a hash"));
-            abort(); /* unreachable? */
-        }
-
-        mapattrs_sz += RHASH_SIZE(inner_pairs);
-    }
-
-    mapattrs = hyperdex_ds_allocate_map_attribute(arena, mapattrs_sz);
-
-    if (!mapattrs)
-    {
-        hyperdex_ruby_out_of_memory();
-    }
-
-    *_mapattrs = mapattrs;
-    *_mapattrs_sz = mapattrs_sz;
-
-    for (i = 0; i < RARRAY_LEN(outer_pairs); ++i)
-    {
-        outer_pair = rb_ary_entry(outer_pairs, i);
-        attr = rb_ary_entry(outer_pair, 0);
-        inner_pairs = rb_ary_entry(outer_pair, 1);
-        inner_pairs = rb_funcall(inner_pairs, rb_intern("to_a"), 0);
-
-        for (j = 0; RARRAY_LEN(inner_pairs); ++j)
-        {
-            inner_pair = rb_ary_entry(inner_pairs, j);
-            key = rb_ary_entry(inner_pair, 0);
-            val = rb_ary_entry(inner_pair, 1);
-            mapattrs[mapattrs_idx].attr = hyperdex_ruby_client_convert_cstring(attr, "Attribute name must be a string or symbol");
-            hyperdex_ruby_client_convert_type(arena, key,
-                                              &mapattrs[mapattrs_idx].map_key,
-                                              &mapattrs[mapattrs_idx].map_key_sz,
-                                              &mapattrs[mapattrs_idx].map_key_datatype);
-            hyperdex_ruby_client_convert_type(arena, val,
-                                              &mapattrs[mapattrs_idx].value,
-                                              &mapattrs[mapattrs_idx].value_sz,
-                                              &mapattrs[mapattrs_idx].value_datatype);
-            ++mapattrs_idx;
-        }
-    }
+	VALUE outer_pairs = Qnil;
+	VALUE outer_pair = Qnil;
+	VALUE inner_pairs = Qnil;
+	VALUE inner_pair = Qnil;
+	VALUE attr = Qnil;
+	VALUE key = Qnil;
+	VALUE val = Qnil;
+	struct hyperdex_client_map_attribute *mapattrs = NULL;
+	size_t mapattrs_sz = 0;
+	size_t mapattrs_idx = 0;
+	ssize_t i = 0;
+	size_t j = 0;
+	if (TYPE(x) != T_HASH)
+	{
+		rb_exc_raise(rb_exc_new2(rb_eTypeError, "Map attributes must be specified as a hash"));
+		abort(); /* unreachable? */
+	}
+	outer_pairs = rb_funcall(x, rb_intern("to_a"), 0);
+	for (i = 0; i < RARRAY_LEN(outer_pairs); ++i)
+	{
+		outer_pair = rb_ary_entry(outer_pairs, i);
+		inner_pairs = rb_ary_entry(outer_pair, 1);
+		if (TYPE(inner_pairs) != T_HASH)
+		{
+			rb_exc_raise(rb_exc_new2(rb_eTypeError, "Map attributes must be specified as a hash"));
+			abort(); /* unreachable? */
+		}
+		mapattrs_sz += RHASH_SIZE(inner_pairs);
+	}
+	mapattrs = hyperdex_ds_allocate_map_attribute(arena, mapattrs_sz);
+	if (!mapattrs)
+	{
+		hyperdex_ruby_out_of_memory();
+	}
+	*_mapattrs = mapattrs;
+	*_mapattrs_sz = mapattrs_sz;
+	for (i = 0; i < RARRAY_LEN(outer_pairs); ++i)
+	{
+		outer_pair = rb_ary_entry(outer_pairs, i);
+		attr = rb_ary_entry(outer_pair, 0);
+		inner_pairs = rb_ary_entry(outer_pair, 1);
+		inner_pairs = rb_funcall(inner_pairs, rb_intern("to_a"), 0);
+		for (j = 0; RARRAY_LEN(inner_pairs); ++j)
+		{
+			inner_pair = rb_ary_entry(inner_pairs, j);
+			key = rb_ary_entry(inner_pair, 0);
+			val = rb_ary_entry(inner_pair, 1);
+			mapattrs[mapattrs_idx].attr = hyperdex_ruby_client_convert_cstring(attr, "Attribute name must be a string or symbol");
+			hyperdex_ruby_client_convert_type(arena, key,
+			                                  &mapattrs[mapattrs_idx].map_key,
+			                                  &mapattrs[mapattrs_idx].map_key_sz,
+			                                  &mapattrs[mapattrs_idx].map_key_datatype);
+			hyperdex_ruby_client_convert_type(arena, val,
+			                                  &mapattrs[mapattrs_idx].value,
+			                                  &mapattrs[mapattrs_idx].value_sz,
+			                                  &mapattrs[mapattrs_idx].value_datatype);
+			++mapattrs_idx;
+		}
+	}
 }
 
 static void
-hyperdex_ruby_client_convert_maxmin(struct hyperdex_ds_arena* arena,
+hyperdex_ruby_client_convert_maxmin(struct hyperdex_ds_arena *arena,
                                     VALUE x,
-                                    int* maxmin)
+                                    int *maxmin)
 {
-    *maxmin = x == Qtrue ? 1: 0;
-    (void) arena;
+	*maxmin = x == Qtrue ? 1 : 0;
+	(void) arena;
 }
 
 static size_t
 hyperdex_ruby_client_estimate_predicate_size(VALUE x)
 {
-    VALUE pred = Qnil;
-    struct hyperdex_ruby_client_predicate* p = NULL;
-    ssize_t i = 0;
-    size_t sum = 0;
-
-    if (TYPE(x) == T_DATA &&
-        rb_obj_is_kind_of(x, class_predicate) == Qtrue)
-    {
-        Data_Get_Struct(x, struct hyperdex_ruby_client_predicate, p);
-        return p->num_checks;
-    }
-    else if (TYPE(x) == T_ARRAY &&
-             RARRAY_LEN(x) > 0 &&
-             rb_obj_is_kind_of(rb_ary_entry(x, 0), class_predicate) == Qtrue)
-    {
-        for (i = 0; i < RARRAY_LEN(x); ++i)
-        {
-            pred = rb_ary_entry(x, i);
-
-            if (TYPE(pred) != T_DATA ||
-                rb_obj_is_kind_of(pred, class_predicate) != Qtrue)
-            {
-                rb_raise(rb_eTypeError, "Cannot convert predicate to a HyperDex type");
-                return 0;
-            }
-
-            Data_Get_Struct(pred, struct hyperdex_ruby_client_predicate, p);
-            sum += p->num_checks;
-        }
-
-        return sum;
-    }
-    else
-    {
-        return 1;
-    }
+	VALUE pred = Qnil;
+	struct hyperdex_ruby_client_predicate *p = NULL;
+	ssize_t i = 0;
+	size_t sum = 0;
+	if (TYPE(x) == T_DATA &&
+	    rb_obj_is_kind_of(x, class_predicate) == Qtrue)
+	{
+		Data_Get_Struct(x, struct hyperdex_ruby_client_predicate, p);
+		return p->num_checks;
+	}
+	else if (TYPE(x) == T_ARRAY &&
+	         RARRAY_LEN(x) > 0 &&
+	         rb_obj_is_kind_of(rb_ary_entry(x, 0), class_predicate) == Qtrue)
+	{
+		for (i = 0; i < RARRAY_LEN(x); ++i)
+		{
+			pred = rb_ary_entry(x, i);
+			if (TYPE(pred) != T_DATA ||
+			    rb_obj_is_kind_of(pred, class_predicate) != Qtrue)
+			{
+				rb_raise(rb_eTypeError, "Cannot convert predicate to a HyperDex type");
+				return 0;
+			}
+			Data_Get_Struct(pred, struct hyperdex_ruby_client_predicate, p);
+			sum += p->num_checks;
+		}
+		return sum;
+	}
+	else
+	{
+		return 1;
+	}
 }
 
 static size_t
-hyperdex_ruby_client_convert_predicate(struct hyperdex_ds_arena* arena,
-                                       const char* attr,
+hyperdex_ruby_client_convert_predicate(struct hyperdex_ds_arena *arena,
+                                       const char *attr,
                                        VALUE x,
-                                       struct hyperdex_client_attribute_check* checks,
+                                       struct hyperdex_client_attribute_check *checks,
                                        size_t checks_idx)
 {
-    VALUE pred = Qnil;
-    struct hyperdex_ruby_client_predicate* p = NULL;
-    size_t i = 0;
-
-    if (TYPE(x) == T_DATA &&
-        rb_obj_is_kind_of(x, class_predicate) == Qtrue)
-    {
-        Data_Get_Struct(x, struct hyperdex_ruby_client_predicate, p);
-
-        for (i = 0; i < p->num_checks; ++i)
-        {
-            checks[checks_idx + i].attr = attr;
-            checks[checks_idx + i].predicate = p->checks[i].predicate;
-            hyperdex_ruby_client_convert_type(arena, p->checks[i].v,
-                                              &checks[checks_idx + i].value,
-                                              &checks[checks_idx + i].value_sz,
-                                              &checks[checks_idx + i].datatype);
-        }
-
-        return checks_idx + p->num_checks;
-    }
-    else if (TYPE(x) == T_ARRAY &&
-             RARRAY_LEN(x) > 0 &&
-             rb_obj_is_kind_of(rb_ary_entry(x, 0), class_predicate) == Qtrue)
-    {
-        for (i = 0; i < (size_t)RARRAY_LEN(x); ++i)
-        {
-            pred = rb_ary_entry(x, i);
-            assert(TYPE(pred) == T_DATA);
-            assert(rb_obj_is_kind_of(pred, class_predicate) == Qtrue);
-            checks_idx = hyperdex_ruby_client_convert_predicate(arena, attr, pred, checks, checks_idx);
-        }
-
-        return checks_idx;
-    }
-    else
-    {
-        checks[checks_idx].attr = attr;
-        checks[checks_idx].predicate = HYPERPREDICATE_EQUALS,
-        hyperdex_ruby_client_convert_type(arena, x,
-                                          &checks[checks_idx].value,
-                                          &checks[checks_idx].value_sz,
-                                          &checks[checks_idx].datatype);
-        return checks_idx + 1;
-    }
+	VALUE pred = Qnil;
+	struct hyperdex_ruby_client_predicate *p = NULL;
+	size_t i = 0;
+	if (TYPE(x) == T_DATA &&
+	    rb_obj_is_kind_of(x, class_predicate) == Qtrue)
+	{
+		Data_Get_Struct(x, struct hyperdex_ruby_client_predicate, p);
+		for (i = 0; i < p->num_checks; ++i)
+		{
+			checks[checks_idx + i].attr = attr;
+			checks[checks_idx + i].predicate = p->checks[i].predicate;
+			hyperdex_ruby_client_convert_type(arena, p->checks[i].v,
+			                                  &checks[checks_idx + i].value,
+			                                  &checks[checks_idx + i].value_sz,
+			                                  &checks[checks_idx + i].datatype);
+		}
+		return checks_idx + p->num_checks;
+	}
+	else if (TYPE(x) == T_ARRAY &&
+	         RARRAY_LEN(x) > 0 &&
+	         rb_obj_is_kind_of(rb_ary_entry(x, 0), class_predicate) == Qtrue)
+	{
+		for (i = 0; i < (size_t)RARRAY_LEN(x); ++i)
+		{
+			pred = rb_ary_entry(x, i);
+			assert(TYPE(pred) == T_DATA);
+			assert(rb_obj_is_kind_of(pred, class_predicate) == Qtrue);
+			checks_idx = hyperdex_ruby_client_convert_predicate(arena, attr, pred, checks, checks_idx);
+		}
+		return checks_idx;
+	}
+	else
+	{
+		checks[checks_idx].attr = attr;
+		checks[checks_idx].predicate = HYPERPREDICATE_EQUALS,
+		                   hyperdex_ruby_client_convert_type(arena, x,
+		                           &checks[checks_idx].value,
+		                           &checks[checks_idx].value_sz,
+		                           &checks[checks_idx].datatype);
+		return checks_idx + 1;
+	}
 }
 
 static void
-hyperdex_ruby_client_convert_predicates(struct hyperdex_ds_arena* arena,
+hyperdex_ruby_client_convert_predicates(struct hyperdex_ds_arena *arena,
                                         VALUE x,
-                                        const struct hyperdex_client_attribute_check** _checks,
-                                        size_t* _checks_sz)
+                                        const struct hyperdex_client_attribute_check **_checks,
+                                        size_t *_checks_sz)
 {
-    VALUE hash_pairs = Qnil;
-    VALUE hash_pair = Qnil;
-    VALUE key = Qnil;
-    VALUE val = Qnil;
-    struct hyperdex_client_attribute_check* checks = NULL;
-    size_t checks_sz = 0;
-    size_t checks_idx = 0;
-    ssize_t i = 0;
-    const char* attr;
-
-    if (TYPE(x) != T_HASH)
-    {
-        rb_exc_raise(rb_exc_new2(rb_eTypeError, "Predicates must be specified as a hash"));
-        abort(); /* unreachable? */
-    }
-
-    hash_pairs = rb_funcall(x, rb_intern("to_a"), 0);
-
-    /* figure out how many checks to allocate */
-    for (i = 0; i < RARRAY_LEN(hash_pairs); ++i)
-    {
-        hash_pair = rb_ary_entry(hash_pairs, i);
-        val = rb_ary_entry(hash_pair, 1);
-        checks_sz += hyperdex_ruby_client_estimate_predicate_size(val);
-    }
-
-    checks = hyperdex_ds_allocate_attribute_check(arena, checks_sz);
-
-    if (!checks)
-    {
-        hyperdex_ruby_out_of_memory();
-    }
-
-    *_checks = checks;
-    *_checks_sz = checks_sz;
-    checks_idx = 0;
-
-    /* turn the predicate into checks */
-    for (i = 0; i < RARRAY_LEN(hash_pairs); ++i)
-    {
-        hash_pair = rb_ary_entry(hash_pairs, i);
-        key = rb_ary_entry(hash_pair, 0);
-        val = rb_ary_entry(hash_pair, 1);
-
-        attr = hyperdex_ruby_client_convert_cstring(key, "Attribute name must be a string or symbol");
-        checks_idx = hyperdex_ruby_client_convert_predicate(arena, attr, val, checks, checks_idx);
-    }
+	VALUE hash_pairs = Qnil;
+	VALUE hash_pair = Qnil;
+	VALUE key = Qnil;
+	VALUE val = Qnil;
+	struct hyperdex_client_attribute_check *checks = NULL;
+	size_t checks_sz = 0;
+	size_t checks_idx = 0;
+	ssize_t i = 0;
+	const char *attr;
+	if (TYPE(x) != T_HASH)
+	{
+		rb_exc_raise(rb_exc_new2(rb_eTypeError, "Predicates must be specified as a hash"));
+		abort(); /* unreachable? */
+	}
+	hash_pairs = rb_funcall(x, rb_intern("to_a"), 0);
+	/* figure out how many checks to allocate */
+	for (i = 0; i < RARRAY_LEN(hash_pairs); ++i)
+	{
+		hash_pair = rb_ary_entry(hash_pairs, i);
+		val = rb_ary_entry(hash_pair, 1);
+		checks_sz += hyperdex_ruby_client_estimate_predicate_size(val);
+	}
+	checks = hyperdex_ds_allocate_attribute_check(arena, checks_sz);
+	if (!checks)
+	{
+		hyperdex_ruby_out_of_memory();
+	}
+	*_checks = checks;
+	*_checks_sz = checks_sz;
+	checks_idx = 0;
+	/* turn the predicate into checks */
+	for (i = 0; i < RARRAY_LEN(hash_pairs); ++i)
+	{
+		hash_pair = rb_ary_entry(hash_pairs, i);
+		key = rb_ary_entry(hash_pair, 0);
+		val = rb_ary_entry(hash_pair, 1);
+		attr = hyperdex_ruby_client_convert_cstring(key, "Attribute name must be a string or symbol");
+		checks_idx = hyperdex_ruby_client_convert_predicate(arena, attr, val, checks, checks_idx);
+	}
 }
 
 static void
-hyperdex_ruby_client_convert_attributenames(struct hyperdex_ds_arena* arena,
+hyperdex_ruby_client_convert_attributenames(struct hyperdex_ds_arena *arena,
                                             VALUE x,
-                                            const char*** names, size_t* names_sz)
+                                            const char *** names, size_t *names_sz)
 {
-    size_t i = 0;
-    *names_sz = RARRAY_LEN(x);
-    *names = hyperdex_ds_malloc(arena, sizeof(char*) * (*names_sz));
-
-    if (!(*names))
-    {
-        hyperdex_ruby_out_of_memory();
-    }
-
-    for (i = 0; i < *names_sz; ++i)
-    {
-        (*names)[i] = hyperdex_ruby_client_convert_cstring(rb_ary_entry(x, i),
-                "Attribute name must be a string or symbol");
-    }
+	size_t i = 0;
+	*names_sz = RARRAY_LEN(x);
+	*names = hyperdex_ds_malloc(arena, sizeof(char *) * (*names_sz));
+	if (!(*names))
+	{
+		hyperdex_ruby_out_of_memory();
+	}
+	for (i = 0; i < *names_sz; ++i)
+	{
+		(*names)[i] = hyperdex_ruby_client_convert_cstring(rb_ary_entry(x, i),
+		              "Attribute name must be a string or symbol");
+	}
 }
 
 static void
-hyperdex_ruby_client_convert_sortby(struct hyperdex_ds_arena* arena,
+hyperdex_ruby_client_convert_sortby(struct hyperdex_ds_arena *arena,
                                     VALUE x,
-                                    const char** sortby)
+                                    const char **sortby)
 {
-    *sortby = hyperdex_ruby_client_convert_cstring(x, "sortby must be a string or symbol");
-    (void) arena;
+	*sortby = hyperdex_ruby_client_convert_cstring(x, "sortby must be a string or symbol");
+	(void) arena;
 }
 
 static void
-hyperdex_ruby_client_convert_spacename(struct hyperdex_ds_arena* arena,
+hyperdex_ruby_client_convert_spacename(struct hyperdex_ds_arena *arena,
                                        VALUE x,
-                                       const char** spacename)
+                                       const char **spacename)
 {
-    *spacename = hyperdex_ruby_client_convert_cstring(x, "spacename must be a string or symbol");
-    (void) arena;
+	*spacename = hyperdex_ruby_client_convert_cstring(x, "spacename must be a string or symbol");
+	(void) arena;
 }
 
 /********************************** C -> Ruby *********************************/
 
 static VALUE
-hyperdex_ruby_client_build_attribute(const struct hyperdex_client_attribute* attrs)
+hyperdex_ruby_client_build_attribute(const struct hyperdex_client_attribute *attrs)
 {
-    struct hyperdex_ds_iterator iter;
-    const char* tmp_str = NULL;
-    size_t tmp_str_sz = 0;
-    const char* tmp_str2 = NULL;
-    size_t tmp_str2_sz = 0;
-    int64_t tmp_i = 0;
-    int64_t tmp_i2 = 0;
-    double tmp_d = 0;
-    double tmp_d2 = 0;
-    int result = 0;
-    VALUE ret = Qnil;
-    VALUE tmp = Qnil;
-    VALUE tmp2 = Qnil;
-
-    switch (attrs->datatype)
-    {
-        case HYPERDATATYPE_STRING:
-            return rb_str_new(attrs->value, attrs->value_sz);
-        case HYPERDATATYPE_INT64:
-            if (hyperdex_ds_unpack_int(attrs->value, attrs->value_sz, &tmp_i) < 0)
-            {
-                hyperdex_ruby_client_throw_exception(HYPERDEX_CLIENT_SERVERERROR, "server sent malformed int");
-            }
-
-            return LL2NUM(tmp_i);
-        case HYPERDATATYPE_FLOAT:
-            if (hyperdex_ds_unpack_float(attrs->value, attrs->value_sz, &tmp_d) < 0)
-            {
-                hyperdex_ruby_client_throw_exception(HYPERDEX_CLIENT_SERVERERROR, "server sent malformed float");
-            }
-
-            return rb_float_new(tmp_d);
-        case HYPERDATATYPE_DOCUMENT:
-            hyperdex_ruby_client_throw_exception(HYPERDEX_CLIENT_WRONGTYPE, "Ruby bindings do not support JSON objects");
-        case HYPERDATATYPE_LIST_STRING:
-            ret = rb_ary_new();
-            hyperdex_ds_iterator_init(&iter, attrs->datatype, attrs->value, attrs->value_sz);
-
-            while ((result = hyperdex_ds_iterate_list_string_next(&iter, &tmp_str, &tmp_str_sz)) > 0)
-            {
-                tmp = rb_str_new(tmp_str, tmp_str_sz);
-                rb_ary_push(ret, tmp);
-            }
-
-            if (result < 0)
-            {
-                hyperdex_ruby_client_throw_exception(HYPERDEX_CLIENT_SERVERERROR, "server sent malformed list(string)");
-            }
-
-            return ret;
-        case HYPERDATATYPE_LIST_INT64:
-            ret = rb_ary_new();
-            hyperdex_ds_iterator_init(&iter, attrs->datatype, attrs->value, attrs->value_sz);
-
-            while ((result = hyperdex_ds_iterate_list_int_next(&iter, &tmp_i)) > 0)
-            {
-                tmp = LL2NUM(tmp_i);
-                rb_ary_push(ret, tmp);
-            }
-
-            if (result < 0)
-            {
-                hyperdex_ruby_client_throw_exception(HYPERDEX_CLIENT_SERVERERROR, "server sent malformed list(int)");
-            }
-
-            return ret;
-        case HYPERDATATYPE_LIST_FLOAT:
-            ret = rb_ary_new();
-            hyperdex_ds_iterator_init(&iter, attrs->datatype, attrs->value, attrs->value_sz);
-
-            while ((result = hyperdex_ds_iterate_list_float_next(&iter, &tmp_d)) > 0)
-            {
-                tmp = rb_float_new(tmp_d);
-                rb_ary_push(ret, tmp);
-            }
-
-            if (result < 0)
-            {
-                hyperdex_ruby_client_throw_exception(HYPERDEX_CLIENT_SERVERERROR, "server sent malformed list(float)");
-            }
-
-            return ret;
-        case HYPERDATATYPE_SET_STRING:
-            ret = rb_ary_new();
-            hyperdex_ds_iterator_init(&iter, attrs->datatype, attrs->value, attrs->value_sz);
-
-            while ((result = hyperdex_ds_iterate_set_string_next(&iter, &tmp_str, &tmp_str_sz)) > 0)
-            {
-                tmp = rb_str_new(tmp_str, tmp_str_sz);
-                rb_ary_push(ret, tmp);
-            }
-
-            if (result < 0)
-            {
-                hyperdex_ruby_client_throw_exception(HYPERDEX_CLIENT_SERVERERROR, "server sent malformed set(string)");
-            }
-
-            return rb_class_new_instance(1, &ret, Set);
-        case HYPERDATATYPE_SET_INT64:
-            ret = rb_ary_new();
-            hyperdex_ds_iterator_init(&iter, attrs->datatype, attrs->value, attrs->value_sz);
-
-            while ((result = hyperdex_ds_iterate_set_int_next(&iter, &tmp_i)) > 0)
-            {
-                tmp = LL2NUM(tmp_i);
-                rb_ary_push(ret, tmp);
-            }
-
-            if (result < 0)
-            {
-                hyperdex_ruby_client_throw_exception(HYPERDEX_CLIENT_SERVERERROR, "server sent malformed set(int)");
-            }
-
-            return rb_class_new_instance(1, &ret, Set);
-        case HYPERDATATYPE_SET_FLOAT:
-            ret = rb_ary_new();
-            hyperdex_ds_iterator_init(&iter, attrs->datatype, attrs->value, attrs->value_sz);
-
-            while ((result = hyperdex_ds_iterate_set_float_next(&iter, &tmp_d)) > 0)
-            {
-                tmp = rb_float_new(tmp_d);
-                rb_ary_push(ret, tmp);
-            }
-
-            if (result < 0)
-            {
-                hyperdex_ruby_client_throw_exception(HYPERDEX_CLIENT_SERVERERROR, "server sent malformed set(float)");
-            }
-
-            return rb_class_new_instance(1, &ret, Set);
-        case HYPERDATATYPE_MAP_STRING_STRING:
-            ret = rb_hash_new();
-            hyperdex_ds_iterator_init(&iter, attrs->datatype, attrs->value, attrs->value_sz);
-
-            while ((result = hyperdex_ds_iterate_map_string_string_next(&iter, &tmp_str, &tmp_str_sz, &tmp_str2, &tmp_str2_sz)) > 0)
-            {
-                tmp = rb_str_new(tmp_str, tmp_str_sz);
-                tmp2 = rb_str_new(tmp_str2, tmp_str2_sz);
-                rb_hash_aset(ret, tmp, tmp2);
-            }
-
-            if (result < 0)
-            {
-                hyperdex_ruby_client_throw_exception(HYPERDEX_CLIENT_SERVERERROR, "server sent malformed map(string, string)");
-            }
-
-            return ret;
-        case HYPERDATATYPE_MAP_STRING_INT64:
-            ret = rb_hash_new();
-            hyperdex_ds_iterator_init(&iter, attrs->datatype, attrs->value, attrs->value_sz);
-
-            while ((result = hyperdex_ds_iterate_map_string_int_next(&iter, &tmp_str, &tmp_str_sz, &tmp_i)) > 0)
-            {
-                tmp = rb_str_new(tmp_str, tmp_str_sz);
-                tmp2 = LL2NUM(tmp_i);
-                rb_hash_aset(ret, tmp, tmp2);
-            }
-
-            if (result < 0)
-            {
-                hyperdex_ruby_client_throw_exception(HYPERDEX_CLIENT_SERVERERROR, "server sent malformed map(string, int)");
-            }
-
-            return ret;
-        case HYPERDATATYPE_MAP_STRING_FLOAT:
-            ret = rb_hash_new();
-            hyperdex_ds_iterator_init(&iter, attrs->datatype, attrs->value, attrs->value_sz);
-
-            while ((result = hyperdex_ds_iterate_map_string_float_next(&iter, &tmp_str, &tmp_str_sz, &tmp_d)) > 0)
-            {
-                tmp = rb_str_new(tmp_str, tmp_str_sz);
-                tmp2 = rb_float_new(tmp_d);
-                rb_hash_aset(ret, tmp, tmp2);
-            }
-
-            if (result < 0)
-            {
-                hyperdex_ruby_client_throw_exception(HYPERDEX_CLIENT_SERVERERROR, "server sent malformed map(string, float)");
-            }
-
-            return ret;
-        case HYPERDATATYPE_MAP_INT64_STRING:
-            ret = rb_hash_new();
-            hyperdex_ds_iterator_init(&iter, attrs->datatype, attrs->value, attrs->value_sz);
-
-            while ((result = hyperdex_ds_iterate_map_int_string_next(&iter, &tmp_i, &tmp_str, &tmp_str_sz)) > 0)
-            {
-                tmp = LL2NUM(tmp_i);
-                tmp2 = rb_str_new(tmp_str, tmp_str_sz);
-                rb_hash_aset(ret, tmp, tmp2);
-            }
-
-            if (result < 0)
-            {
-                hyperdex_ruby_client_throw_exception(HYPERDEX_CLIENT_SERVERERROR, "server sent malformed map(int, string)");
-            }
-
-            return ret;
-        case HYPERDATATYPE_MAP_INT64_INT64:
-            ret = rb_hash_new();
-            hyperdex_ds_iterator_init(&iter, attrs->datatype, attrs->value, attrs->value_sz);
-
-            while ((result = hyperdex_ds_iterate_map_int_int_next(&iter, &tmp_i, &tmp_i2)) > 0)
-            {
-                tmp = LL2NUM(tmp_i);
-                tmp2 = LL2NUM(tmp_i2);
-                rb_hash_aset(ret, tmp, tmp2);
-            }
-
-            if (result < 0)
-            {
-                hyperdex_ruby_client_throw_exception(HYPERDEX_CLIENT_SERVERERROR, "server sent malformed map(int, int)");
-            }
-
-            return ret;
-        case HYPERDATATYPE_MAP_INT64_FLOAT:
-            ret = rb_hash_new();
-            hyperdex_ds_iterator_init(&iter, attrs->datatype, attrs->value, attrs->value_sz);
-
-            while ((result = hyperdex_ds_iterate_map_int_float_next(&iter, &tmp_i, &tmp_d)) > 0)
-            {
-                tmp = LL2NUM(tmp_i);
-                tmp2 = rb_float_new(tmp_d);
-                rb_hash_aset(ret, tmp, tmp2);
-            }
-
-            if (result < 0)
-            {
-                hyperdex_ruby_client_throw_exception(HYPERDEX_CLIENT_SERVERERROR, "server sent malformed map(int, float)");
-            }
-
-            return ret;
-        case HYPERDATATYPE_MAP_FLOAT_STRING:
-            ret = rb_hash_new();
-            hyperdex_ds_iterator_init(&iter, attrs->datatype, attrs->value, attrs->value_sz);
-
-            while ((result = hyperdex_ds_iterate_map_float_string_next(&iter, &tmp_d, &tmp_str, &tmp_str_sz)) > 0)
-            {
-                tmp = rb_float_new(tmp_d);
-                tmp2 = rb_str_new(tmp_str, tmp_str_sz);
-                rb_hash_aset(ret, tmp, tmp2);
-            }
-
-            if (result < 0)
-            {
-                hyperdex_ruby_client_throw_exception(HYPERDEX_CLIENT_SERVERERROR, "server sent malformed map(float, string)");
-            }
-
-            return ret;
-        case HYPERDATATYPE_MAP_FLOAT_INT64:
-            ret = rb_hash_new();
-            hyperdex_ds_iterator_init(&iter, attrs->datatype, attrs->value, attrs->value_sz);
-
-            while ((result = hyperdex_ds_iterate_map_float_int_next(&iter, &tmp_d, &tmp_i)) > 0)
-            {
-                tmp = rb_float_new(tmp_d);
-                tmp2 = LL2NUM(tmp_i);
-                rb_hash_aset(ret, tmp, tmp2);
-            }
-
-            if (result < 0)
-            {
-                hyperdex_ruby_client_throw_exception(HYPERDEX_CLIENT_SERVERERROR, "server sent malformed map(float, int)");
-            }
-
-            return ret;
-        case HYPERDATATYPE_MAP_FLOAT_FLOAT:
-            ret = rb_hash_new();
-            hyperdex_ds_iterator_init(&iter, attrs->datatype, attrs->value, attrs->value_sz);
-
-            while ((result = hyperdex_ds_iterate_map_float_float_next(&iter, &tmp_d, &tmp_d2)) > 0)
-            {
-                tmp = rb_float_new(tmp_d);
-                tmp2 = rb_float_new(tmp_d2);
-                rb_hash_aset(ret, tmp, tmp2);
-            }
-
-            if (result < 0)
-            {
-                hyperdex_ruby_client_throw_exception(HYPERDEX_CLIENT_SERVERERROR, "server sent malformed map(float, float)");
-            }
-
-            return ret;
-        case HYPERDATATYPE_GENERIC:
-        case HYPERDATATYPE_LIST_GENERIC:
-        case HYPERDATATYPE_SET_GENERIC:
-        case HYPERDATATYPE_MAP_GENERIC:
-        case HYPERDATATYPE_MAP_STRING_KEYONLY:
-        case HYPERDATATYPE_MAP_INT64_KEYONLY:
-        case HYPERDATATYPE_MAP_FLOAT_KEYONLY:
-        case HYPERDATATYPE_GARBAGE:
-        default:
-            hyperdex_ruby_client_throw_exception(HYPERDEX_CLIENT_SERVERERROR, "server sent malformed attributes");
-            return Qnil;
-    }
+	struct hyperdex_ds_iterator iter;
+	const char *tmp_str = NULL;
+	size_t tmp_str_sz = 0;
+	const char *tmp_str2 = NULL;
+	size_t tmp_str2_sz = 0;
+	int64_t tmp_i = 0;
+	int64_t tmp_i2 = 0;
+	double tmp_d = 0;
+	double tmp_d2 = 0;
+	int result = 0;
+	VALUE ret = Qnil;
+	VALUE tmp = Qnil;
+	VALUE tmp2 = Qnil;
+	switch (attrs->datatype)
+	{
+	case HYPERDATATYPE_STRING:
+		return rb_str_new(attrs->value, attrs->value_sz);
+	case HYPERDATATYPE_INT64:
+		if (hyperdex_ds_unpack_int(attrs->value, attrs->value_sz, &tmp_i) < 0)
+		{
+			hyperdex_ruby_client_throw_exception(HYPERDEX_CLIENT_SERVERERROR, "server sent malformed int");
+		}
+		return LL2NUM(tmp_i);
+	case HYPERDATATYPE_FLOAT:
+		if (hyperdex_ds_unpack_float(attrs->value, attrs->value_sz, &tmp_d) < 0)
+		{
+			hyperdex_ruby_client_throw_exception(HYPERDEX_CLIENT_SERVERERROR, "server sent malformed float");
+		}
+		return rb_float_new(tmp_d);
+	case HYPERDATATYPE_DOCUMENT:
+		hyperdex_ruby_client_throw_exception(HYPERDEX_CLIENT_WRONGTYPE, "Ruby bindings do not support JSON objects");
+	case HYPERDATATYPE_LIST_STRING:
+		ret = rb_ary_new();
+		hyperdex_ds_iterator_init(&iter, attrs->datatype, attrs->value, attrs->value_sz);
+		while ((result = hyperdex_ds_iterate_list_string_next(&iter, &tmp_str, &tmp_str_sz)) > 0)
+		{
+			tmp = rb_str_new(tmp_str, tmp_str_sz);
+			rb_ary_push(ret, tmp);
+		}
+		if (result < 0)
+		{
+			hyperdex_ruby_client_throw_exception(HYPERDEX_CLIENT_SERVERERROR, "server sent malformed list(string)");
+		}
+		return ret;
+	case HYPERDATATYPE_LIST_INT64:
+		ret = rb_ary_new();
+		hyperdex_ds_iterator_init(&iter, attrs->datatype, attrs->value, attrs->value_sz);
+		while ((result = hyperdex_ds_iterate_list_int_next(&iter, &tmp_i)) > 0)
+		{
+			tmp = LL2NUM(tmp_i);
+			rb_ary_push(ret, tmp);
+		}
+		if (result < 0)
+		{
+			hyperdex_ruby_client_throw_exception(HYPERDEX_CLIENT_SERVERERROR, "server sent malformed list(int)");
+		}
+		return ret;
+	case HYPERDATATYPE_LIST_FLOAT:
+		ret = rb_ary_new();
+		hyperdex_ds_iterator_init(&iter, attrs->datatype, attrs->value, attrs->value_sz);
+		while ((result = hyperdex_ds_iterate_list_float_next(&iter, &tmp_d)) > 0)
+		{
+			tmp = rb_float_new(tmp_d);
+			rb_ary_push(ret, tmp);
+		}
+		if (result < 0)
+		{
+			hyperdex_ruby_client_throw_exception(HYPERDEX_CLIENT_SERVERERROR, "server sent malformed list(float)");
+		}
+		return ret;
+	case HYPERDATATYPE_SET_STRING:
+		ret = rb_ary_new();
+		hyperdex_ds_iterator_init(&iter, attrs->datatype, attrs->value, attrs->value_sz);
+		while ((result = hyperdex_ds_iterate_set_string_next(&iter, &tmp_str, &tmp_str_sz)) > 0)
+		{
+			tmp = rb_str_new(tmp_str, tmp_str_sz);
+			rb_ary_push(ret, tmp);
+		}
+		if (result < 0)
+		{
+			hyperdex_ruby_client_throw_exception(HYPERDEX_CLIENT_SERVERERROR, "server sent malformed set(string)");
+		}
+		return rb_class_new_instance(1, &ret, Set);
+	case HYPERDATATYPE_SET_INT64:
+		ret = rb_ary_new();
+		hyperdex_ds_iterator_init(&iter, attrs->datatype, attrs->value, attrs->value_sz);
+		while ((result = hyperdex_ds_iterate_set_int_next(&iter, &tmp_i)) > 0)
+		{
+			tmp = LL2NUM(tmp_i);
+			rb_ary_push(ret, tmp);
+		}
+		if (result < 0)
+		{
+			hyperdex_ruby_client_throw_exception(HYPERDEX_CLIENT_SERVERERROR, "server sent malformed set(int)");
+		}
+		return rb_class_new_instance(1, &ret, Set);
+	case HYPERDATATYPE_SET_FLOAT:
+		ret = rb_ary_new();
+		hyperdex_ds_iterator_init(&iter, attrs->datatype, attrs->value, attrs->value_sz);
+		while ((result = hyperdex_ds_iterate_set_float_next(&iter, &tmp_d)) > 0)
+		{
+			tmp = rb_float_new(tmp_d);
+			rb_ary_push(ret, tmp);
+		}
+		if (result < 0)
+		{
+			hyperdex_ruby_client_throw_exception(HYPERDEX_CLIENT_SERVERERROR, "server sent malformed set(float)");
+		}
+		return rb_class_new_instance(1, &ret, Set);
+	case HYPERDATATYPE_MAP_STRING_STRING:
+		ret = rb_hash_new();
+		hyperdex_ds_iterator_init(&iter, attrs->datatype, attrs->value, attrs->value_sz);
+		while ((result = hyperdex_ds_iterate_map_string_string_next(&iter, &tmp_str, &tmp_str_sz, &tmp_str2, &tmp_str2_sz)) > 0)
+		{
+			tmp = rb_str_new(tmp_str, tmp_str_sz);
+			tmp2 = rb_str_new(tmp_str2, tmp_str2_sz);
+			rb_hash_aset(ret, tmp, tmp2);
+		}
+		if (result < 0)
+		{
+			hyperdex_ruby_client_throw_exception(HYPERDEX_CLIENT_SERVERERROR, "server sent malformed map(string, string)");
+		}
+		return ret;
+	case HYPERDATATYPE_MAP_STRING_INT64:
+		ret = rb_hash_new();
+		hyperdex_ds_iterator_init(&iter, attrs->datatype, attrs->value, attrs->value_sz);
+		while ((result = hyperdex_ds_iterate_map_string_int_next(&iter, &tmp_str, &tmp_str_sz, &tmp_i)) > 0)
+		{
+			tmp = rb_str_new(tmp_str, tmp_str_sz);
+			tmp2 = LL2NUM(tmp_i);
+			rb_hash_aset(ret, tmp, tmp2);
+		}
+		if (result < 0)
+		{
+			hyperdex_ruby_client_throw_exception(HYPERDEX_CLIENT_SERVERERROR, "server sent malformed map(string, int)");
+		}
+		return ret;
+	case HYPERDATATYPE_MAP_STRING_FLOAT:
+		ret = rb_hash_new();
+		hyperdex_ds_iterator_init(&iter, attrs->datatype, attrs->value, attrs->value_sz);
+		while ((result = hyperdex_ds_iterate_map_string_float_next(&iter, &tmp_str, &tmp_str_sz, &tmp_d)) > 0)
+		{
+			tmp = rb_str_new(tmp_str, tmp_str_sz);
+			tmp2 = rb_float_new(tmp_d);
+			rb_hash_aset(ret, tmp, tmp2);
+		}
+		if (result < 0)
+		{
+			hyperdex_ruby_client_throw_exception(HYPERDEX_CLIENT_SERVERERROR, "server sent malformed map(string, float)");
+		}
+		return ret;
+	case HYPERDATATYPE_MAP_INT64_STRING:
+		ret = rb_hash_new();
+		hyperdex_ds_iterator_init(&iter, attrs->datatype, attrs->value, attrs->value_sz);
+		while ((result = hyperdex_ds_iterate_map_int_string_next(&iter, &tmp_i, &tmp_str, &tmp_str_sz)) > 0)
+		{
+			tmp = LL2NUM(tmp_i);
+			tmp2 = rb_str_new(tmp_str, tmp_str_sz);
+			rb_hash_aset(ret, tmp, tmp2);
+		}
+		if (result < 0)
+		{
+			hyperdex_ruby_client_throw_exception(HYPERDEX_CLIENT_SERVERERROR, "server sent malformed map(int, string)");
+		}
+		return ret;
+	case HYPERDATATYPE_MAP_INT64_INT64:
+		ret = rb_hash_new();
+		hyperdex_ds_iterator_init(&iter, attrs->datatype, attrs->value, attrs->value_sz);
+		while ((result = hyperdex_ds_iterate_map_int_int_next(&iter, &tmp_i, &tmp_i2)) > 0)
+		{
+			tmp = LL2NUM(tmp_i);
+			tmp2 = LL2NUM(tmp_i2);
+			rb_hash_aset(ret, tmp, tmp2);
+		}
+		if (result < 0)
+		{
+			hyperdex_ruby_client_throw_exception(HYPERDEX_CLIENT_SERVERERROR, "server sent malformed map(int, int)");
+		}
+		return ret;
+	case HYPERDATATYPE_MAP_INT64_FLOAT:
+		ret = rb_hash_new();
+		hyperdex_ds_iterator_init(&iter, attrs->datatype, attrs->value, attrs->value_sz);
+		while ((result = hyperdex_ds_iterate_map_int_float_next(&iter, &tmp_i, &tmp_d)) > 0)
+		{
+			tmp = LL2NUM(tmp_i);
+			tmp2 = rb_float_new(tmp_d);
+			rb_hash_aset(ret, tmp, tmp2);
+		}
+		if (result < 0)
+		{
+			hyperdex_ruby_client_throw_exception(HYPERDEX_CLIENT_SERVERERROR, "server sent malformed map(int, float)");
+		}
+		return ret;
+	case HYPERDATATYPE_MAP_FLOAT_STRING:
+		ret = rb_hash_new();
+		hyperdex_ds_iterator_init(&iter, attrs->datatype, attrs->value, attrs->value_sz);
+		while ((result = hyperdex_ds_iterate_map_float_string_next(&iter, &tmp_d, &tmp_str, &tmp_str_sz)) > 0)
+		{
+			tmp = rb_float_new(tmp_d);
+			tmp2 = rb_str_new(tmp_str, tmp_str_sz);
+			rb_hash_aset(ret, tmp, tmp2);
+		}
+		if (result < 0)
+		{
+			hyperdex_ruby_client_throw_exception(HYPERDEX_CLIENT_SERVERERROR, "server sent malformed map(float, string)");
+		}
+		return ret;
+	case HYPERDATATYPE_MAP_FLOAT_INT64:
+		ret = rb_hash_new();
+		hyperdex_ds_iterator_init(&iter, attrs->datatype, attrs->value, attrs->value_sz);
+		while ((result = hyperdex_ds_iterate_map_float_int_next(&iter, &tmp_d, &tmp_i)) > 0)
+		{
+			tmp = rb_float_new(tmp_d);
+			tmp2 = LL2NUM(tmp_i);
+			rb_hash_aset(ret, tmp, tmp2);
+		}
+		if (result < 0)
+		{
+			hyperdex_ruby_client_throw_exception(HYPERDEX_CLIENT_SERVERERROR, "server sent malformed map(float, int)");
+		}
+		return ret;
+	case HYPERDATATYPE_MAP_FLOAT_FLOAT:
+		ret = rb_hash_new();
+		hyperdex_ds_iterator_init(&iter, attrs->datatype, attrs->value, attrs->value_sz);
+		while ((result = hyperdex_ds_iterate_map_float_float_next(&iter, &tmp_d, &tmp_d2)) > 0)
+		{
+			tmp = rb_float_new(tmp_d);
+			tmp2 = rb_float_new(tmp_d2);
+			rb_hash_aset(ret, tmp, tmp2);
+		}
+		if (result < 0)
+		{
+			hyperdex_ruby_client_throw_exception(HYPERDEX_CLIENT_SERVERERROR, "server sent malformed map(float, float)");
+		}
+		return ret;
+	case HYPERDATATYPE_GENERIC:
+	case HYPERDATATYPE_LIST_GENERIC:
+	case HYPERDATATYPE_SET_GENERIC:
+	case HYPERDATATYPE_MAP_GENERIC:
+	case HYPERDATATYPE_MAP_STRING_KEYONLY:
+	case HYPERDATATYPE_MAP_INT64_KEYONLY:
+	case HYPERDATATYPE_MAP_FLOAT_KEYONLY:
+	case HYPERDATATYPE_GARBAGE:
+	default:
+		hyperdex_ruby_client_throw_exception(HYPERDEX_CLIENT_SERVERERROR, "server sent malformed attributes");
+		return Qnil;
+	}
 }
 
 static VALUE
-hyperdex_ruby_client_build_attributes(const struct hyperdex_client_attribute* attrs,
+hyperdex_ruby_client_build_attributes(const struct hyperdex_client_attribute *attrs,
                                       size_t attrs_sz)
 {
-    VALUE ret = rb_hash_new();
-    VALUE val = Qnil;
-    size_t i = 0;
-
-    for (i = 0; i < attrs_sz; ++i)
-    {
-        val = hyperdex_ruby_client_build_attribute(attrs + i);
-        rb_hash_aset(ret, ID2SYM(rb_intern(attrs[i].attr)), val);
-    }
-
-    return ret;
+	VALUE ret = rb_hash_new();
+	VALUE val = Qnil;
+	size_t i = 0;
+	for (i = 0; i < attrs_sz; ++i)
+	{
+		val = hyperdex_ruby_client_build_attribute(attrs + i);
+		rb_hash_aset(ret, ID2SYM(rb_intern(attrs[i].attr)), val);
+	}
+	return ret;
 }
 
 /******************************* Deferred Class *******************************/
 
 struct hyperdex_ruby_client_deferred
 {
-    VALUE client;
-    struct hyperdex_ds_arena* arena;
-    int64_t reqid;
-    enum hyperdex_client_returncode status;
-    const struct hyperdex_client_attribute* attrs;
-    size_t attrs_sz;
-    const char* description;
-    uint64_t count;
-    int finished;
-    VALUE (*encode_return)(struct hyperdex_ruby_client_deferred* d);
+	VALUE client;
+	struct hyperdex_ds_arena *arena;
+	int64_t reqid;
+	enum hyperdex_client_returncode status;
+	const struct hyperdex_client_attribute *attrs;
+	size_t attrs_sz;
+	const char *description;
+	uint64_t count;
+	int finished;
+	VALUE (*encode_return)(struct hyperdex_ruby_client_deferred *d);
 };
 
 void
-hyperdex_ruby_client_deferred_mark(struct hyperdex_ruby_client_deferred* dfrd)
+hyperdex_ruby_client_deferred_mark(struct hyperdex_ruby_client_deferred *dfrd)
 {
-    if (dfrd)
-    {
-        rb_gc_mark(dfrd->client);
-    }
+	if (dfrd)
+	{
+		rb_gc_mark(dfrd->client);
+	}
 }
 
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wcast-qual"
 void
-hyperdex_ruby_client_deferred_free(struct hyperdex_ruby_client_deferred* dfrd)
+hyperdex_ruby_client_deferred_free(struct hyperdex_ruby_client_deferred *dfrd)
 {
-    if (dfrd)
-    {
-        if (dfrd->arena)
-        {
-            hyperdex_ds_arena_destroy(dfrd->arena);
-        }
-
-        if (dfrd->attrs)
-        {
-            hyperdex_client_destroy_attrs(dfrd->attrs, dfrd->attrs_sz);
-        }
-
-        if (dfrd->description)
-        {
-            free((void*)dfrd->description);
-        }
-
-        free(dfrd);
-    }
+	if (dfrd)
+	{
+		if (dfrd->arena)
+		{
+			hyperdex_ds_arena_destroy(dfrd->arena);
+		}
+		if (dfrd->attrs)
+		{
+			hyperdex_client_destroy_attrs(dfrd->attrs, dfrd->attrs_sz);
+		}
+		if (dfrd->description)
+		{
+			free((void *)dfrd->description);
+		}
+		free(dfrd);
+	}
 }
 #pragma GCC diagnostic pop
 
 static VALUE
 hyperdex_ruby_client_deferred_alloc(VALUE class)
 {
-    struct hyperdex_ruby_client_deferred* dfrd;
-    dfrd = malloc(sizeof(struct hyperdex_ruby_client_deferred));
-
-    if (!dfrd)
-    {
-        hyperdex_ruby_out_of_memory();
-        return Qnil;
-    }
-
-    memset(dfrd, 0, sizeof(struct hyperdex_ruby_client_deferred));
-    dfrd->client = Qnil;
-    dfrd->arena = hyperdex_ds_arena_create();
-
-    if (!dfrd->arena)
-    {
-        hyperdex_ruby_out_of_memory();
-        return Qnil;
-    }
-
-    dfrd->reqid = -1;
-    dfrd->status = HYPERDEX_CLIENT_GARBAGE;
-    dfrd->attrs = NULL;
-    dfrd->attrs_sz = 0;
-    dfrd->description = NULL;
-    dfrd->count = 0;
-    dfrd->finished = 0;
-    dfrd->encode_return = NULL;
-    return Data_Wrap_Struct(class, hyperdex_ruby_client_deferred_mark, hyperdex_ruby_client_deferred_free, dfrd);
+	struct hyperdex_ruby_client_deferred *dfrd;
+	dfrd = malloc(sizeof(struct hyperdex_ruby_client_deferred));
+	if (!dfrd)
+	{
+		hyperdex_ruby_out_of_memory();
+		return Qnil;
+	}
+	memset(dfrd, 0, sizeof(struct hyperdex_ruby_client_deferred));
+	dfrd->client = Qnil;
+	dfrd->arena = hyperdex_ds_arena_create();
+	if (!dfrd->arena)
+	{
+		hyperdex_ruby_out_of_memory();
+		return Qnil;
+	}
+	dfrd->reqid = -1;
+	dfrd->status = HYPERDEX_CLIENT_GARBAGE;
+	dfrd->attrs = NULL;
+	dfrd->attrs_sz = 0;
+	dfrd->description = NULL;
+	dfrd->count = 0;
+	dfrd->finished = 0;
+	dfrd->encode_return = NULL;
+	return Data_Wrap_Struct(class, hyperdex_ruby_client_deferred_mark, hyperdex_ruby_client_deferred_free, dfrd);
 }
 
 static VALUE
 hyperdex_ruby_client_deferred_init(VALUE self, VALUE client)
 {
-    struct hyperdex_ruby_client_deferred* dfrd = NULL;
-    Data_Get_Struct(self, struct hyperdex_ruby_client_deferred, dfrd);
-    dfrd->client = client;
-    return self;
+	struct hyperdex_ruby_client_deferred *dfrd = NULL;
+	Data_Get_Struct(self, struct hyperdex_ruby_client_deferred, dfrd);
+	dfrd->client = client;
+	return self;
 }
 
 static VALUE
 hyperdex_ruby_client_deferred_callback(VALUE self)
 {
-    VALUE ops;
-    struct hyperdex_ruby_client_deferred* dfrd = NULL;
-    Data_Get_Struct(self, struct hyperdex_ruby_client_deferred, dfrd);
-    dfrd->finished = 1;
-    ops = rb_iv_get(dfrd->client, "ops");
-    rb_hash_delete(ops, INT2NUM(dfrd->reqid));
-    return Qnil;
+	VALUE ops;
+	struct hyperdex_ruby_client_deferred *dfrd = NULL;
+	Data_Get_Struct(self, struct hyperdex_ruby_client_deferred, dfrd);
+	dfrd->finished = 1;
+	ops = rb_iv_get(dfrd->client, "ops");
+	rb_hash_delete(ops, INT2NUM(dfrd->reqid));
+	return Qnil;
 }
 
 static VALUE
 hyperdex_ruby_client_deferred_wait(VALUE self)
 {
-    struct hyperdex_ruby_client_deferred* dfrd = NULL;
-    Data_Get_Struct(self, struct hyperdex_ruby_client_deferred, dfrd);
-
-    while (!dfrd->finished && dfrd->reqid >= 0)
-    {
-        rb_funcall(dfrd->client, rb_intern("loop"), 0);
-    }
-
-    dfrd->finished = 1;
-    assert(dfrd->encode_return);
-    return dfrd->encode_return(dfrd);
+	struct hyperdex_ruby_client_deferred *dfrd = NULL;
+	Data_Get_Struct(self, struct hyperdex_ruby_client_deferred, dfrd);
+	while (!dfrd->finished && dfrd->reqid >= 0)
+	{
+		rb_funcall(dfrd->client, rb_intern("loop"), 0);
+	}
+	dfrd->finished = 1;
+	assert(dfrd->encode_return);
+	return dfrd->encode_return(dfrd);
 }
 
 static VALUE
-hyperdex_ruby_client_deferred_encode_status(struct hyperdex_ruby_client_deferred* d)
+hyperdex_ruby_client_deferred_encode_status(struct hyperdex_ruby_client_deferred *d)
 {
-    struct hyperdex_client* client = NULL;
-
-    if (d->status == HYPERDEX_CLIENT_SUCCESS)
-    {
-        return Qtrue;
-    }
-    else if (d->status == HYPERDEX_CLIENT_NOTFOUND)
-    {
-        return Qnil;
-    }
-    else if (d->status == HYPERDEX_CLIENT_CMPFAIL)
-    {
-        return Qfalse;
-    }
-    else
-    {
-        Data_Get_Struct(d->client, struct hyperdex_client, client);
-        hyperdex_ruby_client_throw_exception(d->status, hyperdex_client_error_message(client));
-        return Qnil;
-    }
+	struct hyperdex_client *client = NULL;
+	if (d->status == HYPERDEX_CLIENT_SUCCESS)
+	{
+		return Qtrue;
+	}
+	else if (d->status == HYPERDEX_CLIENT_NOTFOUND)
+	{
+		return Qnil;
+	}
+	else if (d->status == HYPERDEX_CLIENT_CMPFAIL)
+	{
+		return Qfalse;
+	}
+	else
+	{
+		Data_Get_Struct(d->client, struct hyperdex_client, client);
+		hyperdex_ruby_client_throw_exception(d->status, hyperdex_client_error_message(client));
+		return Qnil;
+	}
 }
 
 static VALUE
-hyperdex_ruby_client_deferred_encode_status_attributes(struct hyperdex_ruby_client_deferred* d)
+hyperdex_ruby_client_deferred_encode_status_attributes(struct hyperdex_ruby_client_deferred *d)
 {
-    struct hyperdex_client* client = NULL;
-
-    if (d->status == HYPERDEX_CLIENT_SUCCESS)
-    {
-        return hyperdex_ruby_client_build_attributes(d->attrs, d->attrs_sz);
-    }
-    else if (d->status == HYPERDEX_CLIENT_NOTFOUND)
-    {
-        return Qnil;
-    }
-    else if (d->status == HYPERDEX_CLIENT_CMPFAIL)
-    {
-        return Qfalse;
-    }
-    else
-    {
-        Data_Get_Struct(d->client, struct hyperdex_client, client);
-        hyperdex_ruby_client_throw_exception(d->status, hyperdex_client_error_message(client));
-        return Qnil;
-    }
+	struct hyperdex_client *client = NULL;
+	if (d->status == HYPERDEX_CLIENT_SUCCESS)
+	{
+		return hyperdex_ruby_client_build_attributes(d->attrs, d->attrs_sz);
+	}
+	else if (d->status == HYPERDEX_CLIENT_NOTFOUND)
+	{
+		return Qnil;
+	}
+	else if (d->status == HYPERDEX_CLIENT_CMPFAIL)
+	{
+		return Qfalse;
+	}
+	else
+	{
+		Data_Get_Struct(d->client, struct hyperdex_client, client);
+		hyperdex_ruby_client_throw_exception(d->status, hyperdex_client_error_message(client));
+		return Qnil;
+	}
 }
 
 static VALUE
-hyperdex_ruby_client_deferred_encode_status_count(struct hyperdex_ruby_client_deferred* d)
+hyperdex_ruby_client_deferred_encode_status_count(struct hyperdex_ruby_client_deferred *d)
 {
-    struct hyperdex_client* client = NULL;
-
-    if (d->status == HYPERDEX_CLIENT_SUCCESS)
-    {
-        return INT2NUM(d->count);
-    }
-    else if (d->status == HYPERDEX_CLIENT_NOTFOUND)
-    {
-        return Qnil;
-    }
-    else if (d->status == HYPERDEX_CLIENT_CMPFAIL)
-    {
-        return Qfalse;
-    }
-    else
-    {
-        Data_Get_Struct(d->client, struct hyperdex_client, client);
-        hyperdex_ruby_client_throw_exception(d->status, hyperdex_client_error_message(client));
-        return Qnil;
-    }
+	struct hyperdex_client *client = NULL;
+	if (d->status == HYPERDEX_CLIENT_SUCCESS)
+	{
+		return INT2NUM(d->count);
+	}
+	else if (d->status == HYPERDEX_CLIENT_NOTFOUND)
+	{
+		return Qnil;
+	}
+	else if (d->status == HYPERDEX_CLIENT_CMPFAIL)
+	{
+		return Qfalse;
+	}
+	else
+	{
+		Data_Get_Struct(d->client, struct hyperdex_client, client);
+		hyperdex_ruby_client_throw_exception(d->status, hyperdex_client_error_message(client));
+		return Qnil;
+	}
 }
 
 static VALUE
-hyperdex_ruby_client_deferred_encode_status_description(struct hyperdex_ruby_client_deferred* d)
+hyperdex_ruby_client_deferred_encode_status_description(struct hyperdex_ruby_client_deferred *d)
 {
-    struct hyperdex_client* client = NULL;
-
-    if (d->status == HYPERDEX_CLIENT_SUCCESS)
-    {
-        return rb_str_new2(d->description);
-    }
-    else if (d->status == HYPERDEX_CLIENT_NOTFOUND)
-    {
-        return Qnil;
-    }
-    else if (d->status == HYPERDEX_CLIENT_CMPFAIL)
-    {
-        return Qfalse;
-    }
-    else
-    {
-        Data_Get_Struct(d->client, struct hyperdex_client, client);
-        hyperdex_ruby_client_throw_exception(d->status, hyperdex_client_error_message(client));
-        return Qnil;
-    }
+	struct hyperdex_client *client = NULL;
+	if (d->status == HYPERDEX_CLIENT_SUCCESS)
+	{
+		return rb_str_new2(d->description);
+	}
+	else if (d->status == HYPERDEX_CLIENT_NOTFOUND)
+	{
+		return Qnil;
+	}
+	else if (d->status == HYPERDEX_CLIENT_CMPFAIL)
+	{
+		return Qfalse;
+	}
+	else
+	{
+		Data_Get_Struct(d->client, struct hyperdex_client, client);
+		hyperdex_ruby_client_throw_exception(d->status, hyperdex_client_error_message(client));
+		return Qnil;
+	}
 }
 
 /******************************* Iterator Class *******************************/
 
 struct hyperdex_ruby_client_iterator
 {
-    VALUE client;
-    VALUE backlogged;
-    struct hyperdex_ds_arena* arena;
-    int64_t reqid;
-    enum hyperdex_client_returncode status;
-    const struct hyperdex_client_attribute* attrs;
-    size_t attrs_sz;
-    int finished;
-    VALUE (*encode_return)(struct hyperdex_ruby_client_iterator* d);
+	VALUE client;
+	VALUE backlogged;
+	struct hyperdex_ds_arena *arena;
+	int64_t reqid;
+	enum hyperdex_client_returncode status;
+	const struct hyperdex_client_attribute *attrs;
+	size_t attrs_sz;
+	int finished;
+	VALUE (*encode_return)(struct hyperdex_ruby_client_iterator *d);
 };
 
 void
-hyperdex_ruby_client_iterator_mark(struct hyperdex_ruby_client_iterator* iter)
+hyperdex_ruby_client_iterator_mark(struct hyperdex_ruby_client_iterator *iter)
 {
-    if (iter)
-    {
-        rb_gc_mark(iter->client);
-    }
+	if (iter)
+	{
+		rb_gc_mark(iter->client);
+	}
 }
 
 void
-hyperdex_ruby_client_iterator_free(struct hyperdex_ruby_client_iterator* iter)
+hyperdex_ruby_client_iterator_free(struct hyperdex_ruby_client_iterator *iter)
 {
-    if (iter)
-    {
-        if (iter->arena)
-        {
-            hyperdex_ds_arena_destroy(iter->arena);
-        }
-
-        if (iter->attrs)
-        {
-            hyperdex_client_destroy_attrs(iter->attrs, iter->attrs_sz);
-        }
-
-        free(iter);
-    }
+	if (iter)
+	{
+		if (iter->arena)
+		{
+			hyperdex_ds_arena_destroy(iter->arena);
+		}
+		if (iter->attrs)
+		{
+			hyperdex_client_destroy_attrs(iter->attrs, iter->attrs_sz);
+		}
+		free(iter);
+	}
 }
 
 static VALUE
 hyperdex_ruby_client_iterator_alloc(VALUE class)
 {
-    struct hyperdex_ruby_client_iterator* iter;
-    iter = malloc(sizeof(struct hyperdex_ruby_client_iterator));
-
-    if (!iter)
-    {
-        hyperdex_ruby_out_of_memory();
-        return Qnil;
-    }
-
-    memset(iter, 0, sizeof(struct hyperdex_ruby_client_iterator));
-    iter->client = Qnil;
-    iter->backlogged = rb_ary_new();
-    iter->arena = hyperdex_ds_arena_create();
-
-    if (!iter->arena)
-    {
-        hyperdex_ruby_out_of_memory();
-        return Qnil;
-    }
-
-    iter->reqid = -1;
-    iter->status = HYPERDEX_CLIENT_GARBAGE;
-    iter->attrs = NULL;
-    iter->attrs_sz = 0;
-    iter->encode_return = NULL;
-    return Data_Wrap_Struct(class, hyperdex_ruby_client_iterator_mark, hyperdex_ruby_client_iterator_free, iter);
+	struct hyperdex_ruby_client_iterator *iter;
+	iter = malloc(sizeof(struct hyperdex_ruby_client_iterator));
+	if (!iter)
+	{
+		hyperdex_ruby_out_of_memory();
+		return Qnil;
+	}
+	memset(iter, 0, sizeof(struct hyperdex_ruby_client_iterator));
+	iter->client = Qnil;
+	iter->backlogged = rb_ary_new();
+	iter->arena = hyperdex_ds_arena_create();
+	if (!iter->arena)
+	{
+		hyperdex_ruby_out_of_memory();
+		return Qnil;
+	}
+	iter->reqid = -1;
+	iter->status = HYPERDEX_CLIENT_GARBAGE;
+	iter->attrs = NULL;
+	iter->attrs_sz = 0;
+	iter->encode_return = NULL;
+	return Data_Wrap_Struct(class, hyperdex_ruby_client_iterator_mark, hyperdex_ruby_client_iterator_free, iter);
 }
 
 static VALUE
 hyperdex_ruby_client_iterator_init(VALUE self, VALUE client)
 {
-    struct hyperdex_ruby_client_iterator* iter = NULL;
-    Data_Get_Struct(self, struct hyperdex_ruby_client_iterator, iter);
-    iter->client = client;
-    return self;
+	struct hyperdex_ruby_client_iterator *iter = NULL;
+	Data_Get_Struct(self, struct hyperdex_ruby_client_iterator, iter);
+	iter->client = client;
+	return self;
 }
 
 static VALUE
 hyperdex_ruby_client_iterator_callback(VALUE self)
 {
-    VALUE ops;
-    VALUE obj;
-    struct hyperdex_ruby_client_iterator* iter = NULL;
-    struct hyperdex_client* client;
-    Data_Get_Struct(self, struct hyperdex_ruby_client_iterator, iter);
-    Data_Get_Struct(iter->client, struct hyperdex_client, client);
-
-    if (iter->status == HYPERDEX_CLIENT_SEARCHDONE)
-    {
-        iter->finished = 1;
-        ops = rb_iv_get(iter->client, "ops");
-        rb_hash_delete(ops, INT2NUM(iter->reqid));
-    }
-    else if (iter->status == HYPERDEX_CLIENT_SUCCESS)
-    {
-        obj = iter->encode_return(iter);
-        hyperdex_client_destroy_attrs(iter->attrs, iter->attrs_sz);
-        iter->attrs = NULL;
-        iter->attrs_sz = 0;
-        rb_ary_push(iter->backlogged, obj);
-    }
-    else
-    {
-        obj = hyperdex_ruby_client_create_exception(iter->status,
-                                                    hyperdex_client_error_message(client));
-        rb_ary_push(iter->backlogged, obj);
-    }
-
-    return Qnil;
+	VALUE ops;
+	VALUE obj;
+	struct hyperdex_ruby_client_iterator *iter = NULL;
+	struct hyperdex_client *client;
+	Data_Get_Struct(self, struct hyperdex_ruby_client_iterator, iter);
+	Data_Get_Struct(iter->client, struct hyperdex_client, client);
+	if (iter->status == HYPERDEX_CLIENT_SEARCHDONE)
+	{
+		iter->finished = 1;
+		ops = rb_iv_get(iter->client, "ops");
+		rb_hash_delete(ops, INT2NUM(iter->reqid));
+	}
+	else if (iter->status == HYPERDEX_CLIENT_SUCCESS)
+	{
+		obj = iter->encode_return(iter);
+		hyperdex_client_destroy_attrs(iter->attrs, iter->attrs_sz);
+		iter->attrs = NULL;
+		iter->attrs_sz = 0;
+		rb_ary_push(iter->backlogged, obj);
+	}
+	else
+	{
+		obj = hyperdex_ruby_client_create_exception(iter->status,
+		                                            hyperdex_client_error_message(client));
+		rb_ary_push(iter->backlogged, obj);
+	}
+	return Qnil;
 }
 
 static VALUE
 hyperdex_ruby_client_iterator_has_next(VALUE self)
 {
-    struct hyperdex_ruby_client_iterator* iter = NULL;
-    Data_Get_Struct(self, struct hyperdex_ruby_client_iterator, iter);
-
-    while (!iter->finished && RARRAY_LEN(iter->backlogged) == 0)
-    {
-        rb_funcall(iter->client, rb_intern("loop"), 0);
-    }
-
-    return RARRAY_LEN(iter->backlogged) > 0 ? Qtrue : Qfalse;
+	struct hyperdex_ruby_client_iterator *iter = NULL;
+	Data_Get_Struct(self, struct hyperdex_ruby_client_iterator, iter);
+	while (!iter->finished && RARRAY_LEN(iter->backlogged) == 0)
+	{
+		rb_funcall(iter->client, rb_intern("loop"), 0);
+	}
+	return RARRAY_LEN(iter->backlogged) > 0 ? Qtrue : Qfalse;
 }
 
 static VALUE
 hyperdex_ruby_client_iterator_next(VALUE self)
 {
-    struct hyperdex_ruby_client_iterator* iter = NULL;
-    Data_Get_Struct(self, struct hyperdex_ruby_client_iterator, iter);
-    return rb_ary_shift(iter->backlogged);
+	struct hyperdex_ruby_client_iterator *iter = NULL;
+	Data_Get_Struct(self, struct hyperdex_ruby_client_iterator, iter);
+	return rb_ary_shift(iter->backlogged);
 }
 
 static VALUE
-hyperdex_ruby_client_iterator_encode_status_attributes(struct hyperdex_ruby_client_iterator* it)
+hyperdex_ruby_client_iterator_encode_status_attributes(struct hyperdex_ruby_client_iterator *it)
 {
-    struct hyperdex_client* client = NULL;
-
-    if (it->status == HYPERDEX_CLIENT_SUCCESS)
-    {
-        return hyperdex_ruby_client_build_attributes(it->attrs, it->attrs_sz);
-    }
-    else if (it->status == HYPERDEX_CLIENT_NOTFOUND)
-    {
-        return Qnil;
-    }
-    else if (it->status == HYPERDEX_CLIENT_CMPFAIL)
-    {
-        return Qfalse;
-    }
-    else
-    {
-        Data_Get_Struct(it->client, struct hyperdex_client, client);
-        hyperdex_ruby_client_throw_exception(it->status, hyperdex_client_error_message(client));
-        return Qnil;
-    }
+	struct hyperdex_client *client = NULL;
+	if (it->status == HYPERDEX_CLIENT_SUCCESS)
+	{
+		return hyperdex_ruby_client_build_attributes(it->attrs, it->attrs_sz);
+	}
+	else if (it->status == HYPERDEX_CLIENT_NOTFOUND)
+	{
+		return Qnil;
+	}
+	else if (it->status == HYPERDEX_CLIENT_CMPFAIL)
+	{
+		return Qfalse;
+	}
+	else
+	{
+		Data_Get_Struct(it->client, struct hyperdex_client, client);
+		hyperdex_ruby_client_throw_exception(it->status, hyperdex_client_error_message(client));
+		return Qnil;
+	}
 }
 
 /******************************** Client Class ********************************/
@@ -1433,65 +1302,60 @@ hyperdex_ruby_client_iterator_encode_status_attributes(struct hyperdex_ruby_clie
 static VALUE
 hyperdex_ruby_client_alloc(VALUE class)
 {
-    struct hyperdex_client* client = NULL;
-    return Data_Wrap_Struct(class, 0, hyperdex_client_destroy, client);
+	struct hyperdex_client *client = NULL;
+	return Data_Wrap_Struct(class, 0, hyperdex_client_destroy, client);
 }
 
 static VALUE
 hyperdex_ruby_client_init(VALUE self, VALUE host, VALUE port)
 {
-    VALUE ops;
-    struct hyperdex_client* client = NULL;
-    client = hyperdex_client_create(StringValueCStr(host), NUM2UINT(port));
-
-    if (!client)
-    {
-        rb_raise(rb_eSystemCallError, "Could not create Client instance");
-        return Qnil;
-    }
-
-    DATA_PTR(self) = client;
-    ops = rb_hash_new();
-    if (ops == Qnil) return Qnil;
-    rb_iv_set(self, "ops", ops);
-    rb_iv_set(self, "tmp", Qnil);
-    return self;
+	VALUE ops;
+	struct hyperdex_client *client = NULL;
+	client = hyperdex_client_create(StringValueCStr(host), NUM2UINT(port));
+	if (!client)
+	{
+		rb_raise(rb_eSystemCallError, "Could not create Client instance");
+		return Qnil;
+	}
+	DATA_PTR(self) = client;
+	ops = rb_hash_new();
+	if (ops == Qnil) return Qnil;
+	rb_iv_set(self, "ops", ops);
+	rb_iv_set(self, "tmp", Qnil);
+	return self;
 }
 
 static VALUE
 hyperdex_ruby_client_loop(int argc, VALUE *argv, VALUE self)
 {
-    struct hyperdex_client* client;
-    enum hyperdex_client_returncode rc;
-    int64_t ret;
-    VALUE ops;
-    VALUE op;
-    VALUE timeout;
-
-    rb_scan_args(argc, argv, "01", &timeout);
-    if (NIL_P(timeout)) {
-        timeout = INT2NUM(-1);
-    }
-
-    Data_Get_Struct(self, struct hyperdex_client, client);
-    ret = hyperdex_client_loop(client, NUM2INT(timeout), &rc);
-
-    if (ret < 0)
-    {
-        if (rc != HYPERDEX_CLIENT_TIMEOUT)
-        {
-            hyperdex_ruby_client_throw_exception(rc, hyperdex_client_error_message(client));
-        }
-
-        return Qnil;
-    }
-    else
-    {
-        ops = rb_iv_get(self, "ops");
-        op = rb_hash_lookup(ops, LONG2NUM(ret));
-        rb_funcall(op, rb_intern("callback"), 0);
-        return op;
-    }
+	struct hyperdex_client *client;
+	enum hyperdex_client_returncode rc;
+	int64_t ret;
+	VALUE ops;
+	VALUE op;
+	VALUE timeout;
+	rb_scan_args(argc, argv, "01", &timeout);
+	if (NIL_P(timeout))
+	{
+		timeout = INT2NUM(-1);
+	}
+	Data_Get_Struct(self, struct hyperdex_client, client);
+	ret = hyperdex_client_loop(client, NUM2INT(timeout), &rc);
+	if (ret < 0)
+	{
+		if (rc != HYPERDEX_CLIENT_TIMEOUT)
+		{
+			hyperdex_ruby_client_throw_exception(rc, hyperdex_client_error_message(client));
+		}
+		return Qnil;
+	}
+	else
+	{
+		ops = rb_iv_get(self, "ops");
+		op = rb_hash_lookup(ops, LONG2NUM(ret));
+		rb_funcall(op, rb_intern("callback"), 0);
+		return op;
+	}
 }
 
 #include "bindings/ruby/definitions.c"
@@ -1499,179 +1363,173 @@ hyperdex_ruby_client_loop(int argc, VALUE *argv, VALUE self)
 /********************************* Predicates *********************************/
 
 static void
-hyperdex_ruby_client_predicate_mark(struct hyperdex_ruby_client_predicate* pred)
+hyperdex_ruby_client_predicate_mark(struct hyperdex_ruby_client_predicate *pred)
 {
-    size_t i = 0;
-
-    if (!pred)
-    {
-        return;
-    }
-
-    for (i = 0; i < pred->num_checks; ++i)
-    {
-        rb_gc_mark(pred->checks[i].v);
-    }
+	size_t i = 0;
+	if (!pred)
+	{
+		return;
+	}
+	for (i = 0; i < pred->num_checks; ++i)
+	{
+		rb_gc_mark(pred->checks[i].v);
+	}
 }
 
 static VALUE
 hyperdex_ruby_client_predicate_alloc1(VALUE class)
 {
-    struct hyperdex_ruby_client_predicate* pred = NULL;
-    size_t sz = offsetof(struct hyperdex_ruby_client_predicate, checks)
-              + sizeof(struct hyperdex_ruby_client_predicate_inner);
-    pred = malloc(sz);
-
-    if (!pred)
-    {
-        hyperdex_ruby_out_of_memory();
-        return Qnil;
-    }
-
-    memset(pred, 0, sz);
-    pred->num_checks = 1;
-    return Data_Wrap_Struct(class, hyperdex_ruby_client_predicate_mark, free, pred);
+	struct hyperdex_ruby_client_predicate *pred = NULL;
+	size_t sz = offsetof(struct hyperdex_ruby_client_predicate, checks)
+	            + sizeof(struct hyperdex_ruby_client_predicate_inner);
+	pred = malloc(sz);
+	if (!pred)
+	{
+		hyperdex_ruby_out_of_memory();
+		return Qnil;
+	}
+	memset(pred, 0, sz);
+	pred->num_checks = 1;
+	return Data_Wrap_Struct(class, hyperdex_ruby_client_predicate_mark, free, pred);
 }
 
 static VALUE
 hyperdex_ruby_client_predicate_alloc2(VALUE class)
 {
-    struct hyperdex_ruby_client_predicate* pred = NULL;
-    size_t sz = offsetof(struct hyperdex_ruby_client_predicate, checks)
-              + 2 * sizeof(struct hyperdex_ruby_client_predicate_inner);
-    pred = malloc(sz);
-
-    if (!pred)
-    {
-        hyperdex_ruby_out_of_memory();
-        return Qnil;
-    }
-
-    memset(pred, 0, sz);
-    pred->num_checks = 2;
-    return Data_Wrap_Struct(class, hyperdex_ruby_client_predicate_mark, free, pred);
+	struct hyperdex_ruby_client_predicate *pred = NULL;
+	size_t sz = offsetof(struct hyperdex_ruby_client_predicate, checks)
+	            + 2 * sizeof(struct hyperdex_ruby_client_predicate_inner);
+	pred = malloc(sz);
+	if (!pred)
+	{
+		hyperdex_ruby_out_of_memory();
+		return Qnil;
+	}
+	memset(pred, 0, sz);
+	pred->num_checks = 2;
+	return Data_Wrap_Struct(class, hyperdex_ruby_client_predicate_mark, free, pred);
 }
 
 static VALUE
 hyperdex_ruby_client_predicate_init(VALUE self)
 {
-    struct hyperdex_ruby_client_predicate* pred = NULL;
-    Data_Get_Struct(self, struct hyperdex_ruby_client_predicate, pred);
-    pred->checks[0].v = Qnil;
-    pred->checks[0].predicate = HYPERPREDICATE_FAIL;
-    return self;
+	struct hyperdex_ruby_client_predicate *pred = NULL;
+	Data_Get_Struct(self, struct hyperdex_ruby_client_predicate, pred);
+	pred->checks[0].v = Qnil;
+	pred->checks[0].predicate = HYPERPREDICATE_FAIL;
+	return self;
 }
 
 static VALUE
 hyperdex_ruby_client_predicate_equals_init(VALUE self, VALUE v)
 {
-    struct hyperdex_ruby_client_predicate* pred = NULL;
-    Data_Get_Struct(self, struct hyperdex_ruby_client_predicate, pred);
-    pred->checks[0].v = v;
-    pred->checks[0].predicate = HYPERPREDICATE_EQUALS;
-    return self;
+	struct hyperdex_ruby_client_predicate *pred = NULL;
+	Data_Get_Struct(self, struct hyperdex_ruby_client_predicate, pred);
+	pred->checks[0].v = v;
+	pred->checks[0].predicate = HYPERPREDICATE_EQUALS;
+	return self;
 }
 
 static VALUE
 hyperdex_ruby_client_predicate_lessequal_init(VALUE self, VALUE v)
 {
-    struct hyperdex_ruby_client_predicate* pred = NULL;
-    Data_Get_Struct(self, struct hyperdex_ruby_client_predicate, pred);
-    pred->checks[0].v = v;
-    pred->checks[0].predicate = HYPERPREDICATE_LESS_EQUAL;
-    return self;
+	struct hyperdex_ruby_client_predicate *pred = NULL;
+	Data_Get_Struct(self, struct hyperdex_ruby_client_predicate, pred);
+	pred->checks[0].v = v;
+	pred->checks[0].predicate = HYPERPREDICATE_LESS_EQUAL;
+	return self;
 }
 
 static VALUE
 hyperdex_ruby_client_predicate_greaterequal_init(VALUE self, VALUE v)
 {
-    struct hyperdex_ruby_client_predicate* pred = NULL;
-    Data_Get_Struct(self, struct hyperdex_ruby_client_predicate, pred);
-    pred->checks[0].v = v;
-    pred->checks[0].predicate = HYPERPREDICATE_GREATER_EQUAL;
-    return self;
+	struct hyperdex_ruby_client_predicate *pred = NULL;
+	Data_Get_Struct(self, struct hyperdex_ruby_client_predicate, pred);
+	pred->checks[0].v = v;
+	pred->checks[0].predicate = HYPERPREDICATE_GREATER_EQUAL;
+	return self;
 }
 
 static VALUE
 hyperdex_ruby_client_predicate_lessthan_init(VALUE self, VALUE v)
 {
-    struct hyperdex_ruby_client_predicate* pred = NULL;
-    Data_Get_Struct(self, struct hyperdex_ruby_client_predicate, pred);
-    pred->checks[0].v = v;
-    pred->checks[0].predicate = HYPERPREDICATE_LESS_THAN;
-    return self;
+	struct hyperdex_ruby_client_predicate *pred = NULL;
+	Data_Get_Struct(self, struct hyperdex_ruby_client_predicate, pred);
+	pred->checks[0].v = v;
+	pred->checks[0].predicate = HYPERPREDICATE_LESS_THAN;
+	return self;
 }
 
 static VALUE
 hyperdex_ruby_client_predicate_greaterthan_init(VALUE self, VALUE v)
 {
-    struct hyperdex_ruby_client_predicate* pred = NULL;
-    Data_Get_Struct(self, struct hyperdex_ruby_client_predicate, pred);
-    pred->checks[0].v = v;
-    pred->checks[0].predicate = HYPERPREDICATE_GREATER_THAN;
-    return self;
+	struct hyperdex_ruby_client_predicate *pred = NULL;
+	Data_Get_Struct(self, struct hyperdex_ruby_client_predicate, pred);
+	pred->checks[0].v = v;
+	pred->checks[0].predicate = HYPERPREDICATE_GREATER_THAN;
+	return self;
 }
 
 static VALUE
 hyperdex_ruby_client_predicate_range_init(VALUE self, VALUE lower, VALUE upper)
 {
-    struct hyperdex_ruby_client_predicate* pred = NULL;
-    Data_Get_Struct(self, struct hyperdex_ruby_client_predicate, pred);
-    pred->checks[0].v = lower;
-    pred->checks[0].predicate = HYPERPREDICATE_GREATER_EQUAL;
-    pred->checks[1].v = upper;
-    pred->checks[1].predicate = HYPERPREDICATE_LESS_EQUAL;
-    return self;
+	struct hyperdex_ruby_client_predicate *pred = NULL;
+	Data_Get_Struct(self, struct hyperdex_ruby_client_predicate, pred);
+	pred->checks[0].v = lower;
+	pred->checks[0].predicate = HYPERPREDICATE_GREATER_EQUAL;
+	pred->checks[1].v = upper;
+	pred->checks[1].predicate = HYPERPREDICATE_LESS_EQUAL;
+	return self;
 }
 
 static VALUE
 hyperdex_ruby_client_predicate_regex_init(VALUE self, VALUE v)
 {
-    struct hyperdex_ruby_client_predicate* pred = NULL;
-    Data_Get_Struct(self, struct hyperdex_ruby_client_predicate, pred);
-    pred->checks[0].v = v;
-    pred->checks[0].predicate = HYPERPREDICATE_REGEX;
-    return self;
+	struct hyperdex_ruby_client_predicate *pred = NULL;
+	Data_Get_Struct(self, struct hyperdex_ruby_client_predicate, pred);
+	pred->checks[0].v = v;
+	pred->checks[0].predicate = HYPERPREDICATE_REGEX;
+	return self;
 }
 
 static VALUE
 hyperdex_ruby_client_predicate_lengthequals_init(VALUE self, VALUE v)
 {
-    struct hyperdex_ruby_client_predicate* pred = NULL;
-    Data_Get_Struct(self, struct hyperdex_ruby_client_predicate, pred);
-    pred->checks[0].v = v;
-    pred->checks[0].predicate = HYPERPREDICATE_LENGTH_EQUALS;
-    return self;
+	struct hyperdex_ruby_client_predicate *pred = NULL;
+	Data_Get_Struct(self, struct hyperdex_ruby_client_predicate, pred);
+	pred->checks[0].v = v;
+	pred->checks[0].predicate = HYPERPREDICATE_LENGTH_EQUALS;
+	return self;
 }
 
 static VALUE
 hyperdex_ruby_client_predicate_lengthlessequal_init(VALUE self, VALUE v)
 {
-    struct hyperdex_ruby_client_predicate* pred = NULL;
-    Data_Get_Struct(self, struct hyperdex_ruby_client_predicate, pred);
-    pred->checks[0].v = v;
-    pred->checks[0].predicate = HYPERPREDICATE_LENGTH_LESS_EQUAL;
-    return self;
+	struct hyperdex_ruby_client_predicate *pred = NULL;
+	Data_Get_Struct(self, struct hyperdex_ruby_client_predicate, pred);
+	pred->checks[0].v = v;
+	pred->checks[0].predicate = HYPERPREDICATE_LENGTH_LESS_EQUAL;
+	return self;
 }
 
 static VALUE
 hyperdex_ruby_client_predicate_lengthgreaterequal_init(VALUE self, VALUE v)
 {
-    struct hyperdex_ruby_client_predicate* pred = NULL;
-    Data_Get_Struct(self, struct hyperdex_ruby_client_predicate, pred);
-    pred->checks[0].v = v;
-    pred->checks[0].predicate = HYPERPREDICATE_LENGTH_GREATER_EQUAL;
-    return self;
+	struct hyperdex_ruby_client_predicate *pred = NULL;
+	Data_Get_Struct(self, struct hyperdex_ruby_client_predicate, pred);
+	pred->checks[0].v = v;
+	pred->checks[0].predicate = HYPERPREDICATE_LENGTH_GREATER_EQUAL;
+	return self;
 }
 
 static VALUE
 hyperdex_ruby_client_predicate_contains_init(VALUE self, VALUE v)
 {
-    struct hyperdex_ruby_client_predicate* pred = NULL;
-    Data_Get_Struct(self, struct hyperdex_ruby_client_predicate, pred);
-    pred->checks[0].v = v;
-    pred->checks[0].predicate = HYPERPREDICATE_CONTAINS;
-    return self;
+	struct hyperdex_ruby_client_predicate *pred = NULL;
+	Data_Get_Struct(self, struct hyperdex_ruby_client_predicate, pred);
+	pred->checks[0].v = v;
+	pred->checks[0].predicate = HYPERPREDICATE_CONTAINS;
+	return self;
 }
 
 /******************************* Inititalization ******************************/
@@ -1679,99 +1537,81 @@ hyperdex_ruby_client_predicate_contains_init(VALUE self, VALUE v)
 void
 Init_hyperdex_client()
 {
-    /* require the set type */
-    rb_require("set");
-    Set = rb_path2class("Set");
-
-    /* setup the module */
-    mod_hyperdex_client = rb_define_module_under(mod_hyperdex, "Client");
-
-    /* create the Exception class */
-    class_exception = rb_define_class_under(mod_hyperdex_client, "HyperDexClientException", rb_eStandardError);
-    rb_define_attr(class_exception, "status", 1, 0);
-    rb_define_attr(class_exception, "symbol", 1, 0);
-
-    /* create the Deferred class */
-    class_deferred = rb_define_class_under(mod_hyperdex_client, "Deferred", rb_cObject);
-    rb_define_alloc_func(class_deferred, hyperdex_ruby_client_deferred_alloc);
-    rb_define_method(class_deferred, "initialize", hyperdex_ruby_client_deferred_init, 1);
-    rb_define_method(class_deferred, "callback", hyperdex_ruby_client_deferred_callback, 0);
-    rb_define_method(class_deferred, "wait", hyperdex_ruby_client_deferred_wait, 0);
-
-    /* create the Iterator class */
-    class_iterator = rb_define_class_under(mod_hyperdex_client, "Iterator", rb_cObject);
-    rb_define_alloc_func(class_iterator, hyperdex_ruby_client_iterator_alloc);
-    rb_define_method(class_iterator, "initialize", hyperdex_ruby_client_iterator_init, 1);
-    rb_define_method(class_iterator, "callback", hyperdex_ruby_client_iterator_callback, 0);
-    rb_define_method(class_iterator, "has_next", hyperdex_ruby_client_iterator_has_next, 0);
-    rb_define_method(class_iterator, "next", hyperdex_ruby_client_iterator_next, 0);
-
-    /* create the Client class */
-    class_client = rb_define_class_under(mod_hyperdex_client, "Client", rb_cObject);
-    rb_define_alloc_func(class_client, hyperdex_ruby_client_alloc);
-    rb_define_method(class_client, "initialize", hyperdex_ruby_client_init, 2);
-    rb_define_method(class_client, "loop", hyperdex_ruby_client_loop, -1);
-
-    /* include the generated rb_define_* calls */
+	/* require the set type */
+	rb_require("set");
+	Set = rb_path2class("Set");
+	/* setup the module */
+	mod_hyperdex_client = rb_define_module_under(mod_hyperdex, "Client");
+	/* create the Exception class */
+	class_exception = rb_define_class_under(mod_hyperdex_client, "HyperDexClientException", rb_eStandardError);
+	rb_define_attr(class_exception, "status", 1, 0);
+	rb_define_attr(class_exception, "symbol", 1, 0);
+	/* create the Deferred class */
+	class_deferred = rb_define_class_under(mod_hyperdex_client, "Deferred", rb_cObject);
+	rb_define_alloc_func(class_deferred, hyperdex_ruby_client_deferred_alloc);
+	rb_define_method(class_deferred, "initialize", hyperdex_ruby_client_deferred_init, 1);
+	rb_define_method(class_deferred, "callback", hyperdex_ruby_client_deferred_callback, 0);
+	rb_define_method(class_deferred, "wait", hyperdex_ruby_client_deferred_wait, 0);
+	/* create the Iterator class */
+	class_iterator = rb_define_class_under(mod_hyperdex_client, "Iterator", rb_cObject);
+	rb_define_alloc_func(class_iterator, hyperdex_ruby_client_iterator_alloc);
+	rb_define_method(class_iterator, "initialize", hyperdex_ruby_client_iterator_init, 1);
+	rb_define_method(class_iterator, "callback", hyperdex_ruby_client_iterator_callback, 0);
+	rb_define_method(class_iterator, "has_next", hyperdex_ruby_client_iterator_has_next, 0);
+	rb_define_method(class_iterator, "next", hyperdex_ruby_client_iterator_next, 0);
+	/* create the Client class */
+	class_client = rb_define_class_under(mod_hyperdex_client, "Client", rb_cObject);
+	rb_define_alloc_func(class_client, hyperdex_ruby_client_alloc);
+	rb_define_method(class_client, "initialize", hyperdex_ruby_client_init, 2);
+	rb_define_method(class_client, "loop", hyperdex_ruby_client_loop, -1);
+	/* include the generated rb_define_* calls */
 #include "bindings/ruby/prototypes.c"
-
-    /* create the Predicate class */
-    class_predicate = rb_define_class_under(mod_hyperdex_client, "Predicate", rb_cObject);
-    rb_define_alloc_func(class_predicate, hyperdex_ruby_client_predicate_alloc1);
-    rb_define_method(class_predicate, "initialize", hyperdex_ruby_client_predicate_init, 1);
-
-    /* create the Equals class */
-    class_equals = rb_define_class_under(mod_hyperdex_client, "Equals", class_predicate);
-    rb_define_alloc_func(class_equals , hyperdex_ruby_client_predicate_alloc1);
-    rb_define_method(class_equals , "initialize", hyperdex_ruby_client_predicate_equals_init, 1);
-
-    /* create the LessEqual class */
-    class_lessequal = rb_define_class_under(mod_hyperdex_client, "LessEqual", class_predicate);
-    rb_define_alloc_func(class_lessequal , hyperdex_ruby_client_predicate_alloc1);
-    rb_define_method(class_lessequal , "initialize", hyperdex_ruby_client_predicate_lessequal_init, 1);
-
-    /* create the GreaterEqual class */
-    class_greaterequal = rb_define_class_under(mod_hyperdex_client, "GreaterEqual", class_predicate);
-    rb_define_alloc_func(class_greaterequal , hyperdex_ruby_client_predicate_alloc1);
-    rb_define_method(class_greaterequal , "initialize", hyperdex_ruby_client_predicate_greaterequal_init, 1);
-
-    /* create the LessThan class */
-    class_lessthan = rb_define_class_under(mod_hyperdex_client, "LessThan", class_predicate);
-    rb_define_alloc_func(class_lessthan , hyperdex_ruby_client_predicate_alloc1);
-    rb_define_method(class_lessthan , "initialize", hyperdex_ruby_client_predicate_lessthan_init, 1);
-
-    /* create the GreaterThan class */
-    class_greaterthan = rb_define_class_under(mod_hyperdex_client, "GreaterThan", class_predicate);
-    rb_define_alloc_func(class_greaterthan , hyperdex_ruby_client_predicate_alloc1);
-    rb_define_method(class_greaterthan , "initialize", hyperdex_ruby_client_predicate_greaterthan_init, 1);
-
-    /* create the Range class */
-    class_range = rb_define_class_under(mod_hyperdex_client, "Range", class_predicate);
-    rb_define_alloc_func(class_range , hyperdex_ruby_client_predicate_alloc2);
-    rb_define_method(class_range , "initialize", hyperdex_ruby_client_predicate_range_init, 2);
-
-    /* create the Regex class */
-    class_regex = rb_define_class_under(mod_hyperdex_client, "Regex", class_predicate);
-    rb_define_alloc_func(class_regex , hyperdex_ruby_client_predicate_alloc1);
-    rb_define_method(class_regex , "initialize", hyperdex_ruby_client_predicate_regex_init, 1);
-
-    /* create the LengthEquals class */
-    class_lengthequals = rb_define_class_under(mod_hyperdex_client, "LengthEquals", class_predicate);
-    rb_define_alloc_func(class_lengthequals , hyperdex_ruby_client_predicate_alloc1);
-    rb_define_method(class_lengthequals , "initialize", hyperdex_ruby_client_predicate_lengthequals_init, 1);
-
-    /* create the LengthLessEqual class */
-    class_lengthlessequal = rb_define_class_under(mod_hyperdex_client, "LengthLessEqual", class_predicate);
-    rb_define_alloc_func(class_lengthlessequal , hyperdex_ruby_client_predicate_alloc1);
-    rb_define_method(class_lengthlessequal , "initialize", hyperdex_ruby_client_predicate_lengthlessequal_init, 1);
-
-    /* create the LengthGreaterEqual class */
-    class_lengthgreaterequal = rb_define_class_under(mod_hyperdex_client, "LengthGreaterEqual", class_predicate);
-    rb_define_alloc_func(class_lengthgreaterequal , hyperdex_ruby_client_predicate_alloc1);
-    rb_define_method(class_lengthgreaterequal , "initialize", hyperdex_ruby_client_predicate_lengthgreaterequal_init, 1);
-
-    /* create the Contains class */
-    class_contains = rb_define_class_under(mod_hyperdex_client, "Contains", class_predicate);
-    rb_define_alloc_func(class_contains , hyperdex_ruby_client_predicate_alloc1);
-    rb_define_method(class_contains , "initialize", hyperdex_ruby_client_predicate_contains_init, 1);
+	/* create the Predicate class */
+	class_predicate = rb_define_class_under(mod_hyperdex_client, "Predicate", rb_cObject);
+	rb_define_alloc_func(class_predicate, hyperdex_ruby_client_predicate_alloc1);
+	rb_define_method(class_predicate, "initialize", hyperdex_ruby_client_predicate_init, 1);
+	/* create the Equals class */
+	class_equals = rb_define_class_under(mod_hyperdex_client, "Equals", class_predicate);
+	rb_define_alloc_func(class_equals , hyperdex_ruby_client_predicate_alloc1);
+	rb_define_method(class_equals , "initialize", hyperdex_ruby_client_predicate_equals_init, 1);
+	/* create the LessEqual class */
+	class_lessequal = rb_define_class_under(mod_hyperdex_client, "LessEqual", class_predicate);
+	rb_define_alloc_func(class_lessequal , hyperdex_ruby_client_predicate_alloc1);
+	rb_define_method(class_lessequal , "initialize", hyperdex_ruby_client_predicate_lessequal_init, 1);
+	/* create the GreaterEqual class */
+	class_greaterequal = rb_define_class_under(mod_hyperdex_client, "GreaterEqual", class_predicate);
+	rb_define_alloc_func(class_greaterequal , hyperdex_ruby_client_predicate_alloc1);
+	rb_define_method(class_greaterequal , "initialize", hyperdex_ruby_client_predicate_greaterequal_init, 1);
+	/* create the LessThan class */
+	class_lessthan = rb_define_class_under(mod_hyperdex_client, "LessThan", class_predicate);
+	rb_define_alloc_func(class_lessthan , hyperdex_ruby_client_predicate_alloc1);
+	rb_define_method(class_lessthan , "initialize", hyperdex_ruby_client_predicate_lessthan_init, 1);
+	/* create the GreaterThan class */
+	class_greaterthan = rb_define_class_under(mod_hyperdex_client, "GreaterThan", class_predicate);
+	rb_define_alloc_func(class_greaterthan , hyperdex_ruby_client_predicate_alloc1);
+	rb_define_method(class_greaterthan , "initialize", hyperdex_ruby_client_predicate_greaterthan_init, 1);
+	/* create the Range class */
+	class_range = rb_define_class_under(mod_hyperdex_client, "Range", class_predicate);
+	rb_define_alloc_func(class_range , hyperdex_ruby_client_predicate_alloc2);
+	rb_define_method(class_range , "initialize", hyperdex_ruby_client_predicate_range_init, 2);
+	/* create the Regex class */
+	class_regex = rb_define_class_under(mod_hyperdex_client, "Regex", class_predicate);
+	rb_define_alloc_func(class_regex , hyperdex_ruby_client_predicate_alloc1);
+	rb_define_method(class_regex , "initialize", hyperdex_ruby_client_predicate_regex_init, 1);
+	/* create the LengthEquals class */
+	class_lengthequals = rb_define_class_under(mod_hyperdex_client, "LengthEquals", class_predicate);
+	rb_define_alloc_func(class_lengthequals , hyperdex_ruby_client_predicate_alloc1);
+	rb_define_method(class_lengthequals , "initialize", hyperdex_ruby_client_predicate_lengthequals_init, 1);
+	/* create the LengthLessEqual class */
+	class_lengthlessequal = rb_define_class_under(mod_hyperdex_client, "LengthLessEqual", class_predicate);
+	rb_define_alloc_func(class_lengthlessequal , hyperdex_ruby_client_predicate_alloc1);
+	rb_define_method(class_lengthlessequal , "initialize", hyperdex_ruby_client_predicate_lengthlessequal_init, 1);
+	/* create the LengthGreaterEqual class */
+	class_lengthgreaterequal = rb_define_class_under(mod_hyperdex_client, "LengthGreaterEqual", class_predicate);
+	rb_define_alloc_func(class_lengthgreaterequal , hyperdex_ruby_client_predicate_alloc1);
+	rb_define_method(class_lengthgreaterequal , "initialize", hyperdex_ruby_client_predicate_lengthgreaterequal_init, 1);
+	/* create the Contains class */
+	class_contains = rb_define_class_under(mod_hyperdex_client, "Contains", class_predicate);
+	rb_define_alloc_func(class_contains , hyperdex_ruby_client_predicate_alloc1);
+	rb_define_method(class_contains , "initialize", hyperdex_ruby_client_predicate_contains_init, 1);
 }
diff --git a/bindings/ruby/definitions.c b/bindings/ruby/definitions.c
index a902b3b3d..ea52cffcb 100644
--- a/bindings/ruby/definitions.c
+++ b/bindings/ruby/definitions.c
@@ -28,1880 +28,1852 @@
 /* This file is generated by bindings/ruby.py */
 
 static VALUE
-hyperdex_ruby_client_asynccall__spacename_key__status_attributes(int64_t (*f)(struct hyperdex_client* client, const char* space, const char* key, size_t key_sz, enum hyperdex_client_returncode* status, const struct hyperdex_client_attribute** attrs, size_t* attrs_sz), VALUE self, VALUE spacename, VALUE key)
-{
-    VALUE op;
-    const char* in_space;
-    const char* in_key;
-    size_t in_key_sz;
-    struct hyperdex_client* client;
-    struct hyperdex_ruby_client_deferred* o;
-    op = rb_class_new_instance(1, &self, class_deferred);
-    rb_iv_set(self, "tmp", op);
-    Data_Get_Struct(self, struct hyperdex_client, client);
-    Data_Get_Struct(op, struct hyperdex_ruby_client_deferred, o);
-    hyperdex_ruby_client_convert_spacename(o->arena, spacename, &in_space);
-    hyperdex_ruby_client_convert_key(o->arena, key, &in_key, &in_key_sz);
-    o->reqid = f(client, in_space, in_key, in_key_sz, &o->status, &o->attrs, &o->attrs_sz);
-
-    if (o->reqid < 0)
-    {
-        hyperdex_ruby_client_throw_exception(o->status, hyperdex_client_error_message(client));
-    }
-
-    o->encode_return = hyperdex_ruby_client_deferred_encode_status_attributes;
-    rb_hash_aset(rb_iv_get(self, "ops"), LONG2NUM(o->reqid), op);
-    rb_iv_set(self, "tmp", Qnil);
-    return op;
-}
-
-static VALUE
-hyperdex_ruby_client_asynccall__spacename_key_attributenames__status_attributes(int64_t (*f)(struct hyperdex_client* client, const char* space, const char* key, size_t key_sz, const char** attrnames, size_t attrnames_sz, enum hyperdex_client_returncode* status, const struct hyperdex_client_attribute** attrs, size_t* attrs_sz), VALUE self, VALUE spacename, VALUE key, VALUE attributenames)
-{
-    VALUE op;
-    const char* in_space;
-    const char* in_key;
-    size_t in_key_sz;
-    const char** in_attrnames;
-    size_t in_attrnames_sz;
-    struct hyperdex_client* client;
-    struct hyperdex_ruby_client_deferred* o;
-    op = rb_class_new_instance(1, &self, class_deferred);
-    rb_iv_set(self, "tmp", op);
-    Data_Get_Struct(self, struct hyperdex_client, client);
-    Data_Get_Struct(op, struct hyperdex_ruby_client_deferred, o);
-    hyperdex_ruby_client_convert_spacename(o->arena, spacename, &in_space);
-    hyperdex_ruby_client_convert_key(o->arena, key, &in_key, &in_key_sz);
-    hyperdex_ruby_client_convert_attributenames(o->arena, attributenames, &in_attrnames, &in_attrnames_sz);
-    o->reqid = f(client, in_space, in_key, in_key_sz, in_attrnames, in_attrnames_sz, &o->status, &o->attrs, &o->attrs_sz);
-
-    if (o->reqid < 0)
-    {
-        hyperdex_ruby_client_throw_exception(o->status, hyperdex_client_error_message(client));
-    }
-
-    o->encode_return = hyperdex_ruby_client_deferred_encode_status_attributes;
-    rb_hash_aset(rb_iv_get(self, "ops"), LONG2NUM(o->reqid), op);
-    rb_iv_set(self, "tmp", Qnil);
-    return op;
-}
-
-static VALUE
-hyperdex_ruby_client_asynccall__spacename_key_attributes__status(int64_t (*f)(struct hyperdex_client* client, const char* space, const char* key, size_t key_sz, const struct hyperdex_client_attribute* attrs, size_t attrs_sz, enum hyperdex_client_returncode* status), VALUE self, VALUE spacename, VALUE key, VALUE attributes)
-{
-    VALUE op;
-    const char* in_space;
-    const char* in_key;
-    size_t in_key_sz;
-    const struct hyperdex_client_attribute* in_attrs;
-    size_t in_attrs_sz;
-    struct hyperdex_client* client;
-    struct hyperdex_ruby_client_deferred* o;
-    op = rb_class_new_instance(1, &self, class_deferred);
-    rb_iv_set(self, "tmp", op);
-    Data_Get_Struct(self, struct hyperdex_client, client);
-    Data_Get_Struct(op, struct hyperdex_ruby_client_deferred, o);
-    hyperdex_ruby_client_convert_spacename(o->arena, spacename, &in_space);
-    hyperdex_ruby_client_convert_key(o->arena, key, &in_key, &in_key_sz);
-    hyperdex_ruby_client_convert_attributes(o->arena, attributes, &in_attrs, &in_attrs_sz);
-    o->reqid = f(client, in_space, in_key, in_key_sz, in_attrs, in_attrs_sz, &o->status);
-
-    if (o->reqid < 0)
-    {
-        hyperdex_ruby_client_throw_exception(o->status, hyperdex_client_error_message(client));
-    }
-
-    o->encode_return = hyperdex_ruby_client_deferred_encode_status;
-    rb_hash_aset(rb_iv_get(self, "ops"), LONG2NUM(o->reqid), op);
-    rb_iv_set(self, "tmp", Qnil);
-    return op;
-}
-
-static VALUE
-hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(int64_t (*f)(struct hyperdex_client* client, const char* space, const char* key, size_t key_sz, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, const struct hyperdex_client_attribute* attrs, size_t attrs_sz, enum hyperdex_client_returncode* status), VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
-{
-    VALUE op;
-    const char* in_space;
-    const char* in_key;
-    size_t in_key_sz;
-    const struct hyperdex_client_attribute_check* in_checks;
-    size_t in_checks_sz;
-    const struct hyperdex_client_attribute* in_attrs;
-    size_t in_attrs_sz;
-    struct hyperdex_client* client;
-    struct hyperdex_ruby_client_deferred* o;
-    op = rb_class_new_instance(1, &self, class_deferred);
-    rb_iv_set(self, "tmp", op);
-    Data_Get_Struct(self, struct hyperdex_client, client);
-    Data_Get_Struct(op, struct hyperdex_ruby_client_deferred, o);
-    hyperdex_ruby_client_convert_spacename(o->arena, spacename, &in_space);
-    hyperdex_ruby_client_convert_key(o->arena, key, &in_key, &in_key_sz);
-    hyperdex_ruby_client_convert_predicates(o->arena, predicates, &in_checks, &in_checks_sz);
-    hyperdex_ruby_client_convert_attributes(o->arena, attributes, &in_attrs, &in_attrs_sz);
-    o->reqid = f(client, in_space, in_key, in_key_sz, in_checks, in_checks_sz, in_attrs, in_attrs_sz, &o->status);
-
-    if (o->reqid < 0)
-    {
-        hyperdex_ruby_client_throw_exception(o->status, hyperdex_client_error_message(client));
-    }
-
-    o->encode_return = hyperdex_ruby_client_deferred_encode_status;
-    rb_hash_aset(rb_iv_get(self, "ops"), LONG2NUM(o->reqid), op);
-    rb_iv_set(self, "tmp", Qnil);
-    return op;
-}
-
-static VALUE
-hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(int64_t (*f)(struct hyperdex_client* client, const char* space, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, const struct hyperdex_client_attribute* attrs, size_t attrs_sz, enum hyperdex_client_returncode* status, uint64_t* count), VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
-{
-    VALUE op;
-    const char* in_space;
-    const struct hyperdex_client_attribute_check* in_checks;
-    size_t in_checks_sz;
-    const struct hyperdex_client_attribute* in_attrs;
-    size_t in_attrs_sz;
-    struct hyperdex_client* client;
-    struct hyperdex_ruby_client_deferred* o;
-    op = rb_class_new_instance(1, &self, class_deferred);
-    rb_iv_set(self, "tmp", op);
-    Data_Get_Struct(self, struct hyperdex_client, client);
-    Data_Get_Struct(op, struct hyperdex_ruby_client_deferred, o);
-    hyperdex_ruby_client_convert_spacename(o->arena, spacename, &in_space);
-    hyperdex_ruby_client_convert_predicates(o->arena, predicates, &in_checks, &in_checks_sz);
-    hyperdex_ruby_client_convert_attributes(o->arena, attributes, &in_attrs, &in_attrs_sz);
-    o->reqid = f(client, in_space, in_checks, in_checks_sz, in_attrs, in_attrs_sz, &o->status, &o->count);
-
-    if (o->reqid < 0)
-    {
-        hyperdex_ruby_client_throw_exception(o->status, hyperdex_client_error_message(client));
-    }
-
-    o->encode_return = hyperdex_ruby_client_deferred_encode_status_count;
-    rb_hash_aset(rb_iv_get(self, "ops"), LONG2NUM(o->reqid), op);
-    rb_iv_set(self, "tmp", Qnil);
-    return op;
-}
-
-static VALUE
-hyperdex_ruby_client_asynccall__spacename_key__status(int64_t (*f)(struct hyperdex_client* client, const char* space, const char* key, size_t key_sz, enum hyperdex_client_returncode* status), VALUE self, VALUE spacename, VALUE key)
-{
-    VALUE op;
-    const char* in_space;
-    const char* in_key;
-    size_t in_key_sz;
-    struct hyperdex_client* client;
-    struct hyperdex_ruby_client_deferred* o;
-    op = rb_class_new_instance(1, &self, class_deferred);
-    rb_iv_set(self, "tmp", op);
-    Data_Get_Struct(self, struct hyperdex_client, client);
-    Data_Get_Struct(op, struct hyperdex_ruby_client_deferred, o);
-    hyperdex_ruby_client_convert_spacename(o->arena, spacename, &in_space);
-    hyperdex_ruby_client_convert_key(o->arena, key, &in_key, &in_key_sz);
-    o->reqid = f(client, in_space, in_key, in_key_sz, &o->status);
-
-    if (o->reqid < 0)
-    {
-        hyperdex_ruby_client_throw_exception(o->status, hyperdex_client_error_message(client));
-    }
-
-    o->encode_return = hyperdex_ruby_client_deferred_encode_status;
-    rb_hash_aset(rb_iv_get(self, "ops"), LONG2NUM(o->reqid), op);
-    rb_iv_set(self, "tmp", Qnil);
-    return op;
-}
-
-static VALUE
-hyperdex_ruby_client_asynccall__spacename_key_predicates__status(int64_t (*f)(struct hyperdex_client* client, const char* space, const char* key, size_t key_sz, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, enum hyperdex_client_returncode* status), VALUE self, VALUE spacename, VALUE key, VALUE predicates)
-{
-    VALUE op;
-    const char* in_space;
-    const char* in_key;
-    size_t in_key_sz;
-    const struct hyperdex_client_attribute_check* in_checks;
-    size_t in_checks_sz;
-    struct hyperdex_client* client;
-    struct hyperdex_ruby_client_deferred* o;
-    op = rb_class_new_instance(1, &self, class_deferred);
-    rb_iv_set(self, "tmp", op);
-    Data_Get_Struct(self, struct hyperdex_client, client);
-    Data_Get_Struct(op, struct hyperdex_ruby_client_deferred, o);
-    hyperdex_ruby_client_convert_spacename(o->arena, spacename, &in_space);
-    hyperdex_ruby_client_convert_key(o->arena, key, &in_key, &in_key_sz);
-    hyperdex_ruby_client_convert_predicates(o->arena, predicates, &in_checks, &in_checks_sz);
-    o->reqid = f(client, in_space, in_key, in_key_sz, in_checks, in_checks_sz, &o->status);
-
-    if (o->reqid < 0)
-    {
-        hyperdex_ruby_client_throw_exception(o->status, hyperdex_client_error_message(client));
-    }
-
-    o->encode_return = hyperdex_ruby_client_deferred_encode_status;
-    rb_hash_aset(rb_iv_get(self, "ops"), LONG2NUM(o->reqid), op);
-    rb_iv_set(self, "tmp", Qnil);
-    return op;
-}
-
-static VALUE
-hyperdex_ruby_client_asynccall__spacename_predicates__status_count(int64_t (*f)(struct hyperdex_client* client, const char* space, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, enum hyperdex_client_returncode* status, uint64_t* count), VALUE self, VALUE spacename, VALUE predicates)
-{
-    VALUE op;
-    const char* in_space;
-    const struct hyperdex_client_attribute_check* in_checks;
-    size_t in_checks_sz;
-    struct hyperdex_client* client;
-    struct hyperdex_ruby_client_deferred* o;
-    op = rb_class_new_instance(1, &self, class_deferred);
-    rb_iv_set(self, "tmp", op);
-    Data_Get_Struct(self, struct hyperdex_client, client);
-    Data_Get_Struct(op, struct hyperdex_ruby_client_deferred, o);
-    hyperdex_ruby_client_convert_spacename(o->arena, spacename, &in_space);
-    hyperdex_ruby_client_convert_predicates(o->arena, predicates, &in_checks, &in_checks_sz);
-    o->reqid = f(client, in_space, in_checks, in_checks_sz, &o->status, &o->count);
-
-    if (o->reqid < 0)
-    {
-        hyperdex_ruby_client_throw_exception(o->status, hyperdex_client_error_message(client));
-    }
-
-    o->encode_return = hyperdex_ruby_client_deferred_encode_status_count;
-    rb_hash_aset(rb_iv_get(self, "ops"), LONG2NUM(o->reqid), op);
-    rb_iv_set(self, "tmp", Qnil);
-    return op;
-}
-
-static VALUE
-hyperdex_ruby_client_asynccall__spacename_key_mapattributes__status(int64_t (*f)(struct hyperdex_client* client, const char* space, const char* key, size_t key_sz, const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz, enum hyperdex_client_returncode* status), VALUE self, VALUE spacename, VALUE key, VALUE mapattributes)
-{
-    VALUE op;
-    const char* in_space;
-    const char* in_key;
-    size_t in_key_sz;
-    const struct hyperdex_client_map_attribute* in_mapattrs;
-    size_t in_mapattrs_sz;
-    struct hyperdex_client* client;
-    struct hyperdex_ruby_client_deferred* o;
-    op = rb_class_new_instance(1, &self, class_deferred);
-    rb_iv_set(self, "tmp", op);
-    Data_Get_Struct(self, struct hyperdex_client, client);
-    Data_Get_Struct(op, struct hyperdex_ruby_client_deferred, o);
-    hyperdex_ruby_client_convert_spacename(o->arena, spacename, &in_space);
-    hyperdex_ruby_client_convert_key(o->arena, key, &in_key, &in_key_sz);
-    hyperdex_ruby_client_convert_mapattributes(o->arena, mapattributes, &in_mapattrs, &in_mapattrs_sz);
-    o->reqid = f(client, in_space, in_key, in_key_sz, in_mapattrs, in_mapattrs_sz, &o->status);
-
-    if (o->reqid < 0)
-    {
-        hyperdex_ruby_client_throw_exception(o->status, hyperdex_client_error_message(client));
-    }
-
-    o->encode_return = hyperdex_ruby_client_deferred_encode_status;
-    rb_hash_aset(rb_iv_get(self, "ops"), LONG2NUM(o->reqid), op);
-    rb_iv_set(self, "tmp", Qnil);
-    return op;
-}
-
-static VALUE
-hyperdex_ruby_client_asynccall__spacename_key_predicates_mapattributes__status(int64_t (*f)(struct hyperdex_client* client, const char* space, const char* key, size_t key_sz, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz, enum hyperdex_client_returncode* status), VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE mapattributes)
-{
-    VALUE op;
-    const char* in_space;
-    const char* in_key;
-    size_t in_key_sz;
-    const struct hyperdex_client_attribute_check* in_checks;
-    size_t in_checks_sz;
-    const struct hyperdex_client_map_attribute* in_mapattrs;
-    size_t in_mapattrs_sz;
-    struct hyperdex_client* client;
-    struct hyperdex_ruby_client_deferred* o;
-    op = rb_class_new_instance(1, &self, class_deferred);
-    rb_iv_set(self, "tmp", op);
-    Data_Get_Struct(self, struct hyperdex_client, client);
-    Data_Get_Struct(op, struct hyperdex_ruby_client_deferred, o);
-    hyperdex_ruby_client_convert_spacename(o->arena, spacename, &in_space);
-    hyperdex_ruby_client_convert_key(o->arena, key, &in_key, &in_key_sz);
-    hyperdex_ruby_client_convert_predicates(o->arena, predicates, &in_checks, &in_checks_sz);
-    hyperdex_ruby_client_convert_mapattributes(o->arena, mapattributes, &in_mapattrs, &in_mapattrs_sz);
-    o->reqid = f(client, in_space, in_key, in_key_sz, in_checks, in_checks_sz, in_mapattrs, in_mapattrs_sz, &o->status);
-
-    if (o->reqid < 0)
-    {
-        hyperdex_ruby_client_throw_exception(o->status, hyperdex_client_error_message(client));
-    }
-
-    o->encode_return = hyperdex_ruby_client_deferred_encode_status;
-    rb_hash_aset(rb_iv_get(self, "ops"), LONG2NUM(o->reqid), op);
-    rb_iv_set(self, "tmp", Qnil);
-    return op;
-}
-
-static VALUE
-hyperdex_ruby_client_asynccall__spacename_predicates_mapattributes__status_count(int64_t (*f)(struct hyperdex_client* client, const char* space, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz, enum hyperdex_client_returncode* status, uint64_t* count), VALUE self, VALUE spacename, VALUE predicates, VALUE mapattributes)
-{
-    VALUE op;
-    const char* in_space;
-    const struct hyperdex_client_attribute_check* in_checks;
-    size_t in_checks_sz;
-    const struct hyperdex_client_map_attribute* in_mapattrs;
-    size_t in_mapattrs_sz;
-    struct hyperdex_client* client;
-    struct hyperdex_ruby_client_deferred* o;
-    op = rb_class_new_instance(1, &self, class_deferred);
-    rb_iv_set(self, "tmp", op);
-    Data_Get_Struct(self, struct hyperdex_client, client);
-    Data_Get_Struct(op, struct hyperdex_ruby_client_deferred, o);
-    hyperdex_ruby_client_convert_spacename(o->arena, spacename, &in_space);
-    hyperdex_ruby_client_convert_predicates(o->arena, predicates, &in_checks, &in_checks_sz);
-    hyperdex_ruby_client_convert_mapattributes(o->arena, mapattributes, &in_mapattrs, &in_mapattrs_sz);
-    o->reqid = f(client, in_space, in_checks, in_checks_sz, in_mapattrs, in_mapattrs_sz, &o->status, &o->count);
-
-    if (o->reqid < 0)
-    {
-        hyperdex_ruby_client_throw_exception(o->status, hyperdex_client_error_message(client));
-    }
-
-    o->encode_return = hyperdex_ruby_client_deferred_encode_status_count;
-    rb_hash_aset(rb_iv_get(self, "ops"), LONG2NUM(o->reqid), op);
-    rb_iv_set(self, "tmp", Qnil);
-    return op;
-}
-
-static VALUE
-hyperdex_ruby_client_iterator__spacename_predicates__status_attributes(int64_t (*f)(struct hyperdex_client* client, const char* space, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, enum hyperdex_client_returncode* status, const struct hyperdex_client_attribute** attrs, size_t* attrs_sz), VALUE self, VALUE spacename, VALUE predicates)
-{
-    VALUE op;
-    const char* in_space;
-    const struct hyperdex_client_attribute_check* in_checks;
-    size_t in_checks_sz;
-    struct hyperdex_client* client;
-    struct hyperdex_ruby_client_iterator* o;
-    op = rb_class_new_instance(1, &self, class_iterator);
-    rb_iv_set(self, "tmp", op);
-    Data_Get_Struct(self, struct hyperdex_client, client);
-    Data_Get_Struct(op, struct hyperdex_ruby_client_iterator, o);
-    hyperdex_ruby_client_convert_spacename(o->arena, spacename, &in_space);
-    hyperdex_ruby_client_convert_predicates(o->arena, predicates, &in_checks, &in_checks_sz);
-    o->reqid = f(client, in_space, in_checks, in_checks_sz, &o->status, &o->attrs, &o->attrs_sz);
-
-    if (o->reqid < 0)
-    {
-        hyperdex_ruby_client_throw_exception(o->status, hyperdex_client_error_message(client));
-    }
-
-    o->encode_return = hyperdex_ruby_client_iterator_encode_status_attributes;
-    rb_hash_aset(rb_iv_get(self, "ops"), LONG2NUM(o->reqid), op);
-    rb_iv_set(self, "tmp", Qnil);
-    return op;
-}
-
-static VALUE
-hyperdex_ruby_client_asynccall__spacename_predicates__status_description(int64_t (*f)(struct hyperdex_client* client, const char* space, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, enum hyperdex_client_returncode* status, const char** description), VALUE self, VALUE spacename, VALUE predicates)
-{
-    VALUE op;
-    const char* in_space;
-    const struct hyperdex_client_attribute_check* in_checks;
-    size_t in_checks_sz;
-    struct hyperdex_client* client;
-    struct hyperdex_ruby_client_deferred* o;
-    op = rb_class_new_instance(1, &self, class_deferred);
-    rb_iv_set(self, "tmp", op);
-    Data_Get_Struct(self, struct hyperdex_client, client);
-    Data_Get_Struct(op, struct hyperdex_ruby_client_deferred, o);
-    hyperdex_ruby_client_convert_spacename(o->arena, spacename, &in_space);
-    hyperdex_ruby_client_convert_predicates(o->arena, predicates, &in_checks, &in_checks_sz);
-    o->reqid = f(client, in_space, in_checks, in_checks_sz, &o->status, &o->description);
-
-    if (o->reqid < 0)
-    {
-        hyperdex_ruby_client_throw_exception(o->status, hyperdex_client_error_message(client));
-    }
-
-    o->encode_return = hyperdex_ruby_client_deferred_encode_status_description;
-    rb_hash_aset(rb_iv_get(self, "ops"), LONG2NUM(o->reqid), op);
-    rb_iv_set(self, "tmp", Qnil);
-    return op;
-}
-
-static VALUE
-hyperdex_ruby_client_iterator__spacename_predicates_sortby_limit_maxmin__status_attributes(int64_t (*f)(struct hyperdex_client* client, const char* space, const struct hyperdex_client_attribute_check* checks, size_t checks_sz, const char* sort_by, uint64_t limit, int maxmin, enum hyperdex_client_returncode* status, const struct hyperdex_client_attribute** attrs, size_t* attrs_sz), VALUE self, VALUE spacename, VALUE predicates, VALUE sortby, VALUE limit, VALUE maxmin)
-{
-    VALUE op;
-    const char* in_space;
-    const struct hyperdex_client_attribute_check* in_checks;
-    size_t in_checks_sz;
-    const char* in_sort_by;
-    uint64_t in_limit;
-    int in_maxmin;
-    struct hyperdex_client* client;
-    struct hyperdex_ruby_client_iterator* o;
-    op = rb_class_new_instance(1, &self, class_iterator);
-    rb_iv_set(self, "tmp", op);
-    Data_Get_Struct(self, struct hyperdex_client, client);
-    Data_Get_Struct(op, struct hyperdex_ruby_client_iterator, o);
-    hyperdex_ruby_client_convert_spacename(o->arena, spacename, &in_space);
-    hyperdex_ruby_client_convert_predicates(o->arena, predicates, &in_checks, &in_checks_sz);
-    hyperdex_ruby_client_convert_sortby(o->arena, sortby, &in_sort_by);
-    hyperdex_ruby_client_convert_limit(o->arena, limit, &in_limit);
-    hyperdex_ruby_client_convert_maxmin(o->arena, maxmin, &in_maxmin);
-    o->reqid = f(client, in_space, in_checks, in_checks_sz, in_sort_by, in_limit, in_maxmin, &o->status, &o->attrs, &o->attrs_sz);
-
-    if (o->reqid < 0)
-    {
-        hyperdex_ruby_client_throw_exception(o->status, hyperdex_client_error_message(client));
-    }
-
-    o->encode_return = hyperdex_ruby_client_iterator_encode_status_attributes;
-    rb_hash_aset(rb_iv_get(self, "ops"), LONG2NUM(o->reqid), op);
-    rb_iv_set(self, "tmp", Qnil);
-    return op;
+hyperdex_ruby_client_asynccall__spacename_key__status_attributes(int64_t (*f)(struct hyperdex_client *client, const char *space, const char *key, size_t key_sz, enum hyperdex_client_returncode *status, const struct hyperdex_client_attribute **attrs, size_t *attrs_sz), VALUE self, VALUE spacename, VALUE key)
+{
+	VALUE op;
+	const char *in_space;
+	const char *in_key;
+	size_t in_key_sz;
+	struct hyperdex_client *client;
+	struct hyperdex_ruby_client_deferred *o;
+	op = rb_class_new_instance(1, &self, class_deferred);
+	rb_iv_set(self, "tmp", op);
+	Data_Get_Struct(self, struct hyperdex_client, client);
+	Data_Get_Struct(op, struct hyperdex_ruby_client_deferred, o);
+	hyperdex_ruby_client_convert_spacename(o->arena, spacename, &in_space);
+	hyperdex_ruby_client_convert_key(o->arena, key, &in_key, &in_key_sz);
+	o->reqid = f(client, in_space, in_key, in_key_sz, &o->status, &o->attrs, &o->attrs_sz);
+	if (o->reqid < 0)
+	{
+		hyperdex_ruby_client_throw_exception(o->status, hyperdex_client_error_message(client));
+	}
+	o->encode_return = hyperdex_ruby_client_deferred_encode_status_attributes;
+	rb_hash_aset(rb_iv_get(self, "ops"), LONG2NUM(o->reqid), op);
+	rb_iv_set(self, "tmp", Qnil);
+	return op;
+}
+
+static VALUE
+hyperdex_ruby_client_asynccall__spacename_key_attributenames__status_attributes(int64_t (*f)(struct hyperdex_client *client, const char *space, const char *key, size_t key_sz, const char **attrnames, size_t attrnames_sz, enum hyperdex_client_returncode *status, const struct hyperdex_client_attribute **attrs, size_t *attrs_sz), VALUE self, VALUE spacename, VALUE key, VALUE attributenames)
+{
+	VALUE op;
+	const char *in_space;
+	const char *in_key;
+	size_t in_key_sz;
+	const char **in_attrnames;
+	size_t in_attrnames_sz;
+	struct hyperdex_client *client;
+	struct hyperdex_ruby_client_deferred *o;
+	op = rb_class_new_instance(1, &self, class_deferred);
+	rb_iv_set(self, "tmp", op);
+	Data_Get_Struct(self, struct hyperdex_client, client);
+	Data_Get_Struct(op, struct hyperdex_ruby_client_deferred, o);
+	hyperdex_ruby_client_convert_spacename(o->arena, spacename, &in_space);
+	hyperdex_ruby_client_convert_key(o->arena, key, &in_key, &in_key_sz);
+	hyperdex_ruby_client_convert_attributenames(o->arena, attributenames, &in_attrnames, &in_attrnames_sz);
+	o->reqid = f(client, in_space, in_key, in_key_sz, in_attrnames, in_attrnames_sz, &o->status, &o->attrs, &o->attrs_sz);
+	if (o->reqid < 0)
+	{
+		hyperdex_ruby_client_throw_exception(o->status, hyperdex_client_error_message(client));
+	}
+	o->encode_return = hyperdex_ruby_client_deferred_encode_status_attributes;
+	rb_hash_aset(rb_iv_get(self, "ops"), LONG2NUM(o->reqid), op);
+	rb_iv_set(self, "tmp", Qnil);
+	return op;
+}
+
+static VALUE
+hyperdex_ruby_client_asynccall__spacename_key_attributes__status(int64_t (*f)(struct hyperdex_client *client, const char *space, const char *key, size_t key_sz, const struct hyperdex_client_attribute *attrs, size_t attrs_sz, enum hyperdex_client_returncode *status), VALUE self, VALUE spacename, VALUE key, VALUE attributes)
+{
+	VALUE op;
+	const char *in_space;
+	const char *in_key;
+	size_t in_key_sz;
+	const struct hyperdex_client_attribute *in_attrs;
+	size_t in_attrs_sz;
+	struct hyperdex_client *client;
+	struct hyperdex_ruby_client_deferred *o;
+	op = rb_class_new_instance(1, &self, class_deferred);
+	rb_iv_set(self, "tmp", op);
+	Data_Get_Struct(self, struct hyperdex_client, client);
+	Data_Get_Struct(op, struct hyperdex_ruby_client_deferred, o);
+	hyperdex_ruby_client_convert_spacename(o->arena, spacename, &in_space);
+	hyperdex_ruby_client_convert_key(o->arena, key, &in_key, &in_key_sz);
+	hyperdex_ruby_client_convert_attributes(o->arena, attributes, &in_attrs, &in_attrs_sz);
+	o->reqid = f(client, in_space, in_key, in_key_sz, in_attrs, in_attrs_sz, &o->status);
+	if (o->reqid < 0)
+	{
+		hyperdex_ruby_client_throw_exception(o->status, hyperdex_client_error_message(client));
+	}
+	o->encode_return = hyperdex_ruby_client_deferred_encode_status;
+	rb_hash_aset(rb_iv_get(self, "ops"), LONG2NUM(o->reqid), op);
+	rb_iv_set(self, "tmp", Qnil);
+	return op;
+}
+
+static VALUE
+hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(int64_t (*f)(struct hyperdex_client *client, const char *space, const char *key, size_t key_sz, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, const struct hyperdex_client_attribute *attrs, size_t attrs_sz, enum hyperdex_client_returncode *status), VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
+{
+	VALUE op;
+	const char *in_space;
+	const char *in_key;
+	size_t in_key_sz;
+	const struct hyperdex_client_attribute_check *in_checks;
+	size_t in_checks_sz;
+	const struct hyperdex_client_attribute *in_attrs;
+	size_t in_attrs_sz;
+	struct hyperdex_client *client;
+	struct hyperdex_ruby_client_deferred *o;
+	op = rb_class_new_instance(1, &self, class_deferred);
+	rb_iv_set(self, "tmp", op);
+	Data_Get_Struct(self, struct hyperdex_client, client);
+	Data_Get_Struct(op, struct hyperdex_ruby_client_deferred, o);
+	hyperdex_ruby_client_convert_spacename(o->arena, spacename, &in_space);
+	hyperdex_ruby_client_convert_key(o->arena, key, &in_key, &in_key_sz);
+	hyperdex_ruby_client_convert_predicates(o->arena, predicates, &in_checks, &in_checks_sz);
+	hyperdex_ruby_client_convert_attributes(o->arena, attributes, &in_attrs, &in_attrs_sz);
+	o->reqid = f(client, in_space, in_key, in_key_sz, in_checks, in_checks_sz, in_attrs, in_attrs_sz, &o->status);
+	if (o->reqid < 0)
+	{
+		hyperdex_ruby_client_throw_exception(o->status, hyperdex_client_error_message(client));
+	}
+	o->encode_return = hyperdex_ruby_client_deferred_encode_status;
+	rb_hash_aset(rb_iv_get(self, "ops"), LONG2NUM(o->reqid), op);
+	rb_iv_set(self, "tmp", Qnil);
+	return op;
+}
+
+static VALUE
+hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(int64_t (*f)(struct hyperdex_client *client, const char *space, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, const struct hyperdex_client_attribute *attrs, size_t attrs_sz, enum hyperdex_client_returncode *status, uint64_t *count), VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
+{
+	VALUE op;
+	const char *in_space;
+	const struct hyperdex_client_attribute_check *in_checks;
+	size_t in_checks_sz;
+	const struct hyperdex_client_attribute *in_attrs;
+	size_t in_attrs_sz;
+	struct hyperdex_client *client;
+	struct hyperdex_ruby_client_deferred *o;
+	op = rb_class_new_instance(1, &self, class_deferred);
+	rb_iv_set(self, "tmp", op);
+	Data_Get_Struct(self, struct hyperdex_client, client);
+	Data_Get_Struct(op, struct hyperdex_ruby_client_deferred, o);
+	hyperdex_ruby_client_convert_spacename(o->arena, spacename, &in_space);
+	hyperdex_ruby_client_convert_predicates(o->arena, predicates, &in_checks, &in_checks_sz);
+	hyperdex_ruby_client_convert_attributes(o->arena, attributes, &in_attrs, &in_attrs_sz);
+	o->reqid = f(client, in_space, in_checks, in_checks_sz, in_attrs, in_attrs_sz, &o->status, &o->count);
+	if (o->reqid < 0)
+	{
+		hyperdex_ruby_client_throw_exception(o->status, hyperdex_client_error_message(client));
+	}
+	o->encode_return = hyperdex_ruby_client_deferred_encode_status_count;
+	rb_hash_aset(rb_iv_get(self, "ops"), LONG2NUM(o->reqid), op);
+	rb_iv_set(self, "tmp", Qnil);
+	return op;
+}
+
+static VALUE
+hyperdex_ruby_client_asynccall__spacename_key__status(int64_t (*f)(struct hyperdex_client *client, const char *space, const char *key, size_t key_sz, enum hyperdex_client_returncode *status), VALUE self, VALUE spacename, VALUE key)
+{
+	VALUE op;
+	const char *in_space;
+	const char *in_key;
+	size_t in_key_sz;
+	struct hyperdex_client *client;
+	struct hyperdex_ruby_client_deferred *o;
+	op = rb_class_new_instance(1, &self, class_deferred);
+	rb_iv_set(self, "tmp", op);
+	Data_Get_Struct(self, struct hyperdex_client, client);
+	Data_Get_Struct(op, struct hyperdex_ruby_client_deferred, o);
+	hyperdex_ruby_client_convert_spacename(o->arena, spacename, &in_space);
+	hyperdex_ruby_client_convert_key(o->arena, key, &in_key, &in_key_sz);
+	o->reqid = f(client, in_space, in_key, in_key_sz, &o->status);
+	if (o->reqid < 0)
+	{
+		hyperdex_ruby_client_throw_exception(o->status, hyperdex_client_error_message(client));
+	}
+	o->encode_return = hyperdex_ruby_client_deferred_encode_status;
+	rb_hash_aset(rb_iv_get(self, "ops"), LONG2NUM(o->reqid), op);
+	rb_iv_set(self, "tmp", Qnil);
+	return op;
+}
+
+static VALUE
+hyperdex_ruby_client_asynccall__spacename_key_predicates__status(int64_t (*f)(struct hyperdex_client *client, const char *space, const char *key, size_t key_sz, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, enum hyperdex_client_returncode *status), VALUE self, VALUE spacename, VALUE key, VALUE predicates)
+{
+	VALUE op;
+	const char *in_space;
+	const char *in_key;
+	size_t in_key_sz;
+	const struct hyperdex_client_attribute_check *in_checks;
+	size_t in_checks_sz;
+	struct hyperdex_client *client;
+	struct hyperdex_ruby_client_deferred *o;
+	op = rb_class_new_instance(1, &self, class_deferred);
+	rb_iv_set(self, "tmp", op);
+	Data_Get_Struct(self, struct hyperdex_client, client);
+	Data_Get_Struct(op, struct hyperdex_ruby_client_deferred, o);
+	hyperdex_ruby_client_convert_spacename(o->arena, spacename, &in_space);
+	hyperdex_ruby_client_convert_key(o->arena, key, &in_key, &in_key_sz);
+	hyperdex_ruby_client_convert_predicates(o->arena, predicates, &in_checks, &in_checks_sz);
+	o->reqid = f(client, in_space, in_key, in_key_sz, in_checks, in_checks_sz, &o->status);
+	if (o->reqid < 0)
+	{
+		hyperdex_ruby_client_throw_exception(o->status, hyperdex_client_error_message(client));
+	}
+	o->encode_return = hyperdex_ruby_client_deferred_encode_status;
+	rb_hash_aset(rb_iv_get(self, "ops"), LONG2NUM(o->reqid), op);
+	rb_iv_set(self, "tmp", Qnil);
+	return op;
+}
+
+static VALUE
+hyperdex_ruby_client_asynccall__spacename_predicates__status_count(int64_t (*f)(struct hyperdex_client *client, const char *space, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, enum hyperdex_client_returncode *status, uint64_t *count), VALUE self, VALUE spacename, VALUE predicates)
+{
+	VALUE op;
+	const char *in_space;
+	const struct hyperdex_client_attribute_check *in_checks;
+	size_t in_checks_sz;
+	struct hyperdex_client *client;
+	struct hyperdex_ruby_client_deferred *o;
+	op = rb_class_new_instance(1, &self, class_deferred);
+	rb_iv_set(self, "tmp", op);
+	Data_Get_Struct(self, struct hyperdex_client, client);
+	Data_Get_Struct(op, struct hyperdex_ruby_client_deferred, o);
+	hyperdex_ruby_client_convert_spacename(o->arena, spacename, &in_space);
+	hyperdex_ruby_client_convert_predicates(o->arena, predicates, &in_checks, &in_checks_sz);
+	o->reqid = f(client, in_space, in_checks, in_checks_sz, &o->status, &o->count);
+	if (o->reqid < 0)
+	{
+		hyperdex_ruby_client_throw_exception(o->status, hyperdex_client_error_message(client));
+	}
+	o->encode_return = hyperdex_ruby_client_deferred_encode_status_count;
+	rb_hash_aset(rb_iv_get(self, "ops"), LONG2NUM(o->reqid), op);
+	rb_iv_set(self, "tmp", Qnil);
+	return op;
+}
+
+static VALUE
+hyperdex_ruby_client_asynccall__spacename_key_mapattributes__status(int64_t (*f)(struct hyperdex_client *client, const char *space, const char *key, size_t key_sz, const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz, enum hyperdex_client_returncode *status), VALUE self, VALUE spacename, VALUE key, VALUE mapattributes)
+{
+	VALUE op;
+	const char *in_space;
+	const char *in_key;
+	size_t in_key_sz;
+	const struct hyperdex_client_map_attribute *in_mapattrs;
+	size_t in_mapattrs_sz;
+	struct hyperdex_client *client;
+	struct hyperdex_ruby_client_deferred *o;
+	op = rb_class_new_instance(1, &self, class_deferred);
+	rb_iv_set(self, "tmp", op);
+	Data_Get_Struct(self, struct hyperdex_client, client);
+	Data_Get_Struct(op, struct hyperdex_ruby_client_deferred, o);
+	hyperdex_ruby_client_convert_spacename(o->arena, spacename, &in_space);
+	hyperdex_ruby_client_convert_key(o->arena, key, &in_key, &in_key_sz);
+	hyperdex_ruby_client_convert_mapattributes(o->arena, mapattributes, &in_mapattrs, &in_mapattrs_sz);
+	o->reqid = f(client, in_space, in_key, in_key_sz, in_mapattrs, in_mapattrs_sz, &o->status);
+	if (o->reqid < 0)
+	{
+		hyperdex_ruby_client_throw_exception(o->status, hyperdex_client_error_message(client));
+	}
+	o->encode_return = hyperdex_ruby_client_deferred_encode_status;
+	rb_hash_aset(rb_iv_get(self, "ops"), LONG2NUM(o->reqid), op);
+	rb_iv_set(self, "tmp", Qnil);
+	return op;
+}
+
+static VALUE
+hyperdex_ruby_client_asynccall__spacename_key_predicates_mapattributes__status(int64_t (*f)(struct hyperdex_client *client, const char *space, const char *key, size_t key_sz, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz, enum hyperdex_client_returncode *status), VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE mapattributes)
+{
+	VALUE op;
+	const char *in_space;
+	const char *in_key;
+	size_t in_key_sz;
+	const struct hyperdex_client_attribute_check *in_checks;
+	size_t in_checks_sz;
+	const struct hyperdex_client_map_attribute *in_mapattrs;
+	size_t in_mapattrs_sz;
+	struct hyperdex_client *client;
+	struct hyperdex_ruby_client_deferred *o;
+	op = rb_class_new_instance(1, &self, class_deferred);
+	rb_iv_set(self, "tmp", op);
+	Data_Get_Struct(self, struct hyperdex_client, client);
+	Data_Get_Struct(op, struct hyperdex_ruby_client_deferred, o);
+	hyperdex_ruby_client_convert_spacename(o->arena, spacename, &in_space);
+	hyperdex_ruby_client_convert_key(o->arena, key, &in_key, &in_key_sz);
+	hyperdex_ruby_client_convert_predicates(o->arena, predicates, &in_checks, &in_checks_sz);
+	hyperdex_ruby_client_convert_mapattributes(o->arena, mapattributes, &in_mapattrs, &in_mapattrs_sz);
+	o->reqid = f(client, in_space, in_key, in_key_sz, in_checks, in_checks_sz, in_mapattrs, in_mapattrs_sz, &o->status);
+	if (o->reqid < 0)
+	{
+		hyperdex_ruby_client_throw_exception(o->status, hyperdex_client_error_message(client));
+	}
+	o->encode_return = hyperdex_ruby_client_deferred_encode_status;
+	rb_hash_aset(rb_iv_get(self, "ops"), LONG2NUM(o->reqid), op);
+	rb_iv_set(self, "tmp", Qnil);
+	return op;
+}
+
+static VALUE
+hyperdex_ruby_client_asynccall__spacename_predicates_mapattributes__status_count(int64_t (*f)(struct hyperdex_client *client, const char *space, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz, enum hyperdex_client_returncode *status, uint64_t *count), VALUE self, VALUE spacename, VALUE predicates, VALUE mapattributes)
+{
+	VALUE op;
+	const char *in_space;
+	const struct hyperdex_client_attribute_check *in_checks;
+	size_t in_checks_sz;
+	const struct hyperdex_client_map_attribute *in_mapattrs;
+	size_t in_mapattrs_sz;
+	struct hyperdex_client *client;
+	struct hyperdex_ruby_client_deferred *o;
+	op = rb_class_new_instance(1, &self, class_deferred);
+	rb_iv_set(self, "tmp", op);
+	Data_Get_Struct(self, struct hyperdex_client, client);
+	Data_Get_Struct(op, struct hyperdex_ruby_client_deferred, o);
+	hyperdex_ruby_client_convert_spacename(o->arena, spacename, &in_space);
+	hyperdex_ruby_client_convert_predicates(o->arena, predicates, &in_checks, &in_checks_sz);
+	hyperdex_ruby_client_convert_mapattributes(o->arena, mapattributes, &in_mapattrs, &in_mapattrs_sz);
+	o->reqid = f(client, in_space, in_checks, in_checks_sz, in_mapattrs, in_mapattrs_sz, &o->status, &o->count);
+	if (o->reqid < 0)
+	{
+		hyperdex_ruby_client_throw_exception(o->status, hyperdex_client_error_message(client));
+	}
+	o->encode_return = hyperdex_ruby_client_deferred_encode_status_count;
+	rb_hash_aset(rb_iv_get(self, "ops"), LONG2NUM(o->reqid), op);
+	rb_iv_set(self, "tmp", Qnil);
+	return op;
+}
+
+static VALUE
+hyperdex_ruby_client_iterator__spacename_predicates__status_attributes(int64_t (*f)(struct hyperdex_client *client, const char *space, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, enum hyperdex_client_returncode *status, const struct hyperdex_client_attribute **attrs, size_t *attrs_sz), VALUE self, VALUE spacename, VALUE predicates)
+{
+	VALUE op;
+	const char *in_space;
+	const struct hyperdex_client_attribute_check *in_checks;
+	size_t in_checks_sz;
+	struct hyperdex_client *client;
+	struct hyperdex_ruby_client_iterator *o;
+	op = rb_class_new_instance(1, &self, class_iterator);
+	rb_iv_set(self, "tmp", op);
+	Data_Get_Struct(self, struct hyperdex_client, client);
+	Data_Get_Struct(op, struct hyperdex_ruby_client_iterator, o);
+	hyperdex_ruby_client_convert_spacename(o->arena, spacename, &in_space);
+	hyperdex_ruby_client_convert_predicates(o->arena, predicates, &in_checks, &in_checks_sz);
+	o->reqid = f(client, in_space, in_checks, in_checks_sz, &o->status, &o->attrs, &o->attrs_sz);
+	if (o->reqid < 0)
+	{
+		hyperdex_ruby_client_throw_exception(o->status, hyperdex_client_error_message(client));
+	}
+	o->encode_return = hyperdex_ruby_client_iterator_encode_status_attributes;
+	rb_hash_aset(rb_iv_get(self, "ops"), LONG2NUM(o->reqid), op);
+	rb_iv_set(self, "tmp", Qnil);
+	return op;
+}
+
+static VALUE
+hyperdex_ruby_client_asynccall__spacename_predicates__status_description(int64_t (*f)(struct hyperdex_client *client, const char *space, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, enum hyperdex_client_returncode *status, const char **description), VALUE self, VALUE spacename, VALUE predicates)
+{
+	VALUE op;
+	const char *in_space;
+	const struct hyperdex_client_attribute_check *in_checks;
+	size_t in_checks_sz;
+	struct hyperdex_client *client;
+	struct hyperdex_ruby_client_deferred *o;
+	op = rb_class_new_instance(1, &self, class_deferred);
+	rb_iv_set(self, "tmp", op);
+	Data_Get_Struct(self, struct hyperdex_client, client);
+	Data_Get_Struct(op, struct hyperdex_ruby_client_deferred, o);
+	hyperdex_ruby_client_convert_spacename(o->arena, spacename, &in_space);
+	hyperdex_ruby_client_convert_predicates(o->arena, predicates, &in_checks, &in_checks_sz);
+	o->reqid = f(client, in_space, in_checks, in_checks_sz, &o->status, &o->description);
+	if (o->reqid < 0)
+	{
+		hyperdex_ruby_client_throw_exception(o->status, hyperdex_client_error_message(client));
+	}
+	o->encode_return = hyperdex_ruby_client_deferred_encode_status_description;
+	rb_hash_aset(rb_iv_get(self, "ops"), LONG2NUM(o->reqid), op);
+	rb_iv_set(self, "tmp", Qnil);
+	return op;
+}
+
+static VALUE
+hyperdex_ruby_client_iterator__spacename_predicates_sortby_limit_maxmin__status_attributes(int64_t (*f)(struct hyperdex_client *client, const char *space, const struct hyperdex_client_attribute_check *checks, size_t checks_sz, const char *sort_by, uint64_t limit, int maxmin, enum hyperdex_client_returncode *status, const struct hyperdex_client_attribute **attrs, size_t *attrs_sz), VALUE self, VALUE spacename, VALUE predicates, VALUE sortby, VALUE limit, VALUE maxmin)
+{
+	VALUE op;
+	const char *in_space;
+	const struct hyperdex_client_attribute_check *in_checks;
+	size_t in_checks_sz;
+	const char *in_sort_by;
+	uint64_t in_limit;
+	int in_maxmin;
+	struct hyperdex_client *client;
+	struct hyperdex_ruby_client_iterator *o;
+	op = rb_class_new_instance(1, &self, class_iterator);
+	rb_iv_set(self, "tmp", op);
+	Data_Get_Struct(self, struct hyperdex_client, client);
+	Data_Get_Struct(op, struct hyperdex_ruby_client_iterator, o);
+	hyperdex_ruby_client_convert_spacename(o->arena, spacename, &in_space);
+	hyperdex_ruby_client_convert_predicates(o->arena, predicates, &in_checks, &in_checks_sz);
+	hyperdex_ruby_client_convert_sortby(o->arena, sortby, &in_sort_by);
+	hyperdex_ruby_client_convert_limit(o->arena, limit, &in_limit);
+	hyperdex_ruby_client_convert_maxmin(o->arena, maxmin, &in_maxmin);
+	o->reqid = f(client, in_space, in_checks, in_checks_sz, in_sort_by, in_limit, in_maxmin, &o->status, &o->attrs, &o->attrs_sz);
+	if (o->reqid < 0)
+	{
+		hyperdex_ruby_client_throw_exception(o->status, hyperdex_client_error_message(client));
+	}
+	o->encode_return = hyperdex_ruby_client_iterator_encode_status_attributes;
+	rb_hash_aset(rb_iv_get(self, "ops"), LONG2NUM(o->reqid), op);
+	rb_iv_set(self, "tmp", Qnil);
+	return op;
 }
 static VALUE
 hyperdex_ruby_client_get(VALUE self, VALUE spacename, VALUE key)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key__status_attributes(hyperdex_client_get, self, spacename, key);
+	return hyperdex_ruby_client_asynccall__spacename_key__status_attributes(hyperdex_client_get, self, spacename, key);
 }
 VALUE
 hyperdex_ruby_client_wait_get(VALUE self, VALUE spacename, VALUE key)
 {
-    VALUE deferred = hyperdex_ruby_client_get(self, spacename, key);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_get(self, spacename, key);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_get_partial(VALUE self, VALUE spacename, VALUE key, VALUE attributenames)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_attributenames__status_attributes(hyperdex_client_get_partial, self, spacename, key, attributenames);
+	return hyperdex_ruby_client_asynccall__spacename_key_attributenames__status_attributes(hyperdex_client_get_partial, self, spacename, key, attributenames);
 }
 VALUE
 hyperdex_ruby_client_wait_get_partial(VALUE self, VALUE spacename, VALUE key, VALUE attributenames)
 {
-    VALUE deferred = hyperdex_ruby_client_get_partial(self, spacename, key, attributenames);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_get_partial(self, spacename, key, attributenames);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_put(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_put, self, spacename, key, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_put, self, spacename, key, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_put(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_put(self, spacename, key, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_put(self, spacename, key, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_cond_put(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_put, self, spacename, key, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_put, self, spacename, key, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_cond_put(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_cond_put(self, spacename, key, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_cond_put(self, spacename, key, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_cond_put_or_create(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_put_or_create, self, spacename, key, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_put_or_create, self, spacename, key, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_cond_put_or_create(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_cond_put_or_create(self, spacename, key, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_cond_put_or_create(self, spacename, key, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_group_put(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_put, self, spacename, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_put, self, spacename, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_group_put(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_group_put(self, spacename, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_group_put(self, spacename, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_put_if_not_exist(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_put_if_not_exist, self, spacename, key, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_put_if_not_exist, self, spacename, key, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_put_if_not_exist(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_put_if_not_exist(self, spacename, key, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_put_if_not_exist(self, spacename, key, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_del(VALUE self, VALUE spacename, VALUE key)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key__status(hyperdex_client_del, self, spacename, key);
+	return hyperdex_ruby_client_asynccall__spacename_key__status(hyperdex_client_del, self, spacename, key);
 }
 VALUE
 hyperdex_ruby_client_wait_del(VALUE self, VALUE spacename, VALUE key)
 {
-    VALUE deferred = hyperdex_ruby_client_del(self, spacename, key);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_del(self, spacename, key);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_cond_del(VALUE self, VALUE spacename, VALUE key, VALUE predicates)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_predicates__status(hyperdex_client_cond_del, self, spacename, key, predicates);
+	return hyperdex_ruby_client_asynccall__spacename_key_predicates__status(hyperdex_client_cond_del, self, spacename, key, predicates);
 }
 VALUE
 hyperdex_ruby_client_wait_cond_del(VALUE self, VALUE spacename, VALUE key, VALUE predicates)
 {
-    VALUE deferred = hyperdex_ruby_client_cond_del(self, spacename, key, predicates);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_cond_del(self, spacename, key, predicates);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_group_del(VALUE self, VALUE spacename, VALUE predicates)
 {
-    return hyperdex_ruby_client_asynccall__spacename_predicates__status_count(hyperdex_client_group_del, self, spacename, predicates);
+	return hyperdex_ruby_client_asynccall__spacename_predicates__status_count(hyperdex_client_group_del, self, spacename, predicates);
 }
 VALUE
 hyperdex_ruby_client_wait_group_del(VALUE self, VALUE spacename, VALUE predicates)
 {
-    VALUE deferred = hyperdex_ruby_client_group_del(self, spacename, predicates);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_group_del(self, spacename, predicates);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_atomic_add(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_atomic_add, self, spacename, key, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_atomic_add, self, spacename, key, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_atomic_add(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_atomic_add(self, spacename, key, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_atomic_add(self, spacename, key, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_cond_atomic_add(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_atomic_add, self, spacename, key, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_atomic_add, self, spacename, key, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_cond_atomic_add(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_cond_atomic_add(self, spacename, key, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_cond_atomic_add(self, spacename, key, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_group_atomic_add(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_atomic_add, self, spacename, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_atomic_add, self, spacename, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_group_atomic_add(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_group_atomic_add(self, spacename, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_group_atomic_add(self, spacename, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_atomic_sub(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_atomic_sub, self, spacename, key, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_atomic_sub, self, spacename, key, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_atomic_sub(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_atomic_sub(self, spacename, key, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_atomic_sub(self, spacename, key, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_cond_atomic_sub(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_atomic_sub, self, spacename, key, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_atomic_sub, self, spacename, key, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_cond_atomic_sub(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_cond_atomic_sub(self, spacename, key, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_cond_atomic_sub(self, spacename, key, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_group_atomic_sub(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_atomic_sub, self, spacename, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_atomic_sub, self, spacename, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_group_atomic_sub(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_group_atomic_sub(self, spacename, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_group_atomic_sub(self, spacename, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_atomic_mul(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_atomic_mul, self, spacename, key, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_atomic_mul, self, spacename, key, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_atomic_mul(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_atomic_mul(self, spacename, key, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_atomic_mul(self, spacename, key, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_cond_atomic_mul(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_atomic_mul, self, spacename, key, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_atomic_mul, self, spacename, key, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_cond_atomic_mul(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_cond_atomic_mul(self, spacename, key, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_cond_atomic_mul(self, spacename, key, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_group_atomic_mul(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_atomic_mul, self, spacename, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_atomic_mul, self, spacename, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_group_atomic_mul(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_group_atomic_mul(self, spacename, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_group_atomic_mul(self, spacename, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_atomic_div(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_atomic_div, self, spacename, key, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_atomic_div, self, spacename, key, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_atomic_div(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_atomic_div(self, spacename, key, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_atomic_div(self, spacename, key, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_cond_atomic_div(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_atomic_div, self, spacename, key, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_atomic_div, self, spacename, key, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_cond_atomic_div(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_cond_atomic_div(self, spacename, key, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_cond_atomic_div(self, spacename, key, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_group_atomic_div(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_atomic_div, self, spacename, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_atomic_div, self, spacename, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_group_atomic_div(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_group_atomic_div(self, spacename, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_group_atomic_div(self, spacename, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_atomic_mod(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_atomic_mod, self, spacename, key, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_atomic_mod, self, spacename, key, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_atomic_mod(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_atomic_mod(self, spacename, key, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_atomic_mod(self, spacename, key, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_cond_atomic_mod(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_atomic_mod, self, spacename, key, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_atomic_mod, self, spacename, key, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_cond_atomic_mod(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_cond_atomic_mod(self, spacename, key, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_cond_atomic_mod(self, spacename, key, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_group_atomic_mod(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_atomic_mod, self, spacename, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_atomic_mod, self, spacename, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_group_atomic_mod(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_group_atomic_mod(self, spacename, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_group_atomic_mod(self, spacename, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_atomic_and(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_atomic_and, self, spacename, key, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_atomic_and, self, spacename, key, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_atomic_and(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_atomic_and(self, spacename, key, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_atomic_and(self, spacename, key, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_cond_atomic_and(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_atomic_and, self, spacename, key, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_atomic_and, self, spacename, key, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_cond_atomic_and(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_cond_atomic_and(self, spacename, key, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_cond_atomic_and(self, spacename, key, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_group_atomic_and(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_atomic_and, self, spacename, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_atomic_and, self, spacename, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_group_atomic_and(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_group_atomic_and(self, spacename, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_group_atomic_and(self, spacename, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_atomic_or(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_atomic_or, self, spacename, key, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_atomic_or, self, spacename, key, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_atomic_or(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_atomic_or(self, spacename, key, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_atomic_or(self, spacename, key, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_cond_atomic_or(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_atomic_or, self, spacename, key, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_atomic_or, self, spacename, key, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_cond_atomic_or(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_cond_atomic_or(self, spacename, key, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_cond_atomic_or(self, spacename, key, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_group_atomic_or(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_atomic_or, self, spacename, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_atomic_or, self, spacename, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_group_atomic_or(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_group_atomic_or(self, spacename, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_group_atomic_or(self, spacename, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_atomic_xor(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_atomic_xor, self, spacename, key, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_atomic_xor, self, spacename, key, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_atomic_xor(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_atomic_xor(self, spacename, key, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_atomic_xor(self, spacename, key, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_cond_atomic_xor(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_atomic_xor, self, spacename, key, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_atomic_xor, self, spacename, key, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_cond_atomic_xor(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_cond_atomic_xor(self, spacename, key, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_cond_atomic_xor(self, spacename, key, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_group_atomic_xor(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_atomic_xor, self, spacename, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_atomic_xor, self, spacename, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_group_atomic_xor(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_group_atomic_xor(self, spacename, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_group_atomic_xor(self, spacename, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_atomic_min(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_atomic_min, self, spacename, key, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_atomic_min, self, spacename, key, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_atomic_min(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_atomic_min(self, spacename, key, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_atomic_min(self, spacename, key, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_cond_atomic_min(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_atomic_min, self, spacename, key, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_atomic_min, self, spacename, key, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_cond_atomic_min(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_cond_atomic_min(self, spacename, key, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_cond_atomic_min(self, spacename, key, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_group_atomic_min(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_atomic_min, self, spacename, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_atomic_min, self, spacename, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_group_atomic_min(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_group_atomic_min(self, spacename, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_group_atomic_min(self, spacename, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_atomic_max(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_atomic_max, self, spacename, key, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_atomic_max, self, spacename, key, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_atomic_max(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_atomic_max(self, spacename, key, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_atomic_max(self, spacename, key, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_cond_atomic_max(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_atomic_max, self, spacename, key, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_atomic_max, self, spacename, key, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_cond_atomic_max(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_cond_atomic_max(self, spacename, key, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_cond_atomic_max(self, spacename, key, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_group_atomic_max(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_atomic_max, self, spacename, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_atomic_max, self, spacename, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_group_atomic_max(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_group_atomic_max(self, spacename, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_group_atomic_max(self, spacename, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_string_prepend(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_string_prepend, self, spacename, key, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_string_prepend, self, spacename, key, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_string_prepend(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_string_prepend(self, spacename, key, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_string_prepend(self, spacename, key, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_cond_string_prepend(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_string_prepend, self, spacename, key, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_string_prepend, self, spacename, key, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_cond_string_prepend(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_cond_string_prepend(self, spacename, key, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_cond_string_prepend(self, spacename, key, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_group_string_prepend(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_string_prepend, self, spacename, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_string_prepend, self, spacename, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_group_string_prepend(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_group_string_prepend(self, spacename, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_group_string_prepend(self, spacename, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_string_append(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_string_append, self, spacename, key, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_string_append, self, spacename, key, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_string_append(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_string_append(self, spacename, key, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_string_append(self, spacename, key, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_cond_string_append(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_string_append, self, spacename, key, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_string_append, self, spacename, key, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_cond_string_append(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_cond_string_append(self, spacename, key, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_cond_string_append(self, spacename, key, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_group_string_append(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_string_append, self, spacename, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_string_append, self, spacename, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_group_string_append(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_group_string_append(self, spacename, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_group_string_append(self, spacename, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_string_ltrim(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_string_ltrim, self, spacename, key, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_string_ltrim, self, spacename, key, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_string_ltrim(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_string_ltrim(self, spacename, key, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_string_ltrim(self, spacename, key, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_cond_string_ltrim(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_string_ltrim, self, spacename, key, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_string_ltrim, self, spacename, key, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_cond_string_ltrim(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_cond_string_ltrim(self, spacename, key, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_cond_string_ltrim(self, spacename, key, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_group_string_ltrim(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_string_ltrim, self, spacename, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_string_ltrim, self, spacename, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_group_string_ltrim(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_group_string_ltrim(self, spacename, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_group_string_ltrim(self, spacename, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_string_rtrim(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_string_rtrim, self, spacename, key, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_string_rtrim, self, spacename, key, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_string_rtrim(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_string_rtrim(self, spacename, key, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_string_rtrim(self, spacename, key, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_cond_string_rtrim(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_string_rtrim, self, spacename, key, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_string_rtrim, self, spacename, key, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_cond_string_rtrim(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_cond_string_rtrim(self, spacename, key, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_cond_string_rtrim(self, spacename, key, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_group_string_rtrim(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_string_rtrim, self, spacename, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_string_rtrim, self, spacename, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_group_string_rtrim(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_group_string_rtrim(self, spacename, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_group_string_rtrim(self, spacename, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_list_lpush(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_list_lpush, self, spacename, key, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_list_lpush, self, spacename, key, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_list_lpush(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_list_lpush(self, spacename, key, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_list_lpush(self, spacename, key, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_cond_list_lpush(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_list_lpush, self, spacename, key, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_list_lpush, self, spacename, key, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_cond_list_lpush(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_cond_list_lpush(self, spacename, key, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_cond_list_lpush(self, spacename, key, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_group_list_lpush(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_list_lpush, self, spacename, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_list_lpush, self, spacename, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_group_list_lpush(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_group_list_lpush(self, spacename, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_group_list_lpush(self, spacename, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_list_rpush(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_list_rpush, self, spacename, key, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_list_rpush, self, spacename, key, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_list_rpush(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_list_rpush(self, spacename, key, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_list_rpush(self, spacename, key, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_cond_list_rpush(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_list_rpush, self, spacename, key, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_list_rpush, self, spacename, key, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_cond_list_rpush(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_cond_list_rpush(self, spacename, key, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_cond_list_rpush(self, spacename, key, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_group_list_rpush(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_list_rpush, self, spacename, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_list_rpush, self, spacename, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_group_list_rpush(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_group_list_rpush(self, spacename, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_group_list_rpush(self, spacename, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_set_add(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_set_add, self, spacename, key, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_set_add, self, spacename, key, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_set_add(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_set_add(self, spacename, key, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_set_add(self, spacename, key, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_cond_set_add(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_set_add, self, spacename, key, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_set_add, self, spacename, key, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_cond_set_add(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_cond_set_add(self, spacename, key, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_cond_set_add(self, spacename, key, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_group_set_add(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_set_add, self, spacename, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_set_add, self, spacename, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_group_set_add(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_group_set_add(self, spacename, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_group_set_add(self, spacename, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_set_remove(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_set_remove, self, spacename, key, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_set_remove, self, spacename, key, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_set_remove(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_set_remove(self, spacename, key, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_set_remove(self, spacename, key, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_cond_set_remove(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_set_remove, self, spacename, key, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_set_remove, self, spacename, key, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_cond_set_remove(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_cond_set_remove(self, spacename, key, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_cond_set_remove(self, spacename, key, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_group_set_remove(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_set_remove, self, spacename, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_set_remove, self, spacename, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_group_set_remove(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_group_set_remove(self, spacename, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_group_set_remove(self, spacename, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_set_intersect(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_set_intersect, self, spacename, key, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_set_intersect, self, spacename, key, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_set_intersect(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_set_intersect(self, spacename, key, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_set_intersect(self, spacename, key, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_cond_set_intersect(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_set_intersect, self, spacename, key, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_set_intersect, self, spacename, key, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_cond_set_intersect(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_cond_set_intersect(self, spacename, key, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_cond_set_intersect(self, spacename, key, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_group_set_intersect(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_set_intersect, self, spacename, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_set_intersect, self, spacename, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_group_set_intersect(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_group_set_intersect(self, spacename, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_group_set_intersect(self, spacename, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_set_union(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_set_union, self, spacename, key, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_set_union, self, spacename, key, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_set_union(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_set_union(self, spacename, key, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_set_union(self, spacename, key, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_cond_set_union(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_set_union, self, spacename, key, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_set_union, self, spacename, key, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_cond_set_union(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_cond_set_union(self, spacename, key, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_cond_set_union(self, spacename, key, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_group_set_union(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_set_union, self, spacename, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_set_union, self, spacename, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_group_set_union(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_group_set_union(self, spacename, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_group_set_union(self, spacename, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_document_rename(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_document_rename, self, spacename, key, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_document_rename, self, spacename, key, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_document_rename(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_document_rename(self, spacename, key, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_document_rename(self, spacename, key, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_cond_document_rename(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_document_rename, self, spacename, key, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_document_rename, self, spacename, key, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_cond_document_rename(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_cond_document_rename(self, spacename, key, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_cond_document_rename(self, spacename, key, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_group_document_rename(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_document_rename, self, spacename, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_document_rename, self, spacename, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_group_document_rename(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_group_document_rename(self, spacename, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_group_document_rename(self, spacename, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_document_unset(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_document_unset, self, spacename, key, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_document_unset, self, spacename, key, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_document_unset(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_document_unset(self, spacename, key, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_document_unset(self, spacename, key, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_cond_document_unset(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_document_unset, self, spacename, key, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_document_unset, self, spacename, key, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_cond_document_unset(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_cond_document_unset(self, spacename, key, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_cond_document_unset(self, spacename, key, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_group_document_unset(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_document_unset, self, spacename, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_document_unset, self, spacename, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_group_document_unset(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_group_document_unset(self, spacename, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_group_document_unset(self, spacename, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_map_add(VALUE self, VALUE spacename, VALUE key, VALUE mapattributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_mapattributes__status(hyperdex_client_map_add, self, spacename, key, mapattributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_mapattributes__status(hyperdex_client_map_add, self, spacename, key, mapattributes);
 }
 VALUE
 hyperdex_ruby_client_wait_map_add(VALUE self, VALUE spacename, VALUE key, VALUE mapattributes)
 {
-    VALUE deferred = hyperdex_ruby_client_map_add(self, spacename, key, mapattributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_map_add(self, spacename, key, mapattributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_cond_map_add(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE mapattributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_add, self, spacename, key, predicates, mapattributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_add, self, spacename, key, predicates, mapattributes);
 }
 VALUE
 hyperdex_ruby_client_wait_cond_map_add(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE mapattributes)
 {
-    VALUE deferred = hyperdex_ruby_client_cond_map_add(self, spacename, key, predicates, mapattributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_cond_map_add(self, spacename, key, predicates, mapattributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_group_map_add(VALUE self, VALUE spacename, VALUE predicates, VALUE mapattributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_add, self, spacename, predicates, mapattributes);
+	return hyperdex_ruby_client_asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_add, self, spacename, predicates, mapattributes);
 }
 VALUE
 hyperdex_ruby_client_wait_group_map_add(VALUE self, VALUE spacename, VALUE predicates, VALUE mapattributes)
 {
-    VALUE deferred = hyperdex_ruby_client_group_map_add(self, spacename, predicates, mapattributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_group_map_add(self, spacename, predicates, mapattributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_map_remove(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_map_remove, self, spacename, key, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_attributes__status(hyperdex_client_map_remove, self, spacename, key, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_map_remove(VALUE self, VALUE spacename, VALUE key, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_map_remove(self, spacename, key, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_map_remove(self, spacename, key, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_cond_map_remove(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_map_remove, self, spacename, key, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_predicates_attributes__status(hyperdex_client_cond_map_remove, self, spacename, key, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_cond_map_remove(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_cond_map_remove(self, spacename, key, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_cond_map_remove(self, spacename, key, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_group_map_remove(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_map_remove, self, spacename, predicates, attributes);
+	return hyperdex_ruby_client_asynccall__spacename_predicates_attributes__status_count(hyperdex_client_group_map_remove, self, spacename, predicates, attributes);
 }
 VALUE
 hyperdex_ruby_client_wait_group_map_remove(VALUE self, VALUE spacename, VALUE predicates, VALUE attributes)
 {
-    VALUE deferred = hyperdex_ruby_client_group_map_remove(self, spacename, predicates, attributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_group_map_remove(self, spacename, predicates, attributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_map_atomic_add(VALUE self, VALUE spacename, VALUE key, VALUE mapattributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_mapattributes__status(hyperdex_client_map_atomic_add, self, spacename, key, mapattributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_mapattributes__status(hyperdex_client_map_atomic_add, self, spacename, key, mapattributes);
 }
 VALUE
 hyperdex_ruby_client_wait_map_atomic_add(VALUE self, VALUE spacename, VALUE key, VALUE mapattributes)
 {
-    VALUE deferred = hyperdex_ruby_client_map_atomic_add(self, spacename, key, mapattributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_map_atomic_add(self, spacename, key, mapattributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_cond_map_atomic_add(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE mapattributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_atomic_add, self, spacename, key, predicates, mapattributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_atomic_add, self, spacename, key, predicates, mapattributes);
 }
 VALUE
 hyperdex_ruby_client_wait_cond_map_atomic_add(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE mapattributes)
 {
-    VALUE deferred = hyperdex_ruby_client_cond_map_atomic_add(self, spacename, key, predicates, mapattributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_cond_map_atomic_add(self, spacename, key, predicates, mapattributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_group_map_atomic_add(VALUE self, VALUE spacename, VALUE predicates, VALUE mapattributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_atomic_add, self, spacename, predicates, mapattributes);
+	return hyperdex_ruby_client_asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_atomic_add, self, spacename, predicates, mapattributes);
 }
 VALUE
 hyperdex_ruby_client_wait_group_map_atomic_add(VALUE self, VALUE spacename, VALUE predicates, VALUE mapattributes)
 {
-    VALUE deferred = hyperdex_ruby_client_group_map_atomic_add(self, spacename, predicates, mapattributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_group_map_atomic_add(self, spacename, predicates, mapattributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_map_atomic_sub(VALUE self, VALUE spacename, VALUE key, VALUE mapattributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_mapattributes__status(hyperdex_client_map_atomic_sub, self, spacename, key, mapattributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_mapattributes__status(hyperdex_client_map_atomic_sub, self, spacename, key, mapattributes);
 }
 VALUE
 hyperdex_ruby_client_wait_map_atomic_sub(VALUE self, VALUE spacename, VALUE key, VALUE mapattributes)
 {
-    VALUE deferred = hyperdex_ruby_client_map_atomic_sub(self, spacename, key, mapattributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_map_atomic_sub(self, spacename, key, mapattributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_cond_map_atomic_sub(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE mapattributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_atomic_sub, self, spacename, key, predicates, mapattributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_atomic_sub, self, spacename, key, predicates, mapattributes);
 }
 VALUE
 hyperdex_ruby_client_wait_cond_map_atomic_sub(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE mapattributes)
 {
-    VALUE deferred = hyperdex_ruby_client_cond_map_atomic_sub(self, spacename, key, predicates, mapattributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_cond_map_atomic_sub(self, spacename, key, predicates, mapattributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_group_map_atomic_sub(VALUE self, VALUE spacename, VALUE predicates, VALUE mapattributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_atomic_sub, self, spacename, predicates, mapattributes);
+	return hyperdex_ruby_client_asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_atomic_sub, self, spacename, predicates, mapattributes);
 }
 VALUE
 hyperdex_ruby_client_wait_group_map_atomic_sub(VALUE self, VALUE spacename, VALUE predicates, VALUE mapattributes)
 {
-    VALUE deferred = hyperdex_ruby_client_group_map_atomic_sub(self, spacename, predicates, mapattributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_group_map_atomic_sub(self, spacename, predicates, mapattributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_map_atomic_mul(VALUE self, VALUE spacename, VALUE key, VALUE mapattributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_mapattributes__status(hyperdex_client_map_atomic_mul, self, spacename, key, mapattributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_mapattributes__status(hyperdex_client_map_atomic_mul, self, spacename, key, mapattributes);
 }
 VALUE
 hyperdex_ruby_client_wait_map_atomic_mul(VALUE self, VALUE spacename, VALUE key, VALUE mapattributes)
 {
-    VALUE deferred = hyperdex_ruby_client_map_atomic_mul(self, spacename, key, mapattributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_map_atomic_mul(self, spacename, key, mapattributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_cond_map_atomic_mul(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE mapattributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_atomic_mul, self, spacename, key, predicates, mapattributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_atomic_mul, self, spacename, key, predicates, mapattributes);
 }
 VALUE
 hyperdex_ruby_client_wait_cond_map_atomic_mul(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE mapattributes)
 {
-    VALUE deferred = hyperdex_ruby_client_cond_map_atomic_mul(self, spacename, key, predicates, mapattributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_cond_map_atomic_mul(self, spacename, key, predicates, mapattributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_group_map_atomic_mul(VALUE self, VALUE spacename, VALUE predicates, VALUE mapattributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_atomic_mul, self, spacename, predicates, mapattributes);
+	return hyperdex_ruby_client_asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_atomic_mul, self, spacename, predicates, mapattributes);
 }
 VALUE
 hyperdex_ruby_client_wait_group_map_atomic_mul(VALUE self, VALUE spacename, VALUE predicates, VALUE mapattributes)
 {
-    VALUE deferred = hyperdex_ruby_client_group_map_atomic_mul(self, spacename, predicates, mapattributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_group_map_atomic_mul(self, spacename, predicates, mapattributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_map_atomic_div(VALUE self, VALUE spacename, VALUE key, VALUE mapattributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_mapattributes__status(hyperdex_client_map_atomic_div, self, spacename, key, mapattributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_mapattributes__status(hyperdex_client_map_atomic_div, self, spacename, key, mapattributes);
 }
 VALUE
 hyperdex_ruby_client_wait_map_atomic_div(VALUE self, VALUE spacename, VALUE key, VALUE mapattributes)
 {
-    VALUE deferred = hyperdex_ruby_client_map_atomic_div(self, spacename, key, mapattributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_map_atomic_div(self, spacename, key, mapattributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_cond_map_atomic_div(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE mapattributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_atomic_div, self, spacename, key, predicates, mapattributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_atomic_div, self, spacename, key, predicates, mapattributes);
 }
 VALUE
 hyperdex_ruby_client_wait_cond_map_atomic_div(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE mapattributes)
 {
-    VALUE deferred = hyperdex_ruby_client_cond_map_atomic_div(self, spacename, key, predicates, mapattributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_cond_map_atomic_div(self, spacename, key, predicates, mapattributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_group_map_atomic_div(VALUE self, VALUE spacename, VALUE predicates, VALUE mapattributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_atomic_div, self, spacename, predicates, mapattributes);
+	return hyperdex_ruby_client_asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_atomic_div, self, spacename, predicates, mapattributes);
 }
 VALUE
 hyperdex_ruby_client_wait_group_map_atomic_div(VALUE self, VALUE spacename, VALUE predicates, VALUE mapattributes)
 {
-    VALUE deferred = hyperdex_ruby_client_group_map_atomic_div(self, spacename, predicates, mapattributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_group_map_atomic_div(self, spacename, predicates, mapattributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_map_atomic_mod(VALUE self, VALUE spacename, VALUE key, VALUE mapattributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_mapattributes__status(hyperdex_client_map_atomic_mod, self, spacename, key, mapattributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_mapattributes__status(hyperdex_client_map_atomic_mod, self, spacename, key, mapattributes);
 }
 VALUE
 hyperdex_ruby_client_wait_map_atomic_mod(VALUE self, VALUE spacename, VALUE key, VALUE mapattributes)
 {
-    VALUE deferred = hyperdex_ruby_client_map_atomic_mod(self, spacename, key, mapattributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_map_atomic_mod(self, spacename, key, mapattributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_cond_map_atomic_mod(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE mapattributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_atomic_mod, self, spacename, key, predicates, mapattributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_atomic_mod, self, spacename, key, predicates, mapattributes);
 }
 VALUE
 hyperdex_ruby_client_wait_cond_map_atomic_mod(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE mapattributes)
 {
-    VALUE deferred = hyperdex_ruby_client_cond_map_atomic_mod(self, spacename, key, predicates, mapattributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_cond_map_atomic_mod(self, spacename, key, predicates, mapattributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_group_map_atomic_mod(VALUE self, VALUE spacename, VALUE predicates, VALUE mapattributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_atomic_mod, self, spacename, predicates, mapattributes);
+	return hyperdex_ruby_client_asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_atomic_mod, self, spacename, predicates, mapattributes);
 }
 VALUE
 hyperdex_ruby_client_wait_group_map_atomic_mod(VALUE self, VALUE spacename, VALUE predicates, VALUE mapattributes)
 {
-    VALUE deferred = hyperdex_ruby_client_group_map_atomic_mod(self, spacename, predicates, mapattributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_group_map_atomic_mod(self, spacename, predicates, mapattributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_map_atomic_and(VALUE self, VALUE spacename, VALUE key, VALUE mapattributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_mapattributes__status(hyperdex_client_map_atomic_and, self, spacename, key, mapattributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_mapattributes__status(hyperdex_client_map_atomic_and, self, spacename, key, mapattributes);
 }
 VALUE
 hyperdex_ruby_client_wait_map_atomic_and(VALUE self, VALUE spacename, VALUE key, VALUE mapattributes)
 {
-    VALUE deferred = hyperdex_ruby_client_map_atomic_and(self, spacename, key, mapattributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_map_atomic_and(self, spacename, key, mapattributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_cond_map_atomic_and(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE mapattributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_atomic_and, self, spacename, key, predicates, mapattributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_atomic_and, self, spacename, key, predicates, mapattributes);
 }
 VALUE
 hyperdex_ruby_client_wait_cond_map_atomic_and(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE mapattributes)
 {
-    VALUE deferred = hyperdex_ruby_client_cond_map_atomic_and(self, spacename, key, predicates, mapattributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_cond_map_atomic_and(self, spacename, key, predicates, mapattributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_group_map_atomic_and(VALUE self, VALUE spacename, VALUE predicates, VALUE mapattributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_atomic_and, self, spacename, predicates, mapattributes);
+	return hyperdex_ruby_client_asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_atomic_and, self, spacename, predicates, mapattributes);
 }
 VALUE
 hyperdex_ruby_client_wait_group_map_atomic_and(VALUE self, VALUE spacename, VALUE predicates, VALUE mapattributes)
 {
-    VALUE deferred = hyperdex_ruby_client_group_map_atomic_and(self, spacename, predicates, mapattributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_group_map_atomic_and(self, spacename, predicates, mapattributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_map_atomic_or(VALUE self, VALUE spacename, VALUE key, VALUE mapattributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_mapattributes__status(hyperdex_client_map_atomic_or, self, spacename, key, mapattributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_mapattributes__status(hyperdex_client_map_atomic_or, self, spacename, key, mapattributes);
 }
 VALUE
 hyperdex_ruby_client_wait_map_atomic_or(VALUE self, VALUE spacename, VALUE key, VALUE mapattributes)
 {
-    VALUE deferred = hyperdex_ruby_client_map_atomic_or(self, spacename, key, mapattributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_map_atomic_or(self, spacename, key, mapattributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_cond_map_atomic_or(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE mapattributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_atomic_or, self, spacename, key, predicates, mapattributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_atomic_or, self, spacename, key, predicates, mapattributes);
 }
 VALUE
 hyperdex_ruby_client_wait_cond_map_atomic_or(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE mapattributes)
 {
-    VALUE deferred = hyperdex_ruby_client_cond_map_atomic_or(self, spacename, key, predicates, mapattributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_cond_map_atomic_or(self, spacename, key, predicates, mapattributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_group_map_atomic_or(VALUE self, VALUE spacename, VALUE predicates, VALUE mapattributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_atomic_or, self, spacename, predicates, mapattributes);
+	return hyperdex_ruby_client_asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_atomic_or, self, spacename, predicates, mapattributes);
 }
 VALUE
 hyperdex_ruby_client_wait_group_map_atomic_or(VALUE self, VALUE spacename, VALUE predicates, VALUE mapattributes)
 {
-    VALUE deferred = hyperdex_ruby_client_group_map_atomic_or(self, spacename, predicates, mapattributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_group_map_atomic_or(self, spacename, predicates, mapattributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_map_atomic_xor(VALUE self, VALUE spacename, VALUE key, VALUE mapattributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_mapattributes__status(hyperdex_client_map_atomic_xor, self, spacename, key, mapattributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_mapattributes__status(hyperdex_client_map_atomic_xor, self, spacename, key, mapattributes);
 }
 VALUE
 hyperdex_ruby_client_wait_map_atomic_xor(VALUE self, VALUE spacename, VALUE key, VALUE mapattributes)
 {
-    VALUE deferred = hyperdex_ruby_client_map_atomic_xor(self, spacename, key, mapattributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_map_atomic_xor(self, spacename, key, mapattributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_cond_map_atomic_xor(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE mapattributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_atomic_xor, self, spacename, key, predicates, mapattributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_atomic_xor, self, spacename, key, predicates, mapattributes);
 }
 VALUE
 hyperdex_ruby_client_wait_cond_map_atomic_xor(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE mapattributes)
 {
-    VALUE deferred = hyperdex_ruby_client_cond_map_atomic_xor(self, spacename, key, predicates, mapattributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_cond_map_atomic_xor(self, spacename, key, predicates, mapattributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_group_map_atomic_xor(VALUE self, VALUE spacename, VALUE predicates, VALUE mapattributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_atomic_xor, self, spacename, predicates, mapattributes);
+	return hyperdex_ruby_client_asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_atomic_xor, self, spacename, predicates, mapattributes);
 }
 VALUE
 hyperdex_ruby_client_wait_group_map_atomic_xor(VALUE self, VALUE spacename, VALUE predicates, VALUE mapattributes)
 {
-    VALUE deferred = hyperdex_ruby_client_group_map_atomic_xor(self, spacename, predicates, mapattributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_group_map_atomic_xor(self, spacename, predicates, mapattributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_map_string_prepend(VALUE self, VALUE spacename, VALUE key, VALUE mapattributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_mapattributes__status(hyperdex_client_map_string_prepend, self, spacename, key, mapattributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_mapattributes__status(hyperdex_client_map_string_prepend, self, spacename, key, mapattributes);
 }
 VALUE
 hyperdex_ruby_client_wait_map_string_prepend(VALUE self, VALUE spacename, VALUE key, VALUE mapattributes)
 {
-    VALUE deferred = hyperdex_ruby_client_map_string_prepend(self, spacename, key, mapattributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_map_string_prepend(self, spacename, key, mapattributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_cond_map_string_prepend(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE mapattributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_string_prepend, self, spacename, key, predicates, mapattributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_string_prepend, self, spacename, key, predicates, mapattributes);
 }
 VALUE
 hyperdex_ruby_client_wait_cond_map_string_prepend(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE mapattributes)
 {
-    VALUE deferred = hyperdex_ruby_client_cond_map_string_prepend(self, spacename, key, predicates, mapattributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_cond_map_string_prepend(self, spacename, key, predicates, mapattributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_group_map_string_prepend(VALUE self, VALUE spacename, VALUE predicates, VALUE mapattributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_string_prepend, self, spacename, predicates, mapattributes);
+	return hyperdex_ruby_client_asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_string_prepend, self, spacename, predicates, mapattributes);
 }
 VALUE
 hyperdex_ruby_client_wait_group_map_string_prepend(VALUE self, VALUE spacename, VALUE predicates, VALUE mapattributes)
 {
-    VALUE deferred = hyperdex_ruby_client_group_map_string_prepend(self, spacename, predicates, mapattributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_group_map_string_prepend(self, spacename, predicates, mapattributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_map_string_append(VALUE self, VALUE spacename, VALUE key, VALUE mapattributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_mapattributes__status(hyperdex_client_map_string_append, self, spacename, key, mapattributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_mapattributes__status(hyperdex_client_map_string_append, self, spacename, key, mapattributes);
 }
 VALUE
 hyperdex_ruby_client_wait_map_string_append(VALUE self, VALUE spacename, VALUE key, VALUE mapattributes)
 {
-    VALUE deferred = hyperdex_ruby_client_map_string_append(self, spacename, key, mapattributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_map_string_append(self, spacename, key, mapattributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_cond_map_string_append(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE mapattributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_string_append, self, spacename, key, predicates, mapattributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_string_append, self, spacename, key, predicates, mapattributes);
 }
 VALUE
 hyperdex_ruby_client_wait_cond_map_string_append(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE mapattributes)
 {
-    VALUE deferred = hyperdex_ruby_client_cond_map_string_append(self, spacename, key, predicates, mapattributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_cond_map_string_append(self, spacename, key, predicates, mapattributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_group_map_string_append(VALUE self, VALUE spacename, VALUE predicates, VALUE mapattributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_string_append, self, spacename, predicates, mapattributes);
+	return hyperdex_ruby_client_asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_string_append, self, spacename, predicates, mapattributes);
 }
 VALUE
 hyperdex_ruby_client_wait_group_map_string_append(VALUE self, VALUE spacename, VALUE predicates, VALUE mapattributes)
 {
-    VALUE deferred = hyperdex_ruby_client_group_map_string_append(self, spacename, predicates, mapattributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_group_map_string_append(self, spacename, predicates, mapattributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_map_atomic_min(VALUE self, VALUE spacename, VALUE key, VALUE mapattributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_mapattributes__status(hyperdex_client_map_atomic_min, self, spacename, key, mapattributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_mapattributes__status(hyperdex_client_map_atomic_min, self, spacename, key, mapattributes);
 }
 VALUE
 hyperdex_ruby_client_wait_map_atomic_min(VALUE self, VALUE spacename, VALUE key, VALUE mapattributes)
 {
-    VALUE deferred = hyperdex_ruby_client_map_atomic_min(self, spacename, key, mapattributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_map_atomic_min(self, spacename, key, mapattributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_cond_map_atomic_min(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE mapattributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_atomic_min, self, spacename, key, predicates, mapattributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_atomic_min, self, spacename, key, predicates, mapattributes);
 }
 VALUE
 hyperdex_ruby_client_wait_cond_map_atomic_min(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE mapattributes)
 {
-    VALUE deferred = hyperdex_ruby_client_cond_map_atomic_min(self, spacename, key, predicates, mapattributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_cond_map_atomic_min(self, spacename, key, predicates, mapattributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_group_map_atomic_min(VALUE self, VALUE spacename, VALUE predicates, VALUE mapattributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_atomic_min, self, spacename, predicates, mapattributes);
+	return hyperdex_ruby_client_asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_atomic_min, self, spacename, predicates, mapattributes);
 }
 VALUE
 hyperdex_ruby_client_wait_group_map_atomic_min(VALUE self, VALUE spacename, VALUE predicates, VALUE mapattributes)
 {
-    VALUE deferred = hyperdex_ruby_client_group_map_atomic_min(self, spacename, predicates, mapattributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_group_map_atomic_min(self, spacename, predicates, mapattributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_map_atomic_max(VALUE self, VALUE spacename, VALUE key, VALUE mapattributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_mapattributes__status(hyperdex_client_map_atomic_max, self, spacename, key, mapattributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_mapattributes__status(hyperdex_client_map_atomic_max, self, spacename, key, mapattributes);
 }
 VALUE
 hyperdex_ruby_client_wait_map_atomic_max(VALUE self, VALUE spacename, VALUE key, VALUE mapattributes)
 {
-    VALUE deferred = hyperdex_ruby_client_map_atomic_max(self, spacename, key, mapattributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_map_atomic_max(self, spacename, key, mapattributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_cond_map_atomic_max(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE mapattributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_atomic_max, self, spacename, key, predicates, mapattributes);
+	return hyperdex_ruby_client_asynccall__spacename_key_predicates_mapattributes__status(hyperdex_client_cond_map_atomic_max, self, spacename, key, predicates, mapattributes);
 }
 VALUE
 hyperdex_ruby_client_wait_cond_map_atomic_max(VALUE self, VALUE spacename, VALUE key, VALUE predicates, VALUE mapattributes)
 {
-    VALUE deferred = hyperdex_ruby_client_cond_map_atomic_max(self, spacename, key, predicates, mapattributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_cond_map_atomic_max(self, spacename, key, predicates, mapattributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_group_map_atomic_max(VALUE self, VALUE spacename, VALUE predicates, VALUE mapattributes)
 {
-    return hyperdex_ruby_client_asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_atomic_max, self, spacename, predicates, mapattributes);
+	return hyperdex_ruby_client_asynccall__spacename_predicates_mapattributes__status_count(hyperdex_client_group_map_atomic_max, self, spacename, predicates, mapattributes);
 }
 VALUE
 hyperdex_ruby_client_wait_group_map_atomic_max(VALUE self, VALUE spacename, VALUE predicates, VALUE mapattributes)
 {
-    VALUE deferred = hyperdex_ruby_client_group_map_atomic_max(self, spacename, predicates, mapattributes);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_group_map_atomic_max(self, spacename, predicates, mapattributes);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_search(VALUE self, VALUE spacename, VALUE predicates)
 {
-    return hyperdex_ruby_client_iterator__spacename_predicates__status_attributes(hyperdex_client_search, self, spacename, predicates);
+	return hyperdex_ruby_client_iterator__spacename_predicates__status_attributes(hyperdex_client_search, self, spacename, predicates);
 }
 
 static VALUE
 hyperdex_ruby_client_search_describe(VALUE self, VALUE spacename, VALUE predicates)
 {
-    return hyperdex_ruby_client_asynccall__spacename_predicates__status_description(hyperdex_client_search_describe, self, spacename, predicates);
+	return hyperdex_ruby_client_asynccall__spacename_predicates__status_description(hyperdex_client_search_describe, self, spacename, predicates);
 }
 VALUE
 hyperdex_ruby_client_wait_search_describe(VALUE self, VALUE spacename, VALUE predicates)
 {
-    VALUE deferred = hyperdex_ruby_client_search_describe(self, spacename, predicates);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_search_describe(self, spacename, predicates);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
 
 static VALUE
 hyperdex_ruby_client_sorted_search(VALUE self, VALUE spacename, VALUE predicates, VALUE sortby, VALUE limit, VALUE maxmin)
 {
-    return hyperdex_ruby_client_iterator__spacename_predicates_sortby_limit_maxmin__status_attributes(hyperdex_client_sorted_search, self, spacename, predicates, sortby, limit, maxmin);
+	return hyperdex_ruby_client_iterator__spacename_predicates_sortby_limit_maxmin__status_attributes(hyperdex_client_sorted_search, self, spacename, predicates, sortby, limit, maxmin);
 }
 
 static VALUE
 hyperdex_ruby_client_count(VALUE self, VALUE spacename, VALUE predicates)
 {
-    return hyperdex_ruby_client_asynccall__spacename_predicates__status_count(hyperdex_client_count, self, spacename, predicates);
+	return hyperdex_ruby_client_asynccall__spacename_predicates__status_count(hyperdex_client_count, self, spacename, predicates);
 }
 VALUE
 hyperdex_ruby_client_wait_count(VALUE self, VALUE spacename, VALUE predicates)
 {
-    VALUE deferred = hyperdex_ruby_client_count(self, spacename, predicates);
-    return rb_funcall(deferred, rb_intern("wait"), 0);
+	VALUE deferred = hyperdex_ruby_client_count(self, spacename, predicates);
+	return rb_funcall(deferred, rb_intern("wait"), 0);
 }
diff --git a/bindings/ruby/hyperdex.c b/bindings/ruby/hyperdex.c
index 41fe0a90e..27ffe3054 100644
--- a/bindings/ruby/hyperdex.c
+++ b/bindings/ruby/hyperdex.c
@@ -43,12 +43,11 @@ Init_hyperdex_admin();
 HYPERDEX_API void
 Init_hyperdex()
 {
-    mod_hyperdex = rb_define_module("HyperDex");
-
+	mod_hyperdex = rb_define_module("HyperDex");
 #ifdef HYPERDEX_CLIENT
-    Init_hyperdex_client();
+	Init_hyperdex_client();
 #endif
 #ifdef HYPERDEX_ADMIN
-    Init_hyperdex_admin();
+	Init_hyperdex_admin();
 #endif
 };
diff --git a/cityhash/city.cc b/cityhash/city.cc
index d453143c6..d41245266 100644
--- a/cityhash/city.cc
+++ b/cityhash/city.cc
@@ -42,16 +42,18 @@ typedef std::pair<uint64, uint64> uint128;
 
 using namespace std;
 
-static uint64 UNALIGNED_LOAD64(const char *p) {
-  uint64 result;
-  memcpy(&result, p, sizeof(result));
-  return result;
+static uint64 UNALIGNED_LOAD64(const char *p)
+{
+	uint64 result;
+	memcpy(&result, p, sizeof(result));
+	return result;
 }
 
-static uint32 UNALIGNED_LOAD32(const char *p) {
-  uint32 result;
-  memcpy(&result, p, sizeof(result));
-  return result;
+static uint32 UNALIGNED_LOAD32(const char *p)
+{
+	uint32 result;
+	memcpy(&result, p, sizeof(result));
+	return result;
 }
 
 #ifdef _MSC_VER
@@ -104,12 +106,14 @@ static uint32 UNALIGNED_LOAD32(const char *p) {
 #endif
 #endif
 
-static uint64 Fetch64(const char *p) {
-  return uint64_in_expected_order(UNALIGNED_LOAD64(p));
+static uint64 Fetch64(const char *p)
+{
+	return uint64_in_expected_order(UNALIGNED_LOAD64(p));
 }
 
-static uint32 Fetch32(const char *p) {
-  return uint32_in_expected_order(UNALIGNED_LOAD32(p));
+static uint32 Fetch32(const char *p)
+{
+	return uint32_in_expected_order(UNALIGNED_LOAD32(p));
 }
 
 // Some primes between 2^63 and 2^64 for various uses.
@@ -124,387 +128,426 @@ static const uint32_t c2 = 0x1b873593;
 // A 32-bit to 32-bit integer hash copied from Murmur3.
 static uint32 fmix(uint32 h)
 {
-  h ^= h >> 16;
-  h *= 0x85ebca6b;
-  h ^= h >> 13;
-  h *= 0xc2b2ae35;
-  h ^= h >> 16;
-  return h;
+	h ^= h >> 16;
+	h *= 0x85ebca6b;
+	h ^= h >> 13;
+	h *= 0xc2b2ae35;
+	h ^= h >> 16;
+	return h;
 }
 
-static uint32 Rotate32(uint32 val, int shift) {
-  // Avoid shifting by 32: doing so yields an undefined result.
-  return shift == 0 ? val : ((val >> shift) | (val << (32 - shift)));
+static uint32 Rotate32(uint32 val, int shift)
+{
+	// Avoid shifting by 32: doing so yields an undefined result.
+	return shift == 0 ? val : ((val >> shift) | (val << (32 - shift)));
 }
 
 #undef PERMUTE3
 #define PERMUTE3(a, b, c) do { std::swap(a, b); std::swap(a, c); } while (0)
 
-static uint32 Mur(uint32 a, uint32 h) {
-  // Helper from Murmur3 for combining two 32-bit values.
-  a *= c1;
-  a = Rotate32(a, 17);
-  a *= c2;
-  h ^= a;
-  h = Rotate32(h, 19);
-  return h * 5 + 0xe6546b64;
+static uint32 Mur(uint32 a, uint32 h)
+{
+	// Helper from Murmur3 for combining two 32-bit values.
+	a *= c1;
+	a = Rotate32(a, 17);
+	a *= c2;
+	h ^= a;
+	h = Rotate32(h, 19);
+	return h * 5 + 0xe6546b64;
 }
 
-static uint32 Hash32Len13to24(const char *s, size_t len) {
-  uint32 a = Fetch32(s - 4 + (len >> 1));
-  uint32 b = Fetch32(s + 4);
-  uint32 c = Fetch32(s + len - 8);
-  uint32 d = Fetch32(s + (len >> 1));
-  uint32 e = Fetch32(s);
-  uint32 f = Fetch32(s + len - 4);
-  uint32 h = len;
-
-  return fmix(Mur(f, Mur(e, Mur(d, Mur(c, Mur(b, Mur(a, h)))))));
+static uint32 Hash32Len13to24(const char *s, size_t len)
+{
+	uint32 a = Fetch32(s - 4 + (len >> 1));
+	uint32 b = Fetch32(s + 4);
+	uint32 c = Fetch32(s + len - 8);
+	uint32 d = Fetch32(s + (len >> 1));
+	uint32 e = Fetch32(s);
+	uint32 f = Fetch32(s + len - 4);
+	uint32 h = len;
+	return fmix(Mur(f, Mur(e, Mur(d, Mur(c, Mur(b, Mur(a, h)))))));
 }
 
-static uint32 Hash32Len0to4(const char *s, size_t len) {
-  uint32 b = 0;
-  uint32 c = 9;
-  for (size_t i = 0; i < len; i++) {
-    signed char v = s[i];
-    b = b * c1 + v;
-    c ^= b;
-  }
-  return fmix(Mur(b, Mur(len, c)));
+static uint32 Hash32Len0to4(const char *s, size_t len)
+{
+	uint32 b = 0;
+	uint32 c = 9;
+	for (size_t i = 0; i < len; i++)
+	{
+		signed char v = s[i];
+		b = b * c1 + v;
+		c ^= b;
+	}
+	return fmix(Mur(b, Mur(len, c)));
 }
 
-static uint32 Hash32Len5to12(const char *s, size_t len) {
-  uint32 a = len, b = len * 5, c = 9, d = b;
-  a += Fetch32(s);
-  b += Fetch32(s + len - 4);
-  c += Fetch32(s + ((len >> 1) & 4));
-  return fmix(Mur(c, Mur(b, Mur(a, d))));
+static uint32 Hash32Len5to12(const char *s, size_t len)
+{
+	uint32 a = len, b = len * 5, c = 9, d = b;
+	a += Fetch32(s);
+	b += Fetch32(s + len - 4);
+	c += Fetch32(s + ((len >> 1) & 4));
+	return fmix(Mur(c, Mur(b, Mur(a, d))));
 }
 
-uint32 CityHash32(const char *s, size_t len) {
-  if (len <= 24) {
-    return len <= 12 ?
-        (len <= 4 ? Hash32Len0to4(s, len) : Hash32Len5to12(s, len)) :
-        Hash32Len13to24(s, len);
-  }
-
-  // len > 24
-  uint32 h = len, g = c1 * len, f = g;
-  uint32 a0 = Rotate32(Fetch32(s + len - 4) * c1, 17) * c2;
-  uint32 a1 = Rotate32(Fetch32(s + len - 8) * c1, 17) * c2;
-  uint32 a2 = Rotate32(Fetch32(s + len - 16) * c1, 17) * c2;
-  uint32 a3 = Rotate32(Fetch32(s + len - 12) * c1, 17) * c2;
-  uint32 a4 = Rotate32(Fetch32(s + len - 20) * c1, 17) * c2;
-  h ^= a0;
-  h = Rotate32(h, 19);
-  h = h * 5 + 0xe6546b64;
-  h ^= a2;
-  h = Rotate32(h, 19);
-  h = h * 5 + 0xe6546b64;
-  g ^= a1;
-  g = Rotate32(g, 19);
-  g = g * 5 + 0xe6546b64;
-  g ^= a3;
-  g = Rotate32(g, 19);
-  g = g * 5 + 0xe6546b64;
-  f += a4;
-  f = Rotate32(f, 19);
-  f = f * 5 + 0xe6546b64;
-  size_t iters = (len - 1) / 20;
-  do {
-    uint32 b0 = Rotate32(Fetch32(s) * c1, 17) * c2;
-    uint32 b1 = Fetch32(s + 4);
-    uint32 b2 = Rotate32(Fetch32(s + 8) * c1, 17) * c2;
-    uint32 b3 = Rotate32(Fetch32(s + 12) * c1, 17) * c2;
-    uint32 b4 = Fetch32(s + 16);
-    h ^= b0;
-    h = Rotate32(h, 18);
-    h = h * 5 + 0xe6546b64;
-    f += b1;
-    f = Rotate32(f, 19);
-    f = f * c1;
-    g += b2;
-    g = Rotate32(g, 18);
-    g = g * 5 + 0xe6546b64;
-    h ^= b3 + b1;
-    h = Rotate32(h, 19);
-    h = h * 5 + 0xe6546b64;
-    g ^= b4;
-    g = bswap_32(g) * 5;
-    h += b4 * 5;
-    h = bswap_32(h);
-    f += b0;
-    PERMUTE3(f, h, g);
-    s += 20;
-  } while (--iters != 0);
-  g = Rotate32(g, 11) * c1;
-  g = Rotate32(g, 17) * c1;
-  f = Rotate32(f, 11) * c1;
-  f = Rotate32(f, 17) * c1;
-  h = Rotate32(h + g, 19);
-  h = h * 5 + 0xe6546b64;
-  h = Rotate32(h, 17) * c1;
-  h = Rotate32(h + f, 19);
-  h = h * 5 + 0xe6546b64;
-  h = Rotate32(h, 17) * c1;
-  return h;
+uint32 CityHash32(const char *s, size_t len)
+{
+	if (len <= 24)
+	{
+		return len <= 12 ?
+		       (len <= 4 ? Hash32Len0to4(s, len) : Hash32Len5to12(s, len)) :
+		       Hash32Len13to24(s, len);
+	}
+	// len > 24
+	uint32 h = len, g = c1 * len, f = g;
+	uint32 a0 = Rotate32(Fetch32(s + len - 4) * c1, 17) * c2;
+	uint32 a1 = Rotate32(Fetch32(s + len - 8) * c1, 17) * c2;
+	uint32 a2 = Rotate32(Fetch32(s + len - 16) * c1, 17) * c2;
+	uint32 a3 = Rotate32(Fetch32(s + len - 12) * c1, 17) * c2;
+	uint32 a4 = Rotate32(Fetch32(s + len - 20) * c1, 17) * c2;
+	h ^= a0;
+	h = Rotate32(h, 19);
+	h = h * 5 + 0xe6546b64;
+	h ^= a2;
+	h = Rotate32(h, 19);
+	h = h * 5 + 0xe6546b64;
+	g ^= a1;
+	g = Rotate32(g, 19);
+	g = g * 5 + 0xe6546b64;
+	g ^= a3;
+	g = Rotate32(g, 19);
+	g = g * 5 + 0xe6546b64;
+	f += a4;
+	f = Rotate32(f, 19);
+	f = f * 5 + 0xe6546b64;
+	size_t iters = (len - 1) / 20;
+	do
+	{
+		uint32 b0 = Rotate32(Fetch32(s) * c1, 17) * c2;
+		uint32 b1 = Fetch32(s + 4);
+		uint32 b2 = Rotate32(Fetch32(s + 8) * c1, 17) * c2;
+		uint32 b3 = Rotate32(Fetch32(s + 12) * c1, 17) * c2;
+		uint32 b4 = Fetch32(s + 16);
+		h ^= b0;
+		h = Rotate32(h, 18);
+		h = h * 5 + 0xe6546b64;
+		f += b1;
+		f = Rotate32(f, 19);
+		f = f * c1;
+		g += b2;
+		g = Rotate32(g, 18);
+		g = g * 5 + 0xe6546b64;
+		h ^= b3 + b1;
+		h = Rotate32(h, 19);
+		h = h * 5 + 0xe6546b64;
+		g ^= b4;
+		g = bswap_32(g) * 5;
+		h += b4 * 5;
+		h = bswap_32(h);
+		f += b0;
+		PERMUTE3(f, h, g);
+		s += 20;
+	}
+	while (--iters != 0);
+	g = Rotate32(g, 11) * c1;
+	g = Rotate32(g, 17) * c1;
+	f = Rotate32(f, 11) * c1;
+	f = Rotate32(f, 17) * c1;
+	h = Rotate32(h + g, 19);
+	h = h * 5 + 0xe6546b64;
+	h = Rotate32(h, 17) * c1;
+	h = Rotate32(h + f, 19);
+	h = h * 5 + 0xe6546b64;
+	h = Rotate32(h, 17) * c1;
+	return h;
 }
 
 // Bitwise right rotate.  Normally this will compile to a single
 // instruction, especially if the shift is a manifest constant.
-static uint64 Rotate(uint64 val, int shift) {
-  // Avoid shifting by 64: doing so yields an undefined result.
-  return shift == 0 ? val : ((val >> shift) | (val << (64 - shift)));
+static uint64 Rotate(uint64 val, int shift)
+{
+	// Avoid shifting by 64: doing so yields an undefined result.
+	return shift == 0 ? val : ((val >> shift) | (val << (64 - shift)));
 }
 
-static uint64 ShiftMix(uint64 val) {
-  return val ^ (val >> 47);
+static uint64 ShiftMix(uint64 val)
+{
+	return val ^ (val >> 47);
 }
 
-static uint64 HashLen16(uint64 u, uint64 v) {
-  return Hash128to64(uint128(u, v));
+static uint64 HashLen16(uint64 u, uint64 v)
+{
+	return Hash128to64(uint128(u, v));
 }
 
-static uint64 HashLen16(uint64 u, uint64 v, uint64 mul) {
-  // Murmur-inspired hashing.
-  uint64 a = (u ^ v) * mul;
-  a ^= (a >> 47);
-  uint64 b = (v ^ a) * mul;
-  b ^= (b >> 47);
-  b *= mul;
-  return b;
+static uint64 HashLen16(uint64 u, uint64 v, uint64 mul)
+{
+	// Murmur-inspired hashing.
+	uint64 a = (u ^ v) * mul;
+	a ^= (a >> 47);
+	uint64 b = (v ^ a) * mul;
+	b ^= (b >> 47);
+	b *= mul;
+	return b;
 }
 
-static uint64 HashLen0to16(const char *s, size_t len) {
-  if (len >= 8) {
-    uint64 mul = k2 + len * 2;
-    uint64 a = Fetch64(s) + k2;
-    uint64 b = Fetch64(s + len - 8);
-    uint64 c = Rotate(b, 37) * mul + a;
-    uint64 d = (Rotate(a, 25) + b) * mul;
-    return HashLen16(c, d, mul);
-  }
-  if (len >= 4) {
-    uint64 mul = k2 + len * 2;
-    uint64 a = Fetch32(s);
-    return HashLen16(len + (a << 3), Fetch32(s + len - 4), mul);
-  }
-  if (len > 0) {
-    uint8 a = s[0];
-    uint8 b = s[len >> 1];
-    uint8 c = s[len - 1];
-    uint32 y = static_cast<uint32>(a) + (static_cast<uint32>(b) << 8);
-    uint32 z = len + (static_cast<uint32>(c) << 2);
-    return ShiftMix(y * k2 ^ z * k0) * k2;
-  }
-  return k2;
+static uint64 HashLen0to16(const char *s, size_t len)
+{
+	if (len >= 8)
+	{
+		uint64 mul = k2 + len * 2;
+		uint64 a = Fetch64(s) + k2;
+		uint64 b = Fetch64(s + len - 8);
+		uint64 c = Rotate(b, 37) * mul + a;
+		uint64 d = (Rotate(a, 25) + b) * mul;
+		return HashLen16(c, d, mul);
+	}
+	if (len >= 4)
+	{
+		uint64 mul = k2 + len * 2;
+		uint64 a = Fetch32(s);
+		return HashLen16(len + (a << 3), Fetch32(s + len - 4), mul);
+	}
+	if (len > 0)
+	{
+		uint8 a = s[0];
+		uint8 b = s[len >> 1];
+		uint8 c = s[len - 1];
+		uint32 y = static_cast<uint32>(a) + (static_cast<uint32>(b) << 8);
+		uint32 z = len + (static_cast<uint32>(c) << 2);
+		return ShiftMix(y * k2 ^ z * k0) * k2;
+	}
+	return k2;
 }
 
 // This probably works well for 16-byte strings as well, but it may be overkill
 // in that case.
-static uint64 HashLen17to32(const char *s, size_t len) {
-  uint64 mul = k2 + len * 2;
-  uint64 a = Fetch64(s) * k1;
-  uint64 b = Fetch64(s + 8);
-  uint64 c = Fetch64(s + len - 8) * mul;
-  uint64 d = Fetch64(s + len - 16) * k2;
-  return HashLen16(Rotate(a + b, 43) + Rotate(c, 30) + d,
-                   a + Rotate(b + k2, 18) + c, mul);
+static uint64 HashLen17to32(const char *s, size_t len)
+{
+	uint64 mul = k2 + len * 2;
+	uint64 a = Fetch64(s) * k1;
+	uint64 b = Fetch64(s + 8);
+	uint64 c = Fetch64(s + len - 8) * mul;
+	uint64 d = Fetch64(s + len - 16) * k2;
+	return HashLen16(Rotate(a + b, 43) + Rotate(c, 30) + d,
+	                 a + Rotate(b + k2, 18) + c, mul);
 }
 
 // Return a 16-byte hash for 48 bytes.  Quick and dirty.
 // Callers do best to use "random-looking" values for a and b.
 static pair<uint64, uint64> WeakHashLen32WithSeeds(
-    uint64 w, uint64 x, uint64 y, uint64 z, uint64 a, uint64 b) {
-  a += w;
-  b = Rotate(b + a + z, 21);
-  uint64 c = a;
-  a += x;
-  a += y;
-  b += Rotate(a, 44);
-  return make_pair(a + z, b + c);
+    uint64 w, uint64 x, uint64 y, uint64 z, uint64 a, uint64 b)
+{
+	a += w;
+	b = Rotate(b + a + z, 21);
+	uint64 c = a;
+	a += x;
+	a += y;
+	b += Rotate(a, 44);
+	return make_pair(a + z, b + c);
 }
 
 // Return a 16-byte hash for s[0] ... s[31], a, and b.  Quick and dirty.
 static pair<uint64, uint64> WeakHashLen32WithSeeds(
-    const char* s, uint64 a, uint64 b) {
-  return WeakHashLen32WithSeeds(Fetch64(s),
-                                Fetch64(s + 8),
-                                Fetch64(s + 16),
-                                Fetch64(s + 24),
-                                a,
-                                b);
+    const char *s, uint64 a, uint64 b)
+{
+	return WeakHashLen32WithSeeds(Fetch64(s),
+	                              Fetch64(s + 8),
+	                              Fetch64(s + 16),
+	                              Fetch64(s + 24),
+	                              a,
+	                              b);
 }
 
 // Return an 8-byte hash for 33 to 64 bytes.
-static uint64 HashLen33to64(const char *s, size_t len) {
-  uint64 mul = k2 + len * 2;
-  uint64 a = Fetch64(s) * k2;
-  uint64 b = Fetch64(s + 8);
-  uint64 c = Fetch64(s + len - 24);
-  uint64 d = Fetch64(s + len - 32);
-  uint64 e = Fetch64(s + 16) * k2;
-  uint64 f = Fetch64(s + 24) * 9;
-  uint64 g = Fetch64(s + len - 8);
-  uint64 h = Fetch64(s + len - 16) * mul;
-  uint64 u = Rotate(a + g, 43) + (Rotate(b, 30) + c) * 9;
-  uint64 v = ((a + g) ^ d) + f + 1;
-  uint64 w = bswap_64((u + v) * mul) + h;
-  uint64 x = Rotate(e + f, 42) + c;
-  uint64 y = (bswap_64((v + w) * mul) + g) * mul;
-  uint64 z = e + f + c;
-  a = bswap_64((x + z) * mul + y) + b;
-  b = ShiftMix((z + a) * mul + d + h) * mul;
-  return b + x;
+static uint64 HashLen33to64(const char *s, size_t len)
+{
+	uint64 mul = k2 + len * 2;
+	uint64 a = Fetch64(s) * k2;
+	uint64 b = Fetch64(s + 8);
+	uint64 c = Fetch64(s + len - 24);
+	uint64 d = Fetch64(s + len - 32);
+	uint64 e = Fetch64(s + 16) * k2;
+	uint64 f = Fetch64(s + 24) * 9;
+	uint64 g = Fetch64(s + len - 8);
+	uint64 h = Fetch64(s + len - 16) * mul;
+	uint64 u = Rotate(a + g, 43) + (Rotate(b, 30) + c) * 9;
+	uint64 v = ((a + g) ^ d) + f + 1;
+	uint64 w = bswap_64((u + v) * mul) + h;
+	uint64 x = Rotate(e + f, 42) + c;
+	uint64 y = (bswap_64((v + w) * mul) + g) * mul;
+	uint64 z = e + f + c;
+	a = bswap_64((x + z) * mul + y) + b;
+	b = ShiftMix((z + a) * mul + d + h) * mul;
+	return b + x;
 }
 
-uint64 CityHash64(const char *s, size_t len) {
-  if (len <= 32) {
-    if (len <= 16) {
-      return HashLen0to16(s, len);
-    } else {
-      return HashLen17to32(s, len);
-    }
-  } else if (len <= 64) {
-    return HashLen33to64(s, len);
-  }
-
-  // For strings over 64 bytes we hash the end first, and then as we
-  // loop we keep 56 bytes of state: v, w, x, y, and z.
-  uint64 x = Fetch64(s + len - 40);
-  uint64 y = Fetch64(s + len - 16) + Fetch64(s + len - 56);
-  uint64 z = HashLen16(Fetch64(s + len - 48) + len, Fetch64(s + len - 24));
-  pair<uint64, uint64> v = WeakHashLen32WithSeeds(s + len - 64, len, z);
-  pair<uint64, uint64> w = WeakHashLen32WithSeeds(s + len - 32, y + k1, x);
-  x = x * k1 + Fetch64(s);
-
-  // Decrease len to the nearest multiple of 64, and operate on 64-byte chunks.
-  len = (len - 1) & ~static_cast<size_t>(63);
-  do {
-    x = Rotate(x + y + v.first + Fetch64(s + 8), 37) * k1;
-    y = Rotate(y + v.second + Fetch64(s + 48), 42) * k1;
-    x ^= w.second;
-    y += v.first + Fetch64(s + 40);
-    z = Rotate(z + w.first, 33) * k1;
-    v = WeakHashLen32WithSeeds(s, v.second * k1, x + w.first);
-    w = WeakHashLen32WithSeeds(s + 32, z + w.second, y + Fetch64(s + 16));
-    std::swap(z, x);
-    s += 64;
-    len -= 64;
-  } while (len != 0);
-  return HashLen16(HashLen16(v.first, w.first) + ShiftMix(y) * k1 + z,
-                   HashLen16(v.second, w.second) + x);
+uint64 CityHash64(const char *s, size_t len)
+{
+	if (len <= 32)
+	{
+		if (len <= 16)
+		{
+			return HashLen0to16(s, len);
+		}
+		else
+		{
+			return HashLen17to32(s, len);
+		}
+	}
+	else if (len <= 64)
+	{
+		return HashLen33to64(s, len);
+	}
+	// For strings over 64 bytes we hash the end first, and then as we
+	// loop we keep 56 bytes of state: v, w, x, y, and z.
+	uint64 x = Fetch64(s + len - 40);
+	uint64 y = Fetch64(s + len - 16) + Fetch64(s + len - 56);
+	uint64 z = HashLen16(Fetch64(s + len - 48) + len, Fetch64(s + len - 24));
+	pair<uint64, uint64> v = WeakHashLen32WithSeeds(s + len - 64, len, z);
+	pair<uint64, uint64> w = WeakHashLen32WithSeeds(s + len - 32, y + k1, x);
+	x = x * k1 + Fetch64(s);
+	// Decrease len to the nearest multiple of 64, and operate on 64-byte chunks.
+	len = (len - 1) & ~static_cast<size_t>(63);
+	do
+	{
+		x = Rotate(x + y + v.first + Fetch64(s + 8), 37) * k1;
+		y = Rotate(y + v.second + Fetch64(s + 48), 42) * k1;
+		x ^= w.second;
+		y += v.first + Fetch64(s + 40);
+		z = Rotate(z + w.first, 33) * k1;
+		v = WeakHashLen32WithSeeds(s, v.second * k1, x + w.first);
+		w = WeakHashLen32WithSeeds(s + 32, z + w.second, y + Fetch64(s + 16));
+		std::swap(z, x);
+		s += 64;
+		len -= 64;
+	}
+	while (len != 0);
+	return HashLen16(HashLen16(v.first, w.first) + ShiftMix(y) * k1 + z,
+	                 HashLen16(v.second, w.second) + x);
 }
 
-uint64 CityHash64WithSeed(const char *s, size_t len, uint64 seed) {
-  return CityHash64WithSeeds(s, len, k2, seed);
+uint64 CityHash64WithSeed(const char *s, size_t len, uint64 seed)
+{
+	return CityHash64WithSeeds(s, len, k2, seed);
 }
 
 uint64 CityHash64WithSeeds(const char *s, size_t len,
-                           uint64 seed0, uint64 seed1) {
-  return HashLen16(CityHash64(s, len) - seed0, seed1);
+                           uint64 seed0, uint64 seed1)
+{
+	return HashLen16(CityHash64(s, len) - seed0, seed1);
 }
 
 // A subroutine for CityHash128().  Returns a decent 128-bit hash for strings
 // of any length representable in signed long.  Based on City and Murmur.
-static uint128 CityMurmur(const char *s, size_t len, uint128 seed) {
-  uint64 a = Uint128Low64(seed);
-  uint64 b = Uint128High64(seed);
-  uint64 c = 0;
-  uint64 d = 0;
-  signed long l = len - 16;
-  if (l <= 0) {  // len <= 16
-    a = ShiftMix(a * k1) * k1;
-    c = b * k1 + HashLen0to16(s, len);
-    d = ShiftMix(a + (len >= 8 ? Fetch64(s) : c));
-  } else {  // len > 16
-    c = HashLen16(Fetch64(s + len - 8) + k1, a);
-    d = HashLen16(b + len, c + Fetch64(s + len - 16));
-    a += d;
-    do {
-      a ^= ShiftMix(Fetch64(s) * k1) * k1;
-      a *= k1;
-      b ^= a;
-      c ^= ShiftMix(Fetch64(s + 8) * k1) * k1;
-      c *= k1;
-      d ^= c;
-      s += 16;
-      l -= 16;
-    } while (l > 0);
-  }
-  a = HashLen16(a, c);
-  b = HashLen16(d, b);
-  return uint128(a ^ b, HashLen16(b, a));
+static uint128 CityMurmur(const char *s, size_t len, uint128 seed)
+{
+	uint64 a = Uint128Low64(seed);
+	uint64 b = Uint128High64(seed);
+	uint64 c = 0;
+	uint64 d = 0;
+	signed long l = len - 16;
+	if (l <= 0)    // len <= 16
+	{
+		a = ShiftMix(a * k1) * k1;
+		c = b * k1 + HashLen0to16(s, len);
+		d = ShiftMix(a + (len >= 8 ? Fetch64(s) : c));
+	}
+	else      // len > 16
+	{
+		c = HashLen16(Fetch64(s + len - 8) + k1, a);
+		d = HashLen16(b + len, c + Fetch64(s + len - 16));
+		a += d;
+		do
+		{
+			a ^= ShiftMix(Fetch64(s) * k1) * k1;
+			a *= k1;
+			b ^= a;
+			c ^= ShiftMix(Fetch64(s + 8) * k1) * k1;
+			c *= k1;
+			d ^= c;
+			s += 16;
+			l -= 16;
+		}
+		while (l > 0);
+	}
+	a = HashLen16(a, c);
+	b = HashLen16(d, b);
+	return uint128(a ^ b, HashLen16(b, a));
 }
 
-uint128 CityHash128WithSeed(const char *s, size_t len, uint128 seed) {
-  if (len < 128) {
-    return CityMurmur(s, len, seed);
-  }
-
-  // We expect len >= 128 to be the common case.  Keep 56 bytes of state:
-  // v, w, x, y, and z.
-  pair<uint64, uint64> v, w;
-  uint64 x = Uint128Low64(seed);
-  uint64 y = Uint128High64(seed);
-  uint64 z = len * k1;
-  v.first = Rotate(y ^ k1, 49) * k1 + Fetch64(s);
-  v.second = Rotate(v.first, 42) * k1 + Fetch64(s + 8);
-  w.first = Rotate(y + z, 35) * k1 + x;
-  w.second = Rotate(x + Fetch64(s + 88), 53) * k1;
-
-  // This is the same inner loop as CityHash64(), manually unrolled.
-  do {
-    x = Rotate(x + y + v.first + Fetch64(s + 8), 37) * k1;
-    y = Rotate(y + v.second + Fetch64(s + 48), 42) * k1;
-    x ^= w.second;
-    y += v.first + Fetch64(s + 40);
-    z = Rotate(z + w.first, 33) * k1;
-    v = WeakHashLen32WithSeeds(s, v.second * k1, x + w.first);
-    w = WeakHashLen32WithSeeds(s + 32, z + w.second, y + Fetch64(s + 16));
-    std::swap(z, x);
-    s += 64;
-    x = Rotate(x + y + v.first + Fetch64(s + 8), 37) * k1;
-    y = Rotate(y + v.second + Fetch64(s + 48), 42) * k1;
-    x ^= w.second;
-    y += v.first + Fetch64(s + 40);
-    z = Rotate(z + w.first, 33) * k1;
-    v = WeakHashLen32WithSeeds(s, v.second * k1, x + w.first);
-    w = WeakHashLen32WithSeeds(s + 32, z + w.second, y + Fetch64(s + 16));
-    std::swap(z, x);
-    s += 64;
-    len -= 128;
-  } while (LIKELY(len >= 128));
-  x += Rotate(v.first + z, 49) * k0;
-  y = y * k0 + Rotate(w.second, 37);
-  z = z * k0 + Rotate(w.first, 27);
-  w.first *= 9;
-  v.first *= k0;
-  // If 0 < len < 128, hash up to 4 chunks of 32 bytes each from the end of s.
-  for (size_t tail_done = 0; tail_done < len; ) {
-    tail_done += 32;
-    y = Rotate(x + y, 42) * k0 + v.second;
-    w.first += Fetch64(s + len - tail_done + 16);
-    x = x * k0 + w.first;
-    z += w.second + Fetch64(s + len - tail_done);
-    w.second += v.first;
-    v = WeakHashLen32WithSeeds(s + len - tail_done, v.first + z, v.second);
-    v.first *= k0;
-  }
-  // At this point our 56 bytes of state should contain more than
-  // enough information for a strong 128-bit hash.  We use two
-  // different 56-byte-to-8-byte hashes to get a 16-byte final result.
-  x = HashLen16(x, v.first);
-  y = HashLen16(y + z, w.first);
-  return uint128(HashLen16(x + v.second, w.second) + y,
-                 HashLen16(x + w.second, y + v.second));
+uint128 CityHash128WithSeed(const char *s, size_t len, uint128 seed)
+{
+	if (len < 128)
+	{
+		return CityMurmur(s, len, seed);
+	}
+	// We expect len >= 128 to be the common case.  Keep 56 bytes of state:
+	// v, w, x, y, and z.
+	pair<uint64, uint64> v, w;
+	uint64 x = Uint128Low64(seed);
+	uint64 y = Uint128High64(seed);
+	uint64 z = len * k1;
+	v.first = Rotate(y ^ k1, 49) * k1 + Fetch64(s);
+	v.second = Rotate(v.first, 42) * k1 + Fetch64(s + 8);
+	w.first = Rotate(y + z, 35) * k1 + x;
+	w.second = Rotate(x + Fetch64(s + 88), 53) * k1;
+	// This is the same inner loop as CityHash64(), manually unrolled.
+	do
+	{
+		x = Rotate(x + y + v.first + Fetch64(s + 8), 37) * k1;
+		y = Rotate(y + v.second + Fetch64(s + 48), 42) * k1;
+		x ^= w.second;
+		y += v.first + Fetch64(s + 40);
+		z = Rotate(z + w.first, 33) * k1;
+		v = WeakHashLen32WithSeeds(s, v.second * k1, x + w.first);
+		w = WeakHashLen32WithSeeds(s + 32, z + w.second, y + Fetch64(s + 16));
+		std::swap(z, x);
+		s += 64;
+		x = Rotate(x + y + v.first + Fetch64(s + 8), 37) * k1;
+		y = Rotate(y + v.second + Fetch64(s + 48), 42) * k1;
+		x ^= w.second;
+		y += v.first + Fetch64(s + 40);
+		z = Rotate(z + w.first, 33) * k1;
+		v = WeakHashLen32WithSeeds(s, v.second * k1, x + w.first);
+		w = WeakHashLen32WithSeeds(s + 32, z + w.second, y + Fetch64(s + 16));
+		std::swap(z, x);
+		s += 64;
+		len -= 128;
+	}
+	while (LIKELY(len >= 128));
+	x += Rotate(v.first + z, 49) * k0;
+	y = y * k0 + Rotate(w.second, 37);
+	z = z * k0 + Rotate(w.first, 27);
+	w.first *= 9;
+	v.first *= k0;
+	// If 0 < len < 128, hash up to 4 chunks of 32 bytes each from the end of s.
+	for (size_t tail_done = 0; tail_done < len; )
+	{
+		tail_done += 32;
+		y = Rotate(x + y, 42) * k0 + v.second;
+		w.first += Fetch64(s + len - tail_done + 16);
+		x = x * k0 + w.first;
+		z += w.second + Fetch64(s + len - tail_done);
+		w.second += v.first;
+		v = WeakHashLen32WithSeeds(s + len - tail_done, v.first + z, v.second);
+		v.first *= k0;
+	}
+	// At this point our 56 bytes of state should contain more than
+	// enough information for a strong 128-bit hash.  We use two
+	// different 56-byte-to-8-byte hashes to get a 16-byte final result.
+	x = HashLen16(x, v.first);
+	y = HashLen16(y + z, w.first);
+	return uint128(HashLen16(x + v.second, w.second) + y,
+	               HashLen16(x + w.second, y + v.second));
 }
 
-uint128 CityHash128(const char *s, size_t len) {
-  return len >= 16 ?
-      CityHash128WithSeed(s + 16, len - 16,
-                          uint128(Fetch64(s), Fetch64(s + 8) + k0)) :
-      CityHash128WithSeed(s, len, uint128(k0, k1));
+uint128 CityHash128(const char *s, size_t len)
+{
+	return len >= 16 ?
+	       CityHash128WithSeed(s + 16, len - 16,
+	                           uint128(Fetch64(s), Fetch64(s + 8) + k0)) :
+	       CityHash128WithSeed(s, len, uint128(k0, k1));
 }
 
 #ifdef __SSE4_2__
@@ -513,129 +556,150 @@ uint128 CityHash128(const char *s, size_t len) {
 
 // Requires len >= 240.
 static void CityHashCrc256Long(const char *s, size_t len,
-                               uint32 seed, uint64 *result) {
-  uint64 a = Fetch64(s + 56) + k0;
-  uint64 b = Fetch64(s + 96) + k0;
-  uint64 c = result[0] = HashLen16(b, len);
-  uint64 d = result[1] = Fetch64(s + 120) * k0 + len;
-  uint64 e = Fetch64(s + 184) + seed;
-  uint64 f = 0;
-  uint64 g = 0;
-  uint64 h = c + d;
-  uint64 x = seed;
-  uint64 y = 0;
-  uint64 z = 0;
-
-  // 240 bytes of input per iter.
-  size_t iters = len / 240;
-  len -= iters * 240;
-  do {
+                               uint32 seed, uint64 *result)
+{
+	uint64 a = Fetch64(s + 56) + k0;
+	uint64 b = Fetch64(s + 96) + k0;
+	uint64 c = result[0] = HashLen16(b, len);
+	uint64 d = result[1] = Fetch64(s + 120) * k0 + len;
+	uint64 e = Fetch64(s + 184) + seed;
+	uint64 f = 0;
+	uint64 g = 0;
+	uint64 h = c + d;
+	uint64 x = seed;
+	uint64 y = 0;
+	uint64 z = 0;
+	// 240 bytes of input per iter.
+	size_t iters = len / 240;
+	len -= iters * 240;
+	do
+	{
 #undef CHUNK
 #define CHUNK(r)                                \
-    PERMUTE3(x, z, y);                          \
-    b += Fetch64(s);                            \
-    c += Fetch64(s + 8);                        \
-    d += Fetch64(s + 16);                       \
-    e += Fetch64(s + 24);                       \
-    f += Fetch64(s + 32);                       \
-    a += b;                                     \
-    h += f;                                     \
-    b += c;                                     \
-    f += d;                                     \
-    g += e;                                     \
-    e += z;                                     \
-    g += x;                                     \
-    z = _mm_crc32_u64(z, b + g);                \
-    y = _mm_crc32_u64(y, e + h);                \
-    x = _mm_crc32_u64(x, f + a);                \
-    e = Rotate(e, r);                           \
-    c += e;                                     \
-    s += 40
-
-    CHUNK(0); PERMUTE3(a, h, c);
-    CHUNK(33); PERMUTE3(a, h, f);
-    CHUNK(0); PERMUTE3(b, h, f);
-    CHUNK(42); PERMUTE3(b, h, d);
-    CHUNK(0); PERMUTE3(b, h, e);
-    CHUNK(33); PERMUTE3(a, h, e);
-  } while (--iters > 0);
-
-  while (len >= 40) {
-    CHUNK(29);
-    e ^= Rotate(a, 20);
-    h += Rotate(b, 30);
-    g ^= Rotate(c, 40);
-    f += Rotate(d, 34);
-    PERMUTE3(c, h, g);
-    len -= 40;
-  }
-  if (len > 0) {
-    s = s + len - 40;
-    CHUNK(33);
-    e ^= Rotate(a, 43);
-    h += Rotate(b, 42);
-    g ^= Rotate(c, 41);
-    f += Rotate(d, 40);
-  }
-  result[0] ^= h;
-  result[1] ^= g;
-  g += h;
-  a = HashLen16(a, g + z);
-  x += y << 32;
-  b += x;
-  c = HashLen16(c, z) + h;
-  d = HashLen16(d, e + result[0]);
-  g += e;
-  h += HashLen16(x, f);
-  e = HashLen16(a, d) + g;
-  z = HashLen16(b, c) + a;
-  y = HashLen16(g, h) + c;
-  result[0] = e + z + y + x;
-  a = ShiftMix((a + y) * k0) * k0 + b;
-  result[1] += a + result[0];
-  a = ShiftMix(a * k0) * k0 + c;
-  result[2] = a + result[1];
-  a = ShiftMix((a + e) * k0) * k0;
-  result[3] = a + result[2];
+	PERMUTE3(x, z, y);                          \
+	b += Fetch64(s);                            \
+	c += Fetch64(s + 8);                        \
+	d += Fetch64(s + 16);                       \
+	e += Fetch64(s + 24);                       \
+	f += Fetch64(s + 32);                       \
+	a += b;                                     \
+	h += f;                                     \
+	b += c;                                     \
+	f += d;                                     \
+	g += e;                                     \
+	e += z;                                     \
+	g += x;                                     \
+	z = _mm_crc32_u64(z, b + g);                \
+	y = _mm_crc32_u64(y, e + h);                \
+	x = _mm_crc32_u64(x, f + a);                \
+	e = Rotate(e, r);                           \
+	c += e;                                     \
+	s += 40
+		CHUNK(0);
+		PERMUTE3(a, h, c);
+		CHUNK(33);
+		PERMUTE3(a, h, f);
+		CHUNK(0);
+		PERMUTE3(b, h, f);
+		CHUNK(42);
+		PERMUTE3(b, h, d);
+		CHUNK(0);
+		PERMUTE3(b, h, e);
+		CHUNK(33);
+		PERMUTE3(a, h, e);
+	}
+	while (--iters > 0);
+	while (len >= 40)
+	{
+		CHUNK(29);
+		e ^= Rotate(a, 20);
+		h += Rotate(b, 30);
+		g ^= Rotate(c, 40);
+		f += Rotate(d, 34);
+		PERMUTE3(c, h, g);
+		len -= 40;
+	}
+	if (len > 0)
+	{
+		s = s + len - 40;
+		CHUNK(33);
+		e ^= Rotate(a, 43);
+		h += Rotate(b, 42);
+		g ^= Rotate(c, 41);
+		f += Rotate(d, 40);
+	}
+	result[0] ^= h;
+	result[1] ^= g;
+	g += h;
+	a = HashLen16(a, g + z);
+	x += y << 32;
+	b += x;
+	c = HashLen16(c, z) + h;
+	d = HashLen16(d, e + result[0]);
+	g += e;
+	h += HashLen16(x, f);
+	e = HashLen16(a, d) + g;
+	z = HashLen16(b, c) + a;
+	y = HashLen16(g, h) + c;
+	result[0] = e + z + y + x;
+	a = ShiftMix((a + y) * k0) * k0 + b;
+	result[1] += a + result[0];
+	a = ShiftMix(a * k0) * k0 + c;
+	result[2] = a + result[1];
+	a = ShiftMix((a + e) * k0) * k0;
+	result[3] = a + result[2];
 }
 
 // Requires len < 240.
-static void CityHashCrc256Short(const char *s, size_t len, uint64 *result) {
-  char buf[240];
-  memcpy(buf, s, len);
-  memset(buf + len, 0, 240 - len);
-  CityHashCrc256Long(buf, 240, ~static_cast<uint32>(len), result);
+static void CityHashCrc256Short(const char *s, size_t len, uint64 *result)
+{
+	char buf[240];
+	memcpy(buf, s, len);
+	memset(buf + len, 0, 240 - len);
+	CityHashCrc256Long(buf, 240, ~static_cast<uint32>(len), result);
 }
 
-void CityHashCrc256(const char *s, size_t len, uint64 *result) {
-  if (LIKELY(len >= 240)) {
-    CityHashCrc256Long(s, len, 0, result);
-  } else {
-    CityHashCrc256Short(s, len, result);
-  }
+void CityHashCrc256(const char *s, size_t len, uint64 *result)
+{
+	if (LIKELY(len >= 240))
+	{
+		CityHashCrc256Long(s, len, 0, result);
+	}
+	else
+	{
+		CityHashCrc256Short(s, len, result);
+	}
 }
 
-uint128 CityHashCrc128WithSeed(const char *s, size_t len, uint128 seed) {
-  if (len <= 900) {
-    return CityHash128WithSeed(s, len, seed);
-  } else {
-    uint64 result[4];
-    CityHashCrc256(s, len, result);
-    uint64 u = Uint128High64(seed) + result[0];
-    uint64 v = Uint128Low64(seed) + result[1];
-    return uint128(HashLen16(u, v + result[2]),
-                   HashLen16(Rotate(v, 32), u * k0 + result[3]));
-  }
+uint128 CityHashCrc128WithSeed(const char *s, size_t len, uint128 seed)
+{
+	if (len <= 900)
+	{
+		return CityHash128WithSeed(s, len, seed);
+	}
+	else
+	{
+		uint64 result[4];
+		CityHashCrc256(s, len, result);
+		uint64 u = Uint128High64(seed) + result[0];
+		uint64 v = Uint128Low64(seed) + result[1];
+		return uint128(HashLen16(u, v + result[2]),
+		               HashLen16(Rotate(v, 32), u * k0 + result[3]));
+	}
 }
 
-uint128 CityHashCrc128(const char *s, size_t len) {
-  if (len <= 900) {
-    return CityHash128(s, len);
-  } else {
-    uint64 result[4];
-    CityHashCrc256(s, len, result);
-    return uint128(result[2], result[3]);
-  }
+uint128 CityHashCrc128(const char *s, size_t len)
+{
+	if (len <= 900)
+	{
+		return CityHash128(s, len);
+	}
+	else
+	{
+		uint64 result[4];
+		CityHashCrc256(s, len, result);
+		return uint128(result[2], result[3]);
+	}
 }
 
 #endif
diff --git a/cityhash/city.h b/cityhash/city.h
index cb2ac7925..e1b8c28df 100644
--- a/cityhash/city.h
+++ b/cityhash/city.h
@@ -70,8 +70,8 @@
 
 typedef std::pair<uint64_t, uint64_t> uint128_t;
 
-inline uint64_t Uint128Low64(const uint128_t& x) { return x.first; }
-inline uint64_t Uint128High64(const uint128_t& x) { return x.second; }
+inline uint64_t Uint128Low64(const uint128_t &x) { return x.first; }
+inline uint64_t Uint128High64(const uint128_t &x) { return x.second; }
 
 // Hash function for a byte array.
 uint64_t CityHash64(const char *buf, size_t len);
@@ -97,15 +97,16 @@ uint32_t CityHash32(const char *buf, size_t len);
 
 // Hash 128 input bits down to 64 bits of output.
 // This is intended to be a reasonably good hash function.
-inline uint64_t Hash128to64(const uint128_t& x) {
-  // Murmur-inspired hashing.
-  const uint64_t kMul = 0x9ddfea08eb382d69ULL;
-  uint64_t a = (Uint128Low64(x) ^ Uint128High64(x)) * kMul;
-  a ^= (a >> 47);
-  uint64_t b = (Uint128High64(x) ^ a) * kMul;
-  b ^= (b >> 47);
-  b *= kMul;
-  return b;
+inline uint64_t Hash128to64(const uint128_t &x)
+{
+	// Murmur-inspired hashing.
+	const uint64_t kMul = 0x9ddfea08eb382d69ULL;
+	uint64_t a = (Uint128Low64(x) ^ Uint128High64(x)) * kMul;
+	a ^= (a >> 47);
+	uint64_t b = (Uint128High64(x) ^ a) * kMul;
+	b ^= (b >> 47);
+	b *= kMul;
+	return b;
 }
 
 #endif  // CITY_HASH_H_
diff --git a/cityhash/test/city.cc b/cityhash/test/city.cc
index 6e580d926..812e21d98 100644
--- a/cityhash/test/city.cc
+++ b/cityhash/test/city.cc
@@ -44,1294 +44,1905 @@ static char data[kDataSize];
 static int errors = 0;  // global error count
 
 // Initialize data to pseudorandom values.
-void setup() {
-  uint64 a = 9;
-  uint64 b = 777;
-  for (int i = 0; i < kDataSize; i++) {
-    a += b;
-    b += a;
-    a = (a ^ (a >> 41)) * k0;
-    b = (b ^ (b >> 41)) * k0 + i;
-    uint8 u = b >> 37;
-    memcpy(data + i, &u, 1);  // uint8 -> char
-  }
+void setup()
+{
+	uint64 a = 9;
+	uint64 b = 777;
+	for (int i = 0; i < kDataSize; i++)
+	{
+		a += b;
+		b += a;
+		a = (a ^ (a >> 41)) * k0;
+		b = (b ^ (b >> 41)) * k0 + i;
+		uint8 u = b >> 37;
+		memcpy(data + i, &u, 1);  // uint8 -> char
+	}
 }
 
 #if 1
 
 #define C(x) 0x ## x ## ULL
-static const uint64 testdata[kTestSize][16] = {
-{C(9ae16a3b2f90404f), C(75106db890237a4a), C(3feac5f636039766), C(3df09dfc64c09a2b), C(3cb540c392e51e29), C(6b56343feac0663), C(5b7bc50fd8e8ad92),
-C(3df09dfc64c09a2b), C(3cb540c392e51e29), C(6b56343feac0663), C(5b7bc50fd8e8ad92),
-C(95162f24e6a5f930), C(6808bdf4f1eb06e0), C(b3b1f3a67b624d82), C(c9a62f12bd4cd80b),
-C(dc56d17a)},
-{C(541150e87f415e96), C(1aef0d24b3148a1a), C(bacc300e1e82345a), C(c3cdc41e1df33513), C(2c138ff2596d42f6), C(f58e9082aed3055f), C(162e192b2957163d),
-C(c3cdc41e1df33513), C(2c138ff2596d42f6), C(f58e9082aed3055f), C(162e192b2957163d),
-C(fb99e85e0d16f90c), C(608462c15bdf27e8), C(e7d2c5c943572b62), C(1baaa9327642798c),
-C(99929334)},
-{C(f3786a4b25827c1), C(34ee1a2bf767bd1c), C(2f15ca2ebfb631f2), C(3149ba1dac77270d), C(70e2e076e30703c), C(59bcc9659bc5296), C(9ecbc8132ae2f1d7),
-C(3149ba1dac77270d), C(70e2e076e30703c), C(59bcc9659bc5296), C(9ecbc8132ae2f1d7),
-C(a01d30789bad7cf2), C(ae03fe371981a0e0), C(127e3883b8788934), C(d0ac3d4c0a6fca32),
-C(4252edb7)},
-{C(ef923a7a1af78eab), C(79163b1e1e9a9b18), C(df3b2aca6e1e4a30), C(2193fb7620cbf23b), C(8b6a8ff06cda8302), C(1a44469afd3e091f), C(8b0449376612506),
-C(2193fb7620cbf23b), C(8b6a8ff06cda8302), C(1a44469afd3e091f), C(8b0449376612506),
-C(e9d9d41c32ad91d1), C(b44ab09f58e3c608), C(19e9175f9fcf784), C(839b3c9581b4a480),
-C(ebc34f3c)},
-{C(11df592596f41d88), C(843ec0bce9042f9c), C(cce2ea1e08b1eb30), C(4d09e42f09cc3495), C(666236631b9f253b), C(d28b3763cd02b6a3), C(43b249e57c4d0c1b),
-C(4d09e42f09cc3495), C(666236631b9f253b), C(d28b3763cd02b6a3), C(43b249e57c4d0c1b),
-C(3887101c8adea101), C(8a9355d4efc91df0), C(3e610944cc9fecfd), C(5bf9eb60b08ac0ce),
-C(26f2b463)},
-{C(831f448bdc5600b3), C(62a24be3120a6919), C(1b44098a41e010da), C(dc07df53b949c6b), C(d2b11b2081aeb002), C(d212b02c1b13f772), C(c0bed297b4be1912),
-C(dc07df53b949c6b), C(d2b11b2081aeb002), C(d212b02c1b13f772), C(c0bed297b4be1912),
-C(682d3d2ad304e4af), C(40e9112a655437a1), C(268b09f7ee09843f), C(6b9698d43859ca47),
-C(b042c047)},
-{C(3eca803e70304894), C(d80de767e4a920a), C(a51cfbb292efd53d), C(d183dcda5f73edfa), C(3a93cbf40f30128c), C(1a92544d0b41dbda), C(aec2c4bee81975e1),
-C(d183dcda5f73edfa), C(3a93cbf40f30128c), C(1a92544d0b41dbda), C(aec2c4bee81975e1),
-C(5f91814d1126ba4b), C(f8ac57eee87fcf1f), C(c55c644a5d0023cd), C(adb761e827825ff2),
-C(e73bb0a8)},
-{C(1b5a063fb4c7f9f1), C(318dbc24af66dee9), C(10ef7b32d5c719af), C(b140a02ef5c97712), C(b7d00ef065b51b33), C(635121d532897d98), C(532daf21b312a6d6),
-C(b140a02ef5c97712), C(b7d00ef065b51b33), C(635121d532897d98), C(532daf21b312a6d6),
-C(c0b09b75d943910), C(8c84dfb5ef2a8e96), C(e5c06034b0353433), C(3170faf1c33a45dd),
-C(91dfdd75)},
-{C(a0f10149a0e538d6), C(69d008c20f87419f), C(41b36376185b3e9e), C(26b6689960ccf81d), C(55f23b27bb9efd94), C(3a17f6166dd765db), C(c891a8a62931e782),
-C(26b6689960ccf81d), C(55f23b27bb9efd94), C(3a17f6166dd765db), C(c891a8a62931e782),
-C(23852dc37ddd2607), C(8b7f1b1ec897829e), C(d1d69452a54eed8a), C(56431f2bd766ec24),
-C(c87f95de)},
-{C(fb8d9c70660b910b), C(a45b0cc3476bff1b), C(b28d1996144f0207), C(98ec31113e5e35d2), C(5e4aeb853f1b9aa7), C(bcf5c8fe4465b7c8), C(b1ea3a8243996f15),
-C(98ec31113e5e35d2), C(5e4aeb853f1b9aa7), C(bcf5c8fe4465b7c8), C(b1ea3a8243996f15),
-C(cabbccedb6407571), C(d1e40a84c445ec3a), C(33302aa908cf4039), C(9f15f79211b5cdf8),
-C(3f5538ef)},
-{C(236827beae282a46), C(e43970221139c946), C(4f3ac6faa837a3aa), C(71fec0f972248915), C(2170ec2061f24574), C(9eb346b6caa36e82), C(2908f0fdbca48e73),
-C(71fec0f972248915), C(2170ec2061f24574), C(9eb346b6caa36e82), C(2908f0fdbca48e73),
-C(8101c99f07c64abb), C(b9f4b02b1b6a96a7), C(583a2b10cd222f88), C(199dae4cf9db24c),
-C(70eb1a1f)},
-{C(c385e435136ecf7c), C(d9d17368ff6c4a08), C(1b31eed4e5251a67), C(df01a322c43a6200), C(298b65a1714b5a7e), C(933b83f0aedf23c), C(157bcb44d63f765a),
-C(df01a322c43a6200), C(298b65a1714b5a7e), C(933b83f0aedf23c), C(157bcb44d63f765a),
-C(d6e9fc7a272d8b51), C(3ee5073ef1a9b777), C(63149e31fac02c59), C(2f7979ff636ba1d8),
-C(cfd63b83)},
-{C(e3f6828b6017086d), C(21b4d1900554b3b0), C(bef38be1809e24f1), C(d93251758985ee6c), C(32a9e9f82ba2a932), C(3822aacaa95f3329), C(db349b2f90a490d8),
-C(d93251758985ee6c), C(32a9e9f82ba2a932), C(3822aacaa95f3329), C(db349b2f90a490d8),
-C(8d49194a894a19ca), C(79a78b06e42738e6), C(7e0f1eda3d390c66), C(1c291d7e641100a5),
-C(894a52ef)},
-{C(851fff285561dca0), C(4d1277d73cdf416f), C(28ccffa61010ebe2), C(77a4ccacd131d9ee), C(e1d08eeb2f0e29aa), C(70b9e3051383fa45), C(582d0120425caba),
-C(77a4ccacd131d9ee), C(e1d08eeb2f0e29aa), C(70b9e3051383fa45), C(582d0120425caba),
-C(a740eef1846e4564), C(572dddb74ac3ae00), C(fdb5ca9579163bbd), C(a649b9b799c615d2),
-C(9cde6a54)},
-{C(61152a63595a96d9), C(d1a3a91ef3a7ba45), C(443b6bb4a493ad0c), C(a154296d11362d06), C(d0f0bf1f1cb02fc1), C(ccb87e09309f90d1), C(b24a8e4881911101),
-C(a154296d11362d06), C(d0f0bf1f1cb02fc1), C(ccb87e09309f90d1), C(b24a8e4881911101),
-C(1a481b4528559f58), C(bf837a3150896995), C(4989ef6b941a3757), C(2e725ab72d0b2948),
-C(6c4898d5)},
-{C(44473e03be306c88), C(30097761f872472a), C(9fd1b669bfad82d7), C(3bab18b164396783), C(47e385ff9d4c06f), C(18062081bf558df), C(63416eb68f104a36),
-C(3bab18b164396783), C(47e385ff9d4c06f), C(18062081bf558df), C(63416eb68f104a36),
-C(4abda1560c47ac80), C(1ea0e63dc6587aee), C(33ec79d92ebc1de), C(94f9dccef771e048),
-C(13e1978e)},
-{C(3ead5f21d344056), C(fb6420393cfb05c3), C(407932394cbbd303), C(ac059617f5906673), C(94d50d3dcd3069a7), C(2b26c3b92dea0f0), C(99b7374cc78fc3fb),
-C(ac059617f5906673), C(94d50d3dcd3069a7), C(2b26c3b92dea0f0), C(99b7374cc78fc3fb),
-C(1a8e3c73cdd40ee8), C(cbb5fca06747f45b), C(ceec44238b291841), C(28bf35cce9c90a25),
-C(51b4ba8)},
-{C(6abbfde37ee03b5b), C(83febf188d2cc113), C(cda7b62d94d5b8ee), C(a4375590b8ae7c82), C(168fd42f9ecae4ff), C(23bbde43de2cb214), C(a8c333112a243c8c),
-C(a4375590b8ae7c82), C(168fd42f9ecae4ff), C(23bbde43de2cb214), C(a8c333112a243c8c),
-C(10ac012e8c518b49), C(64a44605d8b29458), C(a67e701d2a679075), C(3a3a20f43ec92303),
-C(b6b06e40)},
-{C(943e7ed63b3c080), C(1ef207e9444ef7f8), C(ef4a9f9f8c6f9b4a), C(6b54fc38d6a84108), C(32f4212a47a4665), C(6b5a9a8f64ee1da6), C(9f74e86c6da69421),
-C(6b54fc38d6a84108), C(32f4212a47a4665), C(6b5a9a8f64ee1da6), C(9f74e86c6da69421),
-C(946dd0cb30c1a08e), C(fdf376956907eaaa), C(a59074c6eec03028), C(b1a3abcf283f34ac),
-C(240a2f2)},
-{C(d72ce05171ef8a1a), C(c6bd6bd869203894), C(c760e6396455d23a), C(f86af0b40dcce7b), C(8d3c15d613394d3c), C(491e400491cd4ece), C(7c19d3530ea3547f),
-C(f86af0b40dcce7b), C(8d3c15d613394d3c), C(491e400491cd4ece), C(7c19d3530ea3547f),
-C(1362963a1dc32af9), C(fb9bc11762e1385c), C(9e164ef1f5376083), C(6c15819b5e828a7e),
-C(5dcefc30)},
-{C(4182832b52d63735), C(337097e123eea414), C(b5a72ca0456df910), C(7ebc034235bc122f), C(d9a7783d4edd8049), C(5f8b04a15ae42361), C(fc193363336453dd),
-C(7ebc034235bc122f), C(d9a7783d4edd8049), C(5f8b04a15ae42361), C(fc193363336453dd),
-C(9b6c50224ef8c4f8), C(ba225c7942d16c3f), C(6f6d55226a73c412), C(abca061fe072152a),
-C(7a48b105)},
-{C(d6cdae892584a2cb), C(58de0fa4eca17dcd), C(43df30b8f5f1cb00), C(9e4ea5a4941e097d), C(547e048d5a9daaba), C(eb6ecbb0b831d185), C(e0168df5fad0c670),
-C(9e4ea5a4941e097d), C(547e048d5a9daaba), C(eb6ecbb0b831d185), C(e0168df5fad0c670),
-C(afa9705f98c2c96a), C(749436f48137a96b), C(759c041fc21df486), C(b23bf400107aa2ec),
-C(fd55007b)},
-{C(5c8e90bc267c5ee4), C(e9ae044075d992d9), C(f234cbfd1f0a1e59), C(ce2744521944f14c), C(104f8032f99dc152), C(4e7f425bfac67ca7), C(9461b911a1c6d589),
-C(ce2744521944f14c), C(104f8032f99dc152), C(4e7f425bfac67ca7), C(9461b911a1c6d589),
-C(5e5ecc726db8b60d), C(cce68b0586083b51), C(8a7f8e54a9cba0fc), C(42f010181d16f049),
-C(6b95894c)},
-{C(bbd7f30ac310a6f3), C(b23b570d2666685f), C(fb13fb08c9814fe7), C(4ee107042e512374), C(1e2c8c0d16097e13), C(210c7500995aa0e6), C(6c13190557106457),
-C(4ee107042e512374), C(1e2c8c0d16097e13), C(210c7500995aa0e6), C(6c13190557106457),
-C(a99b31c96777f381), C(8312ae8301d386c0), C(ed5042b2a4fa96a3), C(d71d1bb23907fe97),
-C(3360e827)},
-{C(36a097aa49519d97), C(8204380a73c4065), C(77c2004bdd9e276a), C(6ee1f817ce0b7aee), C(e9dcb3507f0596ca), C(6bc63c666b5100e2), C(e0b056f1821752af),
-C(6ee1f817ce0b7aee), C(e9dcb3507f0596ca), C(6bc63c666b5100e2), C(e0b056f1821752af),
-C(8ea1114e60292678), C(904b80b46becc77), C(46cd9bb6e9dff52f), C(4c91e3b698355540),
-C(45177e0b)},
-{C(dc78cb032c49217), C(112464083f83e03a), C(96ae53e28170c0f5), C(d367ff54952a958), C(cdad930657371147), C(aa24dc2a9573d5fe), C(eb136daa89da5110),
-C(d367ff54952a958), C(cdad930657371147), C(aa24dc2a9573d5fe), C(eb136daa89da5110),
-C(de623005f6d46057), C(b50c0c92b95e9b7f), C(a8aa54050b81c978), C(573fb5c7895af9b5),
-C(7c6fffe4)},
-{C(441593e0da922dfe), C(936ef46061469b32), C(204a1921197ddd87), C(50d8a70e7a8d8f56), C(256d150ae75dab76), C(e81f4c4a1989036a), C(d0f8db365f9d7e00),
-C(50d8a70e7a8d8f56), C(256d150ae75dab76), C(e81f4c4a1989036a), C(d0f8db365f9d7e00),
-C(753d686677b14522), C(9f76e0cb6f2d0a66), C(ab14f95988ec0d39), C(97621d9da9c9812f),
-C(bbc78da4)},
-{C(2ba3883d71cc2133), C(72f2bbb32bed1a3c), C(27e1bd96d4843251), C(a90f761e8db1543a), C(c339e23c09703cd8), C(f0c6624c4b098fd3), C(1bae2053e41fa4d9),
-C(a90f761e8db1543a), C(c339e23c09703cd8), C(f0c6624c4b098fd3), C(1bae2053e41fa4d9),
-C(3589e273c22ba059), C(63798246e5911a0b), C(18e710ec268fc5dc), C(714a122de1d074f3),
-C(c5c25d39)},
-{C(f2b6d2adf8423600), C(7514e2f016a48722), C(43045743a50396ba), C(23dacb811652ad4f), C(c982da480e0d4c7d), C(3a9c8ed5a399d0a9), C(951b8d084691d4e4),
-C(23dacb811652ad4f), C(c982da480e0d4c7d), C(3a9c8ed5a399d0a9), C(951b8d084691d4e4),
-C(d9f87b4988cff2f7), C(217a191d986aa3bc), C(6ad23c56b480350), C(dd78673938ceb2e7),
-C(b6e5d06e)},
-{C(38fffe7f3680d63c), C(d513325255a7a6d1), C(31ed47790f6ca62f), C(c801faaa0a2e331f), C(491dbc58279c7f88), C(9c0178848321c97a), C(9d934f814f4d6a3c),
-C(c801faaa0a2e331f), C(491dbc58279c7f88), C(9c0178848321c97a), C(9d934f814f4d6a3c),
-C(606a3e4fc8763192), C(bc15cb36a677ee84), C(52d5904157e1fe71), C(1588dd8b1145b79b),
-C(6178504e)},
-{C(b7477bf0b9ce37c6), C(63b1c580a7fd02a4), C(f6433b9f10a5dac), C(68dd76db9d64eca7), C(36297682b64b67), C(42b192d71f414b7a), C(79692cef44fa0206),
-C(68dd76db9d64eca7), C(36297682b64b67), C(42b192d71f414b7a), C(79692cef44fa0206),
-C(f0979252f4776d07), C(4b87cd4f1c9bbf52), C(51b84bbc6312c710), C(150720fbf85428a7),
-C(bd4c3637)},
-{C(55bdb0e71e3edebd), C(c7ab562bcf0568bc), C(43166332f9ee684f), C(b2e25964cd409117), C(a010599d6287c412), C(fa5d6461e768dda2), C(cb3ce74e8ec4f906),
-C(b2e25964cd409117), C(a010599d6287c412), C(fa5d6461e768dda2), C(cb3ce74e8ec4f906),
-C(6120abfd541a2610), C(aa88b148cc95794d), C(2686ca35df6590e3), C(c6b02d18616ce94d),
-C(6e7ac474)},
-{C(782fa1b08b475e7), C(fb7138951c61b23b), C(9829105e234fb11e), C(9a8c431f500ef06e), C(d848581a580b6c12), C(fecfe11e13a2bdb4), C(6c4fa0273d7db08c),
-C(9a8c431f500ef06e), C(d848581a580b6c12), C(fecfe11e13a2bdb4), C(6c4fa0273d7db08c),
-C(482f43bf5ae59fcb), C(f651fbca105d79e6), C(f09f78695d865817), C(7a99d0092085cf47),
-C(1fb4b518)},
-{C(c5dc19b876d37a80), C(15ffcff666cfd710), C(e8c30c72003103e2), C(7870765b470b2c5d), C(78a9103ff960d82), C(7bb50ffc9fac74b3), C(477e70ab2b347db2),
-C(7870765b470b2c5d), C(78a9103ff960d82), C(7bb50ffc9fac74b3), C(477e70ab2b347db2),
-C(a625238bdf7c07cf), C(1128d515174809f5), C(b0f1647e82f45873), C(17792d1c4f222c39),
-C(31d13d6d)},
-{C(5e1141711d2d6706), C(b537f6dee8de6933), C(3af0a1fbbe027c54), C(ea349dbc16c2e441), C(38a7455b6a877547), C(5f97b9750e365411), C(e8cde7f93af49a3),
-C(ea349dbc16c2e441), C(38a7455b6a877547), C(5f97b9750e365411), C(e8cde7f93af49a3),
-C(ba101925ec1f7e26), C(d5e84cab8192c71e), C(e256427726fdd633), C(a4f38e2c6116890d),
-C(26fa72e3)},
-{C(782edf6da001234f), C(f48cbd5c66c48f3), C(808754d1e64e2a32), C(5d9dde77353b1a6d), C(11f58c54581fa8b1), C(da90fa7c28c37478), C(5e9a2eafc670a88a),
-C(5d9dde77353b1a6d), C(11f58c54581fa8b1), C(da90fa7c28c37478), C(5e9a2eafc670a88a),
-C(e35e1bc172e011ef), C(bf9255a4450ae7fe), C(55f85194e26bc55f), C(4f327873e14d0e54),
-C(6a7433bf)},
-{C(d26285842ff04d44), C(8f38d71341eacca9), C(5ca436f4db7a883c), C(bf41e5376b9f0eec), C(2252d21eb7e1c0e9), C(f4b70a971855e732), C(40c7695aa3662afd),
-C(bf41e5376b9f0eec), C(2252d21eb7e1c0e9), C(f4b70a971855e732), C(40c7695aa3662afd),
-C(770fe19e16ab73bb), C(d603ebda6393d749), C(e58c62439aa50dbd), C(96d51e5a02d2d7cf),
-C(4e6df758)},
-{C(c6ab830865a6bae6), C(6aa8e8dd4b98815c), C(efe3846713c371e5), C(a1924cbf0b5f9222), C(7f4872369c2b4258), C(cd6da30530f3ea89), C(b7f8b9a704e6cea1),
-C(a1924cbf0b5f9222), C(7f4872369c2b4258), C(cd6da30530f3ea89), C(b7f8b9a704e6cea1),
-C(fa06ff40433fd535), C(fb1c36fe8f0737f1), C(bb7050561171f80), C(b1bc23235935d897),
-C(d57f63ea)},
-{C(44b3a1929232892), C(61dca0e914fc217), C(a607cc142096b964), C(f7dbc8433c89b274), C(2f5f70581c9b7d32), C(39bf5e5fec82dcca), C(8ade56388901a619),
-C(f7dbc8433c89b274), C(2f5f70581c9b7d32), C(39bf5e5fec82dcca), C(8ade56388901a619),
-C(c1c6a725caab3ea9), C(c1c7906c2f80b898), C(9c3871a04cc884e6), C(df01813cbbdf217f),
-C(52ef73b3)},
-{C(4b603d7932a8de4f), C(fae64c464b8a8f45), C(8fafab75661d602a), C(8ffe870ef4adc087), C(65bea2be41f55b54), C(82f3503f636aef1), C(5f78a282378b6bb0),
-C(8ffe870ef4adc087), C(65bea2be41f55b54), C(82f3503f636aef1), C(5f78a282378b6bb0),
-C(7bf2422c0beceddb), C(9d238d4780114bd), C(7ad198311906597f), C(ec8f892c0422aca3),
-C(3cb36c3)},
-{C(4ec0b54cf1566aff), C(30d2c7269b206bf4), C(77c22e82295e1061), C(3df9b04434771542), C(feddce785ccb661f), C(a644aff716928297), C(dd46aee73824b4ed),
-C(3df9b04434771542), C(feddce785ccb661f), C(a644aff716928297), C(dd46aee73824b4ed),
-C(bf8d71879da29b02), C(fc82dccbfc8022a0), C(31bfcd0d9f48d1d3), C(c64ee24d0e7b5f8b),
-C(72c39bea)},
-{C(ed8b7a4b34954ff7), C(56432de31f4ee757), C(85bd3abaa572b155), C(7d2c38a926dc1b88), C(5245b9eb4cd6791d), C(fb53ab03b9ad0855), C(3664026c8fc669d7),
-C(7d2c38a926dc1b88), C(5245b9eb4cd6791d), C(fb53ab03b9ad0855), C(3664026c8fc669d7),
-C(45024d5080bc196), C(b236ebec2cc2740), C(27231ad0e3443be4), C(145780b63f809250),
-C(a65aa25c)},
-{C(5d28b43694176c26), C(714cc8bc12d060ae), C(3437726273a83fe6), C(864b1b28ec16ea86), C(6a78a5a4039ec2b9), C(8e959533e35a766), C(347b7c22b75ae65f),
-C(864b1b28ec16ea86), C(6a78a5a4039ec2b9), C(8e959533e35a766), C(347b7c22b75ae65f),
-C(5005892bb61e647c), C(fe646519b4a1894d), C(cd801026f74a8a53), C(8713463e9a1ab9ce),
-C(74740539)},
-{C(6a1ef3639e1d202e), C(919bc1bd145ad928), C(30f3f7e48c28a773), C(2e8c49d7c7aaa527), C(5e2328fc8701db7c), C(89ef1afca81f7de8), C(b1857db11985d296),
-C(2e8c49d7c7aaa527), C(5e2328fc8701db7c), C(89ef1afca81f7de8), C(b1857db11985d296),
-C(17763d695f616115), C(b8f7bf1fcdc8322c), C(cf0c61938ab07a27), C(1122d3e6edb4e866),
-C(c3ae3c26)},
-{C(159f4d9e0307b111), C(3e17914a5675a0c), C(af849bd425047b51), C(3b69edadf357432b), C(3a2e311c121e6bf2), C(380fad1e288d57e5), C(bf7c7e8ef0e3b83a),
-C(3b69edadf357432b), C(3a2e311c121e6bf2), C(380fad1e288d57e5), C(bf7c7e8ef0e3b83a),
-C(92966d5f4356ae9b), C(2a03fc66c4d6c036), C(2516d8bddb0d5259), C(b3ffe9737ff5090),
-C(f29db8a2)},
-{C(cc0a840725a7e25b), C(57c69454396e193a), C(976eaf7eee0b4540), C(cd7a46850b95e901), C(c57f7d060dda246f), C(6b9406ead64079bf), C(11b28e20a573b7bd),
-C(cd7a46850b95e901), C(c57f7d060dda246f), C(6b9406ead64079bf), C(11b28e20a573b7bd),
-C(2d6db356e9369ace), C(dc0afe10fba193), C(5cdb10885dbbfce), C(5c700e205782e35a),
-C(1ef4cbf4)},
-{C(a2b27ee22f63c3f1), C(9ebde0ce1b3976b2), C(2fe6a92a257af308), C(8c1df927a930af59), C(a462f4423c9e384e), C(236542255b2ad8d9), C(595d201a2c19d5bc),
-C(8c1df927a930af59), C(a462f4423c9e384e), C(236542255b2ad8d9), C(595d201a2c19d5bc),
-C(22c87d4604a67f3), C(585a06eb4bc44c4f), C(b4175a7ac7eabcd8), C(a457d3eeba14ab8c),
-C(a9be6c41)},
-{C(d8f2f234899bcab3), C(b10b037297c3a168), C(debea2c510ceda7f), C(9498fefb890287ce), C(ae68c2be5b1a69a6), C(6189dfba34ed656c), C(91658f95836e5206),
-C(9498fefb890287ce), C(ae68c2be5b1a69a6), C(6189dfba34ed656c), C(91658f95836e5206),
-C(c0bb4fff32aecd4d), C(94125f505a50eef9), C(6ac406e7cfbce5bb), C(344a4b1dcdb7f5d8),
-C(fa31801)},
-{C(584f28543864844f), C(d7cee9fc2d46f20d), C(a38dca5657387205), C(7a0b6dbab9a14e69), C(c6d0a9d6b0e31ac4), C(a674d85812c7cf6), C(63538c0351049940),
-C(7a0b6dbab9a14e69), C(c6d0a9d6b0e31ac4), C(a674d85812c7cf6), C(63538c0351049940),
-C(9710e5f0bc93d1d), C(c2bea5bd7c54ddd4), C(48739af2bed0d32d), C(ba2c4e09e21fba85),
-C(8331c5d8)},
-{C(a94be46dd9aa41af), C(a57e5b7723d3f9bd), C(34bf845a52fd2f), C(843b58463c8df0ae), C(74b258324e916045), C(bdd7353230eb2b38), C(fad31fced7abade5),
-C(843b58463c8df0ae), C(74b258324e916045), C(bdd7353230eb2b38), C(fad31fced7abade5),
-C(2436aeafb0046f85), C(65bc9af9e5e33161), C(92733b1b3ae90628), C(f48143eaf78a7a89),
-C(e9876db8)},
-{C(9a87bea227491d20), C(a468657e2b9c43e7), C(af9ba60db8d89ef7), C(cc76f429ea7a12bb), C(5f30eaf2bb14870a), C(434e824cb3e0cd11), C(431a4d382e39d16e),
-C(cc76f429ea7a12bb), C(5f30eaf2bb14870a), C(434e824cb3e0cd11), C(431a4d382e39d16e),
-C(9e51f913c4773a8), C(32ab1925823d0add), C(99c61b54c1d8f69d), C(38cfb80f02b43b1f),
-C(27b0604e)},
-{C(27688c24958d1a5c), C(e3b4a1c9429cf253), C(48a95811f70d64bc), C(328063229db22884), C(67e9c95f8ba96028), C(7c6bf01c60436075), C(fa55161e7d9030b2),
-C(328063229db22884), C(67e9c95f8ba96028), C(7c6bf01c60436075), C(fa55161e7d9030b2),
-C(dadbc2f0dab91681), C(da39d7a4934ca11), C(162e845d24c1b45c), C(eb5b9dcd8c6ed31b),
-C(dcec07f2)},
-{C(5d1d37790a1873ad), C(ed9cd4bcc5fa1090), C(ce51cde05d8cd96a), C(f72c26e624407e66), C(a0eb541bdbc6d409), C(c3f40a2f40b3b213), C(6a784de68794492d),
-C(f72c26e624407e66), C(a0eb541bdbc6d409), C(c3f40a2f40b3b213), C(6a784de68794492d),
-C(10a38a23dbef7937), C(6a5560f853252278), C(c3387bbf3c7b82ba), C(fbee7c12eb072805),
-C(cff0a82a)},
-{C(1f03fd18b711eea9), C(566d89b1946d381a), C(6e96e83fc92563ab), C(405f66cf8cae1a32), C(d7261740d8f18ce6), C(fea3af64a413d0b2), C(d64d1810e83520fe),
-C(405f66cf8cae1a32), C(d7261740d8f18ce6), C(fea3af64a413d0b2), C(d64d1810e83520fe),
-C(e1334a00a580c6e8), C(454049e1b52c15f), C(8895d823d9778247), C(efa7f2e88b826618),
-C(fec83621)},
-{C(f0316f286cf527b6), C(f84c29538de1aa5a), C(7612ed3c923d4a71), C(d4eccebe9393ee8a), C(2eb7867c2318cc59), C(1ce621fd700fe396), C(686450d7a346878a),
-C(d4eccebe9393ee8a), C(2eb7867c2318cc59), C(1ce621fd700fe396), C(686450d7a346878a),
-C(75a5f37579f8b4cb), C(500cc16eb6541dc7), C(b7b02317b539d9a6), C(3519ddff5bc20a29),
-C(743d8dc)},
-{C(297008bcb3e3401d), C(61a8e407f82b0c69), C(a4a35bff0524fa0e), C(7a61d8f552a53442), C(821d1d8d8cfacf35), C(7cc06361b86d0559), C(119b617a8c2be199),
-C(7a61d8f552a53442), C(821d1d8d8cfacf35), C(7cc06361b86d0559), C(119b617a8c2be199),
-C(2996487da6721759), C(61a901376070b91d), C(d88dee12ae9c9b3c), C(5665491be1fa53a7),
-C(64d41d26)},
-{C(43c6252411ee3be), C(b4ca1b8077777168), C(2746dc3f7da1737f), C(2247a4b2058d1c50), C(1b3fa184b1d7bcc0), C(deb85613995c06ed), C(cbe1d957485a3ccd),
-C(2247a4b2058d1c50), C(1b3fa184b1d7bcc0), C(deb85613995c06ed), C(cbe1d957485a3ccd),
-C(dfe241f8f33c96b6), C(6597eb05019c2109), C(da344b2a63a219cf), C(79b8e3887612378a),
-C(acd90c81)},
-{C(ce38a9a54fad6599), C(6d6f4a90b9e8755e), C(c3ecc79ff105de3f), C(e8b9ee96efa2d0e), C(90122905c4ab5358), C(84f80c832d71979c), C(229310f3ffbbf4c6),
-C(e8b9ee96efa2d0e), C(90122905c4ab5358), C(84f80c832d71979c), C(229310f3ffbbf4c6),
-C(cc9eb42100cd63a7), C(7a283f2f3da7b9f), C(359b061d314e7a72), C(d0d959720028862),
-C(7c746a4b)},
-{C(270a9305fef70cf), C(600193999d884f3a), C(f4d49eae09ed8a1), C(2e091b85660f1298), C(bfe37fae1cdd64c9), C(8dddfbab930f6494), C(2ccf4b08f5d417a),
-C(2e091b85660f1298), C(bfe37fae1cdd64c9), C(8dddfbab930f6494), C(2ccf4b08f5d417a),
-C(365c2ee85582fe6), C(dee027bcd36db62a), C(b150994d3c7e5838), C(fdfd1a0e692e436d),
-C(b1047e99)},
-{C(e71be7c28e84d119), C(eb6ace59932736e6), C(70c4397807ba12c5), C(7a9d77781ac53509), C(4489c3ccfda3b39c), C(fa722d4f243b4964), C(25f15800bffdd122),
-C(7a9d77781ac53509), C(4489c3ccfda3b39c), C(fa722d4f243b4964), C(25f15800bffdd122),
-C(ed85e4157fbd3297), C(aab1967227d59efd), C(2199631212eb3839), C(3e4c19359aae1cc2),
-C(d1fd1068)},
-{C(b5b58c24b53aaa19), C(d2a6ab0773dd897f), C(ef762fe01ecb5b97), C(9deefbcfa4cab1f1), C(b58f5943cd2492ba), C(a96dcc4d1f4782a7), C(102b62a82309dde5),
-C(9deefbcfa4cab1f1), C(b58f5943cd2492ba), C(a96dcc4d1f4782a7), C(102b62a82309dde5),
-C(35fe52684763b338), C(afe2616651eaad1f), C(43e38715bdfa05e7), C(83c9ba83b5ec4a40),
-C(56486077)},
-{C(44dd59bd301995cf), C(3ccabd76493ada1a), C(540db4c87d55ef23), C(cfc6d7adda35797), C(14c7d1f32332cf03), C(2d553ffbff3be99d), C(c91c4ee0cb563182),
-C(cfc6d7adda35797), C(14c7d1f32332cf03), C(2d553ffbff3be99d), C(c91c4ee0cb563182),
-C(9aa5e507f49136f0), C(760c5dd1a82c4888), C(beea7e974a1cfb5c), C(640b247774fe4bf7),
-C(6069be80)},
-{C(b4d4789eb6f2630b), C(bf6973263ce8ef0e), C(d1c75c50844b9d3), C(bce905900c1ec6ea), C(c30f304f4045487d), C(a5c550166b3a142b), C(2f482b4e35327287),
-C(bce905900c1ec6ea), C(c30f304f4045487d), C(a5c550166b3a142b), C(2f482b4e35327287),
-C(15b21ddddf355438), C(496471fa3006bab), C(2a8fd458d06c1a32), C(db91e8ae812f0b8d),
-C(2078359b)},
-{C(12807833c463737c), C(58e927ea3b3776b4), C(72dd20ef1c2f8ad0), C(910b610de7a967bf), C(801bc862120f6bf5), C(9653efeed5897681), C(f5367ff83e9ebbb3),
-C(910b610de7a967bf), C(801bc862120f6bf5), C(9653efeed5897681), C(f5367ff83e9ebbb3),
-C(cf56d489afd1b0bf), C(c7c793715cae3de8), C(631f91d64abae47c), C(5f1f42fb14a444a2),
-C(9ea21004)},
-{C(e88419922b87176f), C(bcf32f41a7ddbf6f), C(d6ebefd8085c1a0f), C(d1d44fe99451ef72), C(ec951ba8e51e3545), C(c0ca86b360746e96), C(aa679cc066a8040b),
-C(d1d44fe99451ef72), C(ec951ba8e51e3545), C(c0ca86b360746e96), C(aa679cc066a8040b),
-C(51065861ece6ffc1), C(76777368a2997e11), C(87f278f46731100c), C(bbaa4140bdba4527),
-C(9c9cfe88)},
-{C(105191e0ec8f7f60), C(5918dbfcca971e79), C(6b285c8a944767b9), C(d3e86ac4f5eccfa4), C(e5399df2b106ca1), C(814aadfacd217f1d), C(2754e3def1c405a9),
-C(d3e86ac4f5eccfa4), C(e5399df2b106ca1), C(814aadfacd217f1d), C(2754e3def1c405a9),
-C(99290323b9f06e74), C(a9782e043f271461), C(13c8b3b8c275a860), C(6038d620e581e9e7),
-C(b70a6ddd)},
-{C(a5b88bf7399a9f07), C(fca3ddfd96461cc4), C(ebe738fdc0282fc6), C(69afbc800606d0fb), C(6104b97a9db12df7), C(fcc09198bb90bf9f), C(c5e077e41a65ba91),
-C(69afbc800606d0fb), C(6104b97a9db12df7), C(fcc09198bb90bf9f), C(c5e077e41a65ba91),
-C(db261835ee8aa08e), C(db0ee662e5796dc9), C(fc1880ecec499e5f), C(648866fbe1502034),
-C(dea37298)},
-{C(d08c3f5747d84f50), C(4e708b27d1b6f8ac), C(70f70fd734888606), C(909ae019d761d019), C(368bf4aab1b86ef9), C(308bd616d5460239), C(4fd33269f76783ea),
-C(909ae019d761d019), C(368bf4aab1b86ef9), C(308bd616d5460239), C(4fd33269f76783ea),
-C(7d53b37c19713eab), C(6bba6eabda58a897), C(91abb50efc116047), C(4e902f347e0e0e35),
-C(8f480819)},
-{C(2f72d12a40044b4b), C(889689352fec53de), C(f03e6ad87eb2f36), C(ef79f28d874b9e2d), C(b512089e8e63b76c), C(24dc06833bf193a9), C(3c23308ba8e99d7e),
-C(ef79f28d874b9e2d), C(b512089e8e63b76c), C(24dc06833bf193a9), C(3c23308ba8e99d7e),
-C(5ceff7b85cacefb7), C(ef390338898cd73), C(b12967d7d2254f54), C(de874cbd8aef7b75),
-C(30b3b16)},
-{C(aa1f61fdc5c2e11e), C(c2c56cd11277ab27), C(a1e73069fdf1f94f), C(8184bab36bb79df0), C(c81929ce8655b940), C(301b11bf8a4d8ce8), C(73126fd45ab75de9),
-C(8184bab36bb79df0), C(c81929ce8655b940), C(301b11bf8a4d8ce8), C(73126fd45ab75de9),
-C(4bd6f76e4888229a), C(9aae355b54a756d5), C(ca3de9726f6e99d5), C(83f80cac5bc36852),
-C(f31bc4e8)},
-{C(9489b36fe2246244), C(3355367033be74b8), C(5f57c2277cbce516), C(bc61414f9802ecaf), C(8edd1e7a50562924), C(48f4ab74a35e95f2), C(cc1afcfd99a180e7),
-C(bc61414f9802ecaf), C(8edd1e7a50562924), C(48f4ab74a35e95f2), C(cc1afcfd99a180e7),
-C(517dd5e3acf66110), C(7dd3ad9e8978b30d), C(1f6d5dfc70de812b), C(947daaba6441aaf3),
-C(419f953b)},
-{C(358d7c0476a044cd), C(e0b7b47bcbd8854f), C(ffb42ec696705519), C(d45e44c263e95c38), C(df61db53923ae3b1), C(f2bc948cc4fc027c), C(8a8000c6066772a3),
-C(d45e44c263e95c38), C(df61db53923ae3b1), C(f2bc948cc4fc027c), C(8a8000c6066772a3),
-C(9fd93c942d31fa17), C(d7651ecebe09cbd3), C(68682cefb6a6f165), C(541eb99a2dcee40e),
-C(20e9e76d)},
-{C(b0c48df14275265a), C(9da4448975905efa), C(d716618e414ceb6d), C(30e888af70df1e56), C(4bee54bd47274f69), C(178b4059e1a0afe5), C(6e2c96b7f58e5178),
-C(30e888af70df1e56), C(4bee54bd47274f69), C(178b4059e1a0afe5), C(6e2c96b7f58e5178),
-C(bb429d3b9275e9bc), C(c198013f09cafdc6), C(ec0a6ee4fb5de348), C(744e1e8ed2eb1eb0),
-C(646f0ff8)},
-{C(daa70bb300956588), C(410ea6883a240c6d), C(f5c8239fb5673eb3), C(8b1d7bb4903c105f), C(cfb1c322b73891d4), C(5f3b792b22f07297), C(fd64061f8be86811),
-C(8b1d7bb4903c105f), C(cfb1c322b73891d4), C(5f3b792b22f07297), C(fd64061f8be86811),
-C(1d2db712921cfc2b), C(cd1b2b2f2cee18ae), C(6b6f8790dc7feb09), C(46c179efa3f0f518),
-C(eeb7eca8)},
-{C(4ec97a20b6c4c7c2), C(5913b1cd454f29fd), C(a9629f9daf06d685), C(852c9499156a8f3), C(3a180a6abfb79016), C(9fc3c4764037c3c9), C(2890c42fc0d972cf),
-C(852c9499156a8f3), C(3a180a6abfb79016), C(9fc3c4764037c3c9), C(2890c42fc0d972cf),
-C(1f92231d4e537651), C(fab8bb07aa54b7b9), C(e05d2d771c485ed4), C(d50b34bf808ca731),
-C(8112bb9)},
-{C(5c3323628435a2e8), C(1bea45ce9e72a6e3), C(904f0a7027ddb52e), C(939f31de14dcdc7b), C(a68fdf4379df068), C(f169e1f0b835279d), C(7498e432f9619b27),
-C(939f31de14dcdc7b), C(a68fdf4379df068), C(f169e1f0b835279d), C(7498e432f9619b27),
-C(1aa2a1f11088e785), C(d6ad72f45729de78), C(9a63814157c80267), C(55538e35c648e435),
-C(85a6d477)},
-{C(c1ef26bea260abdb), C(6ee423f2137f9280), C(df2118b946ed0b43), C(11b87fb1b900cc39), C(e33e59b90dd815b1), C(aa6cb5c4bafae741), C(739699951ca8c713),
-C(11b87fb1b900cc39), C(e33e59b90dd815b1), C(aa6cb5c4bafae741), C(739699951ca8c713),
-C(2b4389a967310077), C(1d5382568a31c2c9), C(55d1e787fbe68991), C(277c254bc31301e7),
-C(56f76c84)},
-{C(6be7381b115d653a), C(ed046190758ea511), C(de6a45ffc3ed1159), C(a64760e4041447d0), C(e3eac49f3e0c5109), C(dd86c4d4cb6258e2), C(efa9857afd046c7f),
-C(a64760e4041447d0), C(e3eac49f3e0c5109), C(dd86c4d4cb6258e2), C(efa9857afd046c7f),
-C(fab793dae8246f16), C(c9e3b121b31d094c), C(a2a0f55858465226), C(dba6f0ff39436344),
-C(9af45d55)},
-{C(ae3eece1711b2105), C(14fd3f4027f81a4a), C(abb7e45177d151db), C(501f3e9b18861e44), C(465201170074e7d8), C(96d5c91970f2cb12), C(40fd28c43506c95d),
-C(501f3e9b18861e44), C(465201170074e7d8), C(96d5c91970f2cb12), C(40fd28c43506c95d),
-C(e86c4b07802aaff3), C(f317d14112372a70), C(641b13e587711650), C(4915421ab1090eaa),
-C(d1c33760)},
-{C(376c28588b8fb389), C(6b045e84d8491ed2), C(4e857effb7d4e7dc), C(154dd79fd2f984b4), C(f11171775622c1c3), C(1fbe30982e78e6f0), C(a460a15dcf327e44),
-C(154dd79fd2f984b4), C(f11171775622c1c3), C(1fbe30982e78e6f0), C(a460a15dcf327e44),
-C(f359e0900cc3d582), C(7e11070447976d00), C(324e6daf276ea4b5), C(7aa6e2df0cc94fa2),
-C(c56bbf69)},
-{C(58d943503bb6748f), C(419c6c8e88ac70f6), C(586760cbf3d3d368), C(b7e164979d5ccfc1), C(12cb4230d26bf286), C(f1bf910d44bd84cb), C(b32c24c6a40272),
-C(b7e164979d5ccfc1), C(12cb4230d26bf286), C(f1bf910d44bd84cb), C(b32c24c6a40272),
-C(11ed12e34c48c039), C(b0c2538e51d0a6ac), C(4269bb773e1d553a), C(e35a9dbabd34867),
-C(abecfb9b)},
-{C(dfff5989f5cfd9a1), C(bcee2e7ea3a96f83), C(681c7874adb29017), C(3ff6c8ac7c36b63a), C(48bc8831d849e326), C(30b078e76b0214e2), C(42954e6ad721b920),
-C(3ff6c8ac7c36b63a), C(48bc8831d849e326), C(30b078e76b0214e2), C(42954e6ad721b920),
-C(f9aeb33d164b4472), C(7b353b110831dbdc), C(16f64c82f44ae17b), C(b71244cc164b3b2b),
-C(8de13255)},
-{C(7fb19eb1a496e8f5), C(d49e5dfdb5c0833f), C(c0d5d7b2f7c48dc7), C(1a57313a32f22dde), C(30af46e49850bf8b), C(aa0fe8d12f808f83), C(443e31d70873bb6b),
-C(1a57313a32f22dde), C(30af46e49850bf8b), C(aa0fe8d12f808f83), C(443e31d70873bb6b),
-C(bbeb67c49c9fdc13), C(18f1e2a88f59f9d5), C(fb1b05038e5def11), C(d0450b5ce4c39c52),
-C(a98ee299)},
-{C(5dba5b0dadccdbaa), C(4ba8da8ded87fcdc), C(f693fdd25badf2f0), C(e9029e6364286587), C(ae69f49ecb46726c), C(18e002679217c405), C(bd6d66e85332ae9f),
-C(e9029e6364286587), C(ae69f49ecb46726c), C(18e002679217c405), C(bd6d66e85332ae9f),
-C(6bf330b1c353dd2a), C(74e9f2e71e3a4152), C(3f85560b50f6c413), C(d33a52a47eaed2b4),
-C(3015f556)},
-{C(688bef4b135a6829), C(8d31d82abcd54e8e), C(f95f8a30d55036d7), C(3d8c90e27aa2e147), C(2ec937ce0aa236b4), C(89b563996d3a0b78), C(39b02413b23c3f08),
-C(3d8c90e27aa2e147), C(2ec937ce0aa236b4), C(89b563996d3a0b78), C(39b02413b23c3f08),
-C(8d475a2e64faf2d2), C(48567f7dca46ecaf), C(254cda08d5f87a6d), C(ec6ae9f729c47039),
-C(5a430e29)},
-{C(d8323be05433a412), C(8d48fa2b2b76141d), C(3d346f23978336a5), C(4d50c7537562033f), C(57dc7625b61dfe89), C(9723a9f4c08ad93a), C(5309596f48ab456b),
-C(4d50c7537562033f), C(57dc7625b61dfe89), C(9723a9f4c08ad93a), C(5309596f48ab456b),
-C(7e453088019d220f), C(8776067ba6ab9714), C(67e1d06bd195de39), C(74a1a32f8994b918),
-C(2797add0)},
-{C(3b5404278a55a7fc), C(23ca0b327c2d0a81), C(a6d65329571c892c), C(45504801e0e6066b), C(86e6c6d6152a3d04), C(4f3db1c53eca2952), C(d24d69b3e9ef10f3),
-C(45504801e0e6066b), C(86e6c6d6152a3d04), C(4f3db1c53eca2952), C(d24d69b3e9ef10f3),
-C(93a0de2219e66a70), C(8932c7115ccb1f8a), C(5ef503fdf2841a8c), C(38064dd9efa80a41),
-C(27d55016)},
-{C(2a96a3f96c5e9bbc), C(8caf8566e212dda8), C(904de559ca16e45e), C(f13bc2d9c2fe222e), C(be4ccec9a6cdccfd), C(37b2cbdd973a3ac9), C(7b3223cd9c9497be),
-C(f13bc2d9c2fe222e), C(be4ccec9a6cdccfd), C(37b2cbdd973a3ac9), C(7b3223cd9c9497be),
-C(d5904440f376f889), C(62b13187699c473c), C(4751b89251f26726), C(9500d84fa3a61ba8),
-C(84945a82)},
-{C(22bebfdcc26d18ff), C(4b4d8dcb10807ba1), C(40265eee30c6b896), C(3752b423073b119a), C(377dc5eb7c662bdb), C(2b9f07f93a6c25b9), C(96f24ede2bdc0718),
-C(3752b423073b119a), C(377dc5eb7c662bdb), C(2b9f07f93a6c25b9), C(96f24ede2bdc0718),
-C(f7699b12c31417bd), C(17b366f401c58b2), C(bf60188d5f437b37), C(484436e56df17f04),
-C(3ef7e224)},
-{C(627a2249ec6bbcc2), C(c0578b462a46735a), C(4974b8ee1c2d4f1f), C(ebdbb918eb6d837f), C(8fb5f218dd84147c), C(c77dd1f881df2c54), C(62eac298ec226dc3),
-C(ebdbb918eb6d837f), C(8fb5f218dd84147c), C(c77dd1f881df2c54), C(62eac298ec226dc3),
-C(43eded83c4b60bd0), C(9a0a403b5487503b), C(25f305d9147f0bda), C(3ad417f511bc1e64),
-C(35ed8dc8)},
-{C(3abaf1667ba2f3e0), C(ee78476b5eeadc1), C(7e56ac0a6ca4f3f4), C(f1b9b413df9d79ed), C(a7621b6fd02db503), C(d92f7ba9928a4ffe), C(53f56babdcae96a6),
-C(f1b9b413df9d79ed), C(a7621b6fd02db503), C(d92f7ba9928a4ffe), C(53f56babdcae96a6),
-C(5302b89fc48713ab), C(d03e3b04dbe7a2f2), C(fa74ef8af6d376a7), C(103c8cdea1050ef2),
-C(6a75e43d)},
-{C(3931ac68c5f1b2c9), C(efe3892363ab0fb0), C(40b707268337cd36), C(a53a6b64b1ac85c9), C(d50e7f86ee1b832b), C(7bab08fdd26ba0a4), C(7587743c18fe2475),
-C(a53a6b64b1ac85c9), C(d50e7f86ee1b832b), C(7bab08fdd26ba0a4), C(7587743c18fe2475),
-C(e3b5d5d490cf5761), C(dfc053f7d065edd5), C(42ffd8d5fb70129f), C(599ca38677cccdc3),
-C(235d9805)},
-{C(b98fb0606f416754), C(46a6e5547ba99c1e), C(c909d82112a8ed2), C(dbfaae9642b3205a), C(f676a1339402bcb9), C(f4f12a5b1ac11f29), C(7db8bad81249dee4),
-C(dbfaae9642b3205a), C(f676a1339402bcb9), C(f4f12a5b1ac11f29), C(7db8bad81249dee4),
-C(b26e46f2da95922e), C(2aaedd5e12e3c611), C(a0e2d9082966074), C(c64da8a167add63d),
-C(f7d69572)},
-{C(7f7729a33e58fcc4), C(2e4bc1e7a023ead4), C(e707008ea7ca6222), C(47418a71800334a0), C(d10395d8fc64d8a4), C(8257a30062cb66f), C(6786f9b2dc1ff18a),
-C(47418a71800334a0), C(d10395d8fc64d8a4), C(8257a30062cb66f), C(6786f9b2dc1ff18a),
-C(5633f437bb2f180f), C(e5a3a405737d22d6), C(ca0ff1ef6f7f0b74), C(d0ae600684b16df8),
-C(bacd0199)},
-{C(42a0aa9ce82848b3), C(57232730e6bee175), C(f89bb3f370782031), C(caa33cf9b4f6619c), C(b2c8648ad49c209f), C(9e89ece0712db1c0), C(101d8274a711a54b),
-C(caa33cf9b4f6619c), C(b2c8648ad49c209f), C(9e89ece0712db1c0), C(101d8274a711a54b),
-C(538e79f1e70135cd), C(e1f5a76f983c844e), C(653c082fd66088fc), C(1b9c9b464b654958),
-C(e428f50e)},
-{C(6b2c6d38408a4889), C(de3ef6f68fb25885), C(20754f456c203361), C(941f5023c0c943f9), C(dfdeb9564fd66f24), C(2140cec706b9d406), C(7b22429b131e9c72),
-C(941f5023c0c943f9), C(dfdeb9564fd66f24), C(2140cec706b9d406), C(7b22429b131e9c72),
-C(94215c22eb940f45), C(d28b9ed474f7249a), C(6f25e88f2fbf9f56), C(b6718f9e605b38ac),
-C(81eaaad3)},
-{C(930380a3741e862a), C(348d28638dc71658), C(89dedcfd1654ea0d), C(7e7f61684080106), C(837ace9794582976), C(5ac8ca76a357eb1b), C(32b58308625661fb),
-C(7e7f61684080106), C(837ace9794582976), C(5ac8ca76a357eb1b), C(32b58308625661fb),
-C(c09705c4572025d9), C(f9187f6af0291303), C(1c0edd8ee4b02538), C(e6cb105daa0578a),
-C(addbd3e3)},
-{C(94808b5d2aa25f9a), C(cec72968128195e0), C(d9f4da2bdc1e130f), C(272d8dd74f3006cc), C(ec6c2ad1ec03f554), C(4ad276b249a5d5dd), C(549a22a17c0cde12),
-C(272d8dd74f3006cc), C(ec6c2ad1ec03f554), C(4ad276b249a5d5dd), C(549a22a17c0cde12),
-C(602119cb824d7cde), C(f4d3cef240ef35fa), C(e889895e01911bc7), C(785a7e5ac20e852b),
-C(e66dbca0)},
-{C(b31abb08ae6e3d38), C(9eb9a95cbd9e8223), C(8019e79b7ee94ea9), C(7b2271a7a3248e22), C(3b4f700e5a0ba523), C(8ebc520c227206fe), C(da3f861490f5d291),
-C(7b2271a7a3248e22), C(3b4f700e5a0ba523), C(8ebc520c227206fe), C(da3f861490f5d291),
-C(d08a689f9f3aa60e), C(547c1b97a068661f), C(4b15a67fa29172f0), C(eaf40c085191d80f),
-C(afe11fd5)},
-{C(dccb5534a893ea1a), C(ce71c398708c6131), C(fe2396315457c164), C(3f1229f4d0fd96fb), C(33130aa5fa9d43f2), C(e42693d5b34e63ab), C(2f4ef2be67f62104),
-C(3f1229f4d0fd96fb), C(33130aa5fa9d43f2), C(e42693d5b34e63ab), C(2f4ef2be67f62104),
-C(372e5153516e37b9), C(af9ec142ab12cc86), C(777920c09345e359), C(e7c4a383bef8adc6),
-C(a71a406f)},
-{C(6369163565814de6), C(8feb86fb38d08c2f), C(4976933485cc9a20), C(7d3e82d5ba29a90d), C(d5983cc93a9d126a), C(37e9dfd950e7b692), C(80673be6a7888b87),
-C(7d3e82d5ba29a90d), C(d5983cc93a9d126a), C(37e9dfd950e7b692), C(80673be6a7888b87),
-C(57f732dc600808bc), C(59477199802cc78b), C(f824810eb8f2c2de), C(c4a3437f05b3b61c),
-C(9d90eaf5)},
-{C(edee4ff253d9f9b3), C(96ef76fb279ef0ad), C(a4d204d179db2460), C(1f3dcdfa513512d6), C(4dc7ec07283117e4), C(4438bae88ae28bf9), C(aa7eae72c9244a0d),
-C(1f3dcdfa513512d6), C(4dc7ec07283117e4), C(4438bae88ae28bf9), C(aa7eae72c9244a0d),
-C(b9aedc8d3ecc72df), C(b75a8eb090a77d62), C(6b15677f9cd91507), C(51d8282cb3a9ddbf),
-C(6665db10)},
-{C(941993df6e633214), C(929bc1beca5b72c6), C(141fc52b8d55572d), C(b3b782ad308f21ed), C(4f2676485041dee0), C(bfe279aed5cb4bc8), C(2a62508a467a22ff),
-C(b3b782ad308f21ed), C(4f2676485041dee0), C(bfe279aed5cb4bc8), C(2a62508a467a22ff),
-C(e74d29eab742385d), C(56b05cd90ecfc293), C(c603728ea73f8844), C(8638fcd21bc692c4),
-C(9c977cbf)},
-{C(859838293f64cd4c), C(484403b39d44ad79), C(bf674e64d64b9339), C(44d68afda9568f08), C(478568ed51ca1d65), C(679c204ad3d9e766), C(b28e788878488dc1),
-C(44d68afda9568f08), C(478568ed51ca1d65), C(679c204ad3d9e766), C(b28e788878488dc1),
-C(d001a84d3a84fae6), C(d376958fe4cb913e), C(17435277e36c86f0), C(23657b263c347aa6),
-C(ee83ddd4)},
-{C(c19b5648e0d9f555), C(328e47b2b7562993), C(e756b92ba4bd6a51), C(c3314e362764ddb8), C(6481c084ee9ec6b5), C(ede23fb9a251771), C(bd617f2643324590),
-C(c3314e362764ddb8), C(6481c084ee9ec6b5), C(ede23fb9a251771), C(bd617f2643324590),
-C(d2d30c9b95e030f5), C(8a517312ffc5795e), C(8b1f325033bd535e), C(3ee6e867e03f2892),
-C(26519cc)},
-{C(f963b63b9006c248), C(9e9bf727ffaa00bc), C(c73bacc75b917e3a), C(2c6aa706129cc54c), C(17a706f59a49f086), C(c7c1eec455217145), C(6adfdc6e07602d42),
-C(2c6aa706129cc54c), C(17a706f59a49f086), C(c7c1eec455217145), C(6adfdc6e07602d42),
-C(fb75fca30d848dd2), C(5228c9ed14653ed4), C(953958910153b1a2), C(a430103a24f42a5d),
-C(a485a53f)},
-{C(6a8aa0852a8c1f3b), C(c8f1e5e206a21016), C(2aa554aed1ebb524), C(fc3e3c322cd5d89b), C(b7e3911dc2bd4ebb), C(fcd6da5e5fae833a), C(51ed3c41f87f9118),
-C(fc3e3c322cd5d89b), C(b7e3911dc2bd4ebb), C(fcd6da5e5fae833a), C(51ed3c41f87f9118),
-C(f31750cbc19c420a), C(186dab1abada1d86), C(ca7f88cb894b3cd7), C(2859eeb1c373790c),
-C(f62bc412)},
-{C(740428b4d45e5fb8), C(4c95a4ce922cb0a5), C(e99c3ba78feae796), C(914f1ea2fdcebf5c), C(9566453c07cd0601), C(9841bf66d0462cd), C(79140c1c18536aeb),
-C(914f1ea2fdcebf5c), C(9566453c07cd0601), C(9841bf66d0462cd), C(79140c1c18536aeb),
-C(a963b930b05820c2), C(6a7d9fa0c8c45153), C(64214c40d07cf39b), C(7057daf1d806c014),
-C(8975a436)},
-{C(658b883b3a872b86), C(2f0e303f0f64827a), C(975337e23dc45e1), C(99468a917986162b), C(7b31434aac6e0af0), C(f6915c1562c7d82f), C(e4071d82a6dd71db),
-C(99468a917986162b), C(7b31434aac6e0af0), C(f6915c1562c7d82f), C(e4071d82a6dd71db),
-C(5f5331f077b5d996), C(7b314ba21b747a4f), C(5a73cb9521da17f5), C(12ed435fae286d86),
-C(94ff7f41)},
-{C(6df0a977da5d27d4), C(891dd0e7cb19508), C(fd65434a0b71e680), C(8799e4740e573c50), C(9e739b52d0f341e8), C(cdfd34ba7d7b03eb), C(5061812ce6c88499),
-C(8799e4740e573c50), C(9e739b52d0f341e8), C(cdfd34ba7d7b03eb), C(5061812ce6c88499),
-C(612b8d8f2411dc5c), C(878bd883d29c7787), C(47a846727182bb), C(ec4949508c8b3b9a),
-C(760aa031)},
-{C(a900275464ae07ef), C(11f2cfda34beb4a3), C(9abf91e5a1c38e4), C(8063d80ab26f3d6d), C(4177b4b9b4f0393f), C(6de42ba8672b9640), C(d0bccdb72c51c18),
-C(8063d80ab26f3d6d), C(4177b4b9b4f0393f), C(6de42ba8672b9640), C(d0bccdb72c51c18),
-C(af3f611b7f22cf12), C(3863c41492645755), C(928c7a616a8f14f9), C(a82c78eb2eadc58b),
-C(3bda76df)},
-{C(810bc8aa0c40bcb0), C(448a019568d01441), C(f60ec52f60d3aeae), C(52c44837aa6dfc77), C(15d8d8fccdd6dc5b), C(345b793ccfa93055), C(932160fe802ca975),
-C(52c44837aa6dfc77), C(15d8d8fccdd6dc5b), C(345b793ccfa93055), C(932160fe802ca975),
-C(a624b0dd93fc18cd), C(d955b254c2037f1e), C(e540533d370a664c), C(2ba4ec12514e9d7),
-C(498e2e65)},
-{C(22036327deb59ed7), C(adc05ceb97026a02), C(48bff0654262672b), C(c791b313aba3f258), C(443c7757a4727bee), C(e30e4b2372171bdf), C(f3db986c4156f3cb),
-C(c791b313aba3f258), C(443c7757a4727bee), C(e30e4b2372171bdf), C(f3db986c4156f3cb),
-C(a939aefab97c6e15), C(dbeb8acf1d5b0e6c), C(1e0eab667a795bba), C(80dd539902df4d50),
-C(d38deb48)},
-{C(7d14dfa9772b00c8), C(595735efc7eeaed7), C(29872854f94c3507), C(bc241579d8348401), C(16dc832804d728f0), C(e9cc71ae64e3f09e), C(bef634bc978bac31),
-C(bc241579d8348401), C(16dc832804d728f0), C(e9cc71ae64e3f09e), C(bef634bc978bac31),
-C(7f64b1fa2a9129e), C(71d831bd530ac7f3), C(c7ad0a8a6d5be6f1), C(82a7d3a815c7aaab),
-C(82b3fb6b)},
-{C(2d777cddb912675d), C(278d7b10722a13f9), C(f5c02bfb7cc078af), C(4283001239888836), C(f44ca39a6f79db89), C(ed186122d71bcc9f), C(8620017ab5f3ba3b),
-C(4283001239888836), C(f44ca39a6f79db89), C(ed186122d71bcc9f), C(8620017ab5f3ba3b),
-C(e787472187f176c), C(267e64c4728cf181), C(f1ba4b3007c15e30), C(8e3a75d5b02ecfc0),
-C(e500e25f)},
-{C(f2ec98824e8aa613), C(5eb7e3fb53fe3bed), C(12c22860466e1dd4), C(374dd4288e0b72e5), C(ff8916db706c0df4), C(cb1a9e85de5e4b8d), C(d4d12afb67a27659),
-C(374dd4288e0b72e5), C(ff8916db706c0df4), C(cb1a9e85de5e4b8d), C(d4d12afb67a27659),
-C(feb69095d1ba175a), C(e2003aab23a47fad), C(8163a3ecab894b49), C(46d356674ce041f6),
-C(bd2bb07c)},
-{C(5e763988e21f487f), C(24189de8065d8dc5), C(d1519d2403b62aa0), C(9136456740119815), C(4d8ff7733b27eb83), C(ea3040bc0c717ef8), C(7617ab400dfadbc),
-C(9136456740119815), C(4d8ff7733b27eb83), C(ea3040bc0c717ef8), C(7617ab400dfadbc),
-C(fb336770c10b17a1), C(6123b68b5b31f151), C(1e147d5f295eccf2), C(9ecbb1333556f977),
-C(3a2b431d)},
-{C(48949dc327bb96ad), C(e1fd21636c5c50b4), C(3f6eb7f13a8712b4), C(14cf7f02dab0eee8), C(6d01750605e89445), C(4f1cf4006e613b78), C(57c40c4db32bec3b),
-C(14cf7f02dab0eee8), C(6d01750605e89445), C(4f1cf4006e613b78), C(57c40c4db32bec3b),
-C(1fde5a347f4a326e), C(cb5a54308adb0e3f), C(14994b2ba447a23c), C(7067d0abb4257b68),
-C(7322a83d)},
-{C(b7c4209fb24a85c5), C(b35feb319c79ce10), C(f0d3de191833b922), C(570d62758ddf6397), C(5e0204fb68a7b800), C(4383a9236f8b5a2b), C(7bc1a64641d803a4),
-C(570d62758ddf6397), C(5e0204fb68a7b800), C(4383a9236f8b5a2b), C(7bc1a64641d803a4),
-C(5434d61285099f7a), C(d49449aacdd5dd67), C(97855ba0e9a7d75d), C(da67328062f3a62f),
-C(a645ca1c)},
-{C(9c9e5be0943d4b05), C(b73dc69e45201cbb), C(aab17180bfe5083d), C(c738a77a9a55f0e2), C(705221addedd81df), C(fd9bd8d397abcfa3), C(8ccf0004aa86b795),
-C(c738a77a9a55f0e2), C(705221addedd81df), C(fd9bd8d397abcfa3), C(8ccf0004aa86b795),
-C(2bb5db2280068206), C(8c22d29f307a01d), C(274a22de02f473c8), C(b8791870f4268182),
-C(8909a45a)},
-{C(3898bca4dfd6638d), C(f911ff35efef0167), C(24bdf69e5091fc88), C(9b82567ab6560796), C(891b69462b41c224), C(8eccc7e4f3af3b51), C(381e54c3c8f1c7d0),
-C(9b82567ab6560796), C(891b69462b41c224), C(8eccc7e4f3af3b51), C(381e54c3c8f1c7d0),
-C(c80fbc489a558a55), C(1ba88e062a663af7), C(af7b1ef1c0116303), C(bd20e1a5a6b1a0cd),
-C(bd30074c)},
-{C(5b5d2557400e68e7), C(98d610033574cee), C(dfd08772ce385deb), C(3c13e894365dc6c2), C(26fc7bbcda3f0ef), C(dbb71106cdbfea36), C(785239a742c6d26d),
-C(3c13e894365dc6c2), C(26fc7bbcda3f0ef), C(dbb71106cdbfea36), C(785239a742c6d26d),
-C(f810c415ae05b2f4), C(bb9b9e7398526088), C(70128f1bf830a32b), C(bcc73f82b6410899),
-C(c17cf001)},
-{C(a927ed8b2bf09bb6), C(606e52f10ae94eca), C(71c2203feb35a9ee), C(6e65ec14a8fb565), C(34bff6f2ee5a7f79), C(2e329a5be2c011b), C(73161c93331b14f9),
-C(6e65ec14a8fb565), C(34bff6f2ee5a7f79), C(2e329a5be2c011b), C(73161c93331b14f9),
-C(15d13f2408aecf88), C(9f5b61b8a4b55b31), C(8fe25a43b296dba6), C(bdad03b7300f284e),
-C(26ffd25a)},
-{C(8d25746414aedf28), C(34b1629d28b33d3a), C(4d5394aea5f82d7b), C(379f76458a3c8957), C(79dd080f9843af77), C(c46f0a7847f60c1d), C(af1579c5797703cc),
-C(379f76458a3c8957), C(79dd080f9843af77), C(c46f0a7847f60c1d), C(af1579c5797703cc),
-C(8b7d31f338755c14), C(2eff97679512aaa8), C(df07d68e075179ed), C(c8fa6c7a729e7f1f),
-C(f1d8ce3c)},
-{C(b5bbdb73458712f2), C(1ff887b3c2a35137), C(7f7231f702d0ace9), C(1e6f0910c3d25bd8), C(ad9e250862102467), C(1c842a07abab30cd), C(cd8124176bac01ac),
-C(1e6f0910c3d25bd8), C(ad9e250862102467), C(1c842a07abab30cd), C(cd8124176bac01ac),
-C(ea6ebe7a79b67edc), C(73f598ac9db26713), C(4f4e72d7460b8fc), C(365dc4b9fdf13f21),
-C(3ee8fb17)},
-{C(3d32a26e3ab9d254), C(fc4070574dc30d3a), C(f02629579c2b27c9), C(b1cf09b0184a4834), C(5c03db48eb6cc159), C(f18c7fcf34d1df47), C(dfb043419ecf1fa9),
-C(b1cf09b0184a4834), C(5c03db48eb6cc159), C(f18c7fcf34d1df47), C(dfb043419ecf1fa9),
-C(dcd78d13f9ca658f), C(4355d408ffe8e49f), C(81eefee908b593b4), C(590c213c20e981a3),
-C(a77acc2a)},
-{C(9371d3c35fa5e9a5), C(42967cf4d01f30), C(652d1eeae704145c), C(ceaf1a0d15234f15), C(1450a54e45ba9b9), C(65e9c1fd885aa932), C(354d4bc034ba8cbe),
-C(ceaf1a0d15234f15), C(1450a54e45ba9b9), C(65e9c1fd885aa932), C(354d4bc034ba8cbe),
-C(8fd4ff484c08fb4b), C(bf46749866f69ba0), C(cf1c21ede82c9477), C(4217548c43da109),
-C(f4556dee)},
-{C(cbaa3cb8f64f54e0), C(76c3b48ee5c08417), C(9f7d24e87e61ce9), C(85b8e53f22e19507), C(bb57137739ca486b), C(c77f131cca38f761), C(c56ac3cf275be121),
-C(85b8e53f22e19507), C(bb57137739ca486b), C(c77f131cca38f761), C(c56ac3cf275be121),
-C(9ec1a6c9109d2685), C(3dad0922e76afdb0), C(fd58cbf952958103), C(7b04c908e78639a1),
-C(de287a64)},
-{C(b2e23e8116c2ba9f), C(7e4d9c0060101151), C(3310da5e5028f367), C(adc52dddb76f6e5e), C(4aad4e925a962b68), C(204b79b7f7168e64), C(df29ed6671c36952),
-C(adc52dddb76f6e5e), C(4aad4e925a962b68), C(204b79b7f7168e64), C(df29ed6671c36952),
-C(e02927cac396d210), C(5d500e71742b638a), C(5c9998af7f27b124), C(3fba9a2573dc2f7),
-C(878e55b9)},
-{C(8aa77f52d7868eb9), C(4d55bd587584e6e2), C(d2db37041f495f5), C(ce030d15b5fe2f4), C(86b4a7a0780c2431), C(ee070a9ae5b51db7), C(edc293d9595be5d8),
-C(ce030d15b5fe2f4), C(86b4a7a0780c2431), C(ee070a9ae5b51db7), C(edc293d9595be5d8),
-C(3dfc5ec108260a2b), C(8afe28c7123bf4e2), C(da82ef38023a7a5f), C(3e1f77b0174b77c3),
-C(7648486)},
-{C(858fea922c7fe0c3), C(cfe8326bf733bc6f), C(4e5e2018cf8f7dfc), C(64fd1bc011e5bab7), C(5c9e858728015568), C(97ac42c2b00b29b1), C(7f89caf08c109aee),
-C(64fd1bc011e5bab7), C(5c9e858728015568), C(97ac42c2b00b29b1), C(7f89caf08c109aee),
-C(9a8af34fd0e9dacf), C(bbc54161aa1507e0), C(7cda723ccbbfe5ee), C(2c289d839fb93f58),
-C(57ac0fb1)},
-{C(46ef25fdec8392b1), C(e48d7b6d42a5cd35), C(56a6fe1c175299ca), C(fdfa836b41dcef62), C(2f8db8030e847e1b), C(5ba0a49ac4f9b0f8), C(dae897ed3e3fce44),
-C(fdfa836b41dcef62), C(2f8db8030e847e1b), C(5ba0a49ac4f9b0f8), C(dae897ed3e3fce44),
-C(9c432e31aef626e7), C(9a36e1c6cd6e3dd), C(5095a167c34d19d), C(a70005cfa6babbea),
-C(d01967ca)},
-{C(8d078f726b2df464), C(b50ee71cdcabb299), C(f4af300106f9c7ba), C(7d222caae025158a), C(cc028d5fd40241b9), C(dd42515b639e6f97), C(e08e86531a58f87f),
-C(7d222caae025158a), C(cc028d5fd40241b9), C(dd42515b639e6f97), C(e08e86531a58f87f),
-C(d93612c835b37d7b), C(91dd61729b2fa7f4), C(ba765a1bdda09db7), C(55258b451b2b1297),
-C(96ecdf74)},
-{C(35ea86e6960ca950), C(34fe1fe234fc5c76), C(a00207a3dc2a72b7), C(80395e48739e1a67), C(74a67d8f7f43c3d7), C(dd2bdd1d62246c6e), C(a1f44298ba80acf6),
-C(80395e48739e1a67), C(74a67d8f7f43c3d7), C(dd2bdd1d62246c6e), C(a1f44298ba80acf6),
-C(ad86d86c187bf38), C(26feea1f2eee240d), C(ed7f1fd066b23897), C(a768cf1e0fbb502),
-C(779f5506)},
-{C(8aee9edbc15dd011), C(51f5839dc8462695), C(b2213e17c37dca2d), C(133b299a939745c5), C(796e2aac053f52b3), C(e8d9fe1521a4a222), C(819a8863e5d1c290),
-C(133b299a939745c5), C(796e2aac053f52b3), C(e8d9fe1521a4a222), C(819a8863e5d1c290),
-C(c0737f0fe34d36ad), C(e6d6d4a267a5cc31), C(98300a7911674c23), C(bef189661c257098),
-C(3c94c2de)},
-{C(c3e142ba98432dda), C(911d060cab126188), C(b753fbfa8365b844), C(fd1a9ba5e71b08a2), C(7ac0dc2ed7778533), C(b543161ff177188a), C(492fc08a6186f3f4),
-C(fd1a9ba5e71b08a2), C(7ac0dc2ed7778533), C(b543161ff177188a), C(492fc08a6186f3f4),
-C(fc4745f516afd3b6), C(88c30370a53080e), C(65a1bb34abc465e2), C(abbd14662911c8b3),
-C(39f98faf)},
-{C(123ba6b99c8cd8db), C(448e582672ee07c4), C(cebe379292db9e65), C(938f5bbab544d3d6), C(d2a95f9f2d376d73), C(68b2f16149e81aa3), C(ad7e32f82d86c79d),
-C(938f5bbab544d3d6), C(d2a95f9f2d376d73), C(68b2f16149e81aa3), C(ad7e32f82d86c79d),
-C(4574015ae8626ce2), C(455aa6137386a582), C(658ad2542e8ec20), C(e31d7be2ca35d00),
-C(7af31199)},
-{C(ba87acef79d14f53), C(b3e0fcae63a11558), C(d5ac313a593a9f45), C(eea5f5a9f74af591), C(578710bcc36fbea2), C(7a8393432188931d), C(705cfc5ec7cc172),
-C(eea5f5a9f74af591), C(578710bcc36fbea2), C(7a8393432188931d), C(705cfc5ec7cc172),
-C(da85ebe5fc427976), C(bfa5c7a454df54c8), C(4632b72a81bf66d2), C(5dd72877db539ee2),
-C(e341a9d6)},
-{C(bcd3957d5717dc3), C(2da746741b03a007), C(873816f4b1ece472), C(2b826f1a2c08c289), C(da50f56863b55e74), C(b18712f6b3eed83b), C(bdc7cc05ab4c685f),
-C(2b826f1a2c08c289), C(da50f56863b55e74), C(b18712f6b3eed83b), C(bdc7cc05ab4c685f),
-C(9e45fb833d1b0af), C(d7213081db29d82e), C(d2a6b6c6a09ed55e), C(98a7686cba323ca9),
-C(ca24aeeb)},
-{C(61442ff55609168e), C(6447c5fc76e8c9cf), C(6a846de83ae15728), C(effc2663cffc777f), C(93214f8f463afbed), C(a156ef06066f4e4e), C(a407b6ed8769d51e),
-C(effc2663cffc777f), C(93214f8f463afbed), C(a156ef06066f4e4e), C(a407b6ed8769d51e),
-C(bb2f9ed29745c02a), C(981eecd435b36ad9), C(461a5a05fb9cdff4), C(bd6cb2a87b9f910c),
-C(b2252b57)},
-{C(dbe4b1b2d174757f), C(506512da18712656), C(6857f3e0b8dd95f), C(5a4fc2728a9bb671), C(ebb971522ec38759), C(1a5a093e6cf1f72b), C(729b057fe784f504),
-C(5a4fc2728a9bb671), C(ebb971522ec38759), C(1a5a093e6cf1f72b), C(729b057fe784f504),
-C(71fcbf42a767f9cf), C(114cfe772da6cdd), C(60cdf9cb629d9d7a), C(e270d10ad088b24e),
-C(72c81da1)},
-{C(531e8e77b363161c), C(eece0b43e2dae030), C(8294b82c78f34ed1), C(e777b1fd580582f2), C(7b880f58da112699), C(562c6b189a6333f4), C(139d64f88a611d4),
-C(e777b1fd580582f2), C(7b880f58da112699), C(562c6b189a6333f4), C(139d64f88a611d4),
-C(53d8ef17eda64fa4), C(bf3eded14dc60a04), C(2b5c559cf5ec07c5), C(8895f7339d03a48a),
-C(6b9fce95)},
-{C(f71e9c926d711e2b), C(d77af2853a4ceaa1), C(9aa0d6d76a36fae7), C(dd16cd0fbc08393), C(29a414a5d8c58962), C(72793d8d1022b5b2), C(2e8e69cf7cbffdf0),
-C(dd16cd0fbc08393), C(29a414a5d8c58962), C(72793d8d1022b5b2), C(2e8e69cf7cbffdf0),
-C(3721c0473aa99c9a), C(1cff4ed9c31cd91c), C(4990735033cc482b), C(7fdf8c701c72f577),
-C(19399857)},
-{C(cb20ac28f52df368), C(e6705ee7880996de), C(9b665cc3ec6972f2), C(4260e8c254e9924b), C(f197a6eb4591572d), C(8e867ff0fb7ab27c), C(f95502fb503efaf3),
-C(4260e8c254e9924b), C(f197a6eb4591572d), C(8e867ff0fb7ab27c), C(f95502fb503efaf3),
-C(30c41876b08e3e22), C(958e2419e3cd22f4), C(f0f3aa1fe119a107), C(481662310a379100),
-C(3c57a994)},
-{C(e4a794b4acb94b55), C(89795358057b661b), C(9c4cdcec176d7a70), C(4890a83ee435bc8b), C(d8c1c00fceb00914), C(9e7111ba234f900f), C(eb8dbab364d8b604),
-C(4890a83ee435bc8b), C(d8c1c00fceb00914), C(9e7111ba234f900f), C(eb8dbab364d8b604),
-C(b3261452963eebb), C(6cf94b02792c4f95), C(d88fa815ef1e8fc), C(2d687af66604c73),
-C(c053e729)},
-{C(cb942e91443e7208), C(e335de8125567c2a), C(d4d74d268b86df1f), C(8ba0fdd2ffc8b239), C(f413b366c1ffe02f), C(c05b2717c59a8a28), C(981188eab4fcc8fb),
-C(8ba0fdd2ffc8b239), C(f413b366c1ffe02f), C(c05b2717c59a8a28), C(981188eab4fcc8fb),
-C(e563f49a1d9072ba), C(3c6a3aa4a26367dc), C(ba0db13448653f34), C(31065d756074d7d6),
-C(51cbbba7)},
-{C(ecca7563c203f7ba), C(177ae2423ef34bb2), C(f60b7243400c5731), C(cf1edbfe7330e94e), C(881945906bcb3cc6), C(4acf0293244855da), C(65ae042c1c2a28c2),
-C(cf1edbfe7330e94e), C(881945906bcb3cc6), C(4acf0293244855da), C(65ae042c1c2a28c2),
-C(b25fa0a1cab33559), C(d98e8daa28124131), C(fce17f50b9c351b3), C(3f995ccf7386864b),
-C(1acde79a)},
-{C(1652cb940177c8b5), C(8c4fe7d85d2a6d6d), C(f6216ad097e54e72), C(f6521b912b368ae6), C(a9fe4eff81d03e73), C(d6f623629f80d1a3), C(2b9604f32cb7dc34),
-C(f6521b912b368ae6), C(a9fe4eff81d03e73), C(d6f623629f80d1a3), C(2b9604f32cb7dc34),
-C(2a43d84dcf59c7e2), C(d0a197c70c5dae0b), C(6e84d4bbc71d76a0), C(c7e94620378c6cb2),
-C(2d160d13)},
-{C(31fed0fc04c13ce8), C(3d5d03dbf7ff240a), C(727c5c9b51581203), C(6b5ffc1f54fecb29), C(a8e8e7ad5b9a21d9), C(c4d5a32cd6aac22d), C(d7e274ad22d4a79a),
-C(6b5ffc1f54fecb29), C(a8e8e7ad5b9a21d9), C(c4d5a32cd6aac22d), C(d7e274ad22d4a79a),
-C(368841ea5731a112), C(feaf7bc2e73ca48f), C(636fb272e9ea1f6), C(5d9cb7580c3f6207),
-C(787f5801)},
-{C(e7b668947590b9b3), C(baa41ad32938d3fa), C(abcbc8d4ca4b39e4), C(381ee1b7ea534f4e), C(da3759828e3de429), C(3e015d76729f9955), C(cbbec51a6485fbde),
-C(381ee1b7ea534f4e), C(da3759828e3de429), C(3e015d76729f9955), C(cbbec51a6485fbde),
-C(9b86605281f20727), C(fc6fcf508676982a), C(3b135f7a813a1040), C(d3a4706bea1db9c9),
-C(c9629828)},
-{C(1de2119923e8ef3c), C(6ab27c096cf2fe14), C(8c3658edca958891), C(4cc8ed3ada5f0f2), C(4a496b77c1f1c04e), C(9085b0a862084201), C(a1894bde9e3dee21),
-C(4cc8ed3ada5f0f2), C(4a496b77c1f1c04e), C(9085b0a862084201), C(a1894bde9e3dee21),
-C(367fb472dc5b277d), C(7d39ccca16fc6745), C(763f988d70db9106), C(a8b66f7fecb70f02),
-C(be139231)},
-{C(1269df1e69e14fa7), C(992f9d58ac5041b7), C(e97fcf695a7cbbb4), C(e5d0549802d15008), C(424c134ecd0db834), C(6fc44fd91be15c6c), C(a1a5ef95d50e537d),
-C(e5d0549802d15008), C(424c134ecd0db834), C(6fc44fd91be15c6c), C(a1a5ef95d50e537d),
-C(d1e3daf5d05f5308), C(4c7f81600eaa1327), C(109d1b8d1f9d0d2b), C(871e8699e0aeb862),
-C(7df699ef)},
-{C(820826d7aba567ff), C(1f73d28e036a52f3), C(41c4c5a73f3b0893), C(aa0d74d4a98db89b), C(36fd486d07c56e1d), C(d0ad23cbb6660d8a), C(1264a84665b35e19),
-C(aa0d74d4a98db89b), C(36fd486d07c56e1d), C(d0ad23cbb6660d8a), C(1264a84665b35e19),
-C(789682bf7d781b33), C(6bfa6abd2fb5722d), C(6779cb3623d33900), C(435ca5214e1ee5f0),
-C(8ce6b96d)},
-{C(ffe0547e4923cef9), C(3534ed49b9da5b02), C(548a273700fba03d), C(28ac84ca70958f7e), C(d8ae575a68faa731), C(2aaaee9b9dcffd4c), C(6c7faab5c285c6da),
-C(28ac84ca70958f7e), C(d8ae575a68faa731), C(2aaaee9b9dcffd4c), C(6c7faab5c285c6da),
-C(45d94235f99ba78f), C(ab5ea16f39497f5b), C(fb4d6c86fccbdca3), C(8104e6310a5fd2c7),
-C(6f9ed99c)},
-{C(72da8d1b11d8bc8b), C(ba94b56b91b681c6), C(4e8cc51bd9b0fc8c), C(43505ed133be672a), C(e8f2f9d973c2774e), C(677b9b9c7cad6d97), C(4e1f5d56ef17b906),
-C(43505ed133be672a), C(e8f2f9d973c2774e), C(677b9b9c7cad6d97), C(4e1f5d56ef17b906),
-C(eea3a6038f983767), C(87109f077f86db01), C(ecc1ca41f74d61cc), C(34a87e86e83bed17),
-C(e0244796)},
-{C(d62ab4e3f88fc797), C(ea86c7aeb6283ae4), C(b5b93e09a7fe465), C(4344a1a0134afe2), C(ff5c17f02b62341d), C(3214c6a587ce4644), C(a905e7ed0629d05c),
-C(4344a1a0134afe2), C(ff5c17f02b62341d), C(3214c6a587ce4644), C(a905e7ed0629d05c),
-C(b5c72690cd716e82), C(7c6097649e6ebe7b), C(7ceee8c6e56a4dcd), C(80ca849dc53eb9e4),
-C(4ccf7e75)},
-{C(d0f06c28c7b36823), C(1008cb0874de4bb8), C(d6c7ff816c7a737b), C(489b697fe30aa65f), C(4da0fb621fdc7817), C(dc43583b82c58107), C(4b0261debdec3cd6),
-C(489b697fe30aa65f), C(4da0fb621fdc7817), C(dc43583b82c58107), C(4b0261debdec3cd6),
-C(a9748d7b6c0e016c), C(7e8828f7ba4b034b), C(da0fa54348a2512a), C(ebf9745c0962f9ad),
-C(915cef86)},
-{C(99b7042460d72ec6), C(2a53e5e2b8e795c2), C(53a78132d9e1b3e3), C(c043e67e6fc64118), C(ff0abfe926d844d3), C(f2a9fe5db2e910fe), C(ce352cdc84a964dd),
-C(c043e67e6fc64118), C(ff0abfe926d844d3), C(f2a9fe5db2e910fe), C(ce352cdc84a964dd),
-C(b89bc028aa5e6063), C(a354e7fdac04459c), C(68d6547e6e980189), C(c968dddfd573773e),
-C(5cb59482)},
-{C(4f4dfcfc0ec2bae5), C(841233148268a1b8), C(9248a76ab8be0d3), C(334c5a25b5903a8c), C(4c94fef443122128), C(743e7d8454655c40), C(1ab1e6d1452ae2cd),
-C(334c5a25b5903a8c), C(4c94fef443122128), C(743e7d8454655c40), C(1ab1e6d1452ae2cd),
-C(fec766de4a8e476c), C(cc0929da9567e71b), C(5f9ef5b5f150c35a), C(87659cabd649768f),
-C(6ca3f532)},
-{C(fe86bf9d4422b9ae), C(ebce89c90641ef9c), C(1c84e2292c0b5659), C(8bde625a10a8c50d), C(eb8271ded1f79a0b), C(14dc6844f0de7a3c), C(f85b2f9541e7e6da),
-C(8bde625a10a8c50d), C(eb8271ded1f79a0b), C(14dc6844f0de7a3c), C(f85b2f9541e7e6da),
-C(2fe22cfd1683b961), C(ea1d75c5b7aa01ca), C(9eef60a44876bb95), C(950c818e505c6f7f),
-C(e24f3859)},
-{C(a90d81060932dbb0), C(8acfaa88c5fbe92b), C(7c6f3447e90f7f3f), C(dd52fc14c8dd3143), C(1bc7508516e40628), C(3059730266ade626), C(ffa526822f391c2),
-C(dd52fc14c8dd3143), C(1bc7508516e40628), C(3059730266ade626), C(ffa526822f391c2),
-C(e25232d7afc8a406), C(d2b8a5a3f3b5f670), C(6630f33edb7dfe32), C(c71250ba68c4ea86),
-C(adf5a9c7)},
-{C(17938a1b0e7f5952), C(22cadd2f56f8a4be), C(84b0d1183d5ed7c1), C(c1336b92fef91bf6), C(80332a3945f33fa9), C(a0f68b86f726ff92), C(a3db5282cf5f4c0b),
-C(c1336b92fef91bf6), C(80332a3945f33fa9), C(a0f68b86f726ff92), C(a3db5282cf5f4c0b),
-C(82640b6fc4916607), C(2dc2a3aa1a894175), C(8b4c852bdee7cc9), C(10b9d0a08b55ff83),
-C(32264b75)},
-{C(de9e0cb0e16f6e6d), C(238e6283aa4f6594), C(4fb9c914c2f0a13b), C(497cb912b670f3b), C(d963a3f02ff4a5b6), C(4fccefae11b50391), C(42ba47db3f7672f),
-C(497cb912b670f3b), C(d963a3f02ff4a5b6), C(4fccefae11b50391), C(42ba47db3f7672f),
-C(1d6b655a1889feef), C(5f319abf8fafa19f), C(715c2e49deb14620), C(8d9153082ecdcea4),
-C(a64b3376)},
-{C(6d4b876d9b146d1a), C(aab2d64ce8f26739), C(d315f93600e83fe5), C(2fe9fabdbe7fdd4), C(755db249a2d81a69), C(f27929f360446d71), C(79a1bf957c0c1b92),
-C(2fe9fabdbe7fdd4), C(755db249a2d81a69), C(f27929f360446d71), C(79a1bf957c0c1b92),
-C(3c8a28d4c936c9cd), C(df0d3d13b2c6a902), C(c76702dd97cd2edd), C(1aa220f7be16517),
-C(d33890e)},
-{C(e698fa3f54e6ea22), C(bd28e20e7455358c), C(9ace161f6ea76e66), C(d53fb7e3c93a9e4), C(737ae71b051bf108), C(7ac71feb84c2df42), C(3d8075cd293a15b4),
-C(d53fb7e3c93a9e4), C(737ae71b051bf108), C(7ac71feb84c2df42), C(3d8075cd293a15b4),
-C(bf8cee5e095d8a7c), C(e7086b3c7608143a), C(e55b0c2fa938d70c), C(fffb5f58e643649c),
-C(926d4b63)},
-{C(7bc0deed4fb349f7), C(1771aff25dc722fa), C(19ff0644d9681917), C(cf7d7f25bd70cd2c), C(9464ed9baeb41b4f), C(b9064f5c3cb11b71), C(237e39229b012b20),
-C(cf7d7f25bd70cd2c), C(9464ed9baeb41b4f), C(b9064f5c3cb11b71), C(237e39229b012b20),
-C(dd54d3f5d982dffe), C(7fc7562dbfc81dbf), C(5b0dd1924f70945), C(f1760537d8261135),
-C(d51ba539)},
-{C(db4b15e88533f622), C(256d6d2419b41ce9), C(9d7c5378396765d5), C(9040e5b936b8661b), C(276e08fa53ac27fd), C(8c944d39c2bdd2cc), C(e2514c9802a5743c),
-C(9040e5b936b8661b), C(276e08fa53ac27fd), C(8c944d39c2bdd2cc), C(e2514c9802a5743c),
-C(e82107b11ac90386), C(7d6a22bc35055e6), C(fd6ea9d1c438d8ae), C(be6015149e981553),
-C(7f37636d)},
-{C(922834735e86ecb2), C(363382685b88328e), C(e9c92960d7144630), C(8431b1bfd0a2379c), C(90383913aea283f9), C(a6163831eb4924d2), C(5f3921b4f9084aee),
-C(8431b1bfd0a2379c), C(90383913aea283f9), C(a6163831eb4924d2), C(5f3921b4f9084aee),
-C(7a70061a1473e579), C(5b19d80dcd2c6331), C(6196b97931faad27), C(869bf6828e237c3f),
-C(b98026c0)},
-{C(30f1d72c812f1eb8), C(b567cd4a69cd8989), C(820b6c992a51f0bc), C(c54677a80367125e), C(3204fbdba462e606), C(8563278afc9eae69), C(262147dd4bf7e566),
-C(c54677a80367125e), C(3204fbdba462e606), C(8563278afc9eae69), C(262147dd4bf7e566),
-C(2178b63e7ee2d230), C(e9c61ad81f5bff26), C(9af7a81b3c501eca), C(44104a3859f0238f),
-C(b877767e)},
-{C(168884267f3817e9), C(5b376e050f637645), C(1c18314abd34497a), C(9598f6ab0683fcc2), C(1c805abf7b80e1ee), C(dec9ac42ee0d0f32), C(8cd72e3912d24663),
-C(9598f6ab0683fcc2), C(1c805abf7b80e1ee), C(dec9ac42ee0d0f32), C(8cd72e3912d24663),
-C(1f025d405f1c1d87), C(bf7b6221e1668f8f), C(52316f64e692dbb0), C(7bf43df61ec51b39),
-C(aefae77)},
-{C(82e78596ee3e56a7), C(25697d9c87f30d98), C(7600a8342834924d), C(6ba372f4b7ab268b), C(8c3237cf1fe243df), C(3833fc51012903df), C(8e31310108c5683f),
-C(6ba372f4b7ab268b), C(8c3237cf1fe243df), C(3833fc51012903df), C(8e31310108c5683f),
-C(126593715c2de429), C(48ca8f35a3f54b90), C(b9322b632f4f8b0), C(926bb169b7337693),
-C(f686911)},
-{C(aa2d6cf22e3cc252), C(9b4dec4f5e179f16), C(76fb0fba1d99a99a), C(9a62af3dbba140da), C(27857ea044e9dfc1), C(33abce9da2272647), C(b22a7993aaf32556),
-C(9a62af3dbba140da), C(27857ea044e9dfc1), C(33abce9da2272647), C(b22a7993aaf32556),
-C(bf8f88f8019bedf0), C(ed2d7f01fb273905), C(6b45f15901b481cd), C(f88ebb413ba6a8d5),
-C(3deadf12)},
-{C(7bf5ffd7f69385c7), C(fc077b1d8bc82879), C(9c04e36f9ed83a24), C(82065c62e6582188), C(8ef787fd356f5e43), C(2922e53e36e17dfa), C(9805f223d385010b),
-C(82065c62e6582188), C(8ef787fd356f5e43), C(2922e53e36e17dfa), C(9805f223d385010b),
-C(692154f3491b787d), C(e7e64700e414fbf), C(757d4d4ab65069a0), C(cd029446a8e348e2),
-C(ccf02a4e)},
-{C(e89c8ff9f9c6e34b), C(f54c0f669a49f6c4), C(fc3e46f5d846adef), C(22f2aa3df2221cc), C(f66fea90f5d62174), C(b75defaeaa1dd2a7), C(9b994cd9a7214fd5),
-C(22f2aa3df2221cc), C(f66fea90f5d62174), C(b75defaeaa1dd2a7), C(9b994cd9a7214fd5),
-C(fac675a31804b773), C(98bcb3b820c50fc6), C(e14af64d28cf0885), C(27466fbd2b360eb5),
-C(176c1722)},
-{C(a18fbcdccd11e1f4), C(8248216751dfd65e), C(40c089f208d89d7c), C(229b79ab69ae97d), C(a87aabc2ec26e582), C(be2b053721eb26d2), C(10febd7f0c3d6fcb),
-C(229b79ab69ae97d), C(a87aabc2ec26e582), C(be2b053721eb26d2), C(10febd7f0c3d6fcb),
-C(9cc5b9b2f6e3bf7b), C(655d8495fe624a86), C(6381a9f3d1f2bd7e), C(79ebabbfc25c83e2),
-C(26f82ad)},
-{C(2d54f40cc4088b17), C(59d15633b0cd1399), C(a8cc04bb1bffd15b), C(d332cdb073d8dc46), C(272c56466868cb46), C(7e7fcbe35ca6c3f3), C(ee8f51e5a70399d4),
-C(d332cdb073d8dc46), C(272c56466868cb46), C(7e7fcbe35ca6c3f3), C(ee8f51e5a70399d4),
-C(16737a9c7581fe7b), C(ed04bf52f4b75dcb), C(9707ffb36bd30c1a), C(1390f236fdc0de3e),
-C(b5244f42)},
-{C(69276946cb4e87c7), C(62bdbe6183be6fa9), C(3ba9773dac442a1a), C(702e2afc7f5a1825), C(8c49b11ea8151fdc), C(caf3fef61f5a86fa), C(ef0b2ee8649d7272),
-C(702e2afc7f5a1825), C(8c49b11ea8151fdc), C(caf3fef61f5a86fa), C(ef0b2ee8649d7272),
-C(9e34a4e08d9441e1), C(7bdc0cd64d5af533), C(a926b14d99e3d868), C(fca923a17788cce4),
-C(49a689e5)},
-{C(668174a3f443df1d), C(407299392da1ce86), C(c2a3f7d7f2c5be28), C(a590b202a7a5807b), C(968d2593f7ccb54e), C(9dd8d669e3e95dec), C(ee0cc5dd58b6e93a),
-C(a590b202a7a5807b), C(968d2593f7ccb54e), C(9dd8d669e3e95dec), C(ee0cc5dd58b6e93a),
-C(ac65d5a9466fb483), C(221be538b2c9d806), C(5cbe9441784f9fd9), C(d4c7d5d6e3c122b8),
-C(59fcdd3)},
-{C(5e29be847bd5046), C(b561c7f19c8f80c3), C(5e5abd5021ccaeaf), C(7432d63888e0c306), C(74bbceeed479cb71), C(6471586599575fdf), C(6a859ad23365cba2),
-C(7432d63888e0c306), C(74bbceeed479cb71), C(6471586599575fdf), C(6a859ad23365cba2),
-C(f9ceec84acd18dcc), C(74a242ff1907437c), C(f70890194e1ee913), C(777dfcb4bb01f0ba),
-C(4f4b04e9)},
-{C(cd0d79f2164da014), C(4c386bb5c5d6ca0c), C(8e771b03647c3b63), C(69db23875cb0b715), C(ada8dd91504ae37f), C(46bf18dbf045ed6a), C(e1b5f67b0645ab63),
-C(69db23875cb0b715), C(ada8dd91504ae37f), C(46bf18dbf045ed6a), C(e1b5f67b0645ab63),
-C(877be8f5dcddff4), C(6d471b5f9ca2e2d1), C(802c86d6f495b9bb), C(a1f9b9b22b3be704),
-C(8b00f891)},
-{C(e0e6fc0b1628af1d), C(29be5fb4c27a2949), C(1c3f781a604d3630), C(c4af7faf883033aa), C(9bd296c4e9453cac), C(ca45426c1f7e33f9), C(a6bbdcf7074d40c5),
-C(c4af7faf883033aa), C(9bd296c4e9453cac), C(ca45426c1f7e33f9), C(a6bbdcf7074d40c5),
-C(e13a005d7142733b), C(c02b7925c5eeefaf), C(d39119a60441e2d5), C(3c24c710df8f4d43),
-C(16e114f3)},
-{C(2058927664adfd93), C(6e8f968c7963baa5), C(af3dced6fff7c394), C(42e34cf3d53c7876), C(9cddbb26424dc5e), C(64f6340a6d8eddad), C(2196e488eb2a3a4b),
-C(42e34cf3d53c7876), C(9cddbb26424dc5e), C(64f6340a6d8eddad), C(2196e488eb2a3a4b),
-C(c9e9da25911a16fd), C(e21b4683f3e196a8), C(cb80bf1a4c6fdbb4), C(53792e9b3c3e67f8),
-C(d6b6dadc)},
-{C(dc107285fd8e1af7), C(a8641a0609321f3f), C(db06e89ffdc54466), C(bcc7a81ed5432429), C(b6d7bdc6ad2e81f1), C(93605ec471aa37db), C(a2a73f8a85a8e397),
-C(bcc7a81ed5432429), C(b6d7bdc6ad2e81f1), C(93605ec471aa37db), C(a2a73f8a85a8e397),
-C(10a012b8ca7ac24b), C(aac5fd63351595cf), C(5bb4c648a226dea0), C(9d11ecb2b5c05c5f),
-C(897e20ac)},
-{C(fbba1afe2e3280f1), C(755a5f392f07fce), C(9e44a9a15402809a), C(6226a32e25099848), C(ea895661ecf53004), C(4d7e0158db2228b9), C(e5a7d82922f69842),
-C(6226a32e25099848), C(ea895661ecf53004), C(4d7e0158db2228b9), C(e5a7d82922f69842),
-C(2cea7713b69840ca), C(18de7b9ae938375b), C(f127cca08f3cc665), C(b1c22d727665ad2),
-C(f996e05d)},
-{C(bfa10785ddc1011b), C(b6e1c4d2f670f7de), C(517d95604e4fcc1f), C(ca6552a0dfb82c73), C(b024cdf09e34ba07), C(66cd8c5a95d7393b), C(e3939acf790d4a74),
-C(ca6552a0dfb82c73), C(b024cdf09e34ba07), C(66cd8c5a95d7393b), C(e3939acf790d4a74),
-C(97827541a1ef051e), C(ac2fce47ebe6500c), C(b3f06d3bddf3bd6a), C(1d74afb25e1ce5fe),
-C(c4306af6)},
-{C(534cc35f0ee1eb4e), C(b703820f1f3b3dce), C(884aa164cf22363), C(f14ef7f47d8a57a3), C(80d1f86f2e061d7c), C(401d6c2f151b5a62), C(e988460224108944),
-C(f14ef7f47d8a57a3), C(80d1f86f2e061d7c), C(401d6c2f151b5a62), C(e988460224108944),
-C(7804d4135f68cd19), C(5487b4b39e69fe8e), C(8cc5999015358a27), C(8f3729b61c2d5601),
-C(6dcad433)},
-{C(7ca6e3933995dac), C(fd118c77daa8188), C(3aceb7b5e7da6545), C(c8389799445480db), C(5389f5df8aacd50d), C(d136581f22fab5f), C(c2f31f85991da417),
-C(c8389799445480db), C(5389f5df8aacd50d), C(d136581f22fab5f), C(c2f31f85991da417),
-C(aefbf9ff84035a43), C(8accbaf44adadd7c), C(e57f3657344b67f5), C(21490e5e8abdec51),
-C(3c07374d)},
-{C(f0d6044f6efd7598), C(e044d6ba4369856e), C(91968e4f8c8a1a4c), C(70bd1968996bffc2), C(4c613de5d8ab32ac), C(fe1f4f97206f79d8), C(ac0434f2c4e213a9),
-C(70bd1968996bffc2), C(4c613de5d8ab32ac), C(fe1f4f97206f79d8), C(ac0434f2c4e213a9),
-C(7490e9d82cfe22ca), C(5fbbf7f987454238), C(c39e0dc8368ce949), C(22201d3894676c71),
-C(f0f4602c)},
-{C(3d69e52049879d61), C(76610636ea9f74fe), C(e9bf5602f89310c0), C(8eeb177a86053c11), C(e390122c345f34a2), C(1e30e47afbaaf8d6), C(7b892f68e5f91732),
-C(8eeb177a86053c11), C(e390122c345f34a2), C(1e30e47afbaaf8d6), C(7b892f68e5f91732),
-C(b87922525fa44158), C(f440a1ee1a1a766b), C(ee8efad279d08c5c), C(421f910c5b60216e),
-C(3e1ea071)},
-{C(79da242a16acae31), C(183c5f438e29d40), C(6d351710ae92f3de), C(27233b28b5b11e9b), C(c7dfe8988a942700), C(570ed11c4abad984), C(4b4c04632f48311a),
-C(27233b28b5b11e9b), C(c7dfe8988a942700), C(570ed11c4abad984), C(4b4c04632f48311a),
-C(12f33235442cbf9), C(a35315ca0b5b8cdb), C(d8abde62ead5506b), C(fc0fcf8478ad5266),
-C(67580f0c)},
-{C(461c82656a74fb57), C(d84b491b275aa0f7), C(8f262cb29a6eb8b2), C(49fa3070bc7b06d0), C(f12ed446bd0c0539), C(6d43ac5d1dd4b240), C(7609524fe90bec93),
-C(49fa3070bc7b06d0), C(f12ed446bd0c0539), C(6d43ac5d1dd4b240), C(7609524fe90bec93),
-C(391c2b2e076ec241), C(f5e62deda7839f7b), C(3c7b3186a10d870f), C(77ef4f2cba4f1005),
-C(4e109454)},
-{C(53c1a66d0b13003), C(731f060e6fe797fc), C(daa56811791371e3), C(57466046cf6896ed), C(8ac37e0e8b25b0c6), C(3e6074b52ad3cf18), C(aa491ce7b45db297),
-C(57466046cf6896ed), C(8ac37e0e8b25b0c6), C(3e6074b52ad3cf18), C(aa491ce7b45db297),
-C(f7a9227c5e5e22c3), C(3d92e0841e29ce28), C(2d30da5b2859e59d), C(ff37fa1c9cbfafc2),
-C(88a474a7)},
-{C(d3a2efec0f047e9), C(1cabce58853e58ea), C(7a17b2eae3256be4), C(c2dcc9758c910171), C(cb5cddaeff4ddb40), C(5d7cc5869baefef1), C(9644c5853af9cfeb),
-C(c2dcc9758c910171), C(cb5cddaeff4ddb40), C(5d7cc5869baefef1), C(9644c5853af9cfeb),
-C(255c968184694ee1), C(4e4d726eda360927), C(7d27dd5b6d100377), C(9a300e2020ddea2c),
-C(5b5bedd)},
-{C(43c64d7484f7f9b2), C(5da002b64aafaeb7), C(b576c1e45800a716), C(3ee84d3d5b4ca00b), C(5cbc6d701894c3f9), C(d9e946f5ae1ca95), C(24ca06e67f0b1833),
-C(3ee84d3d5b4ca00b), C(5cbc6d701894c3f9), C(d9e946f5ae1ca95), C(24ca06e67f0b1833),
-C(3413d46b4152650e), C(cbdfdbc2ab516f9c), C(2aad8acb739e0c6c), C(2bfc950d9f9fa977),
-C(1aaddfa7)},
-{C(a7dec6ad81cf7fa1), C(180c1ab708683063), C(95e0fd7008d67cff), C(6b11c5073687208), C(7e0a57de0d453f3), C(e48c267d4f646867), C(2168e9136375f9cb),
-C(6b11c5073687208), C(7e0a57de0d453f3), C(e48c267d4f646867), C(2168e9136375f9cb),
-C(64da194aeeea7fdf), C(a3b9f01fa5885678), C(c316f8ee2eb2bd17), C(a7e4d80f83e4427f),
-C(5be07fd8)},
-{C(5408a1df99d4aff), C(b9565e588740f6bd), C(abf241813b08006e), C(7da9e81d89fda7ad), C(274157cabe71440d), C(2c22d9a480b331f7), C(e835c8ac746472d5),
-C(7da9e81d89fda7ad), C(274157cabe71440d), C(2c22d9a480b331f7), C(e835c8ac746472d5),
-C(2038ce817a201ae4), C(46f3289dfe1c5e40), C(435578a42d4b7c56), C(f96d9f409fcf561),
-C(cbca8606)},
-{C(a8b27a6bcaeeed4b), C(aec1eeded6a87e39), C(9daf246d6fed8326), C(d45a938b79f54e8f), C(366b219d6d133e48), C(5b14be3c25c49405), C(fdd791d48811a572),
-C(d45a938b79f54e8f), C(366b219d6d133e48), C(5b14be3c25c49405), C(fdd791d48811a572),
-C(3de67b8d9e95d335), C(903c01307cfbeed5), C(af7d65f32274f1d1), C(4dba141b5fc03c42),
-C(bde64d01)},
-{C(9a952a8246fdc269), C(d0dcfcac74ef278c), C(250f7139836f0f1f), C(c83d3c5f4e5f0320), C(694e7adeb2bf32e5), C(7ad09538a3da27f5), C(2b5c18f934aa5303),
-C(c83d3c5f4e5f0320), C(694e7adeb2bf32e5), C(7ad09538a3da27f5), C(2b5c18f934aa5303),
-C(c4dad7703d34326e), C(825569e2bcdc6a25), C(b83d267709ca900d), C(44ed05151f5d74e6),
-C(ee90cf33)},
-{C(c930841d1d88684f), C(5eb66eb18b7f9672), C(e455d413008a2546), C(bc271bc0df14d647), C(b071100a9ff2edbb), C(2b1a4c1cc31a119a), C(b5d7caa1bd946cef),
-C(bc271bc0df14d647), C(b071100a9ff2edbb), C(2b1a4c1cc31a119a), C(b5d7caa1bd946cef),
-C(e02623ae10f4aadd), C(d79f600389cd06fd), C(1e8da7965303e62b), C(86f50e10eeab0925),
-C(4305c3ce)},
-{C(94dc6971e3cf071a), C(994c7003b73b2b34), C(ea16e85978694e5), C(336c1b59a1fc19f6), C(c173acaecc471305), C(db1267d24f3f3f36), C(e9a5ee98627a6e78),
-C(336c1b59a1fc19f6), C(c173acaecc471305), C(db1267d24f3f3f36), C(e9a5ee98627a6e78),
-C(718f334204305ae5), C(e3b53c148f98d22c), C(a184012df848926), C(6e96386127d51183),
-C(4b3a1d76)},
-{C(7fc98006e25cac9), C(77fee0484cda86a7), C(376ec3d447060456), C(84064a6dcf916340), C(fbf55a26790e0ebb), C(2e7f84151c31a5c2), C(9f7f6d76b950f9bf),
-C(84064a6dcf916340), C(fbf55a26790e0ebb), C(2e7f84151c31a5c2), C(9f7f6d76b950f9bf),
-C(125e094fbee2b146), C(5706aa72b2eef7c2), C(1c4a2daa905ee66e), C(83d48029b5451694),
-C(a8bb6d80)},
-{C(bd781c4454103f6), C(612197322f49c931), C(b9cf17fd7e5462d5), C(e38e526cd3324364), C(85f2b63a5b5e840a), C(485d7cef5aaadd87), C(d2b837a462f6db6d),
-C(e38e526cd3324364), C(85f2b63a5b5e840a), C(485d7cef5aaadd87), C(d2b837a462f6db6d),
-C(3e41cef031520d9a), C(82df73902d7f67e), C(3ba6fd54c15257cb), C(22f91f079be42d40),
-C(1f9fa607)},
-{C(da60e6b14479f9df), C(3bdccf69ece16792), C(18ebf45c4fecfdc9), C(16818ee9d38c6664), C(5519fa9a1e35a329), C(cbd0001e4b08ed8), C(41a965e37a0c731b),
-C(16818ee9d38c6664), C(5519fa9a1e35a329), C(cbd0001e4b08ed8), C(41a965e37a0c731b),
-C(66e7b5dcca1ca28f), C(963b2d993614347d), C(9b6fc6f41d411106), C(aaaecaccf7848c0c),
-C(8d0e4ed2)},
-{C(4ca56a348b6c4d3), C(60618537c3872514), C(2fbb9f0e65871b09), C(30278016830ddd43), C(f046646d9012e074), C(c62a5804f6e7c9da), C(98d51f5830e2bc1e),
-C(30278016830ddd43), C(f046646d9012e074), C(c62a5804f6e7c9da), C(98d51f5830e2bc1e),
-C(7b2cbe5d37e3f29e), C(7b8c3ed50bda4aa0), C(3ea60cc24639e038), C(f7706de9fb0b5801),
-C(1bf31347)},
-{C(ebd22d4b70946401), C(6863602bf7139017), C(c0b1ac4e11b00666), C(7d2782b82bd494b6), C(97159ba1c26b304b), C(42b3b0fd431b2ac2), C(faa81f82691c830c),
-C(7d2782b82bd494b6), C(97159ba1c26b304b), C(42b3b0fd431b2ac2), C(faa81f82691c830c),
-C(7cc6449234c7e185), C(aeaa6fa643ca86a5), C(1412db1c0f2e0133), C(4df2fe3e4072934f),
-C(1ae3fc5b)},
-{C(3cc4693d6cbcb0c), C(501689ea1c70ffa), C(10a4353e9c89e364), C(58c8aba7475e2d95), C(3e2f291698c9427a), C(e8710d19c9de9e41), C(65dda22eb04cf953),
-C(58c8aba7475e2d95), C(3e2f291698c9427a), C(e8710d19c9de9e41), C(65dda22eb04cf953),
-C(d7729c48c250cffa), C(ef76162b2ddfba4b), C(52371e17f4d51f6d), C(ddd002112ff0c833),
-C(459c3930)},
-{C(38908e43f7ba5ef0), C(1ab035d4e7781e76), C(41d133e8c0a68ff7), C(d1090893afaab8bc), C(96c4fe6922772807), C(4522426c2b4205eb), C(efad99a1262e7e0d),
-C(d1090893afaab8bc), C(96c4fe6922772807), C(4522426c2b4205eb), C(efad99a1262e7e0d),
-C(c7696029abdb465e), C(4e18eaf03d517651), C(d006bced54c86ac8), C(4330326d1021860c),
-C(e00c4184)},
-{C(34983ccc6aa40205), C(21802cad34e72bc4), C(1943e8fb3c17bb8), C(fc947167f69c0da5), C(ae79cfdb91b6f6c1), C(7b251d04c26cbda3), C(128a33a79060d25e),
-C(fc947167f69c0da5), C(ae79cfdb91b6f6c1), C(7b251d04c26cbda3), C(128a33a79060d25e),
-C(1eca842dbfe018dd), C(50a4cd2ee0ba9c63), C(c2f5c97d8399682f), C(3f929fc7cbe8ecbb),
-C(ffc7a781)},
-{C(86215c45dcac9905), C(ea546afe851cae4b), C(d85b6457e489e374), C(b7609c8e70386d66), C(36e6ccc278d1636d), C(2f873307c08e6a1c), C(10f252a758505289),
-C(b7609c8e70386d66), C(36e6ccc278d1636d), C(2f873307c08e6a1c), C(10f252a758505289),
-C(c8977646e81ab4b6), C(8017b745cd80213b), C(960687db359bea0), C(ef4a470660799488),
-C(6a125480)},
-{C(420fc255c38db175), C(d503cd0f3c1208d1), C(d4684e74c825a0bc), C(4c10537443152f3d), C(720451d3c895e25d), C(aff60c4d11f513fd), C(881e8d6d2d5fb953),
-C(4c10537443152f3d), C(720451d3c895e25d), C(aff60c4d11f513fd), C(881e8d6d2d5fb953),
-C(9dec034a043f1f55), C(e27a0c22e7bfb39d), C(2220b959128324), C(53240272152dbd8b),
-C(88a1512b)},
-{C(1d7a31f5bc8fe2f9), C(4763991092dcf836), C(ed695f55b97416f4), C(f265edb0c1c411d7), C(30e1e9ec5262b7e6), C(c2c3ba061ce7957a), C(d975f93b89a16409),
-C(f265edb0c1c411d7), C(30e1e9ec5262b7e6), C(c2c3ba061ce7957a), C(d975f93b89a16409),
-C(e9d703123f43450a), C(41383fedfed67c82), C(6e9f43ecbbbd6004), C(c7ccd23a24e77b8),
-C(549bbbe5)},
-{C(94129a84c376a26e), C(c245e859dc231933), C(1b8f74fecf917453), C(e9369d2e9007e74b), C(b1375915d1136052), C(926c2021fe1d2351), C(1d943addaaa2e7e6),
-C(e9369d2e9007e74b), C(b1375915d1136052), C(926c2021fe1d2351), C(1d943addaaa2e7e6),
-C(f5f515869c246738), C(7e309cd0e1c0f2a0), C(153c3c36cf523e3b), C(4931c66872ea6758),
-C(c133d38c)},
-{C(1d3a9809dab05c8d), C(adddeb4f71c93e8), C(ef342eb36631edb), C(301d7a61c4b3dbca), C(861336c3f0552d61), C(12c6db947471300f), C(a679ef0ed761deb9),
-C(301d7a61c4b3dbca), C(861336c3f0552d61), C(12c6db947471300f), C(a679ef0ed761deb9),
-C(5f713b720efcd147), C(37ac330a333aa6b), C(3309dc9ec1616eef), C(52301d7a908026b5),
-C(fcace348)},
-{C(90fa3ccbd60848da), C(dfa6e0595b569e11), C(e585d067a1f5135d), C(6cef866ec295abea), C(c486c0d9214beb2d), C(d6e490944d5fe100), C(59df3175d72c9f38),
-C(6cef866ec295abea), C(c486c0d9214beb2d), C(d6e490944d5fe100), C(59df3175d72c9f38),
-C(3f23aeb4c04d1443), C(9bf0515cd8d24770), C(958554f60ccaade2), C(5182863c90132fe8),
-C(ed7b6f9a)},
-{C(2dbb4fc71b554514), C(9650e04b86be0f82), C(60f2304fba9274d3), C(fcfb9443e997cab), C(f13310d96dec2772), C(709cad2045251af2), C(afd0d30cc6376dad),
-C(fcfb9443e997cab), C(f13310d96dec2772), C(709cad2045251af2), C(afd0d30cc6376dad),
-C(59d4bed30d550d0d), C(58006d4e22d8aad1), C(eee12d2362d1f13b), C(35cf1d7faaf1d228),
-C(6d907dda)},
-{C(b98bf4274d18374a), C(1b669fd4c7f9a19a), C(b1f5972b88ba2b7a), C(73119c99e6d508be), C(5d4036a187735385), C(8fa66e192fd83831), C(2abf64b6b592ed57),
-C(73119c99e6d508be), C(5d4036a187735385), C(8fa66e192fd83831), C(2abf64b6b592ed57),
-C(d4501f95dd84b08c), C(bf1552439c8bea02), C(4f56fe753ba7e0ba), C(4ca8d35cc058cfcd),
-C(7a4d48d5)},
-{C(d6781d0b5e18eb68), C(b992913cae09b533), C(58f6021caaee3a40), C(aafcb77497b5a20b), C(411819e5e79b77a3), C(bd779579c51c77ce), C(58d11f5dcf5d075d),
-C(aafcb77497b5a20b), C(411819e5e79b77a3), C(bd779579c51c77ce), C(58d11f5dcf5d075d),
-C(9eae76cde1cb4233), C(32fe25a9bf657970), C(1c0c807948edb06a), C(b8f29a3dfaee254d),
-C(e686f3db)},
-{C(226651cf18f4884c), C(595052a874f0f51c), C(c9b75162b23bab42), C(3f44f873be4812ec), C(427662c1dbfaa7b2), C(a207ff9638fb6558), C(a738d919e45f550f),
-C(3f44f873be4812ec), C(427662c1dbfaa7b2), C(a207ff9638fb6558), C(a738d919e45f550f),
-C(cb186ea05717e7d6), C(1ca7d68a5871fdc1), C(5d4c119ea8ef3750), C(72b6a10fa2ff9406),
-C(cce7c55)},
-{C(a734fb047d3162d6), C(e523170d240ba3a5), C(125a6972809730e8), C(d396a297799c24a1), C(8fee992e3069bad5), C(2e3a01b0697ccf57), C(ee9c7390bd901cfa),
-C(d396a297799c24a1), C(8fee992e3069bad5), C(2e3a01b0697ccf57), C(ee9c7390bd901cfa),
-C(56f2d9da0af28af2), C(3fdd37b2fe8437cb), C(3d13eeeb60d6aec0), C(2432ae62e800a5ce),
-C(f58b96b)},
-{C(c6df6364a24f75a3), C(c294e2c84c4f5df8), C(a88df65c6a89313b), C(895fe8443183da74), C(c7f2f6f895a67334), C(a0d6b6a506691d31), C(24f51712b459a9f0),
-C(895fe8443183da74), C(c7f2f6f895a67334), C(a0d6b6a506691d31), C(24f51712b459a9f0),
-C(173a699481b9e088), C(1dee9b77bcbf45d3), C(32b98a646a8667d0), C(3adcd4ee28f42a0e),
-C(1bbf6f60)},
-{C(d8d1364c1fbcd10), C(2d7cc7f54832deaa), C(4e22c876a7c57625), C(a3d5d1137d30c4bd), C(1e7d706a49bdfb9e), C(c63282b20ad86db2), C(aec97fa07916bfd6),
-C(a3d5d1137d30c4bd), C(1e7d706a49bdfb9e), C(c63282b20ad86db2), C(aec97fa07916bfd6),
-C(7c9ba3e52d44f73e), C(af62fd245811185d), C(8a9d2dacd8737652), C(bd2cce277d5fbec0),
-C(ce5e0cc2)},
-{C(aae06f9146db885f), C(3598736441e280d9), C(fba339b117083e55), C(b22bf08d9f8aecf7), C(c182730de337b922), C(2b9adc87a0450a46), C(192c29a9cfc00aad),
-C(b22bf08d9f8aecf7), C(c182730de337b922), C(2b9adc87a0450a46), C(192c29a9cfc00aad),
-C(9fd733f1d84a59d9), C(d86bd5c9839ace15), C(af20b57303172876), C(9f63cb7161b5364c),
-C(584cfd6f)},
-{C(8955ef07631e3bcc), C(7d70965ea3926f83), C(39aed4134f8b2db6), C(882efc2561715a9c), C(ef8132a18a540221), C(b20a3c87a8c257c1), C(f541b8628fad6c23),
-C(882efc2561715a9c), C(ef8132a18a540221), C(b20a3c87a8c257c1), C(f541b8628fad6c23),
-C(9552aed57a6e0467), C(4d9fdd56867611a7), C(c330279bf23b9eab), C(44dbbaea2fcb8eba),
-C(8f9bbc33)},
-{C(ad611c609cfbe412), C(d3c00b18bf253877), C(90b2172e1f3d0bfd), C(371a98b2cb084883), C(33a2886ee9f00663), C(be9568818ed6e6bd), C(f244a0fa2673469a),
-C(371a98b2cb084883), C(33a2886ee9f00663), C(be9568818ed6e6bd), C(f244a0fa2673469a),
-C(b447050bd3e559e9), C(d3b695dae7a13383), C(ded0bb65be471188), C(ca3c7a2b78922cae),
-C(d7640d95)},
-{C(d5339adc295d5d69), C(b633cc1dcb8b586a), C(ee84184cf5b1aeaf), C(89f3aab99afbd636), C(f420e004f8148b9a), C(6818073faa797c7c), C(dd3b4e21cbbf42ca),
-C(89f3aab99afbd636), C(f420e004f8148b9a), C(6818073faa797c7c), C(dd3b4e21cbbf42ca),
-C(6a2b7db261164844), C(cbead63d1895852a), C(93d37e1eae05e2f9), C(5d06db2703fbc3ae),
-C(3d12a2b)},
-{C(40d0aeff521375a8), C(77ba1ad7ecebd506), C(547c6f1a7d9df427), C(21c2be098327f49b), C(7e035065ac7bbef5), C(6d7348e63023fb35), C(9d427dc1b67c3830),
-C(21c2be098327f49b), C(7e035065ac7bbef5), C(6d7348e63023fb35), C(9d427dc1b67c3830),
-C(4e3d018a43858341), C(cf924bb44d6b43c5), C(4618b6a26e3446ae), C(54d3013fac3ed469),
-C(aaeafed0)},
-{C(8b2d54ae1a3df769), C(11e7adaee3216679), C(3483781efc563e03), C(9d097dd3152ab107), C(51e21d24126e8563), C(cba56cac884a1354), C(39abb1b595f0a977),
-C(9d097dd3152ab107), C(51e21d24126e8563), C(cba56cac884a1354), C(39abb1b595f0a977),
-C(81e6dd1c1109848f), C(1644b209826d7b15), C(6ac67e4e4b4812f0), C(b3a9f5622c935bf7),
-C(95b9b814)},
-{C(99c175819b4eae28), C(932e8ff9f7a40043), C(ec78dcab07ca9f7c), C(c1a78b82ba815b74), C(458cbdfc82eb322a), C(17f4a192376ed8d7), C(6f9e92968bc8ccef),
-C(c1a78b82ba815b74), C(458cbdfc82eb322a), C(17f4a192376ed8d7), C(6f9e92968bc8ccef),
-C(93e098c333b39905), C(d59b1cace44b7fdc), C(f7a64ed78c64c7c5), C(7c6eca5dd87ec1ce),
-C(45fbe66e)},
-{C(2a418335779b82fc), C(af0295987849a76b), C(c12bc5ff0213f46e), C(5aeead8d6cb25bb9), C(739315f7743ec3ff), C(9ab48d27111d2dcc), C(5b87bd35a975929b),
-C(5aeead8d6cb25bb9), C(739315f7743ec3ff), C(9ab48d27111d2dcc), C(5b87bd35a975929b),
-C(c3dd8d6d95a46bb3), C(7bf9093215a4f483), C(cb557d6ed84285bd), C(daf58422f261fdb5),
-C(b4baa7a8)},
-{C(3b1fc6a3d279e67d), C(70ea1e49c226396), C(25505adcf104697c), C(ba1ffba29f0367aa), C(a20bec1dd15a8b6c), C(e9bf61d2dab0f774), C(f4f35bf5870a049c),
-C(ba1ffba29f0367aa), C(a20bec1dd15a8b6c), C(e9bf61d2dab0f774), C(f4f35bf5870a049c),
-C(26787efa5b92385), C(3d9533590ce30b59), C(a4da3e40530a01d4), C(6395deaefb70067c),
-C(83e962fe)},
-{C(d97eacdf10f1c3c9), C(b54f4654043a36e0), C(b128f6eb09d1234), C(d8ad7ec84a9c9aa2), C(e256cffed11f69e6), C(2cf65e4958ad5bda), C(cfbf9b03245989a7),
-C(d8ad7ec84a9c9aa2), C(e256cffed11f69e6), C(2cf65e4958ad5bda), C(cfbf9b03245989a7),
-C(9fa51e6686cf4444), C(9425c117a34609d5), C(b25f7e2c6f30e96), C(ea5477c3f2b5afd1),
-C(aac3531c)},
-{C(293a5c1c4e203cd4), C(6b3329f1c130cefe), C(f2e32f8ec76aac91), C(361e0a62c8187bff), C(6089971bb84d7133), C(93df7741588dd50b), C(c2a9b6abcd1d80b1),
-C(361e0a62c8187bff), C(6089971bb84d7133), C(93df7741588dd50b), C(c2a9b6abcd1d80b1),
-C(4d2f86869d79bc59), C(85cd24d8aa570ff), C(b0dcf6ef0e94bbb5), C(2037c69aa7a78421),
-C(2b1db7cc)},
-{C(4290e018ffaedde7), C(a14948545418eb5e), C(72d851b202284636), C(4ec02f3d2f2b23f2), C(ab3580708aa7c339), C(cdce066fbab3f65), C(d8ed3ecf3c7647b9),
-C(4ec02f3d2f2b23f2), C(ab3580708aa7c339), C(cdce066fbab3f65), C(d8ed3ecf3c7647b9),
-C(6d2204b3e31f344a), C(61a4d87f80ee61d7), C(446c43dbed4b728f), C(73130ac94f58747e),
-C(cf00cd31)},
-{C(f919a59cbde8bf2f), C(a56d04203b2dc5a5), C(38b06753ac871e48), C(c2c9fc637dbdfcfa), C(292ab8306d149d75), C(7f436b874b9ffc07), C(a5b56b0129218b80),
-C(c2c9fc637dbdfcfa), C(292ab8306d149d75), C(7f436b874b9ffc07), C(a5b56b0129218b80),
-C(9188f7bdc47ec050), C(cfe9345d03a15ade), C(40b520fb2750c49e), C(c2e83d343968af2e),
-C(7d3c43b8)},
-{C(1d70a3f5521d7fa4), C(fb97b3fdc5891965), C(299d49bbbe3535af), C(e1a8286a7d67946e), C(52bd956f047b298), C(cbd74332dd4204ac), C(12b5be7752721976),
-C(e1a8286a7d67946e), C(52bd956f047b298), C(cbd74332dd4204ac), C(12b5be7752721976),
-C(278426e27f6204b6), C(932ca7a7cd610181), C(41647321f0a5914d), C(48f4aa61a0ae80db),
-C(cbd5fac6)},
-{C(6af98d7b656d0d7c), C(d2e99ae96d6b5c0c), C(f63bd1603ef80627), C(bde51033ac0413f8), C(bc0272f691aec629), C(6204332651bebc44), C(1cbf00de026ea9bd),
-C(bde51033ac0413f8), C(bc0272f691aec629), C(6204332651bebc44), C(1cbf00de026ea9bd),
-C(b9c7ed6a75f3ff1e), C(7e310b76a5808e4f), C(acbbd1aad5531885), C(fc245f2473adeb9c),
-C(76d0fec4)},
-{C(395b7a8adb96ab75), C(582df7165b20f4a), C(e52bd30e9ff657f9), C(6c71064996cbec8b), C(352c535edeefcb89), C(ac7f0aba15cd5ecd), C(3aba1ca8353e5c60),
-C(6c71064996cbec8b), C(352c535edeefcb89), C(ac7f0aba15cd5ecd), C(3aba1ca8353e5c60),
-C(5c30a288a80ce646), C(c2940488b6617674), C(925f8cc66b370575), C(aa65d1283b9bb0ef),
-C(405e3402)},
-{C(3822dd82c7df012f), C(b9029b40bd9f122b), C(fd25b988468266c4), C(43e47bd5bab1e0ef), C(4a71f363421f282f), C(880b2f32a2b4e289), C(1299d4eda9d3eadf),
-C(43e47bd5bab1e0ef), C(4a71f363421f282f), C(880b2f32a2b4e289), C(1299d4eda9d3eadf),
-C(d713a40226f5564), C(4d8d34fedc769406), C(a85001b29cd9cac3), C(cae92352a41fd2b0),
-C(c732c481)},
-{C(79f7efe4a80b951a), C(dd3a3fddfc6c9c41), C(ab4c812f9e27aa40), C(832954ec9d0de333), C(94c390aa9bcb6b8a), C(f3b32afdc1f04f82), C(d229c3b72e4b9a74),
-C(832954ec9d0de333), C(94c390aa9bcb6b8a), C(f3b32afdc1f04f82), C(d229c3b72e4b9a74),
-C(1d11860d7ed624a6), C(cadee20b3441b984), C(75307079bf306f7b), C(87902aa3b9753ba4),
-C(a8d123c9)},
-{C(ae6e59f5f055921a), C(e9d9b7bf68e82), C(5ce4e4a5b269cc59), C(4960111789727567), C(149b8a37c7125ab6), C(78c7a13ab9749382), C(1c61131260ca151a),
-C(4960111789727567), C(149b8a37c7125ab6), C(78c7a13ab9749382), C(1c61131260ca151a),
-C(1e93276b35c309a0), C(2618f56230acde58), C(af61130a18e4febf), C(7145deb18e89befe),
-C(1e80ad7d)},
-{C(8959dbbf07387d36), C(b4658afce48ea35d), C(8f3f82437d8cb8d6), C(6566d74954986ba5), C(99d5235cc82519a7), C(257a23805c2d825), C(ad75ccb968e93403),
-C(6566d74954986ba5), C(99d5235cc82519a7), C(257a23805c2d825), C(ad75ccb968e93403),
-C(b45bd4cf78e11f7f), C(80c5536bdc487983), C(a4fd76ecbf018c8a), C(3b9dac78a7a70d43),
-C(52aeb863)},
-{C(4739613234278a49), C(99ea5bcd340bf663), C(258640912e712b12), C(c8a2827404991402), C(7ee5e78550f02675), C(2ec53952db5ac662), C(1526405a9df6794b),
-C(c8a2827404991402), C(7ee5e78550f02675), C(2ec53952db5ac662), C(1526405a9df6794b),
-C(eddc6271170c5e1f), C(f5a85f986001d9d6), C(95427c677bf58d58), C(53ed666dfa85cb29),
-C(ef7c0c18)},
-{C(420e6c926bc54841), C(96dbbf6f4e7c75cd), C(d8d40fa70c3c67bb), C(3edbc10e4bfee91b), C(f0d681304c28ef68), C(77ea602029aaaf9c), C(90f070bd24c8483c),
-C(3edbc10e4bfee91b), C(f0d681304c28ef68), C(77ea602029aaaf9c), C(90f070bd24c8483c),
-C(28bc8e41e08ceb86), C(1eb56e48a65691ef), C(9fea5301c9202f0e), C(3fcb65091aa9f135),
-C(b6ad4b68)},
-{C(c8601bab561bc1b7), C(72b26272a0ff869a), C(56fdfc986d6bc3c4), C(83707730cad725d4), C(c9ca88c3a779674a), C(e1c696fbbd9aa933), C(723f3baab1c17a45),
-C(83707730cad725d4), C(c9ca88c3a779674a), C(e1c696fbbd9aa933), C(723f3baab1c17a45),
-C(f82abc7a1d851682), C(30683836818e857d), C(78bfa3e89a5ab23f), C(6928234482b31817),
-C(c1e46b17)},
-{C(b2d294931a0e20eb), C(284ffd9a0815bc38), C(1f8a103aac9bbe6), C(1ef8e98e1ea57269), C(5971116272f45a8b), C(187ad68ce95d8eac), C(e94e93ee4e8ecaa6),
-C(1ef8e98e1ea57269), C(5971116272f45a8b), C(187ad68ce95d8eac), C(e94e93ee4e8ecaa6),
-C(a0ff2a58611838b5), C(b01e03849bfbae6f), C(d081e202e28ea3ab), C(51836bcee762bf13),
-C(57b8df25)},
-{C(7966f53c37b6c6d7), C(8e6abcfb3aa2b88f), C(7f2e5e0724e5f345), C(3eeb60c3f5f8143d), C(a25aec05c422a24f), C(b026b03ad3cca4db), C(e6e030028cc02a02),
-C(3eeb60c3f5f8143d), C(a25aec05c422a24f), C(b026b03ad3cca4db), C(e6e030028cc02a02),
-C(16fe679338b34bfc), C(c1be385b5c8a9de4), C(65af5df6567530eb), C(ed3b303df4dc6335),
-C(e9fa36d6)},
-{C(be9bb0abd03b7368), C(13bca93a3031be55), C(e864f4f52b55b472), C(36a8d13a2cbb0939), C(254ac73907413230), C(73520d1522315a70), C(8c9fdb5cf1e1a507),
-C(36a8d13a2cbb0939), C(254ac73907413230), C(73520d1522315a70), C(8c9fdb5cf1e1a507),
-C(b3640570b926886), C(fba2344ee87f7bab), C(de57341ab448df05), C(385612ee094fa977),
-C(8f8daefc)},
-{C(a08d128c5f1649be), C(a8166c3dbbe19aad), C(cb9f914f829ec62c), C(5b2b7ca856fad1c3), C(8093022d682e375d), C(ea5d163ba7ea231f), C(d6181d012c0de641),
-C(5b2b7ca856fad1c3), C(8093022d682e375d), C(ea5d163ba7ea231f), C(d6181d012c0de641),
-C(e7d40d0ab8b08159), C(2e82320f51b3a67e), C(27c2e356ea0b63a3), C(58842d01a2b1d077),
-C(6e1bb7e)},
-{C(7c386f0ffe0465ac), C(530419c9d843dbf3), C(7450e3a4f72b8d8c), C(48b218e3b721810d), C(d3757ac8609bc7fc), C(111ba02a88aefc8), C(e86343137d3bfc2a),
-C(48b218e3b721810d), C(d3757ac8609bc7fc), C(111ba02a88aefc8), C(e86343137d3bfc2a),
-C(44ad26b51661b507), C(db1268670274f51e), C(62a5e75beae875f3), C(e266e7a44c5f28c6),
-C(fd0076f0)},
-{C(bb362094e7ef4f8), C(ff3c2a48966f9725), C(55152803acd4a7fe), C(15747d8c505ffd00), C(438a15f391312cd6), C(e46ca62c26d821f5), C(be78d74c9f79cb44),
-C(15747d8c505ffd00), C(438a15f391312cd6), C(e46ca62c26d821f5), C(be78d74c9f79cb44),
-C(a8aa19f3aa59f09a), C(effb3cddab2c9267), C(d78e41ad97cb16a5), C(ace6821513527d32),
-C(899b17b6)},
-{C(cd80dea24321eea4), C(52b4fdc8130c2b15), C(f3ea100b154bfb82), C(d9ccef1d4be46988), C(5ede0c4e383a5e66), C(da69683716a54d1e), C(bfc3fdf02d242d24),
-C(d9ccef1d4be46988), C(5ede0c4e383a5e66), C(da69683716a54d1e), C(bfc3fdf02d242d24),
-C(20ed30274651b3f5), C(4c659824169e86c6), C(637226dae5b52a0e), C(7e050dbd1c71dc7f),
-C(e3e84e31)},
-{C(d599a04125372c3a), C(313136c56a56f363), C(1e993c3677625832), C(2870a99c76a587a4), C(99f74cc0b182dda4), C(8a5e895b2f0ca7b6), C(3d78882d5e0bb1dc),
-C(2870a99c76a587a4), C(99f74cc0b182dda4), C(8a5e895b2f0ca7b6), C(3d78882d5e0bb1dc),
-C(f466123732a3e25e), C(aca5e59716a40e50), C(261d2e7383d0e686), C(ce9362d6a42c15a7),
-C(eef79b6b)},
-{C(dbbf541e9dfda0a), C(1479fceb6db4f844), C(31ab576b59062534), C(a3335c417687cf3a), C(92ff114ac45cda75), C(c3b8a627384f13b5), C(c4f25de33de8b3f7),
-C(a3335c417687cf3a), C(92ff114ac45cda75), C(c3b8a627384f13b5), C(c4f25de33de8b3f7),
-C(eacbf520578c5964), C(4cb19c5ab24f3215), C(e7d8a6f67f0c6e7), C(325c2413eb770ada),
-C(868e3315)},
-{C(c2ee3288be4fe2bf), C(c65d2f5ddf32b92), C(af6ecdf121ba5485), C(c7cd48f7abf1fe59), C(ce600656ace6f53a), C(8a94a4381b108b34), C(f9d1276c64bf59fb),
-C(c7cd48f7abf1fe59), C(ce600656ace6f53a), C(8a94a4381b108b34), C(f9d1276c64bf59fb),
-C(219ce70ff5a112a5), C(e6026c576e2d28d7), C(b8e467f25015e3a6), C(950cb904f37af710),
-C(4639a426)},
-{C(d86603ced1ed4730), C(f9de718aaada7709), C(db8b9755194c6535), C(d803e1eead47604c), C(ad00f7611970a71b), C(bc50036b16ce71f5), C(afba96210a2ca7d6),
-C(d803e1eead47604c), C(ad00f7611970a71b), C(bc50036b16ce71f5), C(afba96210a2ca7d6),
-C(28f7a7be1d6765f0), C(97bd888b93938c68), C(6ad41d1b407ded49), C(b9bfec098dc543e4),
-C(f3213646)},
-{C(915263c671b28809), C(a815378e7ad762fd), C(abec6dc9b669f559), C(d17c928c5342477f), C(745130b795254ad5), C(8c5db926fe88f8ba), C(742a95c953e6d974),
-C(d17c928c5342477f), C(745130b795254ad5), C(8c5db926fe88f8ba), C(742a95c953e6d974),
-C(279db8057b5d3e96), C(98168411565b4ec4), C(50a72c54fa1125fa), C(27766a635db73638),
-C(17f148e9)},
-{C(2b67cdd38c307a5e), C(cb1d45bb5c9fe1c), C(800baf2a02ec18ad), C(6531c1fe32bcb417), C(8c970d8df8cdbeb4), C(917ba5fc67e72b40), C(4b65e4e263e0a426),
-C(6531c1fe32bcb417), C(8c970d8df8cdbeb4), C(917ba5fc67e72b40), C(4b65e4e263e0a426),
-C(e0de33ce88a8b3a9), C(f8ef98a437e16b08), C(a5162c0c7c5f7b62), C(dbdac43361b2b881),
-C(bfd94880)},
-{C(2d107419073b9cd0), C(a96db0740cef8f54), C(ec41ee91b3ecdc1b), C(ffe319654c8e7ebc), C(6a67b8f13ead5a72), C(6dd10a34f80d532f), C(6e9cfaece9fbca4),
-C(ffe319654c8e7ebc), C(6a67b8f13ead5a72), C(6dd10a34f80d532f), C(6e9cfaece9fbca4),
-C(b4468eb6a30aa7e9), C(e87995bee483222a), C(d036c2c90c609391), C(853306e82fa32247),
-C(bb1fa7f3)},
-{C(f3e9487ec0e26dfc), C(1ab1f63224e837fa), C(119983bb5a8125d8), C(8950cfcf4bdf622c), C(8847dca82efeef2f), C(646b75b026708169), C(21cab4b1687bd8b),
-C(8950cfcf4bdf622c), C(8847dca82efeef2f), C(646b75b026708169), C(21cab4b1687bd8b),
-C(243b489a9eae6231), C(5f3e634c4b779876), C(ff8abd1548eaf646), C(c7962f5f0151914b),
-C(88816b1)},
-{C(1160987c8fe86f7d), C(879e6db1481eb91b), C(d7dcb802bfe6885d), C(14453b5cc3d82396), C(4ef700c33ed278bc), C(1639c72ffc00d12e), C(fb140ee6155f700d),
-C(14453b5cc3d82396), C(4ef700c33ed278bc), C(1639c72ffc00d12e), C(fb140ee6155f700d),
-C(2e6b5c96a6620862), C(a1f136998cbe19c), C(74e058a3b6c5a712), C(93dcf6bd33928b17),
-C(5c2faeb3)},
-{C(eab8112c560b967b), C(97f550b58e89dbae), C(846ed506d304051f), C(276aa37744b5a028), C(8c10800ee90ea573), C(e6e57d2b33a1e0b7), C(91f83563cd3b9dda),
-C(276aa37744b5a028), C(8c10800ee90ea573), C(e6e57d2b33a1e0b7), C(91f83563cd3b9dda),
-C(afbb4739570738a1), C(440ba98da5d8f69), C(fde4e9b0eda20350), C(e67dfa5a2138fa1),
-C(51b5fc6f)},
-{C(1addcf0386d35351), C(b5f436561f8f1484), C(85d38e22181c9bb1), C(ff5c03f003c1fefe), C(e1098670afe7ff6), C(ea445030cf86de19), C(f155c68b5c2967f8),
-C(ff5c03f003c1fefe), C(e1098670afe7ff6), C(ea445030cf86de19), C(f155c68b5c2967f8),
-C(95d31b145dbb2e9e), C(914fe1ca3deb3265), C(6066020b1358ccc1), C(c74bb7e2dee15036),
-C(33d94752)},
-{C(d445ba84bf803e09), C(1216c2497038f804), C(2293216ea2237207), C(e2164451c651adfb), C(b2534e65477f9823), C(4d70691a69671e34), C(15be4963dbde8143),
-C(e2164451c651adfb), C(b2534e65477f9823), C(4d70691a69671e34), C(15be4963dbde8143),
-C(762e75c406c5e9a3), C(7b7579f7e0356841), C(480533eb066dfce5), C(90ae14ea6bfeb4ae),
-C(b0c92948)},
-{C(37235a096a8be435), C(d9b73130493589c2), C(3b1024f59378d3be), C(ad159f542d81f04e), C(49626a97a946096), C(d8d3998bf09fd304), C(d127a411eae69459),
-C(ad159f542d81f04e), C(49626a97a946096), C(d8d3998bf09fd304), C(d127a411eae69459),
-C(8f3253c4eb785a7b), C(4049062f37e62397), C(b9fa04d3b670e5c1), C(1211a7967ac9350f),
-C(c7171590)},
-{C(763ad6ea2fe1c99d), C(cf7af5368ac1e26b), C(4d5e451b3bb8d3d4), C(3712eb913d04e2f2), C(2f9500d319c84d89), C(4ac6eb21a8cf06f9), C(7d1917afcde42744),
-C(3712eb913d04e2f2), C(2f9500d319c84d89), C(4ac6eb21a8cf06f9), C(7d1917afcde42744),
-C(6b58604b5dd10903), C(c4288dfbc1e319fc), C(230f75ca96817c6e), C(8894cba3b763756c),
-C(240a67fb)},
-{C(ea627fc84cd1b857), C(85e372494520071f), C(69ec61800845780b), C(a3c1c5ca1b0367), C(eb6933997272bb3d), C(76a72cb62692a655), C(140bb5531edf756e),
-C(a3c1c5ca1b0367), C(eb6933997272bb3d), C(76a72cb62692a655), C(140bb5531edf756e),
-C(8d0d8067d1c925f4), C(7b3fa56d8d77a10c), C(2bd00287b0946d88), C(f08c8e4bd65b8970),
-C(e1843cd5)},
-{C(1f2ffd79f2cdc0c8), C(726a1bc31b337aaa), C(678b7f275ef96434), C(5aa82bfaa99d3978), C(c18f96cade5ce18d), C(38404491f9e34c03), C(891fb8926ba0418c),
-C(5aa82bfaa99d3978), C(c18f96cade5ce18d), C(38404491f9e34c03), C(891fb8926ba0418c),
-C(e5f69a6398114c15), C(7b8ded3623bc6b1d), C(2f3e5c5da5ff70e8), C(1ab142addea6a9ec),
-C(fda1452b)},
-{C(39a9e146ec4b3210), C(f63f75802a78b1ac), C(e2e22539c94741c3), C(8b305d532e61226e), C(caeae80da2ea2e), C(88a6289a76ac684e), C(8ce5b5f9df1cbd85),
-C(8b305d532e61226e), C(caeae80da2ea2e), C(88a6289a76ac684e), C(8ce5b5f9df1cbd85),
-C(8ae1fc4798e00d57), C(e7164b8fb364fc46), C(6a978c9bd3a66943), C(ef10d5ae4dd08dc),
-C(a2cad330)},
-{C(74cba303e2dd9d6d), C(692699b83289fad1), C(dfb9aa7874678480), C(751390a8a5c41bdc), C(6ee5fbf87605d34), C(6ca73f610f3a8f7c), C(e898b3c996570ad),
-C(751390a8a5c41bdc), C(6ee5fbf87605d34), C(6ca73f610f3a8f7c), C(e898b3c996570ad),
-C(98168a5858fc7110), C(6f987fa27aa0daa2), C(f25e3e180d4b36a3), C(d0b03495aeb1be8a),
-C(53467e16)},
-{C(4cbc2b73a43071e0), C(56c5db4c4ca4e0b7), C(1b275a162f46bd3d), C(b87a326e413604bf), C(d8f9a5fa214b03ab), C(8a8bb8265771cf88), C(a655319054f6e70f),
-C(b87a326e413604bf), C(d8f9a5fa214b03ab), C(8a8bb8265771cf88), C(a655319054f6e70f),
-C(b499cb8e65a9af44), C(bee7fafcc8307491), C(5d2e55fa9b27cda2), C(63b120f5fb2d6ee5),
-C(da14a8d0)},
-{C(875638b9715d2221), C(d9ba0615c0c58740), C(616d4be2dfe825aa), C(5df25f13ea7bc284), C(165edfaafd2598fb), C(af7215c5c718c696), C(e9f2f9ca655e769),
-C(5df25f13ea7bc284), C(165edfaafd2598fb), C(af7215c5c718c696), C(e9f2f9ca655e769),
-C(e459cfcb565d3d2d), C(41d032631be2418a), C(c505db05fd946f60), C(54990394a714f5de),
-C(67333551)},
-{C(fb686b2782994a8d), C(edee60693756bb48), C(e6bc3cae0ded2ef5), C(58eb4d03b2c3ddf5), C(6d2542995f9189f1), C(c0beec58a5f5fea2), C(ed67436f42e2a78b),
-C(58eb4d03b2c3ddf5), C(6d2542995f9189f1), C(c0beec58a5f5fea2), C(ed67436f42e2a78b),
-C(dfec763cdb2b5193), C(724a8d5345bd2d6), C(94d4fd1b81457c23), C(28e87c50cdede453),
-C(a0ebd66e)},
-{C(ab21d81a911e6723), C(4c31b07354852f59), C(835da384c9384744), C(7f759dddc6e8549a), C(616dd0ca022c8735), C(94717ad4bc15ceb3), C(f66c7be808ab36e),
-C(7f759dddc6e8549a), C(616dd0ca022c8735), C(94717ad4bc15ceb3), C(f66c7be808ab36e),
-C(af8286b550b2f4b7), C(745bd217d20a9f40), C(c73bfb9c5430f015), C(55e65922666e3fc2),
-C(4b769593)},
-{C(33d013cc0cd46ecf), C(3de726423aea122c), C(116af51117fe21a9), C(f271ba474edc562d), C(e6596e67f9dd3ebd), C(c0a288edf808f383), C(b3def70681c6babc),
-C(f271ba474edc562d), C(e6596e67f9dd3ebd), C(c0a288edf808f383), C(b3def70681c6babc),
-C(7da7864e9989b095), C(bf2f8718693cd8a1), C(264a9144166da776), C(61ad90676870beb6),
-C(6aa75624)},
-{C(8ca92c7cd39fae5d), C(317e620e1bf20f1), C(4f0b33bf2194b97f), C(45744afcf131dbee), C(97222392c2559350), C(498a19b280c6d6ed), C(83ac2c36acdb8d49),
-C(45744afcf131dbee), C(97222392c2559350), C(498a19b280c6d6ed), C(83ac2c36acdb8d49),
-C(7a69645c294daa62), C(abe9d2be8275b3d2), C(39542019de371085), C(7f4efac8488cd6ad),
-C(602a3f96)},
-{C(fdde3b03f018f43e), C(38f932946c78660), C(c84084ce946851ee), C(b6dd09ba7851c7af), C(570de4e1bb13b133), C(c4e784eb97211642), C(8285a7fcdcc7c58d),
-C(b6dd09ba7851c7af), C(570de4e1bb13b133), C(c4e784eb97211642), C(8285a7fcdcc7c58d),
-C(d421f47990da899b), C(8aed409c997eaa13), C(7a045929c2e29ccf), C(b373682a6202c86b),
-C(cd183c4d)},
-{C(9c8502050e9c9458), C(d6d2a1a69964beb9), C(1675766f480229b5), C(216e1d6c86cb524c), C(d01cf6fd4f4065c0), C(fffa4ec5b482ea0f), C(a0e20ee6a5404ac1),
-C(216e1d6c86cb524c), C(d01cf6fd4f4065c0), C(fffa4ec5b482ea0f), C(a0e20ee6a5404ac1),
-C(c1b037e4eebaf85e), C(634e3d7c3ebf89eb), C(bcda972358c67d1), C(fd1352181e5b8578),
-C(960a4d07)},
-{C(348176ca2fa2fdd2), C(3a89c514cc360c2d), C(9f90b8afb318d6d0), C(bceee07c11a9ac30), C(2e2d47dff8e77eb7), C(11a394cd7b6d614a), C(1d7c41d54e15cb4a),
-C(bceee07c11a9ac30), C(2e2d47dff8e77eb7), C(11a394cd7b6d614a), C(1d7c41d54e15cb4a),
-C(15baa5ae7312b0fc), C(f398f596cc984635), C(8ab8fdf87a6788e8), C(b2b5c1234ab47e2),
-C(9ae998c4)},
-{C(4a3d3dfbbaea130b), C(4e221c920f61ed01), C(553fd6cd1304531f), C(bd2b31b5608143fe), C(ab717a10f2554853), C(293857f04d194d22), C(d51be8fa86f254f0),
-C(bd2b31b5608143fe), C(ab717a10f2554853), C(293857f04d194d22), C(d51be8fa86f254f0),
-C(1eee39e07686907e), C(639039fe0e8d3052), C(d6ec1470cef97ff), C(370c82b860034f0f),
-C(74e2179d)},
-{C(b371f768cdf4edb9), C(bdef2ace6d2de0f0), C(e05b4100f7f1baec), C(b9e0d415b4ebd534), C(c97c2a27efaa33d7), C(591cdb35f84ef9da), C(a57d02d0e8e3756c),
-C(b9e0d415b4ebd534), C(c97c2a27efaa33d7), C(591cdb35f84ef9da), C(a57d02d0e8e3756c),
-C(23f55f12d7c5c87b), C(4c7ca0fe23221101), C(dbc3020480334564), C(d985992f32c236b1),
-C(ee9bae25)},
-{C(7a1d2e96934f61f), C(eb1760ae6af7d961), C(887eb0da063005df), C(2228d6725e31b8ab), C(9b98f7e4d0142e70), C(b6a8c2115b8e0fe7), C(b591e2f5ab9b94b1),
-C(2228d6725e31b8ab), C(9b98f7e4d0142e70), C(b6a8c2115b8e0fe7), C(b591e2f5ab9b94b1),
-C(6c1feaa8065318e0), C(4e7e2ca21c2e81fb), C(e9fe5d8ce7993c45), C(ee411fa2f12cf8df),
-C(b66edf10)},
-{C(8be53d466d4728f2), C(86a5ac8e0d416640), C(984aa464cdb5c8bb), C(87049e68f5d38e59), C(7d8ce44ec6bd7751), C(cc28d08ab414839c), C(6c8f0bd34fe843e3),
-C(87049e68f5d38e59), C(7d8ce44ec6bd7751), C(cc28d08ab414839c), C(6c8f0bd34fe843e3),
-C(b8496dcdc01f3e47), C(2f03125c282ac26), C(82a8797ba3f5ef07), C(7c977a4d10bf52b8),
-C(d6209737)},
-{C(829677eb03abf042), C(43cad004b6bc2c0), C(f2f224756803971a), C(98d0dbf796480187), C(fbcb5f3e1bef5742), C(5af2a0463bf6e921), C(ad9555bf0120b3a3),
-C(98d0dbf796480187), C(fbcb5f3e1bef5742), C(5af2a0463bf6e921), C(ad9555bf0120b3a3),
-C(283e39b3dc99f447), C(bedaa1a4a0250c28), C(9d50546624ff9a57), C(4abaf523d1c090f6),
-C(b994a88)},
-{C(754435bae3496fc), C(5707fc006f094dcf), C(8951c86ab19d8e40), C(57c5208e8f021a77), C(f7653fbb69cd9276), C(a484410af21d75cb), C(f19b6844b3d627e8),
-C(57c5208e8f021a77), C(f7653fbb69cd9276), C(a484410af21d75cb), C(f19b6844b3d627e8),
-C(f37400fc3ffd9514), C(36ae0d821734edfd), C(5f37820af1f1f306), C(be637d40e6a5ad0),
-C(a05d43c0)},
-{C(fda9877ea8e3805f), C(31e868b6ffd521b7), C(b08c90681fb6a0fd), C(68110a7f83f5d3ff), C(6d77e045901b85a8), C(84ef681113036d8b), C(3b9f8e3928f56160),
-C(68110a7f83f5d3ff), C(6d77e045901b85a8), C(84ef681113036d8b), C(3b9f8e3928f56160),
-C(fc8b7f56c130835), C(a11f3e800638e841), C(d9572267f5cf28c1), C(7897c8149803f2aa),
-C(c79f73a8)},
-{C(2e36f523ca8f5eb5), C(8b22932f89b27513), C(331cd6ecbfadc1bb), C(d1bfe4df12b04cbf), C(f58c17243fd63842), C(3a453cdba80a60af), C(5737b2ca7470ea95),
-C(d1bfe4df12b04cbf), C(f58c17243fd63842), C(3a453cdba80a60af), C(5737b2ca7470ea95),
-C(54d44a3f4477030c), C(8168e02d4869aa7f), C(77f383a17778559d), C(95e1737d77a268fc),
-C(a490aff5)},
-{C(21a378ef76828208), C(a5c13037fa841da2), C(506d22a53fbe9812), C(61c9c95d91017da5), C(16f7c83ba68f5279), C(9c0619b0808d05f7), C(83c117ce4e6b70a3),
-C(61c9c95d91017da5), C(16f7c83ba68f5279), C(9c0619b0808d05f7), C(83c117ce4e6b70a3),
-C(cfb4c8af7fd01413), C(fdef04e602e72296), C(ed6124d337889b1), C(4919c86707b830da),
-C(dfad65b4)},
-{C(ccdd5600054b16ca), C(f78846e84204cb7b), C(1f9faec82c24eac9), C(58634004c7b2d19a), C(24bb5f51ed3b9073), C(46409de018033d00), C(4a9805eed5ac802e),
-C(58634004c7b2d19a), C(24bb5f51ed3b9073), C(46409de018033d00), C(4a9805eed5ac802e),
-C(e18de8db306baf82), C(46bbf75f1fa025ff), C(5faf2fb09be09487), C(3fbc62bd4e558fb3),
-C(1d07dfb)},
-{C(7854468f4e0cabd0), C(3a3f6b4f098d0692), C(ae2423ec7799d30d), C(29c3529eb165eeba), C(443de3703b657c35), C(66acbce31ae1bc8d), C(1acc99effe1d547e),
-C(29c3529eb165eeba), C(443de3703b657c35), C(66acbce31ae1bc8d), C(1acc99effe1d547e),
-C(cf07f8a57906573d), C(31bafb0bbb9a86e7), C(40c69492702a9346), C(7df61fdaa0b858af),
-C(416df9a0)},
-{C(7f88db5346d8f997), C(88eac9aacc653798), C(68a4d0295f8eefa1), C(ae59ca86f4c3323d), C(25906c09906d5c4c), C(8dd2aa0c0a6584ae), C(232a7d96b38f40e9),
-C(ae59ca86f4c3323d), C(25906c09906d5c4c), C(8dd2aa0c0a6584ae), C(232a7d96b38f40e9),
-C(8986ee00a2ed0042), C(c49ae7e428c8a7d1), C(b7dd8280713ac9c2), C(e018720aed1ebc28),
-C(1f8fb9cc)},
-{C(bb3fb5fb01d60fcf), C(1b7cc0847a215eb6), C(1246c994437990a1), C(d4edc954c07cd8f3), C(224f47e7c00a30ab), C(d5ad7ad7f41ef0c6), C(59e089281d869fd7),
-C(d4edc954c07cd8f3), C(224f47e7c00a30ab), C(d5ad7ad7f41ef0c6), C(59e089281d869fd7),
-C(f29340d07a14b6f1), C(c87c5ef76d9c4ef3), C(463118794193a9a), C(2922dcb0540f0dbc),
-C(7abf48e3)},
-{C(2e783e1761acd84d), C(39158042bac975a0), C(1cd21c5a8071188d), C(b1b7ec44f9302176), C(5cb476450dc0c297), C(dc5ef652521ef6a2), C(3cc79a9e334e1f84),
-C(b1b7ec44f9302176), C(5cb476450dc0c297), C(dc5ef652521ef6a2), C(3cc79a9e334e1f84),
-C(769e2a283dbcc651), C(9f24b105c8511d3f), C(c31c15575de2f27e), C(ecfecf32c3ae2d66),
-C(dea4e3dd)},
-{C(392058251cf22acc), C(944ec4475ead4620), C(b330a10b5cb94166), C(54bc9bee7cbe1767), C(485820bdbe442431), C(54d6120ea2972e90), C(f437a0341f29b72a),
-C(54bc9bee7cbe1767), C(485820bdbe442431), C(54d6120ea2972e90), C(f437a0341f29b72a),
-C(8f30885c784d5704), C(aa95376b16c7906a), C(e826928cfaf93dc3), C(20e8f54d1c16d7d8),
-C(c6064f22)},
-{C(adf5c1e5d6419947), C(2a9747bc659d28aa), C(95c5b8cb1f5d62c), C(80973ea532b0f310), C(a471829aa9c17dd9), C(c2ff3479394804ab), C(6bf44f8606753636),
-C(80973ea532b0f310), C(a471829aa9c17dd9), C(c2ff3479394804ab), C(6bf44f8606753636),
-C(5184d2973e6dd827), C(121b96369a332d9a), C(5c25d3475ab69e50), C(26d2961d62884168),
-C(743bed9c)},
-{C(6bc1db2c2bee5aba), C(e63b0ed635307398), C(7b2eca111f30dbbc), C(230d2b3e47f09830), C(ec8624a821c1caf4), C(ea6ec411cdbf1cb1), C(5f38ae82af364e27),
-C(230d2b3e47f09830), C(ec8624a821c1caf4), C(ea6ec411cdbf1cb1), C(5f38ae82af364e27),
-C(a519ef515ea7187c), C(6bad5efa7ebae05f), C(748abacb11a74a63), C(a28eef963d1396eb),
-C(fce254d5)},
-{C(b00f898229efa508), C(83b7590ad7f6985c), C(2780e70a0592e41d), C(7122413bdbc94035), C(e7f90fae33bf7763), C(4b6bd0fb30b12387), C(557359c0c44f48ca),
-C(7122413bdbc94035), C(e7f90fae33bf7763), C(4b6bd0fb30b12387), C(557359c0c44f48ca),
-C(d5656c3d6bc5f0d), C(983ff8e5e784da99), C(628479671b445bf), C(e179a1e27ce68f5d),
-C(e47ec9d1)},
-{C(b56eb769ce0d9a8c), C(ce196117bfbcaf04), C(b26c3c3797d66165), C(5ed12338f630ab76), C(fab19fcb319116d), C(167f5f42b521724b), C(c4aa56c409568d74),
-C(5ed12338f630ab76), C(fab19fcb319116d), C(167f5f42b521724b), C(c4aa56c409568d74),
-C(75fff4b42f8e9778), C(94218f94710c1ea3), C(b7b05efb738b06a6), C(83fff2deabf9cd3),
-C(334a145c)},
-{C(70c0637675b94150), C(259e1669305b0a15), C(46e1dd9fd387a58d), C(fca4e5bc9292788e), C(cd509dc1facce41c), C(bbba575a59d82fe), C(4e2e71c15b45d4d3),
-C(fca4e5bc9292788e), C(cd509dc1facce41c), C(bbba575a59d82fe), C(4e2e71c15b45d4d3),
-C(5dc54582ead999c), C(72612d1571963c6f), C(30318a9d2d3d1829), C(785dd00f4cc9c9a0),
-C(adec1e3c)},
-{C(74c0b8a6821faafe), C(abac39d7491370e7), C(faf0b2a48a4e6aed), C(967e970df9673d2a), C(d465247cffa415c0), C(33a1df0ca1107722), C(49fc2a10adce4a32),
-C(967e970df9673d2a), C(d465247cffa415c0), C(33a1df0ca1107722), C(49fc2a10adce4a32),
-C(c5707e079a284308), C(573028266635dda6), C(f786f5eee6127fa0), C(b30d79cebfb51266),
-C(f6a9fbf8)},
-{C(5fb5e48ac7b7fa4f), C(a96170f08f5acbc7), C(bbf5c63d4f52a1e5), C(6cc09e60700563e9), C(d18f23221e964791), C(ffc23eeef7af26eb), C(693a954a3622a315),
-C(815308a32a9b0daf), C(efb2ab27bf6fd0bd), C(9f1ffc0986111118), C(f9a3aa1778ea3985),
-C(698fe54b2b93933b), C(dacc2b28404d0f10), C(815308a32a9b0daf), C(efb2ab27bf6fd0bd),
-C(5398210c)},
+static const uint64 testdata[kTestSize][16] =
+{
+	{
+		C(9ae16a3b2f90404f), C(75106db890237a4a), C(3feac5f636039766), C(3df09dfc64c09a2b), C(3cb540c392e51e29), C(6b56343feac0663), C(5b7bc50fd8e8ad92),
+		C(3df09dfc64c09a2b), C(3cb540c392e51e29), C(6b56343feac0663), C(5b7bc50fd8e8ad92),
+		C(95162f24e6a5f930), C(6808bdf4f1eb06e0), C(b3b1f3a67b624d82), C(c9a62f12bd4cd80b),
+		C(dc56d17a)
+	},
+	{
+		C(541150e87f415e96), C(1aef0d24b3148a1a), C(bacc300e1e82345a), C(c3cdc41e1df33513), C(2c138ff2596d42f6), C(f58e9082aed3055f), C(162e192b2957163d),
+		C(c3cdc41e1df33513), C(2c138ff2596d42f6), C(f58e9082aed3055f), C(162e192b2957163d),
+		C(fb99e85e0d16f90c), C(608462c15bdf27e8), C(e7d2c5c943572b62), C(1baaa9327642798c),
+		C(99929334)
+	},
+	{
+		C(f3786a4b25827c1), C(34ee1a2bf767bd1c), C(2f15ca2ebfb631f2), C(3149ba1dac77270d), C(70e2e076e30703c), C(59bcc9659bc5296), C(9ecbc8132ae2f1d7),
+		C(3149ba1dac77270d), C(70e2e076e30703c), C(59bcc9659bc5296), C(9ecbc8132ae2f1d7),
+		C(a01d30789bad7cf2), C(ae03fe371981a0e0), C(127e3883b8788934), C(d0ac3d4c0a6fca32),
+		C(4252edb7)
+	},
+	{
+		C(ef923a7a1af78eab), C(79163b1e1e9a9b18), C(df3b2aca6e1e4a30), C(2193fb7620cbf23b), C(8b6a8ff06cda8302), C(1a44469afd3e091f), C(8b0449376612506),
+		C(2193fb7620cbf23b), C(8b6a8ff06cda8302), C(1a44469afd3e091f), C(8b0449376612506),
+		C(e9d9d41c32ad91d1), C(b44ab09f58e3c608), C(19e9175f9fcf784), C(839b3c9581b4a480),
+		C(ebc34f3c)
+	},
+	{
+		C(11df592596f41d88), C(843ec0bce9042f9c), C(cce2ea1e08b1eb30), C(4d09e42f09cc3495), C(666236631b9f253b), C(d28b3763cd02b6a3), C(43b249e57c4d0c1b),
+		C(4d09e42f09cc3495), C(666236631b9f253b), C(d28b3763cd02b6a3), C(43b249e57c4d0c1b),
+		C(3887101c8adea101), C(8a9355d4efc91df0), C(3e610944cc9fecfd), C(5bf9eb60b08ac0ce),
+		C(26f2b463)
+	},
+	{
+		C(831f448bdc5600b3), C(62a24be3120a6919), C(1b44098a41e010da), C(dc07df53b949c6b), C(d2b11b2081aeb002), C(d212b02c1b13f772), C(c0bed297b4be1912),
+		C(dc07df53b949c6b), C(d2b11b2081aeb002), C(d212b02c1b13f772), C(c0bed297b4be1912),
+		C(682d3d2ad304e4af), C(40e9112a655437a1), C(268b09f7ee09843f), C(6b9698d43859ca47),
+		C(b042c047)
+	},
+	{
+		C(3eca803e70304894), C(d80de767e4a920a), C(a51cfbb292efd53d), C(d183dcda5f73edfa), C(3a93cbf40f30128c), C(1a92544d0b41dbda), C(aec2c4bee81975e1),
+		C(d183dcda5f73edfa), C(3a93cbf40f30128c), C(1a92544d0b41dbda), C(aec2c4bee81975e1),
+		C(5f91814d1126ba4b), C(f8ac57eee87fcf1f), C(c55c644a5d0023cd), C(adb761e827825ff2),
+		C(e73bb0a8)
+	},
+	{
+		C(1b5a063fb4c7f9f1), C(318dbc24af66dee9), C(10ef7b32d5c719af), C(b140a02ef5c97712), C(b7d00ef065b51b33), C(635121d532897d98), C(532daf21b312a6d6),
+		C(b140a02ef5c97712), C(b7d00ef065b51b33), C(635121d532897d98), C(532daf21b312a6d6),
+		C(c0b09b75d943910), C(8c84dfb5ef2a8e96), C(e5c06034b0353433), C(3170faf1c33a45dd),
+		C(91dfdd75)
+	},
+	{
+		C(a0f10149a0e538d6), C(69d008c20f87419f), C(41b36376185b3e9e), C(26b6689960ccf81d), C(55f23b27bb9efd94), C(3a17f6166dd765db), C(c891a8a62931e782),
+		C(26b6689960ccf81d), C(55f23b27bb9efd94), C(3a17f6166dd765db), C(c891a8a62931e782),
+		C(23852dc37ddd2607), C(8b7f1b1ec897829e), C(d1d69452a54eed8a), C(56431f2bd766ec24),
+		C(c87f95de)
+	},
+	{
+		C(fb8d9c70660b910b), C(a45b0cc3476bff1b), C(b28d1996144f0207), C(98ec31113e5e35d2), C(5e4aeb853f1b9aa7), C(bcf5c8fe4465b7c8), C(b1ea3a8243996f15),
+		C(98ec31113e5e35d2), C(5e4aeb853f1b9aa7), C(bcf5c8fe4465b7c8), C(b1ea3a8243996f15),
+		C(cabbccedb6407571), C(d1e40a84c445ec3a), C(33302aa908cf4039), C(9f15f79211b5cdf8),
+		C(3f5538ef)
+	},
+	{
+		C(236827beae282a46), C(e43970221139c946), C(4f3ac6faa837a3aa), C(71fec0f972248915), C(2170ec2061f24574), C(9eb346b6caa36e82), C(2908f0fdbca48e73),
+		C(71fec0f972248915), C(2170ec2061f24574), C(9eb346b6caa36e82), C(2908f0fdbca48e73),
+		C(8101c99f07c64abb), C(b9f4b02b1b6a96a7), C(583a2b10cd222f88), C(199dae4cf9db24c),
+		C(70eb1a1f)
+	},
+	{
+		C(c385e435136ecf7c), C(d9d17368ff6c4a08), C(1b31eed4e5251a67), C(df01a322c43a6200), C(298b65a1714b5a7e), C(933b83f0aedf23c), C(157bcb44d63f765a),
+		C(df01a322c43a6200), C(298b65a1714b5a7e), C(933b83f0aedf23c), C(157bcb44d63f765a),
+		C(d6e9fc7a272d8b51), C(3ee5073ef1a9b777), C(63149e31fac02c59), C(2f7979ff636ba1d8),
+		C(cfd63b83)
+	},
+	{
+		C(e3f6828b6017086d), C(21b4d1900554b3b0), C(bef38be1809e24f1), C(d93251758985ee6c), C(32a9e9f82ba2a932), C(3822aacaa95f3329), C(db349b2f90a490d8),
+		C(d93251758985ee6c), C(32a9e9f82ba2a932), C(3822aacaa95f3329), C(db349b2f90a490d8),
+		C(8d49194a894a19ca), C(79a78b06e42738e6), C(7e0f1eda3d390c66), C(1c291d7e641100a5),
+		C(894a52ef)
+	},
+	{
+		C(851fff285561dca0), C(4d1277d73cdf416f), C(28ccffa61010ebe2), C(77a4ccacd131d9ee), C(e1d08eeb2f0e29aa), C(70b9e3051383fa45), C(582d0120425caba),
+		C(77a4ccacd131d9ee), C(e1d08eeb2f0e29aa), C(70b9e3051383fa45), C(582d0120425caba),
+		C(a740eef1846e4564), C(572dddb74ac3ae00), C(fdb5ca9579163bbd), C(a649b9b799c615d2),
+		C(9cde6a54)
+	},
+	{
+		C(61152a63595a96d9), C(d1a3a91ef3a7ba45), C(443b6bb4a493ad0c), C(a154296d11362d06), C(d0f0bf1f1cb02fc1), C(ccb87e09309f90d1), C(b24a8e4881911101),
+		C(a154296d11362d06), C(d0f0bf1f1cb02fc1), C(ccb87e09309f90d1), C(b24a8e4881911101),
+		C(1a481b4528559f58), C(bf837a3150896995), C(4989ef6b941a3757), C(2e725ab72d0b2948),
+		C(6c4898d5)
+	},
+	{
+		C(44473e03be306c88), C(30097761f872472a), C(9fd1b669bfad82d7), C(3bab18b164396783), C(47e385ff9d4c06f), C(18062081bf558df), C(63416eb68f104a36),
+		C(3bab18b164396783), C(47e385ff9d4c06f), C(18062081bf558df), C(63416eb68f104a36),
+		C(4abda1560c47ac80), C(1ea0e63dc6587aee), C(33ec79d92ebc1de), C(94f9dccef771e048),
+		C(13e1978e)
+	},
+	{
+		C(3ead5f21d344056), C(fb6420393cfb05c3), C(407932394cbbd303), C(ac059617f5906673), C(94d50d3dcd3069a7), C(2b26c3b92dea0f0), C(99b7374cc78fc3fb),
+		C(ac059617f5906673), C(94d50d3dcd3069a7), C(2b26c3b92dea0f0), C(99b7374cc78fc3fb),
+		C(1a8e3c73cdd40ee8), C(cbb5fca06747f45b), C(ceec44238b291841), C(28bf35cce9c90a25),
+		C(51b4ba8)
+	},
+	{
+		C(6abbfde37ee03b5b), C(83febf188d2cc113), C(cda7b62d94d5b8ee), C(a4375590b8ae7c82), C(168fd42f9ecae4ff), C(23bbde43de2cb214), C(a8c333112a243c8c),
+		C(a4375590b8ae7c82), C(168fd42f9ecae4ff), C(23bbde43de2cb214), C(a8c333112a243c8c),
+		C(10ac012e8c518b49), C(64a44605d8b29458), C(a67e701d2a679075), C(3a3a20f43ec92303),
+		C(b6b06e40)
+	},
+	{
+		C(943e7ed63b3c080), C(1ef207e9444ef7f8), C(ef4a9f9f8c6f9b4a), C(6b54fc38d6a84108), C(32f4212a47a4665), C(6b5a9a8f64ee1da6), C(9f74e86c6da69421),
+		C(6b54fc38d6a84108), C(32f4212a47a4665), C(6b5a9a8f64ee1da6), C(9f74e86c6da69421),
+		C(946dd0cb30c1a08e), C(fdf376956907eaaa), C(a59074c6eec03028), C(b1a3abcf283f34ac),
+		C(240a2f2)
+	},
+	{
+		C(d72ce05171ef8a1a), C(c6bd6bd869203894), C(c760e6396455d23a), C(f86af0b40dcce7b), C(8d3c15d613394d3c), C(491e400491cd4ece), C(7c19d3530ea3547f),
+		C(f86af0b40dcce7b), C(8d3c15d613394d3c), C(491e400491cd4ece), C(7c19d3530ea3547f),
+		C(1362963a1dc32af9), C(fb9bc11762e1385c), C(9e164ef1f5376083), C(6c15819b5e828a7e),
+		C(5dcefc30)
+	},
+	{
+		C(4182832b52d63735), C(337097e123eea414), C(b5a72ca0456df910), C(7ebc034235bc122f), C(d9a7783d4edd8049), C(5f8b04a15ae42361), C(fc193363336453dd),
+		C(7ebc034235bc122f), C(d9a7783d4edd8049), C(5f8b04a15ae42361), C(fc193363336453dd),
+		C(9b6c50224ef8c4f8), C(ba225c7942d16c3f), C(6f6d55226a73c412), C(abca061fe072152a),
+		C(7a48b105)
+	},
+	{
+		C(d6cdae892584a2cb), C(58de0fa4eca17dcd), C(43df30b8f5f1cb00), C(9e4ea5a4941e097d), C(547e048d5a9daaba), C(eb6ecbb0b831d185), C(e0168df5fad0c670),
+		C(9e4ea5a4941e097d), C(547e048d5a9daaba), C(eb6ecbb0b831d185), C(e0168df5fad0c670),
+		C(afa9705f98c2c96a), C(749436f48137a96b), C(759c041fc21df486), C(b23bf400107aa2ec),
+		C(fd55007b)
+	},
+	{
+		C(5c8e90bc267c5ee4), C(e9ae044075d992d9), C(f234cbfd1f0a1e59), C(ce2744521944f14c), C(104f8032f99dc152), C(4e7f425bfac67ca7), C(9461b911a1c6d589),
+		C(ce2744521944f14c), C(104f8032f99dc152), C(4e7f425bfac67ca7), C(9461b911a1c6d589),
+		C(5e5ecc726db8b60d), C(cce68b0586083b51), C(8a7f8e54a9cba0fc), C(42f010181d16f049),
+		C(6b95894c)
+	},
+	{
+		C(bbd7f30ac310a6f3), C(b23b570d2666685f), C(fb13fb08c9814fe7), C(4ee107042e512374), C(1e2c8c0d16097e13), C(210c7500995aa0e6), C(6c13190557106457),
+		C(4ee107042e512374), C(1e2c8c0d16097e13), C(210c7500995aa0e6), C(6c13190557106457),
+		C(a99b31c96777f381), C(8312ae8301d386c0), C(ed5042b2a4fa96a3), C(d71d1bb23907fe97),
+		C(3360e827)
+	},
+	{
+		C(36a097aa49519d97), C(8204380a73c4065), C(77c2004bdd9e276a), C(6ee1f817ce0b7aee), C(e9dcb3507f0596ca), C(6bc63c666b5100e2), C(e0b056f1821752af),
+		C(6ee1f817ce0b7aee), C(e9dcb3507f0596ca), C(6bc63c666b5100e2), C(e0b056f1821752af),
+		C(8ea1114e60292678), C(904b80b46becc77), C(46cd9bb6e9dff52f), C(4c91e3b698355540),
+		C(45177e0b)
+	},
+	{
+		C(dc78cb032c49217), C(112464083f83e03a), C(96ae53e28170c0f5), C(d367ff54952a958), C(cdad930657371147), C(aa24dc2a9573d5fe), C(eb136daa89da5110),
+		C(d367ff54952a958), C(cdad930657371147), C(aa24dc2a9573d5fe), C(eb136daa89da5110),
+		C(de623005f6d46057), C(b50c0c92b95e9b7f), C(a8aa54050b81c978), C(573fb5c7895af9b5),
+		C(7c6fffe4)
+	},
+	{
+		C(441593e0da922dfe), C(936ef46061469b32), C(204a1921197ddd87), C(50d8a70e7a8d8f56), C(256d150ae75dab76), C(e81f4c4a1989036a), C(d0f8db365f9d7e00),
+		C(50d8a70e7a8d8f56), C(256d150ae75dab76), C(e81f4c4a1989036a), C(d0f8db365f9d7e00),
+		C(753d686677b14522), C(9f76e0cb6f2d0a66), C(ab14f95988ec0d39), C(97621d9da9c9812f),
+		C(bbc78da4)
+	},
+	{
+		C(2ba3883d71cc2133), C(72f2bbb32bed1a3c), C(27e1bd96d4843251), C(a90f761e8db1543a), C(c339e23c09703cd8), C(f0c6624c4b098fd3), C(1bae2053e41fa4d9),
+		C(a90f761e8db1543a), C(c339e23c09703cd8), C(f0c6624c4b098fd3), C(1bae2053e41fa4d9),
+		C(3589e273c22ba059), C(63798246e5911a0b), C(18e710ec268fc5dc), C(714a122de1d074f3),
+		C(c5c25d39)
+	},
+	{
+		C(f2b6d2adf8423600), C(7514e2f016a48722), C(43045743a50396ba), C(23dacb811652ad4f), C(c982da480e0d4c7d), C(3a9c8ed5a399d0a9), C(951b8d084691d4e4),
+		C(23dacb811652ad4f), C(c982da480e0d4c7d), C(3a9c8ed5a399d0a9), C(951b8d084691d4e4),
+		C(d9f87b4988cff2f7), C(217a191d986aa3bc), C(6ad23c56b480350), C(dd78673938ceb2e7),
+		C(b6e5d06e)
+	},
+	{
+		C(38fffe7f3680d63c), C(d513325255a7a6d1), C(31ed47790f6ca62f), C(c801faaa0a2e331f), C(491dbc58279c7f88), C(9c0178848321c97a), C(9d934f814f4d6a3c),
+		C(c801faaa0a2e331f), C(491dbc58279c7f88), C(9c0178848321c97a), C(9d934f814f4d6a3c),
+		C(606a3e4fc8763192), C(bc15cb36a677ee84), C(52d5904157e1fe71), C(1588dd8b1145b79b),
+		C(6178504e)
+	},
+	{
+		C(b7477bf0b9ce37c6), C(63b1c580a7fd02a4), C(f6433b9f10a5dac), C(68dd76db9d64eca7), C(36297682b64b67), C(42b192d71f414b7a), C(79692cef44fa0206),
+		C(68dd76db9d64eca7), C(36297682b64b67), C(42b192d71f414b7a), C(79692cef44fa0206),
+		C(f0979252f4776d07), C(4b87cd4f1c9bbf52), C(51b84bbc6312c710), C(150720fbf85428a7),
+		C(bd4c3637)
+	},
+	{
+		C(55bdb0e71e3edebd), C(c7ab562bcf0568bc), C(43166332f9ee684f), C(b2e25964cd409117), C(a010599d6287c412), C(fa5d6461e768dda2), C(cb3ce74e8ec4f906),
+		C(b2e25964cd409117), C(a010599d6287c412), C(fa5d6461e768dda2), C(cb3ce74e8ec4f906),
+		C(6120abfd541a2610), C(aa88b148cc95794d), C(2686ca35df6590e3), C(c6b02d18616ce94d),
+		C(6e7ac474)
+	},
+	{
+		C(782fa1b08b475e7), C(fb7138951c61b23b), C(9829105e234fb11e), C(9a8c431f500ef06e), C(d848581a580b6c12), C(fecfe11e13a2bdb4), C(6c4fa0273d7db08c),
+		C(9a8c431f500ef06e), C(d848581a580b6c12), C(fecfe11e13a2bdb4), C(6c4fa0273d7db08c),
+		C(482f43bf5ae59fcb), C(f651fbca105d79e6), C(f09f78695d865817), C(7a99d0092085cf47),
+		C(1fb4b518)
+	},
+	{
+		C(c5dc19b876d37a80), C(15ffcff666cfd710), C(e8c30c72003103e2), C(7870765b470b2c5d), C(78a9103ff960d82), C(7bb50ffc9fac74b3), C(477e70ab2b347db2),
+		C(7870765b470b2c5d), C(78a9103ff960d82), C(7bb50ffc9fac74b3), C(477e70ab2b347db2),
+		C(a625238bdf7c07cf), C(1128d515174809f5), C(b0f1647e82f45873), C(17792d1c4f222c39),
+		C(31d13d6d)
+	},
+	{
+		C(5e1141711d2d6706), C(b537f6dee8de6933), C(3af0a1fbbe027c54), C(ea349dbc16c2e441), C(38a7455b6a877547), C(5f97b9750e365411), C(e8cde7f93af49a3),
+		C(ea349dbc16c2e441), C(38a7455b6a877547), C(5f97b9750e365411), C(e8cde7f93af49a3),
+		C(ba101925ec1f7e26), C(d5e84cab8192c71e), C(e256427726fdd633), C(a4f38e2c6116890d),
+		C(26fa72e3)
+	},
+	{
+		C(782edf6da001234f), C(f48cbd5c66c48f3), C(808754d1e64e2a32), C(5d9dde77353b1a6d), C(11f58c54581fa8b1), C(da90fa7c28c37478), C(5e9a2eafc670a88a),
+		C(5d9dde77353b1a6d), C(11f58c54581fa8b1), C(da90fa7c28c37478), C(5e9a2eafc670a88a),
+		C(e35e1bc172e011ef), C(bf9255a4450ae7fe), C(55f85194e26bc55f), C(4f327873e14d0e54),
+		C(6a7433bf)
+	},
+	{
+		C(d26285842ff04d44), C(8f38d71341eacca9), C(5ca436f4db7a883c), C(bf41e5376b9f0eec), C(2252d21eb7e1c0e9), C(f4b70a971855e732), C(40c7695aa3662afd),
+		C(bf41e5376b9f0eec), C(2252d21eb7e1c0e9), C(f4b70a971855e732), C(40c7695aa3662afd),
+		C(770fe19e16ab73bb), C(d603ebda6393d749), C(e58c62439aa50dbd), C(96d51e5a02d2d7cf),
+		C(4e6df758)
+	},
+	{
+		C(c6ab830865a6bae6), C(6aa8e8dd4b98815c), C(efe3846713c371e5), C(a1924cbf0b5f9222), C(7f4872369c2b4258), C(cd6da30530f3ea89), C(b7f8b9a704e6cea1),
+		C(a1924cbf0b5f9222), C(7f4872369c2b4258), C(cd6da30530f3ea89), C(b7f8b9a704e6cea1),
+		C(fa06ff40433fd535), C(fb1c36fe8f0737f1), C(bb7050561171f80), C(b1bc23235935d897),
+		C(d57f63ea)
+	},
+	{
+		C(44b3a1929232892), C(61dca0e914fc217), C(a607cc142096b964), C(f7dbc8433c89b274), C(2f5f70581c9b7d32), C(39bf5e5fec82dcca), C(8ade56388901a619),
+		C(f7dbc8433c89b274), C(2f5f70581c9b7d32), C(39bf5e5fec82dcca), C(8ade56388901a619),
+		C(c1c6a725caab3ea9), C(c1c7906c2f80b898), C(9c3871a04cc884e6), C(df01813cbbdf217f),
+		C(52ef73b3)
+	},
+	{
+		C(4b603d7932a8de4f), C(fae64c464b8a8f45), C(8fafab75661d602a), C(8ffe870ef4adc087), C(65bea2be41f55b54), C(82f3503f636aef1), C(5f78a282378b6bb0),
+		C(8ffe870ef4adc087), C(65bea2be41f55b54), C(82f3503f636aef1), C(5f78a282378b6bb0),
+		C(7bf2422c0beceddb), C(9d238d4780114bd), C(7ad198311906597f), C(ec8f892c0422aca3),
+		C(3cb36c3)
+	},
+	{
+		C(4ec0b54cf1566aff), C(30d2c7269b206bf4), C(77c22e82295e1061), C(3df9b04434771542), C(feddce785ccb661f), C(a644aff716928297), C(dd46aee73824b4ed),
+		C(3df9b04434771542), C(feddce785ccb661f), C(a644aff716928297), C(dd46aee73824b4ed),
+		C(bf8d71879da29b02), C(fc82dccbfc8022a0), C(31bfcd0d9f48d1d3), C(c64ee24d0e7b5f8b),
+		C(72c39bea)
+	},
+	{
+		C(ed8b7a4b34954ff7), C(56432de31f4ee757), C(85bd3abaa572b155), C(7d2c38a926dc1b88), C(5245b9eb4cd6791d), C(fb53ab03b9ad0855), C(3664026c8fc669d7),
+		C(7d2c38a926dc1b88), C(5245b9eb4cd6791d), C(fb53ab03b9ad0855), C(3664026c8fc669d7),
+		C(45024d5080bc196), C(b236ebec2cc2740), C(27231ad0e3443be4), C(145780b63f809250),
+		C(a65aa25c)
+	},
+	{
+		C(5d28b43694176c26), C(714cc8bc12d060ae), C(3437726273a83fe6), C(864b1b28ec16ea86), C(6a78a5a4039ec2b9), C(8e959533e35a766), C(347b7c22b75ae65f),
+		C(864b1b28ec16ea86), C(6a78a5a4039ec2b9), C(8e959533e35a766), C(347b7c22b75ae65f),
+		C(5005892bb61e647c), C(fe646519b4a1894d), C(cd801026f74a8a53), C(8713463e9a1ab9ce),
+		C(74740539)
+	},
+	{
+		C(6a1ef3639e1d202e), C(919bc1bd145ad928), C(30f3f7e48c28a773), C(2e8c49d7c7aaa527), C(5e2328fc8701db7c), C(89ef1afca81f7de8), C(b1857db11985d296),
+		C(2e8c49d7c7aaa527), C(5e2328fc8701db7c), C(89ef1afca81f7de8), C(b1857db11985d296),
+		C(17763d695f616115), C(b8f7bf1fcdc8322c), C(cf0c61938ab07a27), C(1122d3e6edb4e866),
+		C(c3ae3c26)
+	},
+	{
+		C(159f4d9e0307b111), C(3e17914a5675a0c), C(af849bd425047b51), C(3b69edadf357432b), C(3a2e311c121e6bf2), C(380fad1e288d57e5), C(bf7c7e8ef0e3b83a),
+		C(3b69edadf357432b), C(3a2e311c121e6bf2), C(380fad1e288d57e5), C(bf7c7e8ef0e3b83a),
+		C(92966d5f4356ae9b), C(2a03fc66c4d6c036), C(2516d8bddb0d5259), C(b3ffe9737ff5090),
+		C(f29db8a2)
+	},
+	{
+		C(cc0a840725a7e25b), C(57c69454396e193a), C(976eaf7eee0b4540), C(cd7a46850b95e901), C(c57f7d060dda246f), C(6b9406ead64079bf), C(11b28e20a573b7bd),
+		C(cd7a46850b95e901), C(c57f7d060dda246f), C(6b9406ead64079bf), C(11b28e20a573b7bd),
+		C(2d6db356e9369ace), C(dc0afe10fba193), C(5cdb10885dbbfce), C(5c700e205782e35a),
+		C(1ef4cbf4)
+	},
+	{
+		C(a2b27ee22f63c3f1), C(9ebde0ce1b3976b2), C(2fe6a92a257af308), C(8c1df927a930af59), C(a462f4423c9e384e), C(236542255b2ad8d9), C(595d201a2c19d5bc),
+		C(8c1df927a930af59), C(a462f4423c9e384e), C(236542255b2ad8d9), C(595d201a2c19d5bc),
+		C(22c87d4604a67f3), C(585a06eb4bc44c4f), C(b4175a7ac7eabcd8), C(a457d3eeba14ab8c),
+		C(a9be6c41)
+	},
+	{
+		C(d8f2f234899bcab3), C(b10b037297c3a168), C(debea2c510ceda7f), C(9498fefb890287ce), C(ae68c2be5b1a69a6), C(6189dfba34ed656c), C(91658f95836e5206),
+		C(9498fefb890287ce), C(ae68c2be5b1a69a6), C(6189dfba34ed656c), C(91658f95836e5206),
+		C(c0bb4fff32aecd4d), C(94125f505a50eef9), C(6ac406e7cfbce5bb), C(344a4b1dcdb7f5d8),
+		C(fa31801)
+	},
+	{
+		C(584f28543864844f), C(d7cee9fc2d46f20d), C(a38dca5657387205), C(7a0b6dbab9a14e69), C(c6d0a9d6b0e31ac4), C(a674d85812c7cf6), C(63538c0351049940),
+		C(7a0b6dbab9a14e69), C(c6d0a9d6b0e31ac4), C(a674d85812c7cf6), C(63538c0351049940),
+		C(9710e5f0bc93d1d), C(c2bea5bd7c54ddd4), C(48739af2bed0d32d), C(ba2c4e09e21fba85),
+		C(8331c5d8)
+	},
+	{
+		C(a94be46dd9aa41af), C(a57e5b7723d3f9bd), C(34bf845a52fd2f), C(843b58463c8df0ae), C(74b258324e916045), C(bdd7353230eb2b38), C(fad31fced7abade5),
+		C(843b58463c8df0ae), C(74b258324e916045), C(bdd7353230eb2b38), C(fad31fced7abade5),
+		C(2436aeafb0046f85), C(65bc9af9e5e33161), C(92733b1b3ae90628), C(f48143eaf78a7a89),
+		C(e9876db8)
+	},
+	{
+		C(9a87bea227491d20), C(a468657e2b9c43e7), C(af9ba60db8d89ef7), C(cc76f429ea7a12bb), C(5f30eaf2bb14870a), C(434e824cb3e0cd11), C(431a4d382e39d16e),
+		C(cc76f429ea7a12bb), C(5f30eaf2bb14870a), C(434e824cb3e0cd11), C(431a4d382e39d16e),
+		C(9e51f913c4773a8), C(32ab1925823d0add), C(99c61b54c1d8f69d), C(38cfb80f02b43b1f),
+		C(27b0604e)
+	},
+	{
+		C(27688c24958d1a5c), C(e3b4a1c9429cf253), C(48a95811f70d64bc), C(328063229db22884), C(67e9c95f8ba96028), C(7c6bf01c60436075), C(fa55161e7d9030b2),
+		C(328063229db22884), C(67e9c95f8ba96028), C(7c6bf01c60436075), C(fa55161e7d9030b2),
+		C(dadbc2f0dab91681), C(da39d7a4934ca11), C(162e845d24c1b45c), C(eb5b9dcd8c6ed31b),
+		C(dcec07f2)
+	},
+	{
+		C(5d1d37790a1873ad), C(ed9cd4bcc5fa1090), C(ce51cde05d8cd96a), C(f72c26e624407e66), C(a0eb541bdbc6d409), C(c3f40a2f40b3b213), C(6a784de68794492d),
+		C(f72c26e624407e66), C(a0eb541bdbc6d409), C(c3f40a2f40b3b213), C(6a784de68794492d),
+		C(10a38a23dbef7937), C(6a5560f853252278), C(c3387bbf3c7b82ba), C(fbee7c12eb072805),
+		C(cff0a82a)
+	},
+	{
+		C(1f03fd18b711eea9), C(566d89b1946d381a), C(6e96e83fc92563ab), C(405f66cf8cae1a32), C(d7261740d8f18ce6), C(fea3af64a413d0b2), C(d64d1810e83520fe),
+		C(405f66cf8cae1a32), C(d7261740d8f18ce6), C(fea3af64a413d0b2), C(d64d1810e83520fe),
+		C(e1334a00a580c6e8), C(454049e1b52c15f), C(8895d823d9778247), C(efa7f2e88b826618),
+		C(fec83621)
+	},
+	{
+		C(f0316f286cf527b6), C(f84c29538de1aa5a), C(7612ed3c923d4a71), C(d4eccebe9393ee8a), C(2eb7867c2318cc59), C(1ce621fd700fe396), C(686450d7a346878a),
+		C(d4eccebe9393ee8a), C(2eb7867c2318cc59), C(1ce621fd700fe396), C(686450d7a346878a),
+		C(75a5f37579f8b4cb), C(500cc16eb6541dc7), C(b7b02317b539d9a6), C(3519ddff5bc20a29),
+		C(743d8dc)
+	},
+	{
+		C(297008bcb3e3401d), C(61a8e407f82b0c69), C(a4a35bff0524fa0e), C(7a61d8f552a53442), C(821d1d8d8cfacf35), C(7cc06361b86d0559), C(119b617a8c2be199),
+		C(7a61d8f552a53442), C(821d1d8d8cfacf35), C(7cc06361b86d0559), C(119b617a8c2be199),
+		C(2996487da6721759), C(61a901376070b91d), C(d88dee12ae9c9b3c), C(5665491be1fa53a7),
+		C(64d41d26)
+	},
+	{
+		C(43c6252411ee3be), C(b4ca1b8077777168), C(2746dc3f7da1737f), C(2247a4b2058d1c50), C(1b3fa184b1d7bcc0), C(deb85613995c06ed), C(cbe1d957485a3ccd),
+		C(2247a4b2058d1c50), C(1b3fa184b1d7bcc0), C(deb85613995c06ed), C(cbe1d957485a3ccd),
+		C(dfe241f8f33c96b6), C(6597eb05019c2109), C(da344b2a63a219cf), C(79b8e3887612378a),
+		C(acd90c81)
+	},
+	{
+		C(ce38a9a54fad6599), C(6d6f4a90b9e8755e), C(c3ecc79ff105de3f), C(e8b9ee96efa2d0e), C(90122905c4ab5358), C(84f80c832d71979c), C(229310f3ffbbf4c6),
+		C(e8b9ee96efa2d0e), C(90122905c4ab5358), C(84f80c832d71979c), C(229310f3ffbbf4c6),
+		C(cc9eb42100cd63a7), C(7a283f2f3da7b9f), C(359b061d314e7a72), C(d0d959720028862),
+		C(7c746a4b)
+	},
+	{
+		C(270a9305fef70cf), C(600193999d884f3a), C(f4d49eae09ed8a1), C(2e091b85660f1298), C(bfe37fae1cdd64c9), C(8dddfbab930f6494), C(2ccf4b08f5d417a),
+		C(2e091b85660f1298), C(bfe37fae1cdd64c9), C(8dddfbab930f6494), C(2ccf4b08f5d417a),
+		C(365c2ee85582fe6), C(dee027bcd36db62a), C(b150994d3c7e5838), C(fdfd1a0e692e436d),
+		C(b1047e99)
+	},
+	{
+		C(e71be7c28e84d119), C(eb6ace59932736e6), C(70c4397807ba12c5), C(7a9d77781ac53509), C(4489c3ccfda3b39c), C(fa722d4f243b4964), C(25f15800bffdd122),
+		C(7a9d77781ac53509), C(4489c3ccfda3b39c), C(fa722d4f243b4964), C(25f15800bffdd122),
+		C(ed85e4157fbd3297), C(aab1967227d59efd), C(2199631212eb3839), C(3e4c19359aae1cc2),
+		C(d1fd1068)
+	},
+	{
+		C(b5b58c24b53aaa19), C(d2a6ab0773dd897f), C(ef762fe01ecb5b97), C(9deefbcfa4cab1f1), C(b58f5943cd2492ba), C(a96dcc4d1f4782a7), C(102b62a82309dde5),
+		C(9deefbcfa4cab1f1), C(b58f5943cd2492ba), C(a96dcc4d1f4782a7), C(102b62a82309dde5),
+		C(35fe52684763b338), C(afe2616651eaad1f), C(43e38715bdfa05e7), C(83c9ba83b5ec4a40),
+		C(56486077)
+	},
+	{
+		C(44dd59bd301995cf), C(3ccabd76493ada1a), C(540db4c87d55ef23), C(cfc6d7adda35797), C(14c7d1f32332cf03), C(2d553ffbff3be99d), C(c91c4ee0cb563182),
+		C(cfc6d7adda35797), C(14c7d1f32332cf03), C(2d553ffbff3be99d), C(c91c4ee0cb563182),
+		C(9aa5e507f49136f0), C(760c5dd1a82c4888), C(beea7e974a1cfb5c), C(640b247774fe4bf7),
+		C(6069be80)
+	},
+	{
+		C(b4d4789eb6f2630b), C(bf6973263ce8ef0e), C(d1c75c50844b9d3), C(bce905900c1ec6ea), C(c30f304f4045487d), C(a5c550166b3a142b), C(2f482b4e35327287),
+		C(bce905900c1ec6ea), C(c30f304f4045487d), C(a5c550166b3a142b), C(2f482b4e35327287),
+		C(15b21ddddf355438), C(496471fa3006bab), C(2a8fd458d06c1a32), C(db91e8ae812f0b8d),
+		C(2078359b)
+	},
+	{
+		C(12807833c463737c), C(58e927ea3b3776b4), C(72dd20ef1c2f8ad0), C(910b610de7a967bf), C(801bc862120f6bf5), C(9653efeed5897681), C(f5367ff83e9ebbb3),
+		C(910b610de7a967bf), C(801bc862120f6bf5), C(9653efeed5897681), C(f5367ff83e9ebbb3),
+		C(cf56d489afd1b0bf), C(c7c793715cae3de8), C(631f91d64abae47c), C(5f1f42fb14a444a2),
+		C(9ea21004)
+	},
+	{
+		C(e88419922b87176f), C(bcf32f41a7ddbf6f), C(d6ebefd8085c1a0f), C(d1d44fe99451ef72), C(ec951ba8e51e3545), C(c0ca86b360746e96), C(aa679cc066a8040b),
+		C(d1d44fe99451ef72), C(ec951ba8e51e3545), C(c0ca86b360746e96), C(aa679cc066a8040b),
+		C(51065861ece6ffc1), C(76777368a2997e11), C(87f278f46731100c), C(bbaa4140bdba4527),
+		C(9c9cfe88)
+	},
+	{
+		C(105191e0ec8f7f60), C(5918dbfcca971e79), C(6b285c8a944767b9), C(d3e86ac4f5eccfa4), C(e5399df2b106ca1), C(814aadfacd217f1d), C(2754e3def1c405a9),
+		C(d3e86ac4f5eccfa4), C(e5399df2b106ca1), C(814aadfacd217f1d), C(2754e3def1c405a9),
+		C(99290323b9f06e74), C(a9782e043f271461), C(13c8b3b8c275a860), C(6038d620e581e9e7),
+		C(b70a6ddd)
+	},
+	{
+		C(a5b88bf7399a9f07), C(fca3ddfd96461cc4), C(ebe738fdc0282fc6), C(69afbc800606d0fb), C(6104b97a9db12df7), C(fcc09198bb90bf9f), C(c5e077e41a65ba91),
+		C(69afbc800606d0fb), C(6104b97a9db12df7), C(fcc09198bb90bf9f), C(c5e077e41a65ba91),
+		C(db261835ee8aa08e), C(db0ee662e5796dc9), C(fc1880ecec499e5f), C(648866fbe1502034),
+		C(dea37298)
+	},
+	{
+		C(d08c3f5747d84f50), C(4e708b27d1b6f8ac), C(70f70fd734888606), C(909ae019d761d019), C(368bf4aab1b86ef9), C(308bd616d5460239), C(4fd33269f76783ea),
+		C(909ae019d761d019), C(368bf4aab1b86ef9), C(308bd616d5460239), C(4fd33269f76783ea),
+		C(7d53b37c19713eab), C(6bba6eabda58a897), C(91abb50efc116047), C(4e902f347e0e0e35),
+		C(8f480819)
+	},
+	{
+		C(2f72d12a40044b4b), C(889689352fec53de), C(f03e6ad87eb2f36), C(ef79f28d874b9e2d), C(b512089e8e63b76c), C(24dc06833bf193a9), C(3c23308ba8e99d7e),
+		C(ef79f28d874b9e2d), C(b512089e8e63b76c), C(24dc06833bf193a9), C(3c23308ba8e99d7e),
+		C(5ceff7b85cacefb7), C(ef390338898cd73), C(b12967d7d2254f54), C(de874cbd8aef7b75),
+		C(30b3b16)
+	},
+	{
+		C(aa1f61fdc5c2e11e), C(c2c56cd11277ab27), C(a1e73069fdf1f94f), C(8184bab36bb79df0), C(c81929ce8655b940), C(301b11bf8a4d8ce8), C(73126fd45ab75de9),
+		C(8184bab36bb79df0), C(c81929ce8655b940), C(301b11bf8a4d8ce8), C(73126fd45ab75de9),
+		C(4bd6f76e4888229a), C(9aae355b54a756d5), C(ca3de9726f6e99d5), C(83f80cac5bc36852),
+		C(f31bc4e8)
+	},
+	{
+		C(9489b36fe2246244), C(3355367033be74b8), C(5f57c2277cbce516), C(bc61414f9802ecaf), C(8edd1e7a50562924), C(48f4ab74a35e95f2), C(cc1afcfd99a180e7),
+		C(bc61414f9802ecaf), C(8edd1e7a50562924), C(48f4ab74a35e95f2), C(cc1afcfd99a180e7),
+		C(517dd5e3acf66110), C(7dd3ad9e8978b30d), C(1f6d5dfc70de812b), C(947daaba6441aaf3),
+		C(419f953b)
+	},
+	{
+		C(358d7c0476a044cd), C(e0b7b47bcbd8854f), C(ffb42ec696705519), C(d45e44c263e95c38), C(df61db53923ae3b1), C(f2bc948cc4fc027c), C(8a8000c6066772a3),
+		C(d45e44c263e95c38), C(df61db53923ae3b1), C(f2bc948cc4fc027c), C(8a8000c6066772a3),
+		C(9fd93c942d31fa17), C(d7651ecebe09cbd3), C(68682cefb6a6f165), C(541eb99a2dcee40e),
+		C(20e9e76d)
+	},
+	{
+		C(b0c48df14275265a), C(9da4448975905efa), C(d716618e414ceb6d), C(30e888af70df1e56), C(4bee54bd47274f69), C(178b4059e1a0afe5), C(6e2c96b7f58e5178),
+		C(30e888af70df1e56), C(4bee54bd47274f69), C(178b4059e1a0afe5), C(6e2c96b7f58e5178),
+		C(bb429d3b9275e9bc), C(c198013f09cafdc6), C(ec0a6ee4fb5de348), C(744e1e8ed2eb1eb0),
+		C(646f0ff8)
+	},
+	{
+		C(daa70bb300956588), C(410ea6883a240c6d), C(f5c8239fb5673eb3), C(8b1d7bb4903c105f), C(cfb1c322b73891d4), C(5f3b792b22f07297), C(fd64061f8be86811),
+		C(8b1d7bb4903c105f), C(cfb1c322b73891d4), C(5f3b792b22f07297), C(fd64061f8be86811),
+		C(1d2db712921cfc2b), C(cd1b2b2f2cee18ae), C(6b6f8790dc7feb09), C(46c179efa3f0f518),
+		C(eeb7eca8)
+	},
+	{
+		C(4ec97a20b6c4c7c2), C(5913b1cd454f29fd), C(a9629f9daf06d685), C(852c9499156a8f3), C(3a180a6abfb79016), C(9fc3c4764037c3c9), C(2890c42fc0d972cf),
+		C(852c9499156a8f3), C(3a180a6abfb79016), C(9fc3c4764037c3c9), C(2890c42fc0d972cf),
+		C(1f92231d4e537651), C(fab8bb07aa54b7b9), C(e05d2d771c485ed4), C(d50b34bf808ca731),
+		C(8112bb9)
+	},
+	{
+		C(5c3323628435a2e8), C(1bea45ce9e72a6e3), C(904f0a7027ddb52e), C(939f31de14dcdc7b), C(a68fdf4379df068), C(f169e1f0b835279d), C(7498e432f9619b27),
+		C(939f31de14dcdc7b), C(a68fdf4379df068), C(f169e1f0b835279d), C(7498e432f9619b27),
+		C(1aa2a1f11088e785), C(d6ad72f45729de78), C(9a63814157c80267), C(55538e35c648e435),
+		C(85a6d477)
+	},
+	{
+		C(c1ef26bea260abdb), C(6ee423f2137f9280), C(df2118b946ed0b43), C(11b87fb1b900cc39), C(e33e59b90dd815b1), C(aa6cb5c4bafae741), C(739699951ca8c713),
+		C(11b87fb1b900cc39), C(e33e59b90dd815b1), C(aa6cb5c4bafae741), C(739699951ca8c713),
+		C(2b4389a967310077), C(1d5382568a31c2c9), C(55d1e787fbe68991), C(277c254bc31301e7),
+		C(56f76c84)
+	},
+	{
+		C(6be7381b115d653a), C(ed046190758ea511), C(de6a45ffc3ed1159), C(a64760e4041447d0), C(e3eac49f3e0c5109), C(dd86c4d4cb6258e2), C(efa9857afd046c7f),
+		C(a64760e4041447d0), C(e3eac49f3e0c5109), C(dd86c4d4cb6258e2), C(efa9857afd046c7f),
+		C(fab793dae8246f16), C(c9e3b121b31d094c), C(a2a0f55858465226), C(dba6f0ff39436344),
+		C(9af45d55)
+	},
+	{
+		C(ae3eece1711b2105), C(14fd3f4027f81a4a), C(abb7e45177d151db), C(501f3e9b18861e44), C(465201170074e7d8), C(96d5c91970f2cb12), C(40fd28c43506c95d),
+		C(501f3e9b18861e44), C(465201170074e7d8), C(96d5c91970f2cb12), C(40fd28c43506c95d),
+		C(e86c4b07802aaff3), C(f317d14112372a70), C(641b13e587711650), C(4915421ab1090eaa),
+		C(d1c33760)
+	},
+	{
+		C(376c28588b8fb389), C(6b045e84d8491ed2), C(4e857effb7d4e7dc), C(154dd79fd2f984b4), C(f11171775622c1c3), C(1fbe30982e78e6f0), C(a460a15dcf327e44),
+		C(154dd79fd2f984b4), C(f11171775622c1c3), C(1fbe30982e78e6f0), C(a460a15dcf327e44),
+		C(f359e0900cc3d582), C(7e11070447976d00), C(324e6daf276ea4b5), C(7aa6e2df0cc94fa2),
+		C(c56bbf69)
+	},
+	{
+		C(58d943503bb6748f), C(419c6c8e88ac70f6), C(586760cbf3d3d368), C(b7e164979d5ccfc1), C(12cb4230d26bf286), C(f1bf910d44bd84cb), C(b32c24c6a40272),
+		C(b7e164979d5ccfc1), C(12cb4230d26bf286), C(f1bf910d44bd84cb), C(b32c24c6a40272),
+		C(11ed12e34c48c039), C(b0c2538e51d0a6ac), C(4269bb773e1d553a), C(e35a9dbabd34867),
+		C(abecfb9b)
+	},
+	{
+		C(dfff5989f5cfd9a1), C(bcee2e7ea3a96f83), C(681c7874adb29017), C(3ff6c8ac7c36b63a), C(48bc8831d849e326), C(30b078e76b0214e2), C(42954e6ad721b920),
+		C(3ff6c8ac7c36b63a), C(48bc8831d849e326), C(30b078e76b0214e2), C(42954e6ad721b920),
+		C(f9aeb33d164b4472), C(7b353b110831dbdc), C(16f64c82f44ae17b), C(b71244cc164b3b2b),
+		C(8de13255)
+	},
+	{
+		C(7fb19eb1a496e8f5), C(d49e5dfdb5c0833f), C(c0d5d7b2f7c48dc7), C(1a57313a32f22dde), C(30af46e49850bf8b), C(aa0fe8d12f808f83), C(443e31d70873bb6b),
+		C(1a57313a32f22dde), C(30af46e49850bf8b), C(aa0fe8d12f808f83), C(443e31d70873bb6b),
+		C(bbeb67c49c9fdc13), C(18f1e2a88f59f9d5), C(fb1b05038e5def11), C(d0450b5ce4c39c52),
+		C(a98ee299)
+	},
+	{
+		C(5dba5b0dadccdbaa), C(4ba8da8ded87fcdc), C(f693fdd25badf2f0), C(e9029e6364286587), C(ae69f49ecb46726c), C(18e002679217c405), C(bd6d66e85332ae9f),
+		C(e9029e6364286587), C(ae69f49ecb46726c), C(18e002679217c405), C(bd6d66e85332ae9f),
+		C(6bf330b1c353dd2a), C(74e9f2e71e3a4152), C(3f85560b50f6c413), C(d33a52a47eaed2b4),
+		C(3015f556)
+	},
+	{
+		C(688bef4b135a6829), C(8d31d82abcd54e8e), C(f95f8a30d55036d7), C(3d8c90e27aa2e147), C(2ec937ce0aa236b4), C(89b563996d3a0b78), C(39b02413b23c3f08),
+		C(3d8c90e27aa2e147), C(2ec937ce0aa236b4), C(89b563996d3a0b78), C(39b02413b23c3f08),
+		C(8d475a2e64faf2d2), C(48567f7dca46ecaf), C(254cda08d5f87a6d), C(ec6ae9f729c47039),
+		C(5a430e29)
+	},
+	{
+		C(d8323be05433a412), C(8d48fa2b2b76141d), C(3d346f23978336a5), C(4d50c7537562033f), C(57dc7625b61dfe89), C(9723a9f4c08ad93a), C(5309596f48ab456b),
+		C(4d50c7537562033f), C(57dc7625b61dfe89), C(9723a9f4c08ad93a), C(5309596f48ab456b),
+		C(7e453088019d220f), C(8776067ba6ab9714), C(67e1d06bd195de39), C(74a1a32f8994b918),
+		C(2797add0)
+	},
+	{
+		C(3b5404278a55a7fc), C(23ca0b327c2d0a81), C(a6d65329571c892c), C(45504801e0e6066b), C(86e6c6d6152a3d04), C(4f3db1c53eca2952), C(d24d69b3e9ef10f3),
+		C(45504801e0e6066b), C(86e6c6d6152a3d04), C(4f3db1c53eca2952), C(d24d69b3e9ef10f3),
+		C(93a0de2219e66a70), C(8932c7115ccb1f8a), C(5ef503fdf2841a8c), C(38064dd9efa80a41),
+		C(27d55016)
+	},
+	{
+		C(2a96a3f96c5e9bbc), C(8caf8566e212dda8), C(904de559ca16e45e), C(f13bc2d9c2fe222e), C(be4ccec9a6cdccfd), C(37b2cbdd973a3ac9), C(7b3223cd9c9497be),
+		C(f13bc2d9c2fe222e), C(be4ccec9a6cdccfd), C(37b2cbdd973a3ac9), C(7b3223cd9c9497be),
+		C(d5904440f376f889), C(62b13187699c473c), C(4751b89251f26726), C(9500d84fa3a61ba8),
+		C(84945a82)
+	},
+	{
+		C(22bebfdcc26d18ff), C(4b4d8dcb10807ba1), C(40265eee30c6b896), C(3752b423073b119a), C(377dc5eb7c662bdb), C(2b9f07f93a6c25b9), C(96f24ede2bdc0718),
+		C(3752b423073b119a), C(377dc5eb7c662bdb), C(2b9f07f93a6c25b9), C(96f24ede2bdc0718),
+		C(f7699b12c31417bd), C(17b366f401c58b2), C(bf60188d5f437b37), C(484436e56df17f04),
+		C(3ef7e224)
+	},
+	{
+		C(627a2249ec6bbcc2), C(c0578b462a46735a), C(4974b8ee1c2d4f1f), C(ebdbb918eb6d837f), C(8fb5f218dd84147c), C(c77dd1f881df2c54), C(62eac298ec226dc3),
+		C(ebdbb918eb6d837f), C(8fb5f218dd84147c), C(c77dd1f881df2c54), C(62eac298ec226dc3),
+		C(43eded83c4b60bd0), C(9a0a403b5487503b), C(25f305d9147f0bda), C(3ad417f511bc1e64),
+		C(35ed8dc8)
+	},
+	{
+		C(3abaf1667ba2f3e0), C(ee78476b5eeadc1), C(7e56ac0a6ca4f3f4), C(f1b9b413df9d79ed), C(a7621b6fd02db503), C(d92f7ba9928a4ffe), C(53f56babdcae96a6),
+		C(f1b9b413df9d79ed), C(a7621b6fd02db503), C(d92f7ba9928a4ffe), C(53f56babdcae96a6),
+		C(5302b89fc48713ab), C(d03e3b04dbe7a2f2), C(fa74ef8af6d376a7), C(103c8cdea1050ef2),
+		C(6a75e43d)
+	},
+	{
+		C(3931ac68c5f1b2c9), C(efe3892363ab0fb0), C(40b707268337cd36), C(a53a6b64b1ac85c9), C(d50e7f86ee1b832b), C(7bab08fdd26ba0a4), C(7587743c18fe2475),
+		C(a53a6b64b1ac85c9), C(d50e7f86ee1b832b), C(7bab08fdd26ba0a4), C(7587743c18fe2475),
+		C(e3b5d5d490cf5761), C(dfc053f7d065edd5), C(42ffd8d5fb70129f), C(599ca38677cccdc3),
+		C(235d9805)
+	},
+	{
+		C(b98fb0606f416754), C(46a6e5547ba99c1e), C(c909d82112a8ed2), C(dbfaae9642b3205a), C(f676a1339402bcb9), C(f4f12a5b1ac11f29), C(7db8bad81249dee4),
+		C(dbfaae9642b3205a), C(f676a1339402bcb9), C(f4f12a5b1ac11f29), C(7db8bad81249dee4),
+		C(b26e46f2da95922e), C(2aaedd5e12e3c611), C(a0e2d9082966074), C(c64da8a167add63d),
+		C(f7d69572)
+	},
+	{
+		C(7f7729a33e58fcc4), C(2e4bc1e7a023ead4), C(e707008ea7ca6222), C(47418a71800334a0), C(d10395d8fc64d8a4), C(8257a30062cb66f), C(6786f9b2dc1ff18a),
+		C(47418a71800334a0), C(d10395d8fc64d8a4), C(8257a30062cb66f), C(6786f9b2dc1ff18a),
+		C(5633f437bb2f180f), C(e5a3a405737d22d6), C(ca0ff1ef6f7f0b74), C(d0ae600684b16df8),
+		C(bacd0199)
+	},
+	{
+		C(42a0aa9ce82848b3), C(57232730e6bee175), C(f89bb3f370782031), C(caa33cf9b4f6619c), C(b2c8648ad49c209f), C(9e89ece0712db1c0), C(101d8274a711a54b),
+		C(caa33cf9b4f6619c), C(b2c8648ad49c209f), C(9e89ece0712db1c0), C(101d8274a711a54b),
+		C(538e79f1e70135cd), C(e1f5a76f983c844e), C(653c082fd66088fc), C(1b9c9b464b654958),
+		C(e428f50e)
+	},
+	{
+		C(6b2c6d38408a4889), C(de3ef6f68fb25885), C(20754f456c203361), C(941f5023c0c943f9), C(dfdeb9564fd66f24), C(2140cec706b9d406), C(7b22429b131e9c72),
+		C(941f5023c0c943f9), C(dfdeb9564fd66f24), C(2140cec706b9d406), C(7b22429b131e9c72),
+		C(94215c22eb940f45), C(d28b9ed474f7249a), C(6f25e88f2fbf9f56), C(b6718f9e605b38ac),
+		C(81eaaad3)
+	},
+	{
+		C(930380a3741e862a), C(348d28638dc71658), C(89dedcfd1654ea0d), C(7e7f61684080106), C(837ace9794582976), C(5ac8ca76a357eb1b), C(32b58308625661fb),
+		C(7e7f61684080106), C(837ace9794582976), C(5ac8ca76a357eb1b), C(32b58308625661fb),
+		C(c09705c4572025d9), C(f9187f6af0291303), C(1c0edd8ee4b02538), C(e6cb105daa0578a),
+		C(addbd3e3)
+	},
+	{
+		C(94808b5d2aa25f9a), C(cec72968128195e0), C(d9f4da2bdc1e130f), C(272d8dd74f3006cc), C(ec6c2ad1ec03f554), C(4ad276b249a5d5dd), C(549a22a17c0cde12),
+		C(272d8dd74f3006cc), C(ec6c2ad1ec03f554), C(4ad276b249a5d5dd), C(549a22a17c0cde12),
+		C(602119cb824d7cde), C(f4d3cef240ef35fa), C(e889895e01911bc7), C(785a7e5ac20e852b),
+		C(e66dbca0)
+	},
+	{
+		C(b31abb08ae6e3d38), C(9eb9a95cbd9e8223), C(8019e79b7ee94ea9), C(7b2271a7a3248e22), C(3b4f700e5a0ba523), C(8ebc520c227206fe), C(da3f861490f5d291),
+		C(7b2271a7a3248e22), C(3b4f700e5a0ba523), C(8ebc520c227206fe), C(da3f861490f5d291),
+		C(d08a689f9f3aa60e), C(547c1b97a068661f), C(4b15a67fa29172f0), C(eaf40c085191d80f),
+		C(afe11fd5)
+	},
+	{
+		C(dccb5534a893ea1a), C(ce71c398708c6131), C(fe2396315457c164), C(3f1229f4d0fd96fb), C(33130aa5fa9d43f2), C(e42693d5b34e63ab), C(2f4ef2be67f62104),
+		C(3f1229f4d0fd96fb), C(33130aa5fa9d43f2), C(e42693d5b34e63ab), C(2f4ef2be67f62104),
+		C(372e5153516e37b9), C(af9ec142ab12cc86), C(777920c09345e359), C(e7c4a383bef8adc6),
+		C(a71a406f)
+	},
+	{
+		C(6369163565814de6), C(8feb86fb38d08c2f), C(4976933485cc9a20), C(7d3e82d5ba29a90d), C(d5983cc93a9d126a), C(37e9dfd950e7b692), C(80673be6a7888b87),
+		C(7d3e82d5ba29a90d), C(d5983cc93a9d126a), C(37e9dfd950e7b692), C(80673be6a7888b87),
+		C(57f732dc600808bc), C(59477199802cc78b), C(f824810eb8f2c2de), C(c4a3437f05b3b61c),
+		C(9d90eaf5)
+	},
+	{
+		C(edee4ff253d9f9b3), C(96ef76fb279ef0ad), C(a4d204d179db2460), C(1f3dcdfa513512d6), C(4dc7ec07283117e4), C(4438bae88ae28bf9), C(aa7eae72c9244a0d),
+		C(1f3dcdfa513512d6), C(4dc7ec07283117e4), C(4438bae88ae28bf9), C(aa7eae72c9244a0d),
+		C(b9aedc8d3ecc72df), C(b75a8eb090a77d62), C(6b15677f9cd91507), C(51d8282cb3a9ddbf),
+		C(6665db10)
+	},
+	{
+		C(941993df6e633214), C(929bc1beca5b72c6), C(141fc52b8d55572d), C(b3b782ad308f21ed), C(4f2676485041dee0), C(bfe279aed5cb4bc8), C(2a62508a467a22ff),
+		C(b3b782ad308f21ed), C(4f2676485041dee0), C(bfe279aed5cb4bc8), C(2a62508a467a22ff),
+		C(e74d29eab742385d), C(56b05cd90ecfc293), C(c603728ea73f8844), C(8638fcd21bc692c4),
+		C(9c977cbf)
+	},
+	{
+		C(859838293f64cd4c), C(484403b39d44ad79), C(bf674e64d64b9339), C(44d68afda9568f08), C(478568ed51ca1d65), C(679c204ad3d9e766), C(b28e788878488dc1),
+		C(44d68afda9568f08), C(478568ed51ca1d65), C(679c204ad3d9e766), C(b28e788878488dc1),
+		C(d001a84d3a84fae6), C(d376958fe4cb913e), C(17435277e36c86f0), C(23657b263c347aa6),
+		C(ee83ddd4)
+	},
+	{
+		C(c19b5648e0d9f555), C(328e47b2b7562993), C(e756b92ba4bd6a51), C(c3314e362764ddb8), C(6481c084ee9ec6b5), C(ede23fb9a251771), C(bd617f2643324590),
+		C(c3314e362764ddb8), C(6481c084ee9ec6b5), C(ede23fb9a251771), C(bd617f2643324590),
+		C(d2d30c9b95e030f5), C(8a517312ffc5795e), C(8b1f325033bd535e), C(3ee6e867e03f2892),
+		C(26519cc)
+	},
+	{
+		C(f963b63b9006c248), C(9e9bf727ffaa00bc), C(c73bacc75b917e3a), C(2c6aa706129cc54c), C(17a706f59a49f086), C(c7c1eec455217145), C(6adfdc6e07602d42),
+		C(2c6aa706129cc54c), C(17a706f59a49f086), C(c7c1eec455217145), C(6adfdc6e07602d42),
+		C(fb75fca30d848dd2), C(5228c9ed14653ed4), C(953958910153b1a2), C(a430103a24f42a5d),
+		C(a485a53f)
+	},
+	{
+		C(6a8aa0852a8c1f3b), C(c8f1e5e206a21016), C(2aa554aed1ebb524), C(fc3e3c322cd5d89b), C(b7e3911dc2bd4ebb), C(fcd6da5e5fae833a), C(51ed3c41f87f9118),
+		C(fc3e3c322cd5d89b), C(b7e3911dc2bd4ebb), C(fcd6da5e5fae833a), C(51ed3c41f87f9118),
+		C(f31750cbc19c420a), C(186dab1abada1d86), C(ca7f88cb894b3cd7), C(2859eeb1c373790c),
+		C(f62bc412)
+	},
+	{
+		C(740428b4d45e5fb8), C(4c95a4ce922cb0a5), C(e99c3ba78feae796), C(914f1ea2fdcebf5c), C(9566453c07cd0601), C(9841bf66d0462cd), C(79140c1c18536aeb),
+		C(914f1ea2fdcebf5c), C(9566453c07cd0601), C(9841bf66d0462cd), C(79140c1c18536aeb),
+		C(a963b930b05820c2), C(6a7d9fa0c8c45153), C(64214c40d07cf39b), C(7057daf1d806c014),
+		C(8975a436)
+	},
+	{
+		C(658b883b3a872b86), C(2f0e303f0f64827a), C(975337e23dc45e1), C(99468a917986162b), C(7b31434aac6e0af0), C(f6915c1562c7d82f), C(e4071d82a6dd71db),
+		C(99468a917986162b), C(7b31434aac6e0af0), C(f6915c1562c7d82f), C(e4071d82a6dd71db),
+		C(5f5331f077b5d996), C(7b314ba21b747a4f), C(5a73cb9521da17f5), C(12ed435fae286d86),
+		C(94ff7f41)
+	},
+	{
+		C(6df0a977da5d27d4), C(891dd0e7cb19508), C(fd65434a0b71e680), C(8799e4740e573c50), C(9e739b52d0f341e8), C(cdfd34ba7d7b03eb), C(5061812ce6c88499),
+		C(8799e4740e573c50), C(9e739b52d0f341e8), C(cdfd34ba7d7b03eb), C(5061812ce6c88499),
+		C(612b8d8f2411dc5c), C(878bd883d29c7787), C(47a846727182bb), C(ec4949508c8b3b9a),
+		C(760aa031)
+	},
+	{
+		C(a900275464ae07ef), C(11f2cfda34beb4a3), C(9abf91e5a1c38e4), C(8063d80ab26f3d6d), C(4177b4b9b4f0393f), C(6de42ba8672b9640), C(d0bccdb72c51c18),
+		C(8063d80ab26f3d6d), C(4177b4b9b4f0393f), C(6de42ba8672b9640), C(d0bccdb72c51c18),
+		C(af3f611b7f22cf12), C(3863c41492645755), C(928c7a616a8f14f9), C(a82c78eb2eadc58b),
+		C(3bda76df)
+	},
+	{
+		C(810bc8aa0c40bcb0), C(448a019568d01441), C(f60ec52f60d3aeae), C(52c44837aa6dfc77), C(15d8d8fccdd6dc5b), C(345b793ccfa93055), C(932160fe802ca975),
+		C(52c44837aa6dfc77), C(15d8d8fccdd6dc5b), C(345b793ccfa93055), C(932160fe802ca975),
+		C(a624b0dd93fc18cd), C(d955b254c2037f1e), C(e540533d370a664c), C(2ba4ec12514e9d7),
+		C(498e2e65)
+	},
+	{
+		C(22036327deb59ed7), C(adc05ceb97026a02), C(48bff0654262672b), C(c791b313aba3f258), C(443c7757a4727bee), C(e30e4b2372171bdf), C(f3db986c4156f3cb),
+		C(c791b313aba3f258), C(443c7757a4727bee), C(e30e4b2372171bdf), C(f3db986c4156f3cb),
+		C(a939aefab97c6e15), C(dbeb8acf1d5b0e6c), C(1e0eab667a795bba), C(80dd539902df4d50),
+		C(d38deb48)
+	},
+	{
+		C(7d14dfa9772b00c8), C(595735efc7eeaed7), C(29872854f94c3507), C(bc241579d8348401), C(16dc832804d728f0), C(e9cc71ae64e3f09e), C(bef634bc978bac31),
+		C(bc241579d8348401), C(16dc832804d728f0), C(e9cc71ae64e3f09e), C(bef634bc978bac31),
+		C(7f64b1fa2a9129e), C(71d831bd530ac7f3), C(c7ad0a8a6d5be6f1), C(82a7d3a815c7aaab),
+		C(82b3fb6b)
+	},
+	{
+		C(2d777cddb912675d), C(278d7b10722a13f9), C(f5c02bfb7cc078af), C(4283001239888836), C(f44ca39a6f79db89), C(ed186122d71bcc9f), C(8620017ab5f3ba3b),
+		C(4283001239888836), C(f44ca39a6f79db89), C(ed186122d71bcc9f), C(8620017ab5f3ba3b),
+		C(e787472187f176c), C(267e64c4728cf181), C(f1ba4b3007c15e30), C(8e3a75d5b02ecfc0),
+		C(e500e25f)
+	},
+	{
+		C(f2ec98824e8aa613), C(5eb7e3fb53fe3bed), C(12c22860466e1dd4), C(374dd4288e0b72e5), C(ff8916db706c0df4), C(cb1a9e85de5e4b8d), C(d4d12afb67a27659),
+		C(374dd4288e0b72e5), C(ff8916db706c0df4), C(cb1a9e85de5e4b8d), C(d4d12afb67a27659),
+		C(feb69095d1ba175a), C(e2003aab23a47fad), C(8163a3ecab894b49), C(46d356674ce041f6),
+		C(bd2bb07c)
+	},
+	{
+		C(5e763988e21f487f), C(24189de8065d8dc5), C(d1519d2403b62aa0), C(9136456740119815), C(4d8ff7733b27eb83), C(ea3040bc0c717ef8), C(7617ab400dfadbc),
+		C(9136456740119815), C(4d8ff7733b27eb83), C(ea3040bc0c717ef8), C(7617ab400dfadbc),
+		C(fb336770c10b17a1), C(6123b68b5b31f151), C(1e147d5f295eccf2), C(9ecbb1333556f977),
+		C(3a2b431d)
+	},
+	{
+		C(48949dc327bb96ad), C(e1fd21636c5c50b4), C(3f6eb7f13a8712b4), C(14cf7f02dab0eee8), C(6d01750605e89445), C(4f1cf4006e613b78), C(57c40c4db32bec3b),
+		C(14cf7f02dab0eee8), C(6d01750605e89445), C(4f1cf4006e613b78), C(57c40c4db32bec3b),
+		C(1fde5a347f4a326e), C(cb5a54308adb0e3f), C(14994b2ba447a23c), C(7067d0abb4257b68),
+		C(7322a83d)
+	},
+	{
+		C(b7c4209fb24a85c5), C(b35feb319c79ce10), C(f0d3de191833b922), C(570d62758ddf6397), C(5e0204fb68a7b800), C(4383a9236f8b5a2b), C(7bc1a64641d803a4),
+		C(570d62758ddf6397), C(5e0204fb68a7b800), C(4383a9236f8b5a2b), C(7bc1a64641d803a4),
+		C(5434d61285099f7a), C(d49449aacdd5dd67), C(97855ba0e9a7d75d), C(da67328062f3a62f),
+		C(a645ca1c)
+	},
+	{
+		C(9c9e5be0943d4b05), C(b73dc69e45201cbb), C(aab17180bfe5083d), C(c738a77a9a55f0e2), C(705221addedd81df), C(fd9bd8d397abcfa3), C(8ccf0004aa86b795),
+		C(c738a77a9a55f0e2), C(705221addedd81df), C(fd9bd8d397abcfa3), C(8ccf0004aa86b795),
+		C(2bb5db2280068206), C(8c22d29f307a01d), C(274a22de02f473c8), C(b8791870f4268182),
+		C(8909a45a)
+	},
+	{
+		C(3898bca4dfd6638d), C(f911ff35efef0167), C(24bdf69e5091fc88), C(9b82567ab6560796), C(891b69462b41c224), C(8eccc7e4f3af3b51), C(381e54c3c8f1c7d0),
+		C(9b82567ab6560796), C(891b69462b41c224), C(8eccc7e4f3af3b51), C(381e54c3c8f1c7d0),
+		C(c80fbc489a558a55), C(1ba88e062a663af7), C(af7b1ef1c0116303), C(bd20e1a5a6b1a0cd),
+		C(bd30074c)
+	},
+	{
+		C(5b5d2557400e68e7), C(98d610033574cee), C(dfd08772ce385deb), C(3c13e894365dc6c2), C(26fc7bbcda3f0ef), C(dbb71106cdbfea36), C(785239a742c6d26d),
+		C(3c13e894365dc6c2), C(26fc7bbcda3f0ef), C(dbb71106cdbfea36), C(785239a742c6d26d),
+		C(f810c415ae05b2f4), C(bb9b9e7398526088), C(70128f1bf830a32b), C(bcc73f82b6410899),
+		C(c17cf001)
+	},
+	{
+		C(a927ed8b2bf09bb6), C(606e52f10ae94eca), C(71c2203feb35a9ee), C(6e65ec14a8fb565), C(34bff6f2ee5a7f79), C(2e329a5be2c011b), C(73161c93331b14f9),
+		C(6e65ec14a8fb565), C(34bff6f2ee5a7f79), C(2e329a5be2c011b), C(73161c93331b14f9),
+		C(15d13f2408aecf88), C(9f5b61b8a4b55b31), C(8fe25a43b296dba6), C(bdad03b7300f284e),
+		C(26ffd25a)
+	},
+	{
+		C(8d25746414aedf28), C(34b1629d28b33d3a), C(4d5394aea5f82d7b), C(379f76458a3c8957), C(79dd080f9843af77), C(c46f0a7847f60c1d), C(af1579c5797703cc),
+		C(379f76458a3c8957), C(79dd080f9843af77), C(c46f0a7847f60c1d), C(af1579c5797703cc),
+		C(8b7d31f338755c14), C(2eff97679512aaa8), C(df07d68e075179ed), C(c8fa6c7a729e7f1f),
+		C(f1d8ce3c)
+	},
+	{
+		C(b5bbdb73458712f2), C(1ff887b3c2a35137), C(7f7231f702d0ace9), C(1e6f0910c3d25bd8), C(ad9e250862102467), C(1c842a07abab30cd), C(cd8124176bac01ac),
+		C(1e6f0910c3d25bd8), C(ad9e250862102467), C(1c842a07abab30cd), C(cd8124176bac01ac),
+		C(ea6ebe7a79b67edc), C(73f598ac9db26713), C(4f4e72d7460b8fc), C(365dc4b9fdf13f21),
+		C(3ee8fb17)
+	},
+	{
+		C(3d32a26e3ab9d254), C(fc4070574dc30d3a), C(f02629579c2b27c9), C(b1cf09b0184a4834), C(5c03db48eb6cc159), C(f18c7fcf34d1df47), C(dfb043419ecf1fa9),
+		C(b1cf09b0184a4834), C(5c03db48eb6cc159), C(f18c7fcf34d1df47), C(dfb043419ecf1fa9),
+		C(dcd78d13f9ca658f), C(4355d408ffe8e49f), C(81eefee908b593b4), C(590c213c20e981a3),
+		C(a77acc2a)
+	},
+	{
+		C(9371d3c35fa5e9a5), C(42967cf4d01f30), C(652d1eeae704145c), C(ceaf1a0d15234f15), C(1450a54e45ba9b9), C(65e9c1fd885aa932), C(354d4bc034ba8cbe),
+		C(ceaf1a0d15234f15), C(1450a54e45ba9b9), C(65e9c1fd885aa932), C(354d4bc034ba8cbe),
+		C(8fd4ff484c08fb4b), C(bf46749866f69ba0), C(cf1c21ede82c9477), C(4217548c43da109),
+		C(f4556dee)
+	},
+	{
+		C(cbaa3cb8f64f54e0), C(76c3b48ee5c08417), C(9f7d24e87e61ce9), C(85b8e53f22e19507), C(bb57137739ca486b), C(c77f131cca38f761), C(c56ac3cf275be121),
+		C(85b8e53f22e19507), C(bb57137739ca486b), C(c77f131cca38f761), C(c56ac3cf275be121),
+		C(9ec1a6c9109d2685), C(3dad0922e76afdb0), C(fd58cbf952958103), C(7b04c908e78639a1),
+		C(de287a64)
+	},
+	{
+		C(b2e23e8116c2ba9f), C(7e4d9c0060101151), C(3310da5e5028f367), C(adc52dddb76f6e5e), C(4aad4e925a962b68), C(204b79b7f7168e64), C(df29ed6671c36952),
+		C(adc52dddb76f6e5e), C(4aad4e925a962b68), C(204b79b7f7168e64), C(df29ed6671c36952),
+		C(e02927cac396d210), C(5d500e71742b638a), C(5c9998af7f27b124), C(3fba9a2573dc2f7),
+		C(878e55b9)
+	},
+	{
+		C(8aa77f52d7868eb9), C(4d55bd587584e6e2), C(d2db37041f495f5), C(ce030d15b5fe2f4), C(86b4a7a0780c2431), C(ee070a9ae5b51db7), C(edc293d9595be5d8),
+		C(ce030d15b5fe2f4), C(86b4a7a0780c2431), C(ee070a9ae5b51db7), C(edc293d9595be5d8),
+		C(3dfc5ec108260a2b), C(8afe28c7123bf4e2), C(da82ef38023a7a5f), C(3e1f77b0174b77c3),
+		C(7648486)
+	},
+	{
+		C(858fea922c7fe0c3), C(cfe8326bf733bc6f), C(4e5e2018cf8f7dfc), C(64fd1bc011e5bab7), C(5c9e858728015568), C(97ac42c2b00b29b1), C(7f89caf08c109aee),
+		C(64fd1bc011e5bab7), C(5c9e858728015568), C(97ac42c2b00b29b1), C(7f89caf08c109aee),
+		C(9a8af34fd0e9dacf), C(bbc54161aa1507e0), C(7cda723ccbbfe5ee), C(2c289d839fb93f58),
+		C(57ac0fb1)
+	},
+	{
+		C(46ef25fdec8392b1), C(e48d7b6d42a5cd35), C(56a6fe1c175299ca), C(fdfa836b41dcef62), C(2f8db8030e847e1b), C(5ba0a49ac4f9b0f8), C(dae897ed3e3fce44),
+		C(fdfa836b41dcef62), C(2f8db8030e847e1b), C(5ba0a49ac4f9b0f8), C(dae897ed3e3fce44),
+		C(9c432e31aef626e7), C(9a36e1c6cd6e3dd), C(5095a167c34d19d), C(a70005cfa6babbea),
+		C(d01967ca)
+	},
+	{
+		C(8d078f726b2df464), C(b50ee71cdcabb299), C(f4af300106f9c7ba), C(7d222caae025158a), C(cc028d5fd40241b9), C(dd42515b639e6f97), C(e08e86531a58f87f),
+		C(7d222caae025158a), C(cc028d5fd40241b9), C(dd42515b639e6f97), C(e08e86531a58f87f),
+		C(d93612c835b37d7b), C(91dd61729b2fa7f4), C(ba765a1bdda09db7), C(55258b451b2b1297),
+		C(96ecdf74)
+	},
+	{
+		C(35ea86e6960ca950), C(34fe1fe234fc5c76), C(a00207a3dc2a72b7), C(80395e48739e1a67), C(74a67d8f7f43c3d7), C(dd2bdd1d62246c6e), C(a1f44298ba80acf6),
+		C(80395e48739e1a67), C(74a67d8f7f43c3d7), C(dd2bdd1d62246c6e), C(a1f44298ba80acf6),
+		C(ad86d86c187bf38), C(26feea1f2eee240d), C(ed7f1fd066b23897), C(a768cf1e0fbb502),
+		C(779f5506)
+	},
+	{
+		C(8aee9edbc15dd011), C(51f5839dc8462695), C(b2213e17c37dca2d), C(133b299a939745c5), C(796e2aac053f52b3), C(e8d9fe1521a4a222), C(819a8863e5d1c290),
+		C(133b299a939745c5), C(796e2aac053f52b3), C(e8d9fe1521a4a222), C(819a8863e5d1c290),
+		C(c0737f0fe34d36ad), C(e6d6d4a267a5cc31), C(98300a7911674c23), C(bef189661c257098),
+		C(3c94c2de)
+	},
+	{
+		C(c3e142ba98432dda), C(911d060cab126188), C(b753fbfa8365b844), C(fd1a9ba5e71b08a2), C(7ac0dc2ed7778533), C(b543161ff177188a), C(492fc08a6186f3f4),
+		C(fd1a9ba5e71b08a2), C(7ac0dc2ed7778533), C(b543161ff177188a), C(492fc08a6186f3f4),
+		C(fc4745f516afd3b6), C(88c30370a53080e), C(65a1bb34abc465e2), C(abbd14662911c8b3),
+		C(39f98faf)
+	},
+	{
+		C(123ba6b99c8cd8db), C(448e582672ee07c4), C(cebe379292db9e65), C(938f5bbab544d3d6), C(d2a95f9f2d376d73), C(68b2f16149e81aa3), C(ad7e32f82d86c79d),
+		C(938f5bbab544d3d6), C(d2a95f9f2d376d73), C(68b2f16149e81aa3), C(ad7e32f82d86c79d),
+		C(4574015ae8626ce2), C(455aa6137386a582), C(658ad2542e8ec20), C(e31d7be2ca35d00),
+		C(7af31199)
+	},
+	{
+		C(ba87acef79d14f53), C(b3e0fcae63a11558), C(d5ac313a593a9f45), C(eea5f5a9f74af591), C(578710bcc36fbea2), C(7a8393432188931d), C(705cfc5ec7cc172),
+		C(eea5f5a9f74af591), C(578710bcc36fbea2), C(7a8393432188931d), C(705cfc5ec7cc172),
+		C(da85ebe5fc427976), C(bfa5c7a454df54c8), C(4632b72a81bf66d2), C(5dd72877db539ee2),
+		C(e341a9d6)
+	},
+	{
+		C(bcd3957d5717dc3), C(2da746741b03a007), C(873816f4b1ece472), C(2b826f1a2c08c289), C(da50f56863b55e74), C(b18712f6b3eed83b), C(bdc7cc05ab4c685f),
+		C(2b826f1a2c08c289), C(da50f56863b55e74), C(b18712f6b3eed83b), C(bdc7cc05ab4c685f),
+		C(9e45fb833d1b0af), C(d7213081db29d82e), C(d2a6b6c6a09ed55e), C(98a7686cba323ca9),
+		C(ca24aeeb)
+	},
+	{
+		C(61442ff55609168e), C(6447c5fc76e8c9cf), C(6a846de83ae15728), C(effc2663cffc777f), C(93214f8f463afbed), C(a156ef06066f4e4e), C(a407b6ed8769d51e),
+		C(effc2663cffc777f), C(93214f8f463afbed), C(a156ef06066f4e4e), C(a407b6ed8769d51e),
+		C(bb2f9ed29745c02a), C(981eecd435b36ad9), C(461a5a05fb9cdff4), C(bd6cb2a87b9f910c),
+		C(b2252b57)
+	},
+	{
+		C(dbe4b1b2d174757f), C(506512da18712656), C(6857f3e0b8dd95f), C(5a4fc2728a9bb671), C(ebb971522ec38759), C(1a5a093e6cf1f72b), C(729b057fe784f504),
+		C(5a4fc2728a9bb671), C(ebb971522ec38759), C(1a5a093e6cf1f72b), C(729b057fe784f504),
+		C(71fcbf42a767f9cf), C(114cfe772da6cdd), C(60cdf9cb629d9d7a), C(e270d10ad088b24e),
+		C(72c81da1)
+	},
+	{
+		C(531e8e77b363161c), C(eece0b43e2dae030), C(8294b82c78f34ed1), C(e777b1fd580582f2), C(7b880f58da112699), C(562c6b189a6333f4), C(139d64f88a611d4),
+		C(e777b1fd580582f2), C(7b880f58da112699), C(562c6b189a6333f4), C(139d64f88a611d4),
+		C(53d8ef17eda64fa4), C(bf3eded14dc60a04), C(2b5c559cf5ec07c5), C(8895f7339d03a48a),
+		C(6b9fce95)
+	},
+	{
+		C(f71e9c926d711e2b), C(d77af2853a4ceaa1), C(9aa0d6d76a36fae7), C(dd16cd0fbc08393), C(29a414a5d8c58962), C(72793d8d1022b5b2), C(2e8e69cf7cbffdf0),
+		C(dd16cd0fbc08393), C(29a414a5d8c58962), C(72793d8d1022b5b2), C(2e8e69cf7cbffdf0),
+		C(3721c0473aa99c9a), C(1cff4ed9c31cd91c), C(4990735033cc482b), C(7fdf8c701c72f577),
+		C(19399857)
+	},
+	{
+		C(cb20ac28f52df368), C(e6705ee7880996de), C(9b665cc3ec6972f2), C(4260e8c254e9924b), C(f197a6eb4591572d), C(8e867ff0fb7ab27c), C(f95502fb503efaf3),
+		C(4260e8c254e9924b), C(f197a6eb4591572d), C(8e867ff0fb7ab27c), C(f95502fb503efaf3),
+		C(30c41876b08e3e22), C(958e2419e3cd22f4), C(f0f3aa1fe119a107), C(481662310a379100),
+		C(3c57a994)
+	},
+	{
+		C(e4a794b4acb94b55), C(89795358057b661b), C(9c4cdcec176d7a70), C(4890a83ee435bc8b), C(d8c1c00fceb00914), C(9e7111ba234f900f), C(eb8dbab364d8b604),
+		C(4890a83ee435bc8b), C(d8c1c00fceb00914), C(9e7111ba234f900f), C(eb8dbab364d8b604),
+		C(b3261452963eebb), C(6cf94b02792c4f95), C(d88fa815ef1e8fc), C(2d687af66604c73),
+		C(c053e729)
+	},
+	{
+		C(cb942e91443e7208), C(e335de8125567c2a), C(d4d74d268b86df1f), C(8ba0fdd2ffc8b239), C(f413b366c1ffe02f), C(c05b2717c59a8a28), C(981188eab4fcc8fb),
+		C(8ba0fdd2ffc8b239), C(f413b366c1ffe02f), C(c05b2717c59a8a28), C(981188eab4fcc8fb),
+		C(e563f49a1d9072ba), C(3c6a3aa4a26367dc), C(ba0db13448653f34), C(31065d756074d7d6),
+		C(51cbbba7)
+	},
+	{
+		C(ecca7563c203f7ba), C(177ae2423ef34bb2), C(f60b7243400c5731), C(cf1edbfe7330e94e), C(881945906bcb3cc6), C(4acf0293244855da), C(65ae042c1c2a28c2),
+		C(cf1edbfe7330e94e), C(881945906bcb3cc6), C(4acf0293244855da), C(65ae042c1c2a28c2),
+		C(b25fa0a1cab33559), C(d98e8daa28124131), C(fce17f50b9c351b3), C(3f995ccf7386864b),
+		C(1acde79a)
+	},
+	{
+		C(1652cb940177c8b5), C(8c4fe7d85d2a6d6d), C(f6216ad097e54e72), C(f6521b912b368ae6), C(a9fe4eff81d03e73), C(d6f623629f80d1a3), C(2b9604f32cb7dc34),
+		C(f6521b912b368ae6), C(a9fe4eff81d03e73), C(d6f623629f80d1a3), C(2b9604f32cb7dc34),
+		C(2a43d84dcf59c7e2), C(d0a197c70c5dae0b), C(6e84d4bbc71d76a0), C(c7e94620378c6cb2),
+		C(2d160d13)
+	},
+	{
+		C(31fed0fc04c13ce8), C(3d5d03dbf7ff240a), C(727c5c9b51581203), C(6b5ffc1f54fecb29), C(a8e8e7ad5b9a21d9), C(c4d5a32cd6aac22d), C(d7e274ad22d4a79a),
+		C(6b5ffc1f54fecb29), C(a8e8e7ad5b9a21d9), C(c4d5a32cd6aac22d), C(d7e274ad22d4a79a),
+		C(368841ea5731a112), C(feaf7bc2e73ca48f), C(636fb272e9ea1f6), C(5d9cb7580c3f6207),
+		C(787f5801)
+	},
+	{
+		C(e7b668947590b9b3), C(baa41ad32938d3fa), C(abcbc8d4ca4b39e4), C(381ee1b7ea534f4e), C(da3759828e3de429), C(3e015d76729f9955), C(cbbec51a6485fbde),
+		C(381ee1b7ea534f4e), C(da3759828e3de429), C(3e015d76729f9955), C(cbbec51a6485fbde),
+		C(9b86605281f20727), C(fc6fcf508676982a), C(3b135f7a813a1040), C(d3a4706bea1db9c9),
+		C(c9629828)
+	},
+	{
+		C(1de2119923e8ef3c), C(6ab27c096cf2fe14), C(8c3658edca958891), C(4cc8ed3ada5f0f2), C(4a496b77c1f1c04e), C(9085b0a862084201), C(a1894bde9e3dee21),
+		C(4cc8ed3ada5f0f2), C(4a496b77c1f1c04e), C(9085b0a862084201), C(a1894bde9e3dee21),
+		C(367fb472dc5b277d), C(7d39ccca16fc6745), C(763f988d70db9106), C(a8b66f7fecb70f02),
+		C(be139231)
+	},
+	{
+		C(1269df1e69e14fa7), C(992f9d58ac5041b7), C(e97fcf695a7cbbb4), C(e5d0549802d15008), C(424c134ecd0db834), C(6fc44fd91be15c6c), C(a1a5ef95d50e537d),
+		C(e5d0549802d15008), C(424c134ecd0db834), C(6fc44fd91be15c6c), C(a1a5ef95d50e537d),
+		C(d1e3daf5d05f5308), C(4c7f81600eaa1327), C(109d1b8d1f9d0d2b), C(871e8699e0aeb862),
+		C(7df699ef)
+	},
+	{
+		C(820826d7aba567ff), C(1f73d28e036a52f3), C(41c4c5a73f3b0893), C(aa0d74d4a98db89b), C(36fd486d07c56e1d), C(d0ad23cbb6660d8a), C(1264a84665b35e19),
+		C(aa0d74d4a98db89b), C(36fd486d07c56e1d), C(d0ad23cbb6660d8a), C(1264a84665b35e19),
+		C(789682bf7d781b33), C(6bfa6abd2fb5722d), C(6779cb3623d33900), C(435ca5214e1ee5f0),
+		C(8ce6b96d)
+	},
+	{
+		C(ffe0547e4923cef9), C(3534ed49b9da5b02), C(548a273700fba03d), C(28ac84ca70958f7e), C(d8ae575a68faa731), C(2aaaee9b9dcffd4c), C(6c7faab5c285c6da),
+		C(28ac84ca70958f7e), C(d8ae575a68faa731), C(2aaaee9b9dcffd4c), C(6c7faab5c285c6da),
+		C(45d94235f99ba78f), C(ab5ea16f39497f5b), C(fb4d6c86fccbdca3), C(8104e6310a5fd2c7),
+		C(6f9ed99c)
+	},
+	{
+		C(72da8d1b11d8bc8b), C(ba94b56b91b681c6), C(4e8cc51bd9b0fc8c), C(43505ed133be672a), C(e8f2f9d973c2774e), C(677b9b9c7cad6d97), C(4e1f5d56ef17b906),
+		C(43505ed133be672a), C(e8f2f9d973c2774e), C(677b9b9c7cad6d97), C(4e1f5d56ef17b906),
+		C(eea3a6038f983767), C(87109f077f86db01), C(ecc1ca41f74d61cc), C(34a87e86e83bed17),
+		C(e0244796)
+	},
+	{
+		C(d62ab4e3f88fc797), C(ea86c7aeb6283ae4), C(b5b93e09a7fe465), C(4344a1a0134afe2), C(ff5c17f02b62341d), C(3214c6a587ce4644), C(a905e7ed0629d05c),
+		C(4344a1a0134afe2), C(ff5c17f02b62341d), C(3214c6a587ce4644), C(a905e7ed0629d05c),
+		C(b5c72690cd716e82), C(7c6097649e6ebe7b), C(7ceee8c6e56a4dcd), C(80ca849dc53eb9e4),
+		C(4ccf7e75)
+	},
+	{
+		C(d0f06c28c7b36823), C(1008cb0874de4bb8), C(d6c7ff816c7a737b), C(489b697fe30aa65f), C(4da0fb621fdc7817), C(dc43583b82c58107), C(4b0261debdec3cd6),
+		C(489b697fe30aa65f), C(4da0fb621fdc7817), C(dc43583b82c58107), C(4b0261debdec3cd6),
+		C(a9748d7b6c0e016c), C(7e8828f7ba4b034b), C(da0fa54348a2512a), C(ebf9745c0962f9ad),
+		C(915cef86)
+	},
+	{
+		C(99b7042460d72ec6), C(2a53e5e2b8e795c2), C(53a78132d9e1b3e3), C(c043e67e6fc64118), C(ff0abfe926d844d3), C(f2a9fe5db2e910fe), C(ce352cdc84a964dd),
+		C(c043e67e6fc64118), C(ff0abfe926d844d3), C(f2a9fe5db2e910fe), C(ce352cdc84a964dd),
+		C(b89bc028aa5e6063), C(a354e7fdac04459c), C(68d6547e6e980189), C(c968dddfd573773e),
+		C(5cb59482)
+	},
+	{
+		C(4f4dfcfc0ec2bae5), C(841233148268a1b8), C(9248a76ab8be0d3), C(334c5a25b5903a8c), C(4c94fef443122128), C(743e7d8454655c40), C(1ab1e6d1452ae2cd),
+		C(334c5a25b5903a8c), C(4c94fef443122128), C(743e7d8454655c40), C(1ab1e6d1452ae2cd),
+		C(fec766de4a8e476c), C(cc0929da9567e71b), C(5f9ef5b5f150c35a), C(87659cabd649768f),
+		C(6ca3f532)
+	},
+	{
+		C(fe86bf9d4422b9ae), C(ebce89c90641ef9c), C(1c84e2292c0b5659), C(8bde625a10a8c50d), C(eb8271ded1f79a0b), C(14dc6844f0de7a3c), C(f85b2f9541e7e6da),
+		C(8bde625a10a8c50d), C(eb8271ded1f79a0b), C(14dc6844f0de7a3c), C(f85b2f9541e7e6da),
+		C(2fe22cfd1683b961), C(ea1d75c5b7aa01ca), C(9eef60a44876bb95), C(950c818e505c6f7f),
+		C(e24f3859)
+	},
+	{
+		C(a90d81060932dbb0), C(8acfaa88c5fbe92b), C(7c6f3447e90f7f3f), C(dd52fc14c8dd3143), C(1bc7508516e40628), C(3059730266ade626), C(ffa526822f391c2),
+		C(dd52fc14c8dd3143), C(1bc7508516e40628), C(3059730266ade626), C(ffa526822f391c2),
+		C(e25232d7afc8a406), C(d2b8a5a3f3b5f670), C(6630f33edb7dfe32), C(c71250ba68c4ea86),
+		C(adf5a9c7)
+	},
+	{
+		C(17938a1b0e7f5952), C(22cadd2f56f8a4be), C(84b0d1183d5ed7c1), C(c1336b92fef91bf6), C(80332a3945f33fa9), C(a0f68b86f726ff92), C(a3db5282cf5f4c0b),
+		C(c1336b92fef91bf6), C(80332a3945f33fa9), C(a0f68b86f726ff92), C(a3db5282cf5f4c0b),
+		C(82640b6fc4916607), C(2dc2a3aa1a894175), C(8b4c852bdee7cc9), C(10b9d0a08b55ff83),
+		C(32264b75)
+	},
+	{
+		C(de9e0cb0e16f6e6d), C(238e6283aa4f6594), C(4fb9c914c2f0a13b), C(497cb912b670f3b), C(d963a3f02ff4a5b6), C(4fccefae11b50391), C(42ba47db3f7672f),
+		C(497cb912b670f3b), C(d963a3f02ff4a5b6), C(4fccefae11b50391), C(42ba47db3f7672f),
+		C(1d6b655a1889feef), C(5f319abf8fafa19f), C(715c2e49deb14620), C(8d9153082ecdcea4),
+		C(a64b3376)
+	},
+	{
+		C(6d4b876d9b146d1a), C(aab2d64ce8f26739), C(d315f93600e83fe5), C(2fe9fabdbe7fdd4), C(755db249a2d81a69), C(f27929f360446d71), C(79a1bf957c0c1b92),
+		C(2fe9fabdbe7fdd4), C(755db249a2d81a69), C(f27929f360446d71), C(79a1bf957c0c1b92),
+		C(3c8a28d4c936c9cd), C(df0d3d13b2c6a902), C(c76702dd97cd2edd), C(1aa220f7be16517),
+		C(d33890e)
+	},
+	{
+		C(e698fa3f54e6ea22), C(bd28e20e7455358c), C(9ace161f6ea76e66), C(d53fb7e3c93a9e4), C(737ae71b051bf108), C(7ac71feb84c2df42), C(3d8075cd293a15b4),
+		C(d53fb7e3c93a9e4), C(737ae71b051bf108), C(7ac71feb84c2df42), C(3d8075cd293a15b4),
+		C(bf8cee5e095d8a7c), C(e7086b3c7608143a), C(e55b0c2fa938d70c), C(fffb5f58e643649c),
+		C(926d4b63)
+	},
+	{
+		C(7bc0deed4fb349f7), C(1771aff25dc722fa), C(19ff0644d9681917), C(cf7d7f25bd70cd2c), C(9464ed9baeb41b4f), C(b9064f5c3cb11b71), C(237e39229b012b20),
+		C(cf7d7f25bd70cd2c), C(9464ed9baeb41b4f), C(b9064f5c3cb11b71), C(237e39229b012b20),
+		C(dd54d3f5d982dffe), C(7fc7562dbfc81dbf), C(5b0dd1924f70945), C(f1760537d8261135),
+		C(d51ba539)
+	},
+	{
+		C(db4b15e88533f622), C(256d6d2419b41ce9), C(9d7c5378396765d5), C(9040e5b936b8661b), C(276e08fa53ac27fd), C(8c944d39c2bdd2cc), C(e2514c9802a5743c),
+		C(9040e5b936b8661b), C(276e08fa53ac27fd), C(8c944d39c2bdd2cc), C(e2514c9802a5743c),
+		C(e82107b11ac90386), C(7d6a22bc35055e6), C(fd6ea9d1c438d8ae), C(be6015149e981553),
+		C(7f37636d)
+	},
+	{
+		C(922834735e86ecb2), C(363382685b88328e), C(e9c92960d7144630), C(8431b1bfd0a2379c), C(90383913aea283f9), C(a6163831eb4924d2), C(5f3921b4f9084aee),
+		C(8431b1bfd0a2379c), C(90383913aea283f9), C(a6163831eb4924d2), C(5f3921b4f9084aee),
+		C(7a70061a1473e579), C(5b19d80dcd2c6331), C(6196b97931faad27), C(869bf6828e237c3f),
+		C(b98026c0)
+	},
+	{
+		C(30f1d72c812f1eb8), C(b567cd4a69cd8989), C(820b6c992a51f0bc), C(c54677a80367125e), C(3204fbdba462e606), C(8563278afc9eae69), C(262147dd4bf7e566),
+		C(c54677a80367125e), C(3204fbdba462e606), C(8563278afc9eae69), C(262147dd4bf7e566),
+		C(2178b63e7ee2d230), C(e9c61ad81f5bff26), C(9af7a81b3c501eca), C(44104a3859f0238f),
+		C(b877767e)
+	},
+	{
+		C(168884267f3817e9), C(5b376e050f637645), C(1c18314abd34497a), C(9598f6ab0683fcc2), C(1c805abf7b80e1ee), C(dec9ac42ee0d0f32), C(8cd72e3912d24663),
+		C(9598f6ab0683fcc2), C(1c805abf7b80e1ee), C(dec9ac42ee0d0f32), C(8cd72e3912d24663),
+		C(1f025d405f1c1d87), C(bf7b6221e1668f8f), C(52316f64e692dbb0), C(7bf43df61ec51b39),
+		C(aefae77)
+	},
+	{
+		C(82e78596ee3e56a7), C(25697d9c87f30d98), C(7600a8342834924d), C(6ba372f4b7ab268b), C(8c3237cf1fe243df), C(3833fc51012903df), C(8e31310108c5683f),
+		C(6ba372f4b7ab268b), C(8c3237cf1fe243df), C(3833fc51012903df), C(8e31310108c5683f),
+		C(126593715c2de429), C(48ca8f35a3f54b90), C(b9322b632f4f8b0), C(926bb169b7337693),
+		C(f686911)
+	},
+	{
+		C(aa2d6cf22e3cc252), C(9b4dec4f5e179f16), C(76fb0fba1d99a99a), C(9a62af3dbba140da), C(27857ea044e9dfc1), C(33abce9da2272647), C(b22a7993aaf32556),
+		C(9a62af3dbba140da), C(27857ea044e9dfc1), C(33abce9da2272647), C(b22a7993aaf32556),
+		C(bf8f88f8019bedf0), C(ed2d7f01fb273905), C(6b45f15901b481cd), C(f88ebb413ba6a8d5),
+		C(3deadf12)
+	},
+	{
+		C(7bf5ffd7f69385c7), C(fc077b1d8bc82879), C(9c04e36f9ed83a24), C(82065c62e6582188), C(8ef787fd356f5e43), C(2922e53e36e17dfa), C(9805f223d385010b),
+		C(82065c62e6582188), C(8ef787fd356f5e43), C(2922e53e36e17dfa), C(9805f223d385010b),
+		C(692154f3491b787d), C(e7e64700e414fbf), C(757d4d4ab65069a0), C(cd029446a8e348e2),
+		C(ccf02a4e)
+	},
+	{
+		C(e89c8ff9f9c6e34b), C(f54c0f669a49f6c4), C(fc3e46f5d846adef), C(22f2aa3df2221cc), C(f66fea90f5d62174), C(b75defaeaa1dd2a7), C(9b994cd9a7214fd5),
+		C(22f2aa3df2221cc), C(f66fea90f5d62174), C(b75defaeaa1dd2a7), C(9b994cd9a7214fd5),
+		C(fac675a31804b773), C(98bcb3b820c50fc6), C(e14af64d28cf0885), C(27466fbd2b360eb5),
+		C(176c1722)
+	},
+	{
+		C(a18fbcdccd11e1f4), C(8248216751dfd65e), C(40c089f208d89d7c), C(229b79ab69ae97d), C(a87aabc2ec26e582), C(be2b053721eb26d2), C(10febd7f0c3d6fcb),
+		C(229b79ab69ae97d), C(a87aabc2ec26e582), C(be2b053721eb26d2), C(10febd7f0c3d6fcb),
+		C(9cc5b9b2f6e3bf7b), C(655d8495fe624a86), C(6381a9f3d1f2bd7e), C(79ebabbfc25c83e2),
+		C(26f82ad)
+	},
+	{
+		C(2d54f40cc4088b17), C(59d15633b0cd1399), C(a8cc04bb1bffd15b), C(d332cdb073d8dc46), C(272c56466868cb46), C(7e7fcbe35ca6c3f3), C(ee8f51e5a70399d4),
+		C(d332cdb073d8dc46), C(272c56466868cb46), C(7e7fcbe35ca6c3f3), C(ee8f51e5a70399d4),
+		C(16737a9c7581fe7b), C(ed04bf52f4b75dcb), C(9707ffb36bd30c1a), C(1390f236fdc0de3e),
+		C(b5244f42)
+	},
+	{
+		C(69276946cb4e87c7), C(62bdbe6183be6fa9), C(3ba9773dac442a1a), C(702e2afc7f5a1825), C(8c49b11ea8151fdc), C(caf3fef61f5a86fa), C(ef0b2ee8649d7272),
+		C(702e2afc7f5a1825), C(8c49b11ea8151fdc), C(caf3fef61f5a86fa), C(ef0b2ee8649d7272),
+		C(9e34a4e08d9441e1), C(7bdc0cd64d5af533), C(a926b14d99e3d868), C(fca923a17788cce4),
+		C(49a689e5)
+	},
+	{
+		C(668174a3f443df1d), C(407299392da1ce86), C(c2a3f7d7f2c5be28), C(a590b202a7a5807b), C(968d2593f7ccb54e), C(9dd8d669e3e95dec), C(ee0cc5dd58b6e93a),
+		C(a590b202a7a5807b), C(968d2593f7ccb54e), C(9dd8d669e3e95dec), C(ee0cc5dd58b6e93a),
+		C(ac65d5a9466fb483), C(221be538b2c9d806), C(5cbe9441784f9fd9), C(d4c7d5d6e3c122b8),
+		C(59fcdd3)
+	},
+	{
+		C(5e29be847bd5046), C(b561c7f19c8f80c3), C(5e5abd5021ccaeaf), C(7432d63888e0c306), C(74bbceeed479cb71), C(6471586599575fdf), C(6a859ad23365cba2),
+		C(7432d63888e0c306), C(74bbceeed479cb71), C(6471586599575fdf), C(6a859ad23365cba2),
+		C(f9ceec84acd18dcc), C(74a242ff1907437c), C(f70890194e1ee913), C(777dfcb4bb01f0ba),
+		C(4f4b04e9)
+	},
+	{
+		C(cd0d79f2164da014), C(4c386bb5c5d6ca0c), C(8e771b03647c3b63), C(69db23875cb0b715), C(ada8dd91504ae37f), C(46bf18dbf045ed6a), C(e1b5f67b0645ab63),
+		C(69db23875cb0b715), C(ada8dd91504ae37f), C(46bf18dbf045ed6a), C(e1b5f67b0645ab63),
+		C(877be8f5dcddff4), C(6d471b5f9ca2e2d1), C(802c86d6f495b9bb), C(a1f9b9b22b3be704),
+		C(8b00f891)
+	},
+	{
+		C(e0e6fc0b1628af1d), C(29be5fb4c27a2949), C(1c3f781a604d3630), C(c4af7faf883033aa), C(9bd296c4e9453cac), C(ca45426c1f7e33f9), C(a6bbdcf7074d40c5),
+		C(c4af7faf883033aa), C(9bd296c4e9453cac), C(ca45426c1f7e33f9), C(a6bbdcf7074d40c5),
+		C(e13a005d7142733b), C(c02b7925c5eeefaf), C(d39119a60441e2d5), C(3c24c710df8f4d43),
+		C(16e114f3)
+	},
+	{
+		C(2058927664adfd93), C(6e8f968c7963baa5), C(af3dced6fff7c394), C(42e34cf3d53c7876), C(9cddbb26424dc5e), C(64f6340a6d8eddad), C(2196e488eb2a3a4b),
+		C(42e34cf3d53c7876), C(9cddbb26424dc5e), C(64f6340a6d8eddad), C(2196e488eb2a3a4b),
+		C(c9e9da25911a16fd), C(e21b4683f3e196a8), C(cb80bf1a4c6fdbb4), C(53792e9b3c3e67f8),
+		C(d6b6dadc)
+	},
+	{
+		C(dc107285fd8e1af7), C(a8641a0609321f3f), C(db06e89ffdc54466), C(bcc7a81ed5432429), C(b6d7bdc6ad2e81f1), C(93605ec471aa37db), C(a2a73f8a85a8e397),
+		C(bcc7a81ed5432429), C(b6d7bdc6ad2e81f1), C(93605ec471aa37db), C(a2a73f8a85a8e397),
+		C(10a012b8ca7ac24b), C(aac5fd63351595cf), C(5bb4c648a226dea0), C(9d11ecb2b5c05c5f),
+		C(897e20ac)
+	},
+	{
+		C(fbba1afe2e3280f1), C(755a5f392f07fce), C(9e44a9a15402809a), C(6226a32e25099848), C(ea895661ecf53004), C(4d7e0158db2228b9), C(e5a7d82922f69842),
+		C(6226a32e25099848), C(ea895661ecf53004), C(4d7e0158db2228b9), C(e5a7d82922f69842),
+		C(2cea7713b69840ca), C(18de7b9ae938375b), C(f127cca08f3cc665), C(b1c22d727665ad2),
+		C(f996e05d)
+	},
+	{
+		C(bfa10785ddc1011b), C(b6e1c4d2f670f7de), C(517d95604e4fcc1f), C(ca6552a0dfb82c73), C(b024cdf09e34ba07), C(66cd8c5a95d7393b), C(e3939acf790d4a74),
+		C(ca6552a0dfb82c73), C(b024cdf09e34ba07), C(66cd8c5a95d7393b), C(e3939acf790d4a74),
+		C(97827541a1ef051e), C(ac2fce47ebe6500c), C(b3f06d3bddf3bd6a), C(1d74afb25e1ce5fe),
+		C(c4306af6)
+	},
+	{
+		C(534cc35f0ee1eb4e), C(b703820f1f3b3dce), C(884aa164cf22363), C(f14ef7f47d8a57a3), C(80d1f86f2e061d7c), C(401d6c2f151b5a62), C(e988460224108944),
+		C(f14ef7f47d8a57a3), C(80d1f86f2e061d7c), C(401d6c2f151b5a62), C(e988460224108944),
+		C(7804d4135f68cd19), C(5487b4b39e69fe8e), C(8cc5999015358a27), C(8f3729b61c2d5601),
+		C(6dcad433)
+	},
+	{
+		C(7ca6e3933995dac), C(fd118c77daa8188), C(3aceb7b5e7da6545), C(c8389799445480db), C(5389f5df8aacd50d), C(d136581f22fab5f), C(c2f31f85991da417),
+		C(c8389799445480db), C(5389f5df8aacd50d), C(d136581f22fab5f), C(c2f31f85991da417),
+		C(aefbf9ff84035a43), C(8accbaf44adadd7c), C(e57f3657344b67f5), C(21490e5e8abdec51),
+		C(3c07374d)
+	},
+	{
+		C(f0d6044f6efd7598), C(e044d6ba4369856e), C(91968e4f8c8a1a4c), C(70bd1968996bffc2), C(4c613de5d8ab32ac), C(fe1f4f97206f79d8), C(ac0434f2c4e213a9),
+		C(70bd1968996bffc2), C(4c613de5d8ab32ac), C(fe1f4f97206f79d8), C(ac0434f2c4e213a9),
+		C(7490e9d82cfe22ca), C(5fbbf7f987454238), C(c39e0dc8368ce949), C(22201d3894676c71),
+		C(f0f4602c)
+	},
+	{
+		C(3d69e52049879d61), C(76610636ea9f74fe), C(e9bf5602f89310c0), C(8eeb177a86053c11), C(e390122c345f34a2), C(1e30e47afbaaf8d6), C(7b892f68e5f91732),
+		C(8eeb177a86053c11), C(e390122c345f34a2), C(1e30e47afbaaf8d6), C(7b892f68e5f91732),
+		C(b87922525fa44158), C(f440a1ee1a1a766b), C(ee8efad279d08c5c), C(421f910c5b60216e),
+		C(3e1ea071)
+	},
+	{
+		C(79da242a16acae31), C(183c5f438e29d40), C(6d351710ae92f3de), C(27233b28b5b11e9b), C(c7dfe8988a942700), C(570ed11c4abad984), C(4b4c04632f48311a),
+		C(27233b28b5b11e9b), C(c7dfe8988a942700), C(570ed11c4abad984), C(4b4c04632f48311a),
+		C(12f33235442cbf9), C(a35315ca0b5b8cdb), C(d8abde62ead5506b), C(fc0fcf8478ad5266),
+		C(67580f0c)
+	},
+	{
+		C(461c82656a74fb57), C(d84b491b275aa0f7), C(8f262cb29a6eb8b2), C(49fa3070bc7b06d0), C(f12ed446bd0c0539), C(6d43ac5d1dd4b240), C(7609524fe90bec93),
+		C(49fa3070bc7b06d0), C(f12ed446bd0c0539), C(6d43ac5d1dd4b240), C(7609524fe90bec93),
+		C(391c2b2e076ec241), C(f5e62deda7839f7b), C(3c7b3186a10d870f), C(77ef4f2cba4f1005),
+		C(4e109454)
+	},
+	{
+		C(53c1a66d0b13003), C(731f060e6fe797fc), C(daa56811791371e3), C(57466046cf6896ed), C(8ac37e0e8b25b0c6), C(3e6074b52ad3cf18), C(aa491ce7b45db297),
+		C(57466046cf6896ed), C(8ac37e0e8b25b0c6), C(3e6074b52ad3cf18), C(aa491ce7b45db297),
+		C(f7a9227c5e5e22c3), C(3d92e0841e29ce28), C(2d30da5b2859e59d), C(ff37fa1c9cbfafc2),
+		C(88a474a7)
+	},
+	{
+		C(d3a2efec0f047e9), C(1cabce58853e58ea), C(7a17b2eae3256be4), C(c2dcc9758c910171), C(cb5cddaeff4ddb40), C(5d7cc5869baefef1), C(9644c5853af9cfeb),
+		C(c2dcc9758c910171), C(cb5cddaeff4ddb40), C(5d7cc5869baefef1), C(9644c5853af9cfeb),
+		C(255c968184694ee1), C(4e4d726eda360927), C(7d27dd5b6d100377), C(9a300e2020ddea2c),
+		C(5b5bedd)
+	},
+	{
+		C(43c64d7484f7f9b2), C(5da002b64aafaeb7), C(b576c1e45800a716), C(3ee84d3d5b4ca00b), C(5cbc6d701894c3f9), C(d9e946f5ae1ca95), C(24ca06e67f0b1833),
+		C(3ee84d3d5b4ca00b), C(5cbc6d701894c3f9), C(d9e946f5ae1ca95), C(24ca06e67f0b1833),
+		C(3413d46b4152650e), C(cbdfdbc2ab516f9c), C(2aad8acb739e0c6c), C(2bfc950d9f9fa977),
+		C(1aaddfa7)
+	},
+	{
+		C(a7dec6ad81cf7fa1), C(180c1ab708683063), C(95e0fd7008d67cff), C(6b11c5073687208), C(7e0a57de0d453f3), C(e48c267d4f646867), C(2168e9136375f9cb),
+		C(6b11c5073687208), C(7e0a57de0d453f3), C(e48c267d4f646867), C(2168e9136375f9cb),
+		C(64da194aeeea7fdf), C(a3b9f01fa5885678), C(c316f8ee2eb2bd17), C(a7e4d80f83e4427f),
+		C(5be07fd8)
+	},
+	{
+		C(5408a1df99d4aff), C(b9565e588740f6bd), C(abf241813b08006e), C(7da9e81d89fda7ad), C(274157cabe71440d), C(2c22d9a480b331f7), C(e835c8ac746472d5),
+		C(7da9e81d89fda7ad), C(274157cabe71440d), C(2c22d9a480b331f7), C(e835c8ac746472d5),
+		C(2038ce817a201ae4), C(46f3289dfe1c5e40), C(435578a42d4b7c56), C(f96d9f409fcf561),
+		C(cbca8606)
+	},
+	{
+		C(a8b27a6bcaeeed4b), C(aec1eeded6a87e39), C(9daf246d6fed8326), C(d45a938b79f54e8f), C(366b219d6d133e48), C(5b14be3c25c49405), C(fdd791d48811a572),
+		C(d45a938b79f54e8f), C(366b219d6d133e48), C(5b14be3c25c49405), C(fdd791d48811a572),
+		C(3de67b8d9e95d335), C(903c01307cfbeed5), C(af7d65f32274f1d1), C(4dba141b5fc03c42),
+		C(bde64d01)
+	},
+	{
+		C(9a952a8246fdc269), C(d0dcfcac74ef278c), C(250f7139836f0f1f), C(c83d3c5f4e5f0320), C(694e7adeb2bf32e5), C(7ad09538a3da27f5), C(2b5c18f934aa5303),
+		C(c83d3c5f4e5f0320), C(694e7adeb2bf32e5), C(7ad09538a3da27f5), C(2b5c18f934aa5303),
+		C(c4dad7703d34326e), C(825569e2bcdc6a25), C(b83d267709ca900d), C(44ed05151f5d74e6),
+		C(ee90cf33)
+	},
+	{
+		C(c930841d1d88684f), C(5eb66eb18b7f9672), C(e455d413008a2546), C(bc271bc0df14d647), C(b071100a9ff2edbb), C(2b1a4c1cc31a119a), C(b5d7caa1bd946cef),
+		C(bc271bc0df14d647), C(b071100a9ff2edbb), C(2b1a4c1cc31a119a), C(b5d7caa1bd946cef),
+		C(e02623ae10f4aadd), C(d79f600389cd06fd), C(1e8da7965303e62b), C(86f50e10eeab0925),
+		C(4305c3ce)
+	},
+	{
+		C(94dc6971e3cf071a), C(994c7003b73b2b34), C(ea16e85978694e5), C(336c1b59a1fc19f6), C(c173acaecc471305), C(db1267d24f3f3f36), C(e9a5ee98627a6e78),
+		C(336c1b59a1fc19f6), C(c173acaecc471305), C(db1267d24f3f3f36), C(e9a5ee98627a6e78),
+		C(718f334204305ae5), C(e3b53c148f98d22c), C(a184012df848926), C(6e96386127d51183),
+		C(4b3a1d76)
+	},
+	{
+		C(7fc98006e25cac9), C(77fee0484cda86a7), C(376ec3d447060456), C(84064a6dcf916340), C(fbf55a26790e0ebb), C(2e7f84151c31a5c2), C(9f7f6d76b950f9bf),
+		C(84064a6dcf916340), C(fbf55a26790e0ebb), C(2e7f84151c31a5c2), C(9f7f6d76b950f9bf),
+		C(125e094fbee2b146), C(5706aa72b2eef7c2), C(1c4a2daa905ee66e), C(83d48029b5451694),
+		C(a8bb6d80)
+	},
+	{
+		C(bd781c4454103f6), C(612197322f49c931), C(b9cf17fd7e5462d5), C(e38e526cd3324364), C(85f2b63a5b5e840a), C(485d7cef5aaadd87), C(d2b837a462f6db6d),
+		C(e38e526cd3324364), C(85f2b63a5b5e840a), C(485d7cef5aaadd87), C(d2b837a462f6db6d),
+		C(3e41cef031520d9a), C(82df73902d7f67e), C(3ba6fd54c15257cb), C(22f91f079be42d40),
+		C(1f9fa607)
+	},
+	{
+		C(da60e6b14479f9df), C(3bdccf69ece16792), C(18ebf45c4fecfdc9), C(16818ee9d38c6664), C(5519fa9a1e35a329), C(cbd0001e4b08ed8), C(41a965e37a0c731b),
+		C(16818ee9d38c6664), C(5519fa9a1e35a329), C(cbd0001e4b08ed8), C(41a965e37a0c731b),
+		C(66e7b5dcca1ca28f), C(963b2d993614347d), C(9b6fc6f41d411106), C(aaaecaccf7848c0c),
+		C(8d0e4ed2)
+	},
+	{
+		C(4ca56a348b6c4d3), C(60618537c3872514), C(2fbb9f0e65871b09), C(30278016830ddd43), C(f046646d9012e074), C(c62a5804f6e7c9da), C(98d51f5830e2bc1e),
+		C(30278016830ddd43), C(f046646d9012e074), C(c62a5804f6e7c9da), C(98d51f5830e2bc1e),
+		C(7b2cbe5d37e3f29e), C(7b8c3ed50bda4aa0), C(3ea60cc24639e038), C(f7706de9fb0b5801),
+		C(1bf31347)
+	},
+	{
+		C(ebd22d4b70946401), C(6863602bf7139017), C(c0b1ac4e11b00666), C(7d2782b82bd494b6), C(97159ba1c26b304b), C(42b3b0fd431b2ac2), C(faa81f82691c830c),
+		C(7d2782b82bd494b6), C(97159ba1c26b304b), C(42b3b0fd431b2ac2), C(faa81f82691c830c),
+		C(7cc6449234c7e185), C(aeaa6fa643ca86a5), C(1412db1c0f2e0133), C(4df2fe3e4072934f),
+		C(1ae3fc5b)
+	},
+	{
+		C(3cc4693d6cbcb0c), C(501689ea1c70ffa), C(10a4353e9c89e364), C(58c8aba7475e2d95), C(3e2f291698c9427a), C(e8710d19c9de9e41), C(65dda22eb04cf953),
+		C(58c8aba7475e2d95), C(3e2f291698c9427a), C(e8710d19c9de9e41), C(65dda22eb04cf953),
+		C(d7729c48c250cffa), C(ef76162b2ddfba4b), C(52371e17f4d51f6d), C(ddd002112ff0c833),
+		C(459c3930)
+	},
+	{
+		C(38908e43f7ba5ef0), C(1ab035d4e7781e76), C(41d133e8c0a68ff7), C(d1090893afaab8bc), C(96c4fe6922772807), C(4522426c2b4205eb), C(efad99a1262e7e0d),
+		C(d1090893afaab8bc), C(96c4fe6922772807), C(4522426c2b4205eb), C(efad99a1262e7e0d),
+		C(c7696029abdb465e), C(4e18eaf03d517651), C(d006bced54c86ac8), C(4330326d1021860c),
+		C(e00c4184)
+	},
+	{
+		C(34983ccc6aa40205), C(21802cad34e72bc4), C(1943e8fb3c17bb8), C(fc947167f69c0da5), C(ae79cfdb91b6f6c1), C(7b251d04c26cbda3), C(128a33a79060d25e),
+		C(fc947167f69c0da5), C(ae79cfdb91b6f6c1), C(7b251d04c26cbda3), C(128a33a79060d25e),
+		C(1eca842dbfe018dd), C(50a4cd2ee0ba9c63), C(c2f5c97d8399682f), C(3f929fc7cbe8ecbb),
+		C(ffc7a781)
+	},
+	{
+		C(86215c45dcac9905), C(ea546afe851cae4b), C(d85b6457e489e374), C(b7609c8e70386d66), C(36e6ccc278d1636d), C(2f873307c08e6a1c), C(10f252a758505289),
+		C(b7609c8e70386d66), C(36e6ccc278d1636d), C(2f873307c08e6a1c), C(10f252a758505289),
+		C(c8977646e81ab4b6), C(8017b745cd80213b), C(960687db359bea0), C(ef4a470660799488),
+		C(6a125480)
+	},
+	{
+		C(420fc255c38db175), C(d503cd0f3c1208d1), C(d4684e74c825a0bc), C(4c10537443152f3d), C(720451d3c895e25d), C(aff60c4d11f513fd), C(881e8d6d2d5fb953),
+		C(4c10537443152f3d), C(720451d3c895e25d), C(aff60c4d11f513fd), C(881e8d6d2d5fb953),
+		C(9dec034a043f1f55), C(e27a0c22e7bfb39d), C(2220b959128324), C(53240272152dbd8b),
+		C(88a1512b)
+	},
+	{
+		C(1d7a31f5bc8fe2f9), C(4763991092dcf836), C(ed695f55b97416f4), C(f265edb0c1c411d7), C(30e1e9ec5262b7e6), C(c2c3ba061ce7957a), C(d975f93b89a16409),
+		C(f265edb0c1c411d7), C(30e1e9ec5262b7e6), C(c2c3ba061ce7957a), C(d975f93b89a16409),
+		C(e9d703123f43450a), C(41383fedfed67c82), C(6e9f43ecbbbd6004), C(c7ccd23a24e77b8),
+		C(549bbbe5)
+	},
+	{
+		C(94129a84c376a26e), C(c245e859dc231933), C(1b8f74fecf917453), C(e9369d2e9007e74b), C(b1375915d1136052), C(926c2021fe1d2351), C(1d943addaaa2e7e6),
+		C(e9369d2e9007e74b), C(b1375915d1136052), C(926c2021fe1d2351), C(1d943addaaa2e7e6),
+		C(f5f515869c246738), C(7e309cd0e1c0f2a0), C(153c3c36cf523e3b), C(4931c66872ea6758),
+		C(c133d38c)
+	},
+	{
+		C(1d3a9809dab05c8d), C(adddeb4f71c93e8), C(ef342eb36631edb), C(301d7a61c4b3dbca), C(861336c3f0552d61), C(12c6db947471300f), C(a679ef0ed761deb9),
+		C(301d7a61c4b3dbca), C(861336c3f0552d61), C(12c6db947471300f), C(a679ef0ed761deb9),
+		C(5f713b720efcd147), C(37ac330a333aa6b), C(3309dc9ec1616eef), C(52301d7a908026b5),
+		C(fcace348)
+	},
+	{
+		C(90fa3ccbd60848da), C(dfa6e0595b569e11), C(e585d067a1f5135d), C(6cef866ec295abea), C(c486c0d9214beb2d), C(d6e490944d5fe100), C(59df3175d72c9f38),
+		C(6cef866ec295abea), C(c486c0d9214beb2d), C(d6e490944d5fe100), C(59df3175d72c9f38),
+		C(3f23aeb4c04d1443), C(9bf0515cd8d24770), C(958554f60ccaade2), C(5182863c90132fe8),
+		C(ed7b6f9a)
+	},
+	{
+		C(2dbb4fc71b554514), C(9650e04b86be0f82), C(60f2304fba9274d3), C(fcfb9443e997cab), C(f13310d96dec2772), C(709cad2045251af2), C(afd0d30cc6376dad),
+		C(fcfb9443e997cab), C(f13310d96dec2772), C(709cad2045251af2), C(afd0d30cc6376dad),
+		C(59d4bed30d550d0d), C(58006d4e22d8aad1), C(eee12d2362d1f13b), C(35cf1d7faaf1d228),
+		C(6d907dda)
+	},
+	{
+		C(b98bf4274d18374a), C(1b669fd4c7f9a19a), C(b1f5972b88ba2b7a), C(73119c99e6d508be), C(5d4036a187735385), C(8fa66e192fd83831), C(2abf64b6b592ed57),
+		C(73119c99e6d508be), C(5d4036a187735385), C(8fa66e192fd83831), C(2abf64b6b592ed57),
+		C(d4501f95dd84b08c), C(bf1552439c8bea02), C(4f56fe753ba7e0ba), C(4ca8d35cc058cfcd),
+		C(7a4d48d5)
+	},
+	{
+		C(d6781d0b5e18eb68), C(b992913cae09b533), C(58f6021caaee3a40), C(aafcb77497b5a20b), C(411819e5e79b77a3), C(bd779579c51c77ce), C(58d11f5dcf5d075d),
+		C(aafcb77497b5a20b), C(411819e5e79b77a3), C(bd779579c51c77ce), C(58d11f5dcf5d075d),
+		C(9eae76cde1cb4233), C(32fe25a9bf657970), C(1c0c807948edb06a), C(b8f29a3dfaee254d),
+		C(e686f3db)
+	},
+	{
+		C(226651cf18f4884c), C(595052a874f0f51c), C(c9b75162b23bab42), C(3f44f873be4812ec), C(427662c1dbfaa7b2), C(a207ff9638fb6558), C(a738d919e45f550f),
+		C(3f44f873be4812ec), C(427662c1dbfaa7b2), C(a207ff9638fb6558), C(a738d919e45f550f),
+		C(cb186ea05717e7d6), C(1ca7d68a5871fdc1), C(5d4c119ea8ef3750), C(72b6a10fa2ff9406),
+		C(cce7c55)
+	},
+	{
+		C(a734fb047d3162d6), C(e523170d240ba3a5), C(125a6972809730e8), C(d396a297799c24a1), C(8fee992e3069bad5), C(2e3a01b0697ccf57), C(ee9c7390bd901cfa),
+		C(d396a297799c24a1), C(8fee992e3069bad5), C(2e3a01b0697ccf57), C(ee9c7390bd901cfa),
+		C(56f2d9da0af28af2), C(3fdd37b2fe8437cb), C(3d13eeeb60d6aec0), C(2432ae62e800a5ce),
+		C(f58b96b)
+	},
+	{
+		C(c6df6364a24f75a3), C(c294e2c84c4f5df8), C(a88df65c6a89313b), C(895fe8443183da74), C(c7f2f6f895a67334), C(a0d6b6a506691d31), C(24f51712b459a9f0),
+		C(895fe8443183da74), C(c7f2f6f895a67334), C(a0d6b6a506691d31), C(24f51712b459a9f0),
+		C(173a699481b9e088), C(1dee9b77bcbf45d3), C(32b98a646a8667d0), C(3adcd4ee28f42a0e),
+		C(1bbf6f60)
+	},
+	{
+		C(d8d1364c1fbcd10), C(2d7cc7f54832deaa), C(4e22c876a7c57625), C(a3d5d1137d30c4bd), C(1e7d706a49bdfb9e), C(c63282b20ad86db2), C(aec97fa07916bfd6),
+		C(a3d5d1137d30c4bd), C(1e7d706a49bdfb9e), C(c63282b20ad86db2), C(aec97fa07916bfd6),
+		C(7c9ba3e52d44f73e), C(af62fd245811185d), C(8a9d2dacd8737652), C(bd2cce277d5fbec0),
+		C(ce5e0cc2)
+	},
+	{
+		C(aae06f9146db885f), C(3598736441e280d9), C(fba339b117083e55), C(b22bf08d9f8aecf7), C(c182730de337b922), C(2b9adc87a0450a46), C(192c29a9cfc00aad),
+		C(b22bf08d9f8aecf7), C(c182730de337b922), C(2b9adc87a0450a46), C(192c29a9cfc00aad),
+		C(9fd733f1d84a59d9), C(d86bd5c9839ace15), C(af20b57303172876), C(9f63cb7161b5364c),
+		C(584cfd6f)
+	},
+	{
+		C(8955ef07631e3bcc), C(7d70965ea3926f83), C(39aed4134f8b2db6), C(882efc2561715a9c), C(ef8132a18a540221), C(b20a3c87a8c257c1), C(f541b8628fad6c23),
+		C(882efc2561715a9c), C(ef8132a18a540221), C(b20a3c87a8c257c1), C(f541b8628fad6c23),
+		C(9552aed57a6e0467), C(4d9fdd56867611a7), C(c330279bf23b9eab), C(44dbbaea2fcb8eba),
+		C(8f9bbc33)
+	},
+	{
+		C(ad611c609cfbe412), C(d3c00b18bf253877), C(90b2172e1f3d0bfd), C(371a98b2cb084883), C(33a2886ee9f00663), C(be9568818ed6e6bd), C(f244a0fa2673469a),
+		C(371a98b2cb084883), C(33a2886ee9f00663), C(be9568818ed6e6bd), C(f244a0fa2673469a),
+		C(b447050bd3e559e9), C(d3b695dae7a13383), C(ded0bb65be471188), C(ca3c7a2b78922cae),
+		C(d7640d95)
+	},
+	{
+		C(d5339adc295d5d69), C(b633cc1dcb8b586a), C(ee84184cf5b1aeaf), C(89f3aab99afbd636), C(f420e004f8148b9a), C(6818073faa797c7c), C(dd3b4e21cbbf42ca),
+		C(89f3aab99afbd636), C(f420e004f8148b9a), C(6818073faa797c7c), C(dd3b4e21cbbf42ca),
+		C(6a2b7db261164844), C(cbead63d1895852a), C(93d37e1eae05e2f9), C(5d06db2703fbc3ae),
+		C(3d12a2b)
+	},
+	{
+		C(40d0aeff521375a8), C(77ba1ad7ecebd506), C(547c6f1a7d9df427), C(21c2be098327f49b), C(7e035065ac7bbef5), C(6d7348e63023fb35), C(9d427dc1b67c3830),
+		C(21c2be098327f49b), C(7e035065ac7bbef5), C(6d7348e63023fb35), C(9d427dc1b67c3830),
+		C(4e3d018a43858341), C(cf924bb44d6b43c5), C(4618b6a26e3446ae), C(54d3013fac3ed469),
+		C(aaeafed0)
+	},
+	{
+		C(8b2d54ae1a3df769), C(11e7adaee3216679), C(3483781efc563e03), C(9d097dd3152ab107), C(51e21d24126e8563), C(cba56cac884a1354), C(39abb1b595f0a977),
+		C(9d097dd3152ab107), C(51e21d24126e8563), C(cba56cac884a1354), C(39abb1b595f0a977),
+		C(81e6dd1c1109848f), C(1644b209826d7b15), C(6ac67e4e4b4812f0), C(b3a9f5622c935bf7),
+		C(95b9b814)
+	},
+	{
+		C(99c175819b4eae28), C(932e8ff9f7a40043), C(ec78dcab07ca9f7c), C(c1a78b82ba815b74), C(458cbdfc82eb322a), C(17f4a192376ed8d7), C(6f9e92968bc8ccef),
+		C(c1a78b82ba815b74), C(458cbdfc82eb322a), C(17f4a192376ed8d7), C(6f9e92968bc8ccef),
+		C(93e098c333b39905), C(d59b1cace44b7fdc), C(f7a64ed78c64c7c5), C(7c6eca5dd87ec1ce),
+		C(45fbe66e)
+	},
+	{
+		C(2a418335779b82fc), C(af0295987849a76b), C(c12bc5ff0213f46e), C(5aeead8d6cb25bb9), C(739315f7743ec3ff), C(9ab48d27111d2dcc), C(5b87bd35a975929b),
+		C(5aeead8d6cb25bb9), C(739315f7743ec3ff), C(9ab48d27111d2dcc), C(5b87bd35a975929b),
+		C(c3dd8d6d95a46bb3), C(7bf9093215a4f483), C(cb557d6ed84285bd), C(daf58422f261fdb5),
+		C(b4baa7a8)
+	},
+	{
+		C(3b1fc6a3d279e67d), C(70ea1e49c226396), C(25505adcf104697c), C(ba1ffba29f0367aa), C(a20bec1dd15a8b6c), C(e9bf61d2dab0f774), C(f4f35bf5870a049c),
+		C(ba1ffba29f0367aa), C(a20bec1dd15a8b6c), C(e9bf61d2dab0f774), C(f4f35bf5870a049c),
+		C(26787efa5b92385), C(3d9533590ce30b59), C(a4da3e40530a01d4), C(6395deaefb70067c),
+		C(83e962fe)
+	},
+	{
+		C(d97eacdf10f1c3c9), C(b54f4654043a36e0), C(b128f6eb09d1234), C(d8ad7ec84a9c9aa2), C(e256cffed11f69e6), C(2cf65e4958ad5bda), C(cfbf9b03245989a7),
+		C(d8ad7ec84a9c9aa2), C(e256cffed11f69e6), C(2cf65e4958ad5bda), C(cfbf9b03245989a7),
+		C(9fa51e6686cf4444), C(9425c117a34609d5), C(b25f7e2c6f30e96), C(ea5477c3f2b5afd1),
+		C(aac3531c)
+	},
+	{
+		C(293a5c1c4e203cd4), C(6b3329f1c130cefe), C(f2e32f8ec76aac91), C(361e0a62c8187bff), C(6089971bb84d7133), C(93df7741588dd50b), C(c2a9b6abcd1d80b1),
+		C(361e0a62c8187bff), C(6089971bb84d7133), C(93df7741588dd50b), C(c2a9b6abcd1d80b1),
+		C(4d2f86869d79bc59), C(85cd24d8aa570ff), C(b0dcf6ef0e94bbb5), C(2037c69aa7a78421),
+		C(2b1db7cc)
+	},
+	{
+		C(4290e018ffaedde7), C(a14948545418eb5e), C(72d851b202284636), C(4ec02f3d2f2b23f2), C(ab3580708aa7c339), C(cdce066fbab3f65), C(d8ed3ecf3c7647b9),
+		C(4ec02f3d2f2b23f2), C(ab3580708aa7c339), C(cdce066fbab3f65), C(d8ed3ecf3c7647b9),
+		C(6d2204b3e31f344a), C(61a4d87f80ee61d7), C(446c43dbed4b728f), C(73130ac94f58747e),
+		C(cf00cd31)
+	},
+	{
+		C(f919a59cbde8bf2f), C(a56d04203b2dc5a5), C(38b06753ac871e48), C(c2c9fc637dbdfcfa), C(292ab8306d149d75), C(7f436b874b9ffc07), C(a5b56b0129218b80),
+		C(c2c9fc637dbdfcfa), C(292ab8306d149d75), C(7f436b874b9ffc07), C(a5b56b0129218b80),
+		C(9188f7bdc47ec050), C(cfe9345d03a15ade), C(40b520fb2750c49e), C(c2e83d343968af2e),
+		C(7d3c43b8)
+	},
+	{
+		C(1d70a3f5521d7fa4), C(fb97b3fdc5891965), C(299d49bbbe3535af), C(e1a8286a7d67946e), C(52bd956f047b298), C(cbd74332dd4204ac), C(12b5be7752721976),
+		C(e1a8286a7d67946e), C(52bd956f047b298), C(cbd74332dd4204ac), C(12b5be7752721976),
+		C(278426e27f6204b6), C(932ca7a7cd610181), C(41647321f0a5914d), C(48f4aa61a0ae80db),
+		C(cbd5fac6)
+	},
+	{
+		C(6af98d7b656d0d7c), C(d2e99ae96d6b5c0c), C(f63bd1603ef80627), C(bde51033ac0413f8), C(bc0272f691aec629), C(6204332651bebc44), C(1cbf00de026ea9bd),
+		C(bde51033ac0413f8), C(bc0272f691aec629), C(6204332651bebc44), C(1cbf00de026ea9bd),
+		C(b9c7ed6a75f3ff1e), C(7e310b76a5808e4f), C(acbbd1aad5531885), C(fc245f2473adeb9c),
+		C(76d0fec4)
+	},
+	{
+		C(395b7a8adb96ab75), C(582df7165b20f4a), C(e52bd30e9ff657f9), C(6c71064996cbec8b), C(352c535edeefcb89), C(ac7f0aba15cd5ecd), C(3aba1ca8353e5c60),
+		C(6c71064996cbec8b), C(352c535edeefcb89), C(ac7f0aba15cd5ecd), C(3aba1ca8353e5c60),
+		C(5c30a288a80ce646), C(c2940488b6617674), C(925f8cc66b370575), C(aa65d1283b9bb0ef),
+		C(405e3402)
+	},
+	{
+		C(3822dd82c7df012f), C(b9029b40bd9f122b), C(fd25b988468266c4), C(43e47bd5bab1e0ef), C(4a71f363421f282f), C(880b2f32a2b4e289), C(1299d4eda9d3eadf),
+		C(43e47bd5bab1e0ef), C(4a71f363421f282f), C(880b2f32a2b4e289), C(1299d4eda9d3eadf),
+		C(d713a40226f5564), C(4d8d34fedc769406), C(a85001b29cd9cac3), C(cae92352a41fd2b0),
+		C(c732c481)
+	},
+	{
+		C(79f7efe4a80b951a), C(dd3a3fddfc6c9c41), C(ab4c812f9e27aa40), C(832954ec9d0de333), C(94c390aa9bcb6b8a), C(f3b32afdc1f04f82), C(d229c3b72e4b9a74),
+		C(832954ec9d0de333), C(94c390aa9bcb6b8a), C(f3b32afdc1f04f82), C(d229c3b72e4b9a74),
+		C(1d11860d7ed624a6), C(cadee20b3441b984), C(75307079bf306f7b), C(87902aa3b9753ba4),
+		C(a8d123c9)
+	},
+	{
+		C(ae6e59f5f055921a), C(e9d9b7bf68e82), C(5ce4e4a5b269cc59), C(4960111789727567), C(149b8a37c7125ab6), C(78c7a13ab9749382), C(1c61131260ca151a),
+		C(4960111789727567), C(149b8a37c7125ab6), C(78c7a13ab9749382), C(1c61131260ca151a),
+		C(1e93276b35c309a0), C(2618f56230acde58), C(af61130a18e4febf), C(7145deb18e89befe),
+		C(1e80ad7d)
+	},
+	{
+		C(8959dbbf07387d36), C(b4658afce48ea35d), C(8f3f82437d8cb8d6), C(6566d74954986ba5), C(99d5235cc82519a7), C(257a23805c2d825), C(ad75ccb968e93403),
+		C(6566d74954986ba5), C(99d5235cc82519a7), C(257a23805c2d825), C(ad75ccb968e93403),
+		C(b45bd4cf78e11f7f), C(80c5536bdc487983), C(a4fd76ecbf018c8a), C(3b9dac78a7a70d43),
+		C(52aeb863)
+	},
+	{
+		C(4739613234278a49), C(99ea5bcd340bf663), C(258640912e712b12), C(c8a2827404991402), C(7ee5e78550f02675), C(2ec53952db5ac662), C(1526405a9df6794b),
+		C(c8a2827404991402), C(7ee5e78550f02675), C(2ec53952db5ac662), C(1526405a9df6794b),
+		C(eddc6271170c5e1f), C(f5a85f986001d9d6), C(95427c677bf58d58), C(53ed666dfa85cb29),
+		C(ef7c0c18)
+	},
+	{
+		C(420e6c926bc54841), C(96dbbf6f4e7c75cd), C(d8d40fa70c3c67bb), C(3edbc10e4bfee91b), C(f0d681304c28ef68), C(77ea602029aaaf9c), C(90f070bd24c8483c),
+		C(3edbc10e4bfee91b), C(f0d681304c28ef68), C(77ea602029aaaf9c), C(90f070bd24c8483c),
+		C(28bc8e41e08ceb86), C(1eb56e48a65691ef), C(9fea5301c9202f0e), C(3fcb65091aa9f135),
+		C(b6ad4b68)
+	},
+	{
+		C(c8601bab561bc1b7), C(72b26272a0ff869a), C(56fdfc986d6bc3c4), C(83707730cad725d4), C(c9ca88c3a779674a), C(e1c696fbbd9aa933), C(723f3baab1c17a45),
+		C(83707730cad725d4), C(c9ca88c3a779674a), C(e1c696fbbd9aa933), C(723f3baab1c17a45),
+		C(f82abc7a1d851682), C(30683836818e857d), C(78bfa3e89a5ab23f), C(6928234482b31817),
+		C(c1e46b17)
+	},
+	{
+		C(b2d294931a0e20eb), C(284ffd9a0815bc38), C(1f8a103aac9bbe6), C(1ef8e98e1ea57269), C(5971116272f45a8b), C(187ad68ce95d8eac), C(e94e93ee4e8ecaa6),
+		C(1ef8e98e1ea57269), C(5971116272f45a8b), C(187ad68ce95d8eac), C(e94e93ee4e8ecaa6),
+		C(a0ff2a58611838b5), C(b01e03849bfbae6f), C(d081e202e28ea3ab), C(51836bcee762bf13),
+		C(57b8df25)
+	},
+	{
+		C(7966f53c37b6c6d7), C(8e6abcfb3aa2b88f), C(7f2e5e0724e5f345), C(3eeb60c3f5f8143d), C(a25aec05c422a24f), C(b026b03ad3cca4db), C(e6e030028cc02a02),
+		C(3eeb60c3f5f8143d), C(a25aec05c422a24f), C(b026b03ad3cca4db), C(e6e030028cc02a02),
+		C(16fe679338b34bfc), C(c1be385b5c8a9de4), C(65af5df6567530eb), C(ed3b303df4dc6335),
+		C(e9fa36d6)
+	},
+	{
+		C(be9bb0abd03b7368), C(13bca93a3031be55), C(e864f4f52b55b472), C(36a8d13a2cbb0939), C(254ac73907413230), C(73520d1522315a70), C(8c9fdb5cf1e1a507),
+		C(36a8d13a2cbb0939), C(254ac73907413230), C(73520d1522315a70), C(8c9fdb5cf1e1a507),
+		C(b3640570b926886), C(fba2344ee87f7bab), C(de57341ab448df05), C(385612ee094fa977),
+		C(8f8daefc)
+	},
+	{
+		C(a08d128c5f1649be), C(a8166c3dbbe19aad), C(cb9f914f829ec62c), C(5b2b7ca856fad1c3), C(8093022d682e375d), C(ea5d163ba7ea231f), C(d6181d012c0de641),
+		C(5b2b7ca856fad1c3), C(8093022d682e375d), C(ea5d163ba7ea231f), C(d6181d012c0de641),
+		C(e7d40d0ab8b08159), C(2e82320f51b3a67e), C(27c2e356ea0b63a3), C(58842d01a2b1d077),
+		C(6e1bb7e)
+	},
+	{
+		C(7c386f0ffe0465ac), C(530419c9d843dbf3), C(7450e3a4f72b8d8c), C(48b218e3b721810d), C(d3757ac8609bc7fc), C(111ba02a88aefc8), C(e86343137d3bfc2a),
+		C(48b218e3b721810d), C(d3757ac8609bc7fc), C(111ba02a88aefc8), C(e86343137d3bfc2a),
+		C(44ad26b51661b507), C(db1268670274f51e), C(62a5e75beae875f3), C(e266e7a44c5f28c6),
+		C(fd0076f0)
+	},
+	{
+		C(bb362094e7ef4f8), C(ff3c2a48966f9725), C(55152803acd4a7fe), C(15747d8c505ffd00), C(438a15f391312cd6), C(e46ca62c26d821f5), C(be78d74c9f79cb44),
+		C(15747d8c505ffd00), C(438a15f391312cd6), C(e46ca62c26d821f5), C(be78d74c9f79cb44),
+		C(a8aa19f3aa59f09a), C(effb3cddab2c9267), C(d78e41ad97cb16a5), C(ace6821513527d32),
+		C(899b17b6)
+	},
+	{
+		C(cd80dea24321eea4), C(52b4fdc8130c2b15), C(f3ea100b154bfb82), C(d9ccef1d4be46988), C(5ede0c4e383a5e66), C(da69683716a54d1e), C(bfc3fdf02d242d24),
+		C(d9ccef1d4be46988), C(5ede0c4e383a5e66), C(da69683716a54d1e), C(bfc3fdf02d242d24),
+		C(20ed30274651b3f5), C(4c659824169e86c6), C(637226dae5b52a0e), C(7e050dbd1c71dc7f),
+		C(e3e84e31)
+	},
+	{
+		C(d599a04125372c3a), C(313136c56a56f363), C(1e993c3677625832), C(2870a99c76a587a4), C(99f74cc0b182dda4), C(8a5e895b2f0ca7b6), C(3d78882d5e0bb1dc),
+		C(2870a99c76a587a4), C(99f74cc0b182dda4), C(8a5e895b2f0ca7b6), C(3d78882d5e0bb1dc),
+		C(f466123732a3e25e), C(aca5e59716a40e50), C(261d2e7383d0e686), C(ce9362d6a42c15a7),
+		C(eef79b6b)
+	},
+	{
+		C(dbbf541e9dfda0a), C(1479fceb6db4f844), C(31ab576b59062534), C(a3335c417687cf3a), C(92ff114ac45cda75), C(c3b8a627384f13b5), C(c4f25de33de8b3f7),
+		C(a3335c417687cf3a), C(92ff114ac45cda75), C(c3b8a627384f13b5), C(c4f25de33de8b3f7),
+		C(eacbf520578c5964), C(4cb19c5ab24f3215), C(e7d8a6f67f0c6e7), C(325c2413eb770ada),
+		C(868e3315)
+	},
+	{
+		C(c2ee3288be4fe2bf), C(c65d2f5ddf32b92), C(af6ecdf121ba5485), C(c7cd48f7abf1fe59), C(ce600656ace6f53a), C(8a94a4381b108b34), C(f9d1276c64bf59fb),
+		C(c7cd48f7abf1fe59), C(ce600656ace6f53a), C(8a94a4381b108b34), C(f9d1276c64bf59fb),
+		C(219ce70ff5a112a5), C(e6026c576e2d28d7), C(b8e467f25015e3a6), C(950cb904f37af710),
+		C(4639a426)
+	},
+	{
+		C(d86603ced1ed4730), C(f9de718aaada7709), C(db8b9755194c6535), C(d803e1eead47604c), C(ad00f7611970a71b), C(bc50036b16ce71f5), C(afba96210a2ca7d6),
+		C(d803e1eead47604c), C(ad00f7611970a71b), C(bc50036b16ce71f5), C(afba96210a2ca7d6),
+		C(28f7a7be1d6765f0), C(97bd888b93938c68), C(6ad41d1b407ded49), C(b9bfec098dc543e4),
+		C(f3213646)
+	},
+	{
+		C(915263c671b28809), C(a815378e7ad762fd), C(abec6dc9b669f559), C(d17c928c5342477f), C(745130b795254ad5), C(8c5db926fe88f8ba), C(742a95c953e6d974),
+		C(d17c928c5342477f), C(745130b795254ad5), C(8c5db926fe88f8ba), C(742a95c953e6d974),
+		C(279db8057b5d3e96), C(98168411565b4ec4), C(50a72c54fa1125fa), C(27766a635db73638),
+		C(17f148e9)
+	},
+	{
+		C(2b67cdd38c307a5e), C(cb1d45bb5c9fe1c), C(800baf2a02ec18ad), C(6531c1fe32bcb417), C(8c970d8df8cdbeb4), C(917ba5fc67e72b40), C(4b65e4e263e0a426),
+		C(6531c1fe32bcb417), C(8c970d8df8cdbeb4), C(917ba5fc67e72b40), C(4b65e4e263e0a426),
+		C(e0de33ce88a8b3a9), C(f8ef98a437e16b08), C(a5162c0c7c5f7b62), C(dbdac43361b2b881),
+		C(bfd94880)
+	},
+	{
+		C(2d107419073b9cd0), C(a96db0740cef8f54), C(ec41ee91b3ecdc1b), C(ffe319654c8e7ebc), C(6a67b8f13ead5a72), C(6dd10a34f80d532f), C(6e9cfaece9fbca4),
+		C(ffe319654c8e7ebc), C(6a67b8f13ead5a72), C(6dd10a34f80d532f), C(6e9cfaece9fbca4),
+		C(b4468eb6a30aa7e9), C(e87995bee483222a), C(d036c2c90c609391), C(853306e82fa32247),
+		C(bb1fa7f3)
+	},
+	{
+		C(f3e9487ec0e26dfc), C(1ab1f63224e837fa), C(119983bb5a8125d8), C(8950cfcf4bdf622c), C(8847dca82efeef2f), C(646b75b026708169), C(21cab4b1687bd8b),
+		C(8950cfcf4bdf622c), C(8847dca82efeef2f), C(646b75b026708169), C(21cab4b1687bd8b),
+		C(243b489a9eae6231), C(5f3e634c4b779876), C(ff8abd1548eaf646), C(c7962f5f0151914b),
+		C(88816b1)
+	},
+	{
+		C(1160987c8fe86f7d), C(879e6db1481eb91b), C(d7dcb802bfe6885d), C(14453b5cc3d82396), C(4ef700c33ed278bc), C(1639c72ffc00d12e), C(fb140ee6155f700d),
+		C(14453b5cc3d82396), C(4ef700c33ed278bc), C(1639c72ffc00d12e), C(fb140ee6155f700d),
+		C(2e6b5c96a6620862), C(a1f136998cbe19c), C(74e058a3b6c5a712), C(93dcf6bd33928b17),
+		C(5c2faeb3)
+	},
+	{
+		C(eab8112c560b967b), C(97f550b58e89dbae), C(846ed506d304051f), C(276aa37744b5a028), C(8c10800ee90ea573), C(e6e57d2b33a1e0b7), C(91f83563cd3b9dda),
+		C(276aa37744b5a028), C(8c10800ee90ea573), C(e6e57d2b33a1e0b7), C(91f83563cd3b9dda),
+		C(afbb4739570738a1), C(440ba98da5d8f69), C(fde4e9b0eda20350), C(e67dfa5a2138fa1),
+		C(51b5fc6f)
+	},
+	{
+		C(1addcf0386d35351), C(b5f436561f8f1484), C(85d38e22181c9bb1), C(ff5c03f003c1fefe), C(e1098670afe7ff6), C(ea445030cf86de19), C(f155c68b5c2967f8),
+		C(ff5c03f003c1fefe), C(e1098670afe7ff6), C(ea445030cf86de19), C(f155c68b5c2967f8),
+		C(95d31b145dbb2e9e), C(914fe1ca3deb3265), C(6066020b1358ccc1), C(c74bb7e2dee15036),
+		C(33d94752)
+	},
+	{
+		C(d445ba84bf803e09), C(1216c2497038f804), C(2293216ea2237207), C(e2164451c651adfb), C(b2534e65477f9823), C(4d70691a69671e34), C(15be4963dbde8143),
+		C(e2164451c651adfb), C(b2534e65477f9823), C(4d70691a69671e34), C(15be4963dbde8143),
+		C(762e75c406c5e9a3), C(7b7579f7e0356841), C(480533eb066dfce5), C(90ae14ea6bfeb4ae),
+		C(b0c92948)
+	},
+	{
+		C(37235a096a8be435), C(d9b73130493589c2), C(3b1024f59378d3be), C(ad159f542d81f04e), C(49626a97a946096), C(d8d3998bf09fd304), C(d127a411eae69459),
+		C(ad159f542d81f04e), C(49626a97a946096), C(d8d3998bf09fd304), C(d127a411eae69459),
+		C(8f3253c4eb785a7b), C(4049062f37e62397), C(b9fa04d3b670e5c1), C(1211a7967ac9350f),
+		C(c7171590)
+	},
+	{
+		C(763ad6ea2fe1c99d), C(cf7af5368ac1e26b), C(4d5e451b3bb8d3d4), C(3712eb913d04e2f2), C(2f9500d319c84d89), C(4ac6eb21a8cf06f9), C(7d1917afcde42744),
+		C(3712eb913d04e2f2), C(2f9500d319c84d89), C(4ac6eb21a8cf06f9), C(7d1917afcde42744),
+		C(6b58604b5dd10903), C(c4288dfbc1e319fc), C(230f75ca96817c6e), C(8894cba3b763756c),
+		C(240a67fb)
+	},
+	{
+		C(ea627fc84cd1b857), C(85e372494520071f), C(69ec61800845780b), C(a3c1c5ca1b0367), C(eb6933997272bb3d), C(76a72cb62692a655), C(140bb5531edf756e),
+		C(a3c1c5ca1b0367), C(eb6933997272bb3d), C(76a72cb62692a655), C(140bb5531edf756e),
+		C(8d0d8067d1c925f4), C(7b3fa56d8d77a10c), C(2bd00287b0946d88), C(f08c8e4bd65b8970),
+		C(e1843cd5)
+	},
+	{
+		C(1f2ffd79f2cdc0c8), C(726a1bc31b337aaa), C(678b7f275ef96434), C(5aa82bfaa99d3978), C(c18f96cade5ce18d), C(38404491f9e34c03), C(891fb8926ba0418c),
+		C(5aa82bfaa99d3978), C(c18f96cade5ce18d), C(38404491f9e34c03), C(891fb8926ba0418c),
+		C(e5f69a6398114c15), C(7b8ded3623bc6b1d), C(2f3e5c5da5ff70e8), C(1ab142addea6a9ec),
+		C(fda1452b)
+	},
+	{
+		C(39a9e146ec4b3210), C(f63f75802a78b1ac), C(e2e22539c94741c3), C(8b305d532e61226e), C(caeae80da2ea2e), C(88a6289a76ac684e), C(8ce5b5f9df1cbd85),
+		C(8b305d532e61226e), C(caeae80da2ea2e), C(88a6289a76ac684e), C(8ce5b5f9df1cbd85),
+		C(8ae1fc4798e00d57), C(e7164b8fb364fc46), C(6a978c9bd3a66943), C(ef10d5ae4dd08dc),
+		C(a2cad330)
+	},
+	{
+		C(74cba303e2dd9d6d), C(692699b83289fad1), C(dfb9aa7874678480), C(751390a8a5c41bdc), C(6ee5fbf87605d34), C(6ca73f610f3a8f7c), C(e898b3c996570ad),
+		C(751390a8a5c41bdc), C(6ee5fbf87605d34), C(6ca73f610f3a8f7c), C(e898b3c996570ad),
+		C(98168a5858fc7110), C(6f987fa27aa0daa2), C(f25e3e180d4b36a3), C(d0b03495aeb1be8a),
+		C(53467e16)
+	},
+	{
+		C(4cbc2b73a43071e0), C(56c5db4c4ca4e0b7), C(1b275a162f46bd3d), C(b87a326e413604bf), C(d8f9a5fa214b03ab), C(8a8bb8265771cf88), C(a655319054f6e70f),
+		C(b87a326e413604bf), C(d8f9a5fa214b03ab), C(8a8bb8265771cf88), C(a655319054f6e70f),
+		C(b499cb8e65a9af44), C(bee7fafcc8307491), C(5d2e55fa9b27cda2), C(63b120f5fb2d6ee5),
+		C(da14a8d0)
+	},
+	{
+		C(875638b9715d2221), C(d9ba0615c0c58740), C(616d4be2dfe825aa), C(5df25f13ea7bc284), C(165edfaafd2598fb), C(af7215c5c718c696), C(e9f2f9ca655e769),
+		C(5df25f13ea7bc284), C(165edfaafd2598fb), C(af7215c5c718c696), C(e9f2f9ca655e769),
+		C(e459cfcb565d3d2d), C(41d032631be2418a), C(c505db05fd946f60), C(54990394a714f5de),
+		C(67333551)
+	},
+	{
+		C(fb686b2782994a8d), C(edee60693756bb48), C(e6bc3cae0ded2ef5), C(58eb4d03b2c3ddf5), C(6d2542995f9189f1), C(c0beec58a5f5fea2), C(ed67436f42e2a78b),
+		C(58eb4d03b2c3ddf5), C(6d2542995f9189f1), C(c0beec58a5f5fea2), C(ed67436f42e2a78b),
+		C(dfec763cdb2b5193), C(724a8d5345bd2d6), C(94d4fd1b81457c23), C(28e87c50cdede453),
+		C(a0ebd66e)
+	},
+	{
+		C(ab21d81a911e6723), C(4c31b07354852f59), C(835da384c9384744), C(7f759dddc6e8549a), C(616dd0ca022c8735), C(94717ad4bc15ceb3), C(f66c7be808ab36e),
+		C(7f759dddc6e8549a), C(616dd0ca022c8735), C(94717ad4bc15ceb3), C(f66c7be808ab36e),
+		C(af8286b550b2f4b7), C(745bd217d20a9f40), C(c73bfb9c5430f015), C(55e65922666e3fc2),
+		C(4b769593)
+	},
+	{
+		C(33d013cc0cd46ecf), C(3de726423aea122c), C(116af51117fe21a9), C(f271ba474edc562d), C(e6596e67f9dd3ebd), C(c0a288edf808f383), C(b3def70681c6babc),
+		C(f271ba474edc562d), C(e6596e67f9dd3ebd), C(c0a288edf808f383), C(b3def70681c6babc),
+		C(7da7864e9989b095), C(bf2f8718693cd8a1), C(264a9144166da776), C(61ad90676870beb6),
+		C(6aa75624)
+	},
+	{
+		C(8ca92c7cd39fae5d), C(317e620e1bf20f1), C(4f0b33bf2194b97f), C(45744afcf131dbee), C(97222392c2559350), C(498a19b280c6d6ed), C(83ac2c36acdb8d49),
+		C(45744afcf131dbee), C(97222392c2559350), C(498a19b280c6d6ed), C(83ac2c36acdb8d49),
+		C(7a69645c294daa62), C(abe9d2be8275b3d2), C(39542019de371085), C(7f4efac8488cd6ad),
+		C(602a3f96)
+	},
+	{
+		C(fdde3b03f018f43e), C(38f932946c78660), C(c84084ce946851ee), C(b6dd09ba7851c7af), C(570de4e1bb13b133), C(c4e784eb97211642), C(8285a7fcdcc7c58d),
+		C(b6dd09ba7851c7af), C(570de4e1bb13b133), C(c4e784eb97211642), C(8285a7fcdcc7c58d),
+		C(d421f47990da899b), C(8aed409c997eaa13), C(7a045929c2e29ccf), C(b373682a6202c86b),
+		C(cd183c4d)
+	},
+	{
+		C(9c8502050e9c9458), C(d6d2a1a69964beb9), C(1675766f480229b5), C(216e1d6c86cb524c), C(d01cf6fd4f4065c0), C(fffa4ec5b482ea0f), C(a0e20ee6a5404ac1),
+		C(216e1d6c86cb524c), C(d01cf6fd4f4065c0), C(fffa4ec5b482ea0f), C(a0e20ee6a5404ac1),
+		C(c1b037e4eebaf85e), C(634e3d7c3ebf89eb), C(bcda972358c67d1), C(fd1352181e5b8578),
+		C(960a4d07)
+	},
+	{
+		C(348176ca2fa2fdd2), C(3a89c514cc360c2d), C(9f90b8afb318d6d0), C(bceee07c11a9ac30), C(2e2d47dff8e77eb7), C(11a394cd7b6d614a), C(1d7c41d54e15cb4a),
+		C(bceee07c11a9ac30), C(2e2d47dff8e77eb7), C(11a394cd7b6d614a), C(1d7c41d54e15cb4a),
+		C(15baa5ae7312b0fc), C(f398f596cc984635), C(8ab8fdf87a6788e8), C(b2b5c1234ab47e2),
+		C(9ae998c4)
+	},
+	{
+		C(4a3d3dfbbaea130b), C(4e221c920f61ed01), C(553fd6cd1304531f), C(bd2b31b5608143fe), C(ab717a10f2554853), C(293857f04d194d22), C(d51be8fa86f254f0),
+		C(bd2b31b5608143fe), C(ab717a10f2554853), C(293857f04d194d22), C(d51be8fa86f254f0),
+		C(1eee39e07686907e), C(639039fe0e8d3052), C(d6ec1470cef97ff), C(370c82b860034f0f),
+		C(74e2179d)
+	},
+	{
+		C(b371f768cdf4edb9), C(bdef2ace6d2de0f0), C(e05b4100f7f1baec), C(b9e0d415b4ebd534), C(c97c2a27efaa33d7), C(591cdb35f84ef9da), C(a57d02d0e8e3756c),
+		C(b9e0d415b4ebd534), C(c97c2a27efaa33d7), C(591cdb35f84ef9da), C(a57d02d0e8e3756c),
+		C(23f55f12d7c5c87b), C(4c7ca0fe23221101), C(dbc3020480334564), C(d985992f32c236b1),
+		C(ee9bae25)
+	},
+	{
+		C(7a1d2e96934f61f), C(eb1760ae6af7d961), C(887eb0da063005df), C(2228d6725e31b8ab), C(9b98f7e4d0142e70), C(b6a8c2115b8e0fe7), C(b591e2f5ab9b94b1),
+		C(2228d6725e31b8ab), C(9b98f7e4d0142e70), C(b6a8c2115b8e0fe7), C(b591e2f5ab9b94b1),
+		C(6c1feaa8065318e0), C(4e7e2ca21c2e81fb), C(e9fe5d8ce7993c45), C(ee411fa2f12cf8df),
+		C(b66edf10)
+	},
+	{
+		C(8be53d466d4728f2), C(86a5ac8e0d416640), C(984aa464cdb5c8bb), C(87049e68f5d38e59), C(7d8ce44ec6bd7751), C(cc28d08ab414839c), C(6c8f0bd34fe843e3),
+		C(87049e68f5d38e59), C(7d8ce44ec6bd7751), C(cc28d08ab414839c), C(6c8f0bd34fe843e3),
+		C(b8496dcdc01f3e47), C(2f03125c282ac26), C(82a8797ba3f5ef07), C(7c977a4d10bf52b8),
+		C(d6209737)
+	},
+	{
+		C(829677eb03abf042), C(43cad004b6bc2c0), C(f2f224756803971a), C(98d0dbf796480187), C(fbcb5f3e1bef5742), C(5af2a0463bf6e921), C(ad9555bf0120b3a3),
+		C(98d0dbf796480187), C(fbcb5f3e1bef5742), C(5af2a0463bf6e921), C(ad9555bf0120b3a3),
+		C(283e39b3dc99f447), C(bedaa1a4a0250c28), C(9d50546624ff9a57), C(4abaf523d1c090f6),
+		C(b994a88)
+	},
+	{
+		C(754435bae3496fc), C(5707fc006f094dcf), C(8951c86ab19d8e40), C(57c5208e8f021a77), C(f7653fbb69cd9276), C(a484410af21d75cb), C(f19b6844b3d627e8),
+		C(57c5208e8f021a77), C(f7653fbb69cd9276), C(a484410af21d75cb), C(f19b6844b3d627e8),
+		C(f37400fc3ffd9514), C(36ae0d821734edfd), C(5f37820af1f1f306), C(be637d40e6a5ad0),
+		C(a05d43c0)
+	},
+	{
+		C(fda9877ea8e3805f), C(31e868b6ffd521b7), C(b08c90681fb6a0fd), C(68110a7f83f5d3ff), C(6d77e045901b85a8), C(84ef681113036d8b), C(3b9f8e3928f56160),
+		C(68110a7f83f5d3ff), C(6d77e045901b85a8), C(84ef681113036d8b), C(3b9f8e3928f56160),
+		C(fc8b7f56c130835), C(a11f3e800638e841), C(d9572267f5cf28c1), C(7897c8149803f2aa),
+		C(c79f73a8)
+	},
+	{
+		C(2e36f523ca8f5eb5), C(8b22932f89b27513), C(331cd6ecbfadc1bb), C(d1bfe4df12b04cbf), C(f58c17243fd63842), C(3a453cdba80a60af), C(5737b2ca7470ea95),
+		C(d1bfe4df12b04cbf), C(f58c17243fd63842), C(3a453cdba80a60af), C(5737b2ca7470ea95),
+		C(54d44a3f4477030c), C(8168e02d4869aa7f), C(77f383a17778559d), C(95e1737d77a268fc),
+		C(a490aff5)
+	},
+	{
+		C(21a378ef76828208), C(a5c13037fa841da2), C(506d22a53fbe9812), C(61c9c95d91017da5), C(16f7c83ba68f5279), C(9c0619b0808d05f7), C(83c117ce4e6b70a3),
+		C(61c9c95d91017da5), C(16f7c83ba68f5279), C(9c0619b0808d05f7), C(83c117ce4e6b70a3),
+		C(cfb4c8af7fd01413), C(fdef04e602e72296), C(ed6124d337889b1), C(4919c86707b830da),
+		C(dfad65b4)
+	},
+	{
+		C(ccdd5600054b16ca), C(f78846e84204cb7b), C(1f9faec82c24eac9), C(58634004c7b2d19a), C(24bb5f51ed3b9073), C(46409de018033d00), C(4a9805eed5ac802e),
+		C(58634004c7b2d19a), C(24bb5f51ed3b9073), C(46409de018033d00), C(4a9805eed5ac802e),
+		C(e18de8db306baf82), C(46bbf75f1fa025ff), C(5faf2fb09be09487), C(3fbc62bd4e558fb3),
+		C(1d07dfb)
+	},
+	{
+		C(7854468f4e0cabd0), C(3a3f6b4f098d0692), C(ae2423ec7799d30d), C(29c3529eb165eeba), C(443de3703b657c35), C(66acbce31ae1bc8d), C(1acc99effe1d547e),
+		C(29c3529eb165eeba), C(443de3703b657c35), C(66acbce31ae1bc8d), C(1acc99effe1d547e),
+		C(cf07f8a57906573d), C(31bafb0bbb9a86e7), C(40c69492702a9346), C(7df61fdaa0b858af),
+		C(416df9a0)
+	},
+	{
+		C(7f88db5346d8f997), C(88eac9aacc653798), C(68a4d0295f8eefa1), C(ae59ca86f4c3323d), C(25906c09906d5c4c), C(8dd2aa0c0a6584ae), C(232a7d96b38f40e9),
+		C(ae59ca86f4c3323d), C(25906c09906d5c4c), C(8dd2aa0c0a6584ae), C(232a7d96b38f40e9),
+		C(8986ee00a2ed0042), C(c49ae7e428c8a7d1), C(b7dd8280713ac9c2), C(e018720aed1ebc28),
+		C(1f8fb9cc)
+	},
+	{
+		C(bb3fb5fb01d60fcf), C(1b7cc0847a215eb6), C(1246c994437990a1), C(d4edc954c07cd8f3), C(224f47e7c00a30ab), C(d5ad7ad7f41ef0c6), C(59e089281d869fd7),
+		C(d4edc954c07cd8f3), C(224f47e7c00a30ab), C(d5ad7ad7f41ef0c6), C(59e089281d869fd7),
+		C(f29340d07a14b6f1), C(c87c5ef76d9c4ef3), C(463118794193a9a), C(2922dcb0540f0dbc),
+		C(7abf48e3)
+	},
+	{
+		C(2e783e1761acd84d), C(39158042bac975a0), C(1cd21c5a8071188d), C(b1b7ec44f9302176), C(5cb476450dc0c297), C(dc5ef652521ef6a2), C(3cc79a9e334e1f84),
+		C(b1b7ec44f9302176), C(5cb476450dc0c297), C(dc5ef652521ef6a2), C(3cc79a9e334e1f84),
+		C(769e2a283dbcc651), C(9f24b105c8511d3f), C(c31c15575de2f27e), C(ecfecf32c3ae2d66),
+		C(dea4e3dd)
+	},
+	{
+		C(392058251cf22acc), C(944ec4475ead4620), C(b330a10b5cb94166), C(54bc9bee7cbe1767), C(485820bdbe442431), C(54d6120ea2972e90), C(f437a0341f29b72a),
+		C(54bc9bee7cbe1767), C(485820bdbe442431), C(54d6120ea2972e90), C(f437a0341f29b72a),
+		C(8f30885c784d5704), C(aa95376b16c7906a), C(e826928cfaf93dc3), C(20e8f54d1c16d7d8),
+		C(c6064f22)
+	},
+	{
+		C(adf5c1e5d6419947), C(2a9747bc659d28aa), C(95c5b8cb1f5d62c), C(80973ea532b0f310), C(a471829aa9c17dd9), C(c2ff3479394804ab), C(6bf44f8606753636),
+		C(80973ea532b0f310), C(a471829aa9c17dd9), C(c2ff3479394804ab), C(6bf44f8606753636),
+		C(5184d2973e6dd827), C(121b96369a332d9a), C(5c25d3475ab69e50), C(26d2961d62884168),
+		C(743bed9c)
+	},
+	{
+		C(6bc1db2c2bee5aba), C(e63b0ed635307398), C(7b2eca111f30dbbc), C(230d2b3e47f09830), C(ec8624a821c1caf4), C(ea6ec411cdbf1cb1), C(5f38ae82af364e27),
+		C(230d2b3e47f09830), C(ec8624a821c1caf4), C(ea6ec411cdbf1cb1), C(5f38ae82af364e27),
+		C(a519ef515ea7187c), C(6bad5efa7ebae05f), C(748abacb11a74a63), C(a28eef963d1396eb),
+		C(fce254d5)
+	},
+	{
+		C(b00f898229efa508), C(83b7590ad7f6985c), C(2780e70a0592e41d), C(7122413bdbc94035), C(e7f90fae33bf7763), C(4b6bd0fb30b12387), C(557359c0c44f48ca),
+		C(7122413bdbc94035), C(e7f90fae33bf7763), C(4b6bd0fb30b12387), C(557359c0c44f48ca),
+		C(d5656c3d6bc5f0d), C(983ff8e5e784da99), C(628479671b445bf), C(e179a1e27ce68f5d),
+		C(e47ec9d1)
+	},
+	{
+		C(b56eb769ce0d9a8c), C(ce196117bfbcaf04), C(b26c3c3797d66165), C(5ed12338f630ab76), C(fab19fcb319116d), C(167f5f42b521724b), C(c4aa56c409568d74),
+		C(5ed12338f630ab76), C(fab19fcb319116d), C(167f5f42b521724b), C(c4aa56c409568d74),
+		C(75fff4b42f8e9778), C(94218f94710c1ea3), C(b7b05efb738b06a6), C(83fff2deabf9cd3),
+		C(334a145c)
+	},
+	{
+		C(70c0637675b94150), C(259e1669305b0a15), C(46e1dd9fd387a58d), C(fca4e5bc9292788e), C(cd509dc1facce41c), C(bbba575a59d82fe), C(4e2e71c15b45d4d3),
+		C(fca4e5bc9292788e), C(cd509dc1facce41c), C(bbba575a59d82fe), C(4e2e71c15b45d4d3),
+		C(5dc54582ead999c), C(72612d1571963c6f), C(30318a9d2d3d1829), C(785dd00f4cc9c9a0),
+		C(adec1e3c)
+	},
+	{
+		C(74c0b8a6821faafe), C(abac39d7491370e7), C(faf0b2a48a4e6aed), C(967e970df9673d2a), C(d465247cffa415c0), C(33a1df0ca1107722), C(49fc2a10adce4a32),
+		C(967e970df9673d2a), C(d465247cffa415c0), C(33a1df0ca1107722), C(49fc2a10adce4a32),
+		C(c5707e079a284308), C(573028266635dda6), C(f786f5eee6127fa0), C(b30d79cebfb51266),
+		C(f6a9fbf8)
+	},
+	{
+		C(5fb5e48ac7b7fa4f), C(a96170f08f5acbc7), C(bbf5c63d4f52a1e5), C(6cc09e60700563e9), C(d18f23221e964791), C(ffc23eeef7af26eb), C(693a954a3622a315),
+		C(815308a32a9b0daf), C(efb2ab27bf6fd0bd), C(9f1ffc0986111118), C(f9a3aa1778ea3985),
+		C(698fe54b2b93933b), C(dacc2b28404d0f10), C(815308a32a9b0daf), C(efb2ab27bf6fd0bd),
+		C(5398210c)
+	},
 };
 
-void Check(uint64 expected, uint64 actual) {
-  if (expected != actual) {
-    cerr << "ERROR: expected 0x" << hex << expected << ", but got 0x" << actual << "\n";
-    ++errors;
-  }
+void Check(uint64 expected, uint64 actual)
+{
+	if (expected != actual)
+	{
+		cerr << "ERROR: expected 0x" << hex << expected << ", but got 0x" << actual << "\n";
+		++errors;
+	}
 }
 
-void Test(const uint64* expected, int offset, int len) {
-  const uint128 u = CityHash128(data + offset, len);
-  const uint128 v = CityHash128WithSeed(data + offset, len, kSeed128);
-  Check(expected[0], CityHash64(data + offset, len));
-  Check(expected[15], CityHash32(data + offset, len));
-  Check(expected[1], CityHash64WithSeed(data + offset, len, kSeed0));
-  Check(expected[2], CityHash64WithSeeds(data + offset, len, kSeed0, kSeed1));
-  Check(expected[3], Uint128Low64(u));
-  Check(expected[4], Uint128High64(u));
-  Check(expected[5], Uint128Low64(v));
-  Check(expected[6], Uint128High64(v));
+void Test(const uint64 *expected, int offset, int len)
+{
+	const uint128 u = CityHash128(data + offset, len);
+	const uint128 v = CityHash128WithSeed(data + offset, len, kSeed128);
+	Check(expected[0], CityHash64(data + offset, len));
+	Check(expected[15], CityHash32(data + offset, len));
+	Check(expected[1], CityHash64WithSeed(data + offset, len, kSeed0));
+	Check(expected[2], CityHash64WithSeeds(data + offset, len, kSeed0, kSeed1));
+	Check(expected[3], Uint128Low64(u));
+	Check(expected[4], Uint128High64(u));
+	Check(expected[5], Uint128Low64(v));
+	Check(expected[6], Uint128High64(v));
 #ifdef __SSE4_2__
-  const uint128 y = CityHashCrc128(data + offset, len);
-  const uint128 z = CityHashCrc128WithSeed(data + offset, len, kSeed128);
-  uint64 crc256_results[4];
-  CityHashCrc256(data + offset, len, crc256_results);
-  Check(expected[7], Uint128Low64(y));
-  Check(expected[8], Uint128High64(y));
-  Check(expected[9], Uint128Low64(z));
-  Check(expected[10], Uint128High64(z));
-  for (int i = 0; i < 4; i++) {
-    Check(expected[11 + i], crc256_results[i]);
-  }
+	const uint128 y = CityHashCrc128(data + offset, len);
+	const uint128 z = CityHashCrc128WithSeed(data + offset, len, kSeed128);
+	uint64 crc256_results[4];
+	CityHashCrc256(data + offset, len, crc256_results);
+	Check(expected[7], Uint128Low64(y));
+	Check(expected[8], Uint128High64(y));
+	Check(expected[9], Uint128Low64(z));
+	Check(expected[10], Uint128High64(z));
+	for (int i = 0; i < 4; i++)
+	{
+		Check(expected[11 + i], crc256_results[i]);
+	}
 #endif
 }
 
 #else
 
 #define Test(a, b, c) Dump((b), (c))
-void Dump(int offset, int len) {
-  const uint128 u = CityHash128(data + offset, len);
-  const uint128 v = CityHash128WithSeed(data + offset, len, kSeed128);
-  const uint128 y = CityHashCrc128(data + offset, len);
-  const uint128 z = CityHashCrc128WithSeed(data + offset, len, kSeed128);
-  uint64 crc256_results[4];
-  CityHashCrc256(data + offset, len, crc256_results);
-  cout << hex
-       << "{C(" << CityHash64(data + offset, len) << "), "
-       << "C(" << CityHash64WithSeed(data + offset, len, kSeed0) << "), "
-       << "C(" << CityHash64WithSeeds(data + offset, len, kSeed0, kSeed1) << "), "
-       << "C(" << Uint128Low64(u) << "), "
-       << "C(" << Uint128High64(u) << "), "
-       << "C(" << Uint128Low64(v) << "), "
-       << "C(" << Uint128High64(v) << "),\n"
-       << "C(" << Uint128Low64(y) << "), "
-       << "C(" << Uint128High64(y) << "), "
-       << "C(" << Uint128Low64(z) << "), "
-       << "C(" << Uint128High64(z) << "),\n";
-  for (int i = 0; i < 4; i++) {
-    cout << hex << "C(" << crc256_results[i] << (i == 3 ? "),\n" : "), ");
-  }
-  cout << "C(" << CityHash32(data + offset, len) << ")},\n";
+void Dump(int offset, int len)
+{
+	const uint128 u = CityHash128(data + offset, len);
+	const uint128 v = CityHash128WithSeed(data + offset, len, kSeed128);
+	const uint128 y = CityHashCrc128(data + offset, len);
+	const uint128 z = CityHashCrc128WithSeed(data + offset, len, kSeed128);
+	uint64 crc256_results[4];
+	CityHashCrc256(data + offset, len, crc256_results);
+	cout << hex
+	     << "{C(" << CityHash64(data + offset, len) << "), "
+	     << "C(" << CityHash64WithSeed(data + offset, len, kSeed0) << "), "
+	     << "C(" << CityHash64WithSeeds(data + offset, len, kSeed0, kSeed1) << "), "
+	     << "C(" << Uint128Low64(u) << "), "
+	     << "C(" << Uint128High64(u) << "), "
+	     << "C(" << Uint128Low64(v) << "), "
+	     << "C(" << Uint128High64(v) << "),\n"
+	     << "C(" << Uint128Low64(y) << "), "
+	     << "C(" << Uint128High64(y) << "), "
+	     << "C(" << Uint128Low64(z) << "), "
+	     << "C(" << Uint128High64(z) << "),\n";
+	for (int i = 0; i < 4; i++)
+	{
+		cout << hex << "C(" << crc256_results[i] << (i == 3 ? "),\n" : "), ");
+	}
+	cout << "C(" << CityHash32(data + offset, len) << ")},\n";
 }
 
 #endif
 
-int main(int argc, char** argv) {
-  setup();
-  int i = 0;
-  for ( ; i < kTestSize - 1; i++) {
-    Test(testdata[i], i * i, i);
-  }
-  Test(testdata[i], 0, kDataSize);
-  return errors > 0;
+int main(int argc, char **argv)
+{
+	setup();
+	int i = 0;
+	for ( ; i < kTestSize - 1; i++)
+	{
+		Test(testdata[i], i * i, i);
+	}
+	Test(testdata[i], 0, kDataSize);
+	return errors > 0;
 }
diff --git a/client/c.cc b/client/c.cc
index b2545ed5c..86794d37f 100644
--- a/client/c.cc
+++ b/client/c.cc
@@ -43,2301 +43,2314 @@
 #define FAKE_STATUS     hyperdex_client_returncode _status;     hyperdex_client_returncode* status = &_status
 
 #define SIGNAL_PROTECT_ERR(X) \
-    sigset_t old_sigs; \
-    sigset_t all_sigs; \
-    sigfillset(&all_sigs); \
-    if (pthread_sigmask(SIG_BLOCK, &all_sigs, &old_sigs) < 0) \
-    { \
-        *status = HYPERDEX_CLIENT_INTERNAL; \
-        return (X); \
-    } \
-    e::guard g = e::makeguard(pthread_sigmask, SIG_SETMASK, (sigset_t*)&old_sigs, (sigset_t*)NULL)
+	sigset_t old_sigs; \
+	sigset_t all_sigs; \
+	sigfillset(&all_sigs); \
+	if (pthread_sigmask(SIG_BLOCK, &all_sigs, &old_sigs) < 0) \
+	{ \
+		*status = HYPERDEX_CLIENT_INTERNAL; \
+		return (X); \
+	} \
+	e::guard g = e::makeguard(pthread_sigmask, SIG_SETMASK, (sigset_t*)&old_sigs, (sigset_t*)NULL)
 
 #define SIGNAL_PROTECT SIGNAL_PROTECT_ERR(-1);
 inline void return_void() {}
 #define SIGNAL_PROTECT_VOID SIGNAL_PROTECT_ERR(return_void());
 
 #define C_WRAP_EXCEPT(X) \
-    hyperdex::client* cl = reinterpret_cast<hyperdex::client*>(_cl); \
-    SIGNAL_PROTECT; \
-    try \
-    { \
-        X \
-    } \
-    catch (std::bad_alloc& ba) \
-    { \
-        errno = ENOMEM; \
-        *status = HYPERDEX_CLIENT_NOMEM; \
-        cl->set_error_message("out of memory"); \
-        return -1; \
-    } \
-    catch (...) \
-    { \
-        *status = HYPERDEX_CLIENT_EXCEPTION; \
-        cl->set_error_message("unhandled exception was thrown"); \
-        return -1; \
-    } \
+	hyperdex::client* cl = reinterpret_cast<hyperdex::client*>(_cl); \
+	SIGNAL_PROTECT; \
+	try \
+	{ \
+		X \
+	} \
+	catch (std::bad_alloc& ba) \
+	{ \
+		errno = ENOMEM; \
+		*status = HYPERDEX_CLIENT_NOMEM; \
+		cl->set_error_message("out of memory"); \
+		return -1; \
+	} \
+	catch (...) \
+	{ \
+		*status = HYPERDEX_CLIENT_EXCEPTION; \
+		cl->set_error_message("unhandled exception was thrown"); \
+		return -1; \
+	} \
 
 #ifdef __cplusplus
-extern "C"
-{
+	extern "C"
+	{
 #endif // __cplusplus
 
-HYPERDEX_API hyperdex_client*
-hyperdex_client_create(const char* coordinator, uint16_t port)
-{
-    FAKE_STATUS;
-    SIGNAL_PROTECT_ERR(NULL);
-    try
-    {
-        return reinterpret_cast<hyperdex_client*>(new hyperdex::client(coordinator, port));
-    }
-    catch (std::bad_alloc& ba)
-    {
-        errno = ENOMEM;
-        return NULL;
-    }
-    catch (...)
-    {
-        return NULL;
-    }
-}
-
-HYPERDEX_API hyperdex_client*
-hyperdex_client_create_conn_str(const char* conn_str)
-{
-    FAKE_STATUS;
-    SIGNAL_PROTECT_ERR(NULL);
-    try
-    {
-        return reinterpret_cast<hyperdex_client*>(new hyperdex::client(conn_str));
-    }
-    catch (std::bad_alloc& ba)
-    {
-        errno = ENOMEM;
-        return NULL;
-    }
-    catch (...)
-    {
-        return NULL;
-    }
-}
-
-HYPERDEX_API void
-hyperdex_client_destroy(hyperdex_client* client)
-{
-    delete reinterpret_cast<hyperdex::client*>(client);
-}
-
-HYPERDEX_API const char*
-hyperdex_client_error_message(hyperdex_client* _cl)
-{
-    FAKE_STATUS;
-    SIGNAL_PROTECT_ERR(NULL);
-    hyperdex::client* cl = reinterpret_cast<hyperdex::client*>(_cl);
-    return cl->error_message();
-}
-
-HYPERDEX_API const char*
-hyperdex_client_error_location(hyperdex_client* _cl)
-{
-    FAKE_STATUS;
-    SIGNAL_PROTECT_ERR(NULL);
-    hyperdex::client* cl = reinterpret_cast<hyperdex::client*>(_cl);
-    return cl->error_location();
-}
-
-HYPERDEX_API const char*
-hyperdex_client_returncode_to_string(enum hyperdex_client_returncode stat)
-{
-    FAKE_STATUS;
-    SIGNAL_PROTECT_ERR(NULL);
-    switch (stat)
-    {
-        CSTRINGIFY(HYPERDEX_CLIENT_SUCCESS);
-        CSTRINGIFY(HYPERDEX_CLIENT_NOTFOUND);
-        CSTRINGIFY(HYPERDEX_CLIENT_SEARCHDONE);
-        CSTRINGIFY(HYPERDEX_CLIENT_CMPFAIL);
-        CSTRINGIFY(HYPERDEX_CLIENT_READONLY);
-        CSTRINGIFY(HYPERDEX_CLIENT_UNKNOWNSPACE);
-        CSTRINGIFY(HYPERDEX_CLIENT_COORDFAIL);
-        CSTRINGIFY(HYPERDEX_CLIENT_SERVERERROR);
-        CSTRINGIFY(HYPERDEX_CLIENT_POLLFAILED);
-        CSTRINGIFY(HYPERDEX_CLIENT_OVERFLOW);
-        CSTRINGIFY(HYPERDEX_CLIENT_RECONFIGURE);
-        CSTRINGIFY(HYPERDEX_CLIENT_TIMEOUT);
-        CSTRINGIFY(HYPERDEX_CLIENT_UNKNOWNATTR);
-        CSTRINGIFY(HYPERDEX_CLIENT_DUPEATTR);
-        CSTRINGIFY(HYPERDEX_CLIENT_NONEPENDING);
-        CSTRINGIFY(HYPERDEX_CLIENT_DONTUSEKEY);
-        CSTRINGIFY(HYPERDEX_CLIENT_WRONGTYPE);
-        CSTRINGIFY(HYPERDEX_CLIENT_NOMEM);
-        CSTRINGIFY(HYPERDEX_CLIENT_INTERRUPTED);
-        CSTRINGIFY(HYPERDEX_CLIENT_CLUSTER_JUMP);
-        CSTRINGIFY(HYPERDEX_CLIENT_OFFLINE);
-        CSTRINGIFY(HYPERDEX_CLIENT_UNAUTHORIZED);
-        CSTRINGIFY(HYPERDEX_CLIENT_INTERNAL);
-        CSTRINGIFY(HYPERDEX_CLIENT_EXCEPTION);
-        CSTRINGIFY(HYPERDEX_CLIENT_GARBAGE);
-        default:
-            return "unknown hyperdex_client_returncode";
-    }
-}
-
-HYPERDEX_API enum hyperdatatype
-hyperdex_client_attribute_type(hyperdex_client* _cl,
-                               const char* space, const char* name,
-                               enum hyperdex_client_returncode* status)
-{
-    SIGNAL_PROTECT_ERR(HYPERDATATYPE_GARBAGE);
-    hyperdex::client* cl = reinterpret_cast<hyperdex::client*>(_cl); \
-
-    try
-    {
-        return cl->attribute_type(space, name, status);
-    }
-    catch (std::bad_alloc& ba)
-    {
-        errno = ENOMEM;
-        *status = HYPERDEX_CLIENT_NOMEM;
-        cl->set_error_message("out of memory");
-        return HYPERDATATYPE_GARBAGE;
-    }
-    catch (...)
-    {
-        *status = HYPERDEX_CLIENT_EXCEPTION;
-        cl->set_error_message("unhandled exception was thrown");
-        return HYPERDATATYPE_GARBAGE;
-    }
-}
-
-HYPERDEX_API void
-hyperdex_client_destroy_attrs(const hyperdex_client_attribute* attrs, size_t /*attrs_sz*/)
-{
-    FAKE_STATUS;
-    SIGNAL_PROTECT_VOID;
-    free(const_cast<hyperdex_client_attribute*>(attrs));
-}
-
-HYPERDEX_API void
-hyperdex_client_clear_auth_context(struct hyperdex_client* _cl)
-{
-    FAKE_STATUS;
-    SIGNAL_PROTECT_VOID;
-    hyperdex::client* cl = reinterpret_cast<hyperdex::client*>(_cl);
-    cl->clear_auth_context();
-}
-
-HYPERDEX_API void
-hyperdex_client_set_auth_context(struct hyperdex_client* _cl,
-                                 const char** macaroons, size_t macaroons_sz)
-{
-    FAKE_STATUS;
-    SIGNAL_PROTECT_VOID;
-    hyperdex::client* cl = reinterpret_cast<hyperdex::client*>(_cl);
-    cl->set_auth_context(macaroons, macaroons_sz);
-}
-
-HYPERDEX_API struct hyperdex_client_microtransaction*
-hyperdex_client_uxact_init(struct hyperdex_client* _cl,
-                      const char* space,
-                      enum hyperdex_client_returncode *status)
-{
-
-    SIGNAL_PROTECT_ERR(NULL);
-    hyperdex::client *cl = reinterpret_cast<hyperdex::client*>(_cl);
-    hyperdex::microtransaction *tx = cl->uxact_init(space, status);
-
-    return reinterpret_cast<struct hyperdex_client_microtransaction*>(tx);
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_uxact_commit(struct hyperdex_client* _cl,
-                                struct hyperdex_client_microtransaction *transaction,
-                                const char* key, size_t key_sz)
-{
-    hyperdex::microtransaction* tx = reinterpret_cast<hyperdex::microtransaction*>(transaction);
-    hyperdex_client_returncode *status = tx->status;
-
-    C_WRAP_EXCEPT(
-    return cl->uxact_commit(tx, key, key_sz);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_uxact_group_commit(struct hyperdex_client* _cl,
-                                struct hyperdex_client_microtransaction *transaction,
-                                const hyperdex_client_attribute_check *chks, size_t chks_sz,
-                                uint64_t *count)
-{
-    hyperdex::microtransaction* tx = reinterpret_cast<hyperdex::microtransaction*>(transaction);
-    hyperdex_client_returncode *status = tx->status;
-
-    C_WRAP_EXCEPT(
-    return cl->uxact_group_commit(tx, chks, chks_sz, count);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_uxact_cond_commit(struct hyperdex_client* _cl,
-                                struct hyperdex_client_microtransaction *transaction,
-                                const char* key, size_t key_sz,
-                                const hyperdex_client_attribute_check *chks, size_t chks_sz)
-{
-    hyperdex::microtransaction* tx = reinterpret_cast<hyperdex::microtransaction*>(transaction);
-    hyperdex_client_returncode *status = tx->status;
-
-    C_WRAP_EXCEPT(
-    return cl->uxact_cond_commit(tx, key, key_sz, chks, chks_sz);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_get(struct hyperdex_client* _cl,
-                    const char* space,
-                    const char* key, size_t key_sz,
-                    enum hyperdex_client_returncode* status,
-                    const struct hyperdex_client_attribute** attrs, size_t* attrs_sz)
-{
-    C_WRAP_EXCEPT(
-    return cl->get(space, key, key_sz, status, attrs, attrs_sz);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_get_partial(struct hyperdex_client* _cl,
-                            const char* space,
-                            const char* key, size_t key_sz,
-                            const char** attrnames, size_t attrnames_sz,
-                            enum hyperdex_client_returncode* status,
-                            const struct hyperdex_client_attribute** attrs, size_t* attrs_sz)
-{
-    C_WRAP_EXCEPT(
-    return cl->get_partial(space, key, key_sz, attrnames, attrnames_sz, status, attrs, attrs_sz);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_put(struct hyperdex_client* _cl,
-                    const char* space,
-                    const char* key, size_t key_sz,
-                    const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                    enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(put), strlen(XSTR(put)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_uxact_put(struct hyperdex_client* _cl,
-                          struct hyperdex_client_microtransaction* microtransaction,
-                          const struct hyperdex_client_attribute* attrs, size_t attrs_sz)
-{
-    hyperdex::microtransaction* tx = reinterpret_cast<hyperdex::microtransaction*>(microtransaction);
-    hyperdex_client_returncode *status = tx->status;
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(put), strlen(XSTR(put)));
-    return cl->uxact_add_funcall(tx, opinfo, attrs, attrs_sz, NULL, 0);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_cond_put(struct hyperdex_client* _cl,
-                         const char* space,
-                         const char* key, size_t key_sz,
-                         const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                         const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                         enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_put), strlen(XSTR(cond_put)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_cond_put_or_create(struct hyperdex_client* _cl,
-                                   const char* space,
-                                   const char* key, size_t key_sz,
-                                   const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                   const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                   enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_put_or_create), strlen(XSTR(cond_put_or_create)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_group_put(struct hyperdex_client* _cl,
-                          const char* space,
-                          const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                          const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                          enum hyperdex_client_returncode* status,
-                          uint64_t* count)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_put), strlen(XSTR(group_put)));
-    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_put_if_not_exist(struct hyperdex_client* _cl,
-                                 const char* space,
-                                 const char* key, size_t key_sz,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                 enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(put_if_not_exist), strlen(XSTR(put_if_not_exist)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_del(struct hyperdex_client* _cl,
-                    const char* space,
-                    const char* key, size_t key_sz,
-                    enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(del), strlen(XSTR(del)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, NULL, 0, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_cond_del(struct hyperdex_client* _cl,
-                         const char* space,
-                         const char* key, size_t key_sz,
-                         const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                         enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_del), strlen(XSTR(cond_del)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, NULL, 0, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_group_del(struct hyperdex_client* _cl,
-                          const char* space,
-                          const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                          enum hyperdex_client_returncode* status,
-                          uint64_t* count)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_del), strlen(XSTR(group_del)));
-    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, NULL, 0, NULL, 0, status, count);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_atomic_add(struct hyperdex_client* _cl,
-                           const char* space,
-                           const char* key, size_t key_sz,
-                           const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                           enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(atomic_add), strlen(XSTR(atomic_add)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_uxact_atomic_add(struct hyperdex_client* _cl,
-                                 struct hyperdex_client_microtransaction* microtransaction,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz)
-{
-    hyperdex::microtransaction* tx = reinterpret_cast<hyperdex::microtransaction*>(microtransaction);
-    hyperdex_client_returncode *status = tx->status;
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(atomic_add), strlen(XSTR(atomic_add)));
-    return cl->uxact_add_funcall(tx, opinfo, attrs, attrs_sz, NULL, 0);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_cond_atomic_add(struct hyperdex_client* _cl,
-                                const char* space,
-                                const char* key, size_t key_sz,
-                                const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_atomic_add), strlen(XSTR(cond_atomic_add)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_group_atomic_add(struct hyperdex_client* _cl,
-                                 const char* space,
-                                 const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                 enum hyperdex_client_returncode* status,
-                                 uint64_t* count)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_atomic_add), strlen(XSTR(group_atomic_add)));
-    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_atomic_sub(struct hyperdex_client* _cl,
-                           const char* space,
-                           const char* key, size_t key_sz,
-                           const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                           enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(atomic_sub), strlen(XSTR(atomic_sub)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_uxact_atomic_sub(struct hyperdex_client* _cl,
-                                 struct hyperdex_client_microtransaction* microtransaction,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz)
-{
-    hyperdex::microtransaction* tx = reinterpret_cast<hyperdex::microtransaction*>(microtransaction);
-    hyperdex_client_returncode *status = tx->status;
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(atomic_sub), strlen(XSTR(atomic_sub)));
-    return cl->uxact_add_funcall(tx, opinfo, attrs, attrs_sz, NULL, 0);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_cond_atomic_sub(struct hyperdex_client* _cl,
-                                const char* space,
-                                const char* key, size_t key_sz,
-                                const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_atomic_sub), strlen(XSTR(cond_atomic_sub)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_group_atomic_sub(struct hyperdex_client* _cl,
-                                 const char* space,
-                                 const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                 enum hyperdex_client_returncode* status,
-                                 uint64_t* count)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_atomic_sub), strlen(XSTR(group_atomic_sub)));
-    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_atomic_mul(struct hyperdex_client* _cl,
-                           const char* space,
-                           const char* key, size_t key_sz,
-                           const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                           enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(atomic_mul), strlen(XSTR(atomic_mul)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_uxact_atomic_mul(struct hyperdex_client* _cl,
-                                 struct hyperdex_client_microtransaction* microtransaction,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz)
-{
-    hyperdex::microtransaction* tx = reinterpret_cast<hyperdex::microtransaction*>(microtransaction);
-    hyperdex_client_returncode *status = tx->status;
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(atomic_mul), strlen(XSTR(atomic_mul)));
-    return cl->uxact_add_funcall(tx, opinfo, attrs, attrs_sz, NULL, 0);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_cond_atomic_mul(struct hyperdex_client* _cl,
-                                const char* space,
-                                const char* key, size_t key_sz,
-                                const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_atomic_mul), strlen(XSTR(cond_atomic_mul)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_group_atomic_mul(struct hyperdex_client* _cl,
-                                 const char* space,
-                                 const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                 enum hyperdex_client_returncode* status,
-                                 uint64_t* count)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_atomic_mul), strlen(XSTR(group_atomic_mul)));
-    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_atomic_div(struct hyperdex_client* _cl,
-                           const char* space,
-                           const char* key, size_t key_sz,
-                           const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                           enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(atomic_div), strlen(XSTR(atomic_div)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_uxact_atomic_div(struct hyperdex_client* _cl,
-                                 struct hyperdex_client_microtransaction* microtransaction,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz)
-{
-    hyperdex::microtransaction* tx = reinterpret_cast<hyperdex::microtransaction*>(microtransaction);
-    hyperdex_client_returncode *status = tx->status;
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(atomic_div), strlen(XSTR(atomic_div)));
-    return cl->uxact_add_funcall(tx, opinfo, attrs, attrs_sz, NULL, 0);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_cond_atomic_div(struct hyperdex_client* _cl,
-                                const char* space,
-                                const char* key, size_t key_sz,
-                                const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_atomic_div), strlen(XSTR(cond_atomic_div)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_group_atomic_div(struct hyperdex_client* _cl,
-                                 const char* space,
-                                 const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                 enum hyperdex_client_returncode* status,
-                                 uint64_t* count)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_atomic_div), strlen(XSTR(group_atomic_div)));
-    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_atomic_mod(struct hyperdex_client* _cl,
-                           const char* space,
-                           const char* key, size_t key_sz,
-                           const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                           enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(atomic_mod), strlen(XSTR(atomic_mod)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_cond_atomic_mod(struct hyperdex_client* _cl,
-                                const char* space,
-                                const char* key, size_t key_sz,
-                                const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_atomic_mod), strlen(XSTR(cond_atomic_mod)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_group_atomic_mod(struct hyperdex_client* _cl,
-                                 const char* space,
-                                 const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                 enum hyperdex_client_returncode* status,
-                                 uint64_t* count)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_atomic_mod), strlen(XSTR(group_atomic_mod)));
-    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_atomic_and(struct hyperdex_client* _cl,
-                           const char* space,
-                           const char* key, size_t key_sz,
-                           const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                           enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(atomic_and), strlen(XSTR(atomic_and)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_uxact_atomic_and(struct hyperdex_client* _cl,
-                                 struct hyperdex_client_microtransaction* microtransaction,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz)
-{
-    hyperdex::microtransaction* tx = reinterpret_cast<hyperdex::microtransaction*>(microtransaction);
-    hyperdex_client_returncode *status = tx->status;
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(atomic_and), strlen(XSTR(atomic_and)));
-    return cl->uxact_add_funcall(tx, opinfo, attrs, attrs_sz, NULL, 0);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_cond_atomic_and(struct hyperdex_client* _cl,
-                                const char* space,
-                                const char* key, size_t key_sz,
-                                const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_atomic_and), strlen(XSTR(cond_atomic_and)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_group_atomic_and(struct hyperdex_client* _cl,
-                                 const char* space,
-                                 const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                 enum hyperdex_client_returncode* status,
-                                 uint64_t* count)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_atomic_and), strlen(XSTR(group_atomic_and)));
-    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_atomic_or(struct hyperdex_client* _cl,
-                          const char* space,
-                          const char* key, size_t key_sz,
-                          const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                          enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(atomic_or), strlen(XSTR(atomic_or)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_uxact_atomic_or(struct hyperdex_client* _cl,
-                                struct hyperdex_client_microtransaction* microtransaction,
-                                const struct hyperdex_client_attribute* attrs, size_t attrs_sz)
-{
-    hyperdex::microtransaction* tx = reinterpret_cast<hyperdex::microtransaction*>(microtransaction);
-    hyperdex_client_returncode *status = tx->status;
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(atomic_or), strlen(XSTR(atomic_or)));
-    return cl->uxact_add_funcall(tx, opinfo, attrs, attrs_sz, NULL, 0);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_cond_atomic_or(struct hyperdex_client* _cl,
-                               const char* space,
-                               const char* key, size_t key_sz,
-                               const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                               const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                               enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_atomic_or), strlen(XSTR(cond_atomic_or)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_group_atomic_or(struct hyperdex_client* _cl,
-                                const char* space,
-                                const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                enum hyperdex_client_returncode* status,
-                                uint64_t* count)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_atomic_or), strlen(XSTR(group_atomic_or)));
-    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_atomic_xor(struct hyperdex_client* _cl,
-                           const char* space,
-                           const char* key, size_t key_sz,
-                           const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                           enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(atomic_xor), strlen(XSTR(atomic_xor)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_cond_atomic_xor(struct hyperdex_client* _cl,
-                                const char* space,
-                                const char* key, size_t key_sz,
-                                const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_atomic_xor), strlen(XSTR(cond_atomic_xor)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_group_atomic_xor(struct hyperdex_client* _cl,
-                                 const char* space,
-                                 const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                 enum hyperdex_client_returncode* status,
-                                 uint64_t* count)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_atomic_xor), strlen(XSTR(group_atomic_xor)));
-    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_atomic_min(struct hyperdex_client* _cl,
-                           const char* space,
-                           const char* key, size_t key_sz,
-                           const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                           enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(atomic_min), strlen(XSTR(atomic_min)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_cond_atomic_min(struct hyperdex_client* _cl,
-                                const char* space,
-                                const char* key, size_t key_sz,
-                                const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_atomic_min), strlen(XSTR(cond_atomic_min)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_group_atomic_min(struct hyperdex_client* _cl,
-                                 const char* space,
-                                 const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                 enum hyperdex_client_returncode* status,
-                                 uint64_t* count)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_atomic_min), strlen(XSTR(group_atomic_min)));
-    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_atomic_max(struct hyperdex_client* _cl,
-                           const char* space,
-                           const char* key, size_t key_sz,
-                           const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                           enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(atomic_max), strlen(XSTR(atomic_max)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_cond_atomic_max(struct hyperdex_client* _cl,
-                                const char* space,
-                                const char* key, size_t key_sz,
-                                const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_atomic_max), strlen(XSTR(cond_atomic_max)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_group_atomic_max(struct hyperdex_client* _cl,
-                                 const char* space,
-                                 const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                 enum hyperdex_client_returncode* status,
-                                 uint64_t* count)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_atomic_max), strlen(XSTR(group_atomic_max)));
-    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_string_prepend(struct hyperdex_client* _cl,
-                               const char* space,
-                               const char* key, size_t key_sz,
-                               const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                               enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(string_prepend), strlen(XSTR(string_prepend)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_uxact_string_prepend(struct hyperdex_client* _cl,
-                                     struct hyperdex_client_microtransaction* microtransaction,
-                                     const struct hyperdex_client_attribute* attrs, size_t attrs_sz)
-{
-    hyperdex::microtransaction* tx = reinterpret_cast<hyperdex::microtransaction*>(microtransaction);
-    hyperdex_client_returncode *status = tx->status;
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(string_prepend), strlen(XSTR(string_prepend)));
-    return cl->uxact_add_funcall(tx, opinfo, attrs, attrs_sz, NULL, 0);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_cond_string_prepend(struct hyperdex_client* _cl,
-                                    const char* space,
-                                    const char* key, size_t key_sz,
-                                    const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                    const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                    enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_string_prepend), strlen(XSTR(cond_string_prepend)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_group_string_prepend(struct hyperdex_client* _cl,
-                                     const char* space,
-                                     const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                     const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                     enum hyperdex_client_returncode* status,
-                                     uint64_t* count)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_string_prepend), strlen(XSTR(group_string_prepend)));
-    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_string_append(struct hyperdex_client* _cl,
-                              const char* space,
-                              const char* key, size_t key_sz,
-                              const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                              enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(string_append), strlen(XSTR(string_append)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_uxact_string_append(struct hyperdex_client* _cl,
-                                    struct hyperdex_client_microtransaction* microtransaction,
-                                    const struct hyperdex_client_attribute* attrs, size_t attrs_sz)
-{
-    hyperdex::microtransaction* tx = reinterpret_cast<hyperdex::microtransaction*>(microtransaction);
-    hyperdex_client_returncode *status = tx->status;
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(string_append), strlen(XSTR(string_append)));
-    return cl->uxact_add_funcall(tx, opinfo, attrs, attrs_sz, NULL, 0);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_cond_string_append(struct hyperdex_client* _cl,
-                                   const char* space,
-                                   const char* key, size_t key_sz,
-                                   const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                   const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                   enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_string_append), strlen(XSTR(cond_string_append)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_group_string_append(struct hyperdex_client* _cl,
-                                    const char* space,
-                                    const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                    const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                    enum hyperdex_client_returncode* status,
-                                    uint64_t* count)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_string_append), strlen(XSTR(group_string_append)));
-    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_string_ltrim(struct hyperdex_client* _cl,
-                             const char* space,
-                             const char* key, size_t key_sz,
-                             const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                             enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(string_ltrim), strlen(XSTR(string_ltrim)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_uxact_string_ltrim(struct hyperdex_client* _cl,
-                                   struct hyperdex_client_microtransaction* microtransaction,
-                                   const struct hyperdex_client_attribute* attrs, size_t attrs_sz)
-{
-    hyperdex::microtransaction* tx = reinterpret_cast<hyperdex::microtransaction*>(microtransaction);
-    hyperdex_client_returncode *status = tx->status;
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(string_ltrim), strlen(XSTR(string_ltrim)));
-    return cl->uxact_add_funcall(tx, opinfo, attrs, attrs_sz, NULL, 0);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_cond_string_ltrim(struct hyperdex_client* _cl,
-                                  const char* space,
-                                  const char* key, size_t key_sz,
-                                  const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                  const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                  enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_string_ltrim), strlen(XSTR(cond_string_ltrim)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_group_string_ltrim(struct hyperdex_client* _cl,
-                                   const char* space,
-                                   const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                   const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                   enum hyperdex_client_returncode* status,
-                                   uint64_t* count)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_string_ltrim), strlen(XSTR(group_string_ltrim)));
-    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_string_rtrim(struct hyperdex_client* _cl,
-                             const char* space,
-                             const char* key, size_t key_sz,
-                             const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                             enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(string_rtrim), strlen(XSTR(string_rtrim)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_uxact_string_rtrim(struct hyperdex_client* _cl,
-                                   struct hyperdex_client_microtransaction* microtransaction,
-                                   const struct hyperdex_client_attribute* attrs, size_t attrs_sz)
-{
-    hyperdex::microtransaction* tx = reinterpret_cast<hyperdex::microtransaction*>(microtransaction);
-    hyperdex_client_returncode *status = tx->status;
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(string_rtrim), strlen(XSTR(string_rtrim)));
-    return cl->uxact_add_funcall(tx, opinfo, attrs, attrs_sz, NULL, 0);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_cond_string_rtrim(struct hyperdex_client* _cl,
-                                  const char* space,
-                                  const char* key, size_t key_sz,
-                                  const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                  const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                  enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_string_rtrim), strlen(XSTR(cond_string_rtrim)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_group_string_rtrim(struct hyperdex_client* _cl,
-                                   const char* space,
-                                   const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                   const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                   enum hyperdex_client_returncode* status,
-                                   uint64_t* count)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_string_rtrim), strlen(XSTR(group_string_rtrim)));
-    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_list_lpush(struct hyperdex_client* _cl,
-                           const char* space,
-                           const char* key, size_t key_sz,
-                           const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                           enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(list_lpush), strlen(XSTR(list_lpush)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_uxact_list_lpush(struct hyperdex_client* _cl,
-                                 struct hyperdex_client_microtransaction* microtransaction,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz)
-{
-    hyperdex::microtransaction* tx = reinterpret_cast<hyperdex::microtransaction*>(microtransaction);
-    hyperdex_client_returncode *status = tx->status;
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(list_lpush), strlen(XSTR(list_lpush)));
-    return cl->uxact_add_funcall(tx, opinfo, attrs, attrs_sz, NULL, 0);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_cond_list_lpush(struct hyperdex_client* _cl,
-                                const char* space,
-                                const char* key, size_t key_sz,
-                                const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_list_lpush), strlen(XSTR(cond_list_lpush)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_group_list_lpush(struct hyperdex_client* _cl,
-                                 const char* space,
-                                 const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                 enum hyperdex_client_returncode* status,
-                                 uint64_t* count)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_list_lpush), strlen(XSTR(group_list_lpush)));
-    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_list_rpush(struct hyperdex_client* _cl,
-                           const char* space,
-                           const char* key, size_t key_sz,
-                           const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                           enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(list_rpush), strlen(XSTR(list_rpush)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_uxact_list_rpush(struct hyperdex_client* _cl,
-                                 struct hyperdex_client_microtransaction* microtransaction,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz)
-{
-    hyperdex::microtransaction* tx = reinterpret_cast<hyperdex::microtransaction*>(microtransaction);
-    hyperdex_client_returncode *status = tx->status;
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(list_rpush), strlen(XSTR(list_rpush)));
-    return cl->uxact_add_funcall(tx, opinfo, attrs, attrs_sz, NULL, 0);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_cond_list_rpush(struct hyperdex_client* _cl,
-                                const char* space,
-                                const char* key, size_t key_sz,
-                                const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_list_rpush), strlen(XSTR(cond_list_rpush)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_group_list_rpush(struct hyperdex_client* _cl,
-                                 const char* space,
-                                 const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                 enum hyperdex_client_returncode* status,
-                                 uint64_t* count)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_list_rpush), strlen(XSTR(group_list_rpush)));
-    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_set_add(struct hyperdex_client* _cl,
-                        const char* space,
-                        const char* key, size_t key_sz,
-                        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                        enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(set_add), strlen(XSTR(set_add)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_cond_set_add(struct hyperdex_client* _cl,
-                             const char* space,
-                             const char* key, size_t key_sz,
-                             const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                             const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                             enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_set_add), strlen(XSTR(cond_set_add)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_group_set_add(struct hyperdex_client* _cl,
-                              const char* space,
-                              const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                              const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                              enum hyperdex_client_returncode* status,
-                              uint64_t* count)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_set_add), strlen(XSTR(group_set_add)));
-    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_set_remove(struct hyperdex_client* _cl,
-                           const char* space,
-                           const char* key, size_t key_sz,
-                           const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                           enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(set_remove), strlen(XSTR(set_remove)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_cond_set_remove(struct hyperdex_client* _cl,
-                                const char* space,
-                                const char* key, size_t key_sz,
-                                const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_set_remove), strlen(XSTR(cond_set_remove)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_group_set_remove(struct hyperdex_client* _cl,
-                                 const char* space,
-                                 const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                 enum hyperdex_client_returncode* status,
-                                 uint64_t* count)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_set_remove), strlen(XSTR(group_set_remove)));
-    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_set_intersect(struct hyperdex_client* _cl,
-                              const char* space,
-                              const char* key, size_t key_sz,
-                              const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                              enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(set_intersect), strlen(XSTR(set_intersect)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_cond_set_intersect(struct hyperdex_client* _cl,
-                                   const char* space,
-                                   const char* key, size_t key_sz,
-                                   const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                   const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                   enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_set_intersect), strlen(XSTR(cond_set_intersect)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_group_set_intersect(struct hyperdex_client* _cl,
-                                    const char* space,
-                                    const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                    const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                    enum hyperdex_client_returncode* status,
-                                    uint64_t* count)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_set_intersect), strlen(XSTR(group_set_intersect)));
-    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_set_union(struct hyperdex_client* _cl,
-                          const char* space,
-                          const char* key, size_t key_sz,
-                          const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                          enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(set_union), strlen(XSTR(set_union)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_cond_set_union(struct hyperdex_client* _cl,
-                               const char* space,
-                               const char* key, size_t key_sz,
-                               const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                               const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                               enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_set_union), strlen(XSTR(cond_set_union)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_group_set_union(struct hyperdex_client* _cl,
-                                const char* space,
-                                const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                enum hyperdex_client_returncode* status,
-                                uint64_t* count)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_set_union), strlen(XSTR(group_set_union)));
-    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_document_rename(struct hyperdex_client* _cl,
-                                const char* space,
-                                const char* key, size_t key_sz,
-                                const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(document_rename), strlen(XSTR(document_rename)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_uxact_document_rename(struct hyperdex_client* _cl,
-                                      struct hyperdex_client_microtransaction* microtransaction,
-                                      const struct hyperdex_client_attribute* attrs, size_t attrs_sz)
-{
-    hyperdex::microtransaction* tx = reinterpret_cast<hyperdex::microtransaction*>(microtransaction);
-    hyperdex_client_returncode *status = tx->status;
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(document_rename), strlen(XSTR(document_rename)));
-    return cl->uxact_add_funcall(tx, opinfo, attrs, attrs_sz, NULL, 0);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_cond_document_rename(struct hyperdex_client* _cl,
-                                     const char* space,
-                                     const char* key, size_t key_sz,
-                                     const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                     const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                     enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_document_rename), strlen(XSTR(cond_document_rename)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_group_document_rename(struct hyperdex_client* _cl,
-                                      const char* space,
-                                      const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                      const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                      enum hyperdex_client_returncode* status,
-                                      uint64_t* count)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_document_rename), strlen(XSTR(group_document_rename)));
-    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_document_unset(struct hyperdex_client* _cl,
-                               const char* space,
-                               const char* key, size_t key_sz,
-                               const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                               enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(document_unset), strlen(XSTR(document_unset)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_uxact_document_unset(struct hyperdex_client* _cl,
-                                     struct hyperdex_client_microtransaction* microtransaction,
-                                     const struct hyperdex_client_attribute* attrs, size_t attrs_sz)
-{
-    hyperdex::microtransaction* tx = reinterpret_cast<hyperdex::microtransaction*>(microtransaction);
-    hyperdex_client_returncode *status = tx->status;
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(document_unset), strlen(XSTR(document_unset)));
-    return cl->uxact_add_funcall(tx, opinfo, attrs, attrs_sz, NULL, 0);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_cond_document_unset(struct hyperdex_client* _cl,
-                                    const char* space,
-                                    const char* key, size_t key_sz,
-                                    const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                    const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                    enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_document_unset), strlen(XSTR(cond_document_unset)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_group_document_unset(struct hyperdex_client* _cl,
-                                     const char* space,
-                                     const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                     const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                     enum hyperdex_client_returncode* status,
-                                     uint64_t* count)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_document_unset), strlen(XSTR(group_document_unset)));
-    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_map_add(struct hyperdex_client* _cl,
-                        const char* space,
-                        const char* key, size_t key_sz,
-                        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                        enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(map_add), strlen(XSTR(map_add)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, NULL, 0, mapattrs, mapattrs_sz, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_cond_map_add(struct hyperdex_client* _cl,
-                             const char* space,
-                             const char* key, size_t key_sz,
-                             const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                             const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                             enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_map_add), strlen(XSTR(cond_map_add)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_group_map_add(struct hyperdex_client* _cl,
-                              const char* space,
-                              const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                              const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                              enum hyperdex_client_returncode* status,
-                              uint64_t* count)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_map_add), strlen(XSTR(group_map_add)));
-    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status, count);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_map_remove(struct hyperdex_client* _cl,
-                           const char* space,
-                           const char* key, size_t key_sz,
-                           const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                           enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(map_remove), strlen(XSTR(map_remove)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_cond_map_remove(struct hyperdex_client* _cl,
-                                const char* space,
-                                const char* key, size_t key_sz,
-                                const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_map_remove), strlen(XSTR(cond_map_remove)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_group_map_remove(struct hyperdex_client* _cl,
-                                 const char* space,
-                                 const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                 enum hyperdex_client_returncode* status,
-                                 uint64_t* count)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_map_remove), strlen(XSTR(group_map_remove)));
-    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_map_atomic_add(struct hyperdex_client* _cl,
-                               const char* space,
-                               const char* key, size_t key_sz,
-                               const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                               enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(map_atomic_add), strlen(XSTR(map_atomic_add)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, NULL, 0, mapattrs, mapattrs_sz, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_cond_map_atomic_add(struct hyperdex_client* _cl,
-                                    const char* space,
-                                    const char* key, size_t key_sz,
-                                    const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                    const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                    enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_map_atomic_add), strlen(XSTR(cond_map_atomic_add)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_group_map_atomic_add(struct hyperdex_client* _cl,
-                                     const char* space,
-                                     const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                     const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                     enum hyperdex_client_returncode* status,
-                                     uint64_t* count)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_map_atomic_add), strlen(XSTR(group_map_atomic_add)));
-    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status, count);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_map_atomic_sub(struct hyperdex_client* _cl,
-                               const char* space,
-                               const char* key, size_t key_sz,
-                               const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                               enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(map_atomic_sub), strlen(XSTR(map_atomic_sub)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, NULL, 0, mapattrs, mapattrs_sz, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_cond_map_atomic_sub(struct hyperdex_client* _cl,
-                                    const char* space,
-                                    const char* key, size_t key_sz,
-                                    const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                    const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                    enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_map_atomic_sub), strlen(XSTR(cond_map_atomic_sub)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_group_map_atomic_sub(struct hyperdex_client* _cl,
-                                     const char* space,
-                                     const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                     const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                     enum hyperdex_client_returncode* status,
-                                     uint64_t* count)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_map_atomic_sub), strlen(XSTR(group_map_atomic_sub)));
-    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status, count);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_map_atomic_mul(struct hyperdex_client* _cl,
-                               const char* space,
-                               const char* key, size_t key_sz,
-                               const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                               enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(map_atomic_mul), strlen(XSTR(map_atomic_mul)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, NULL, 0, mapattrs, mapattrs_sz, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_cond_map_atomic_mul(struct hyperdex_client* _cl,
-                                    const char* space,
-                                    const char* key, size_t key_sz,
-                                    const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                    const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                    enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_map_atomic_mul), strlen(XSTR(cond_map_atomic_mul)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_group_map_atomic_mul(struct hyperdex_client* _cl,
-                                     const char* space,
-                                     const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                     const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                     enum hyperdex_client_returncode* status,
-                                     uint64_t* count)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_map_atomic_mul), strlen(XSTR(group_map_atomic_mul)));
-    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status, count);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_map_atomic_div(struct hyperdex_client* _cl,
-                               const char* space,
-                               const char* key, size_t key_sz,
-                               const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                               enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(map_atomic_div), strlen(XSTR(map_atomic_div)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, NULL, 0, mapattrs, mapattrs_sz, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_cond_map_atomic_div(struct hyperdex_client* _cl,
-                                    const char* space,
-                                    const char* key, size_t key_sz,
-                                    const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                    const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                    enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_map_atomic_div), strlen(XSTR(cond_map_atomic_div)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_group_map_atomic_div(struct hyperdex_client* _cl,
-                                     const char* space,
-                                     const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                     const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                     enum hyperdex_client_returncode* status,
-                                     uint64_t* count)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_map_atomic_div), strlen(XSTR(group_map_atomic_div)));
-    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status, count);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_map_atomic_mod(struct hyperdex_client* _cl,
-                               const char* space,
-                               const char* key, size_t key_sz,
-                               const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                               enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(map_atomic_mod), strlen(XSTR(map_atomic_mod)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, NULL, 0, mapattrs, mapattrs_sz, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_cond_map_atomic_mod(struct hyperdex_client* _cl,
-                                    const char* space,
-                                    const char* key, size_t key_sz,
-                                    const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                    const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                    enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_map_atomic_mod), strlen(XSTR(cond_map_atomic_mod)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_group_map_atomic_mod(struct hyperdex_client* _cl,
-                                     const char* space,
-                                     const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                     const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                     enum hyperdex_client_returncode* status,
-                                     uint64_t* count)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_map_atomic_mod), strlen(XSTR(group_map_atomic_mod)));
-    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status, count);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_map_atomic_and(struct hyperdex_client* _cl,
-                               const char* space,
-                               const char* key, size_t key_sz,
-                               const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                               enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(map_atomic_and), strlen(XSTR(map_atomic_and)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, NULL, 0, mapattrs, mapattrs_sz, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_cond_map_atomic_and(struct hyperdex_client* _cl,
-                                    const char* space,
-                                    const char* key, size_t key_sz,
-                                    const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                    const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                    enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_map_atomic_and), strlen(XSTR(cond_map_atomic_and)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_group_map_atomic_and(struct hyperdex_client* _cl,
-                                     const char* space,
-                                     const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                     const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                     enum hyperdex_client_returncode* status,
-                                     uint64_t* count)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_map_atomic_and), strlen(XSTR(group_map_atomic_and)));
-    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status, count);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_map_atomic_or(struct hyperdex_client* _cl,
-                              const char* space,
-                              const char* key, size_t key_sz,
-                              const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                              enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(map_atomic_or), strlen(XSTR(map_atomic_or)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, NULL, 0, mapattrs, mapattrs_sz, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_cond_map_atomic_or(struct hyperdex_client* _cl,
-                                   const char* space,
-                                   const char* key, size_t key_sz,
-                                   const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                   const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                   enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_map_atomic_or), strlen(XSTR(cond_map_atomic_or)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_group_map_atomic_or(struct hyperdex_client* _cl,
-                                    const char* space,
-                                    const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                    const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                    enum hyperdex_client_returncode* status,
-                                    uint64_t* count)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_map_atomic_or), strlen(XSTR(group_map_atomic_or)));
-    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status, count);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_map_atomic_xor(struct hyperdex_client* _cl,
-                               const char* space,
-                               const char* key, size_t key_sz,
-                               const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                               enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(map_atomic_xor), strlen(XSTR(map_atomic_xor)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, NULL, 0, mapattrs, mapattrs_sz, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_cond_map_atomic_xor(struct hyperdex_client* _cl,
-                                    const char* space,
-                                    const char* key, size_t key_sz,
-                                    const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                    const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                    enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_map_atomic_xor), strlen(XSTR(cond_map_atomic_xor)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_group_map_atomic_xor(struct hyperdex_client* _cl,
-                                     const char* space,
-                                     const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                     const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                     enum hyperdex_client_returncode* status,
-                                     uint64_t* count)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_map_atomic_xor), strlen(XSTR(group_map_atomic_xor)));
-    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status, count);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_map_string_prepend(struct hyperdex_client* _cl,
-                                   const char* space,
-                                   const char* key, size_t key_sz,
-                                   const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                   enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(map_string_prepend), strlen(XSTR(map_string_prepend)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, NULL, 0, mapattrs, mapattrs_sz, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_cond_map_string_prepend(struct hyperdex_client* _cl,
-                                        const char* space,
-                                        const char* key, size_t key_sz,
-                                        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                        enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_map_string_prepend), strlen(XSTR(cond_map_string_prepend)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_group_map_string_prepend(struct hyperdex_client* _cl,
-                                         const char* space,
-                                         const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                         const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                         enum hyperdex_client_returncode* status,
-                                         uint64_t* count)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_map_string_prepend), strlen(XSTR(group_map_string_prepend)));
-    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status, count);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_map_string_append(struct hyperdex_client* _cl,
-                                  const char* space,
-                                  const char* key, size_t key_sz,
-                                  const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                  enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(map_string_append), strlen(XSTR(map_string_append)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, NULL, 0, mapattrs, mapattrs_sz, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_cond_map_string_append(struct hyperdex_client* _cl,
-                                       const char* space,
-                                       const char* key, size_t key_sz,
-                                       const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                       const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                       enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_map_string_append), strlen(XSTR(cond_map_string_append)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_group_map_string_append(struct hyperdex_client* _cl,
-                                        const char* space,
-                                        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                        enum hyperdex_client_returncode* status,
-                                        uint64_t* count)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_map_string_append), strlen(XSTR(group_map_string_append)));
-    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status, count);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_map_atomic_min(struct hyperdex_client* _cl,
-                               const char* space,
-                               const char* key, size_t key_sz,
-                               const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                               enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(map_atomic_min), strlen(XSTR(map_atomic_min)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, NULL, 0, mapattrs, mapattrs_sz, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_cond_map_atomic_min(struct hyperdex_client* _cl,
-                                    const char* space,
-                                    const char* key, size_t key_sz,
-                                    const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                    const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                    enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_map_atomic_min), strlen(XSTR(cond_map_atomic_min)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_group_map_atomic_min(struct hyperdex_client* _cl,
-                                     const char* space,
-                                     const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                     const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                     enum hyperdex_client_returncode* status,
-                                     uint64_t* count)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_map_atomic_min), strlen(XSTR(group_map_atomic_min)));
-    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status, count);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_uxact_atomic_min(struct hyperdex_client* _cl,
-                                 struct hyperdex_client_microtransaction* microtransaction,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz)
-{
-    hyperdex::microtransaction* tx = reinterpret_cast<hyperdex::microtransaction*>(microtransaction);
-    hyperdex_client_returncode *status = tx->status;
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(atomic_min), strlen(XSTR(atomic_min)));
-    return cl->uxact_add_funcall(tx, opinfo, attrs, attrs_sz, NULL, 0);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_map_atomic_max(struct hyperdex_client* _cl,
-                               const char* space,
-                               const char* key, size_t key_sz,
-                               const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                               enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(map_atomic_max), strlen(XSTR(map_atomic_max)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, NULL, 0, mapattrs, mapattrs_sz, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_cond_map_atomic_max(struct hyperdex_client* _cl,
-                                    const char* space,
-                                    const char* key, size_t key_sz,
-                                    const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                    const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                    enum hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_map_atomic_max), strlen(XSTR(cond_map_atomic_max)));
-    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_group_map_atomic_max(struct hyperdex_client* _cl,
-                                     const char* space,
-                                     const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                     const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                     enum hyperdex_client_returncode* status,
-                                     uint64_t* count)
-{
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_map_atomic_max), strlen(XSTR(group_map_atomic_max)));
-    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status, count);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_uxact_atomic_max(struct hyperdex_client* _cl,
-                                 struct hyperdex_client_microtransaction* microtransaction,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz)
-{
-    hyperdex::microtransaction* tx = reinterpret_cast<hyperdex::microtransaction*>(microtransaction);
-    hyperdex_client_returncode *status = tx->status;
-    C_WRAP_EXCEPT(
-    const hyperdex_client_keyop_info* opinfo;
-    opinfo = hyperdex_client_keyop_info_lookup(XSTR(atomic_max), strlen(XSTR(atomic_max)));
-    return cl->uxact_add_funcall(tx, opinfo, attrs, attrs_sz, NULL, 0);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_search(struct hyperdex_client* _cl,
-                       const char* space,
-                       const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                       enum hyperdex_client_returncode* status,
-                       const struct hyperdex_client_attribute** attrs, size_t* attrs_sz)
-{
-    C_WRAP_EXCEPT(
-    return cl->search(space, checks, checks_sz, status, attrs, attrs_sz);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_search_describe(struct hyperdex_client* _cl,
-                                const char* space,
-                                const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                enum hyperdex_client_returncode* status,
-                                const char** description)
-{
-    C_WRAP_EXCEPT(
-    return cl->search_describe(space, checks, checks_sz, status, description);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_sorted_search(struct hyperdex_client* _cl,
-                              const char* space,
-                              const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                              const char* sort_by,
-                              uint64_t limit,
-                              int maxmin,
-                              enum hyperdex_client_returncode* status,
-                              const struct hyperdex_client_attribute** attrs, size_t* attrs_sz)
-{
-    C_WRAP_EXCEPT(
-    return cl->sorted_search(space, checks, checks_sz, sort_by, limit, maxmin, status, attrs, attrs_sz);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_count(struct hyperdex_client* _cl,
-                      const char* space,
-                      const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                      enum hyperdex_client_returncode* status,
-                      uint64_t* count)
-{
-    C_WRAP_EXCEPT(
-    return cl->count(space, checks, checks_sz, status, count);
-    );
-}
-
-HYPERDEX_API int64_t
-hyperdex_client_loop(hyperdex_client* _cl, int timeout,
-                     hyperdex_client_returncode* status)
-{
-    C_WRAP_EXCEPT(
-    return cl->loop(timeout, status);
-    );
-}
-
-HYPERDEX_API int
-hyperdex_client_poll_fd(hyperdex_client* _cl)
-{
-    FAKE_STATUS;
-    C_WRAP_EXCEPT(
-    return cl->poll_fd();
-    );
-}
-
-HYPERDEX_API int
-hyperdex_client_block(hyperdex_client* _cl, int timeout)
-{
-    FAKE_STATUS;
-    C_WRAP_EXCEPT(
-    return cl->block(timeout);
-    );
-}
-
-HYPERDEX_API void
-hyperdex_client_set_type_conversion(hyperdex_client* _cl, bool enabled)
-{
-    hyperdex::client* cl = reinterpret_cast<hyperdex::client*>(_cl);
-    cl->set_type_conversion(enabled);
-}
+	HYPERDEX_API hyperdex_client *
+	hyperdex_client_create(const char *coordinator, uint16_t port)
+	{
+		FAKE_STATUS;
+		SIGNAL_PROTECT_ERR(NULL);
+		try
+		{
+			return reinterpret_cast<hyperdex_client *>(new hyperdex::client(coordinator, port));
+		}
+		catch (std::bad_alloc &ba)
+		{
+			errno = ENOMEM;
+			return NULL;
+		}
+		catch (...)
+		{
+			return NULL;
+		}
+	}
+
+	HYPERDEX_API hyperdex_client *
+	hyperdex_client_create_conn_str(const char *conn_str)
+	{
+		FAKE_STATUS;
+		SIGNAL_PROTECT_ERR(NULL);
+		try
+		{
+			return reinterpret_cast<hyperdex_client *>(new hyperdex::client(conn_str));
+		}
+		catch (std::bad_alloc &ba)
+		{
+			errno = ENOMEM;
+			return NULL;
+		}
+		catch (...)
+		{
+			return NULL;
+		}
+	}
+
+	HYPERDEX_API void
+	hyperdex_client_destroy(hyperdex_client *client)
+	{
+		delete reinterpret_cast<hyperdex::client *>(client);
+	}
+
+	HYPERDEX_API const char *
+	hyperdex_client_error_message(hyperdex_client *_cl)
+	{
+		FAKE_STATUS;
+		SIGNAL_PROTECT_ERR(NULL);
+		hyperdex::client *cl = reinterpret_cast<hyperdex::client *>(_cl);
+		return cl->error_message();
+	}
+
+	HYPERDEX_API const char *
+	hyperdex_client_error_location(hyperdex_client *_cl)
+	{
+		FAKE_STATUS;
+		SIGNAL_PROTECT_ERR(NULL);
+		hyperdex::client *cl = reinterpret_cast<hyperdex::client *>(_cl);
+		return cl->error_location();
+	}
+
+	HYPERDEX_API const char *
+	hyperdex_client_returncode_to_string(enum hyperdex_client_returncode stat)
+	{
+		FAKE_STATUS;
+		SIGNAL_PROTECT_ERR(NULL);
+		switch (stat)
+		{
+			CSTRINGIFY(HYPERDEX_CLIENT_SUCCESS);
+			CSTRINGIFY(HYPERDEX_CLIENT_NOTFOUND);
+			CSTRINGIFY(HYPERDEX_CLIENT_SEARCHDONE);
+			CSTRINGIFY(HYPERDEX_CLIENT_CMPFAIL);
+			CSTRINGIFY(HYPERDEX_CLIENT_READONLY);
+			CSTRINGIFY(HYPERDEX_CLIENT_UNKNOWNSPACE);
+			CSTRINGIFY(HYPERDEX_CLIENT_COORDFAIL);
+			CSTRINGIFY(HYPERDEX_CLIENT_SERVERERROR);
+			CSTRINGIFY(HYPERDEX_CLIENT_POLLFAILED);
+			CSTRINGIFY(HYPERDEX_CLIENT_OVERFLOW);
+			CSTRINGIFY(HYPERDEX_CLIENT_RECONFIGURE);
+			CSTRINGIFY(HYPERDEX_CLIENT_TIMEOUT);
+			CSTRINGIFY(HYPERDEX_CLIENT_UNKNOWNATTR);
+			CSTRINGIFY(HYPERDEX_CLIENT_DUPEATTR);
+			CSTRINGIFY(HYPERDEX_CLIENT_NONEPENDING);
+			CSTRINGIFY(HYPERDEX_CLIENT_DONTUSEKEY);
+			CSTRINGIFY(HYPERDEX_CLIENT_WRONGTYPE);
+			CSTRINGIFY(HYPERDEX_CLIENT_NOMEM);
+			CSTRINGIFY(HYPERDEX_CLIENT_INTERRUPTED);
+			CSTRINGIFY(HYPERDEX_CLIENT_CLUSTER_JUMP);
+			CSTRINGIFY(HYPERDEX_CLIENT_OFFLINE);
+			CSTRINGIFY(HYPERDEX_CLIENT_UNAUTHORIZED);
+			CSTRINGIFY(HYPERDEX_CLIENT_INTERNAL);
+			CSTRINGIFY(HYPERDEX_CLIENT_EXCEPTION);
+			CSTRINGIFY(HYPERDEX_CLIENT_GARBAGE);
+		default:
+			return "unknown hyperdex_client_returncode";
+		}
+	}
+
+	HYPERDEX_API enum hyperdatatype
+	hyperdex_client_attribute_type(hyperdex_client *_cl,
+	                               const char *space, const char *name,
+	                               enum hyperdex_client_returncode *status)
+	{
+		SIGNAL_PROTECT_ERR(HYPERDATATYPE_GARBAGE);
+		hyperdex::client *cl = reinterpret_cast<hyperdex::client *>(_cl);
+		\
+
+		try
+		{
+			return cl->attribute_type(space, name, status);
+		}
+		catch (std::bad_alloc &ba)
+		{
+			errno = ENOMEM;
+			*status = HYPERDEX_CLIENT_NOMEM;
+			cl->set_error_message("out of memory");
+			return HYPERDATATYPE_GARBAGE;
+		}
+		catch (...)
+		{
+			*status = HYPERDEX_CLIENT_EXCEPTION;
+			cl->set_error_message("unhandled exception was thrown");
+			return HYPERDATATYPE_GARBAGE;
+		}
+	}
+
+	HYPERDEX_API void
+	hyperdex_client_destroy_attrs(const hyperdex_client_attribute *attrs, size_t /*attrs_sz*/)
+	{
+		FAKE_STATUS;
+		SIGNAL_PROTECT_VOID;
+		if (attrs)
+		{
+			free(const_cast<hyperdex_client_attribute *>(attrs));
+			attrs = NULL;
+		}
+	}
+
+	HYPERDEX_API void
+	hyperdex_client_clear_auth_context(struct hyperdex_client *_cl)
+	{
+		FAKE_STATUS;
+		SIGNAL_PROTECT_VOID;
+		hyperdex::client *cl = reinterpret_cast<hyperdex::client *>(_cl);
+		cl->clear_auth_context();
+	}
+
+	HYPERDEX_API void
+	hyperdex_client_set_auth_context(struct hyperdex_client *_cl,
+	                                 const char **macaroons, size_t macaroons_sz)
+	{
+		FAKE_STATUS;
+		SIGNAL_PROTECT_VOID;
+		hyperdex::client *cl = reinterpret_cast<hyperdex::client *>(_cl);
+		cl->set_auth_context(macaroons, macaroons_sz);
+	}
+
+	HYPERDEX_API struct hyperdex_client_microtransaction *
+	hyperdex_client_uxact_init(struct hyperdex_client *_cl,
+	                           const char *space,
+	                           enum hyperdex_client_returncode *status)
+	{
+		SIGNAL_PROTECT_ERR(NULL);
+		hyperdex::client *cl = reinterpret_cast<hyperdex::client *>(_cl);
+		hyperdex::microtransaction *tx = cl->uxact_init(space, status);
+		return reinterpret_cast<struct hyperdex_client_microtransaction *>(tx);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_uxact_commit(struct hyperdex_client *_cl,
+	                             struct hyperdex_client_microtransaction *transaction,
+	                             const char *key, size_t key_sz)
+	{
+		hyperdex::microtransaction *tx = reinterpret_cast<hyperdex::microtransaction *>(transaction);
+		hyperdex_client_returncode *status = tx->status;
+		C_WRAP_EXCEPT(
+		    return cl->uxact_commit(tx, key, key_sz);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_uxact_group_commit(struct hyperdex_client *_cl,
+	                                   struct hyperdex_client_microtransaction *transaction,
+	                                   const hyperdex_client_attribute_check *chks, size_t chks_sz,
+	                                   uint64_t *count)
+	{
+		hyperdex::microtransaction *tx = reinterpret_cast<hyperdex::microtransaction *>(transaction);
+		hyperdex_client_returncode *status = tx->status;
+		C_WRAP_EXCEPT(
+		    return cl->uxact_group_commit(tx, chks, chks_sz, count);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_uxact_cond_commit(struct hyperdex_client *_cl,
+	                                  struct hyperdex_client_microtransaction *transaction,
+	                                  const char *key, size_t key_sz,
+	                                  const hyperdex_client_attribute_check *chks, size_t chks_sz)
+	{
+		hyperdex::microtransaction *tx = reinterpret_cast<hyperdex::microtransaction *>(transaction);
+		hyperdex_client_returncode *status = tx->status;
+		C_WRAP_EXCEPT(
+		    return cl->uxact_cond_commit(tx, key, key_sz, chks, chks_sz);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_get(struct hyperdex_client *_cl,
+	                    const char *space,
+	                    const char *key, size_t key_sz,
+	                    enum hyperdex_client_returncode *status,
+	                    const struct hyperdex_client_attribute **attrs, size_t *attrs_sz)
+	{
+		C_WRAP_EXCEPT(
+		    return cl->get(space, key, key_sz, status, attrs, attrs_sz);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_get_partial(struct hyperdex_client *_cl,
+	                            const char *space,
+	                            const char *key, size_t key_sz,
+	                            const char **attrnames, size_t attrnames_sz,
+	                            enum hyperdex_client_returncode *status,
+	                            const struct hyperdex_client_attribute **attrs, size_t *attrs_sz)
+	{
+		C_WRAP_EXCEPT(
+		    return cl->get_partial(space, key, key_sz, attrnames, attrnames_sz, status, attrs, attrs_sz);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_put(struct hyperdex_client *_cl,
+	                    const char *space,
+	                    const char *key, size_t key_sz,
+	                    const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                    enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(put), strlen(XSTR(put)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_uxact_put(struct hyperdex_client *_cl,
+	                          struct hyperdex_client_microtransaction *microtransaction,
+	                          const struct hyperdex_client_attribute *attrs, size_t attrs_sz)
+	{
+		hyperdex::microtransaction *tx = reinterpret_cast<hyperdex::microtransaction *>(microtransaction);
+		hyperdex_client_returncode *status = tx->status;
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(put), strlen(XSTR(put)));
+		    return cl->uxact_add_funcall(tx, opinfo, attrs, attrs_sz, NULL, 0);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_cond_put(struct hyperdex_client *_cl,
+	                         const char *space,
+	                         const char *key, size_t key_sz,
+	                         const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                         const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                         enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_put), strlen(XSTR(cond_put)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_cond_put_or_create(struct hyperdex_client *_cl,
+	                                   const char *space,
+	                                   const char *key, size_t key_sz,
+	                                   const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                   const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                   enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_put_or_create), strlen(XSTR(cond_put_or_create)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_group_put(struct hyperdex_client *_cl,
+	                          const char *space,
+	                          const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                          const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                          enum hyperdex_client_returncode *status,
+	                          uint64_t *count)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_put), strlen(XSTR(group_put)));
+		    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_put_if_not_exist(struct hyperdex_client *_cl,
+	                                 const char *space,
+	                                 const char *key, size_t key_sz,
+	                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                 enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(put_if_not_exist), strlen(XSTR(put_if_not_exist)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_del(struct hyperdex_client *_cl,
+	                    const char *space,
+	                    const char *key, size_t key_sz,
+	                    enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(del), strlen(XSTR(del)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, NULL, 0, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_cond_del(struct hyperdex_client *_cl,
+	                         const char *space,
+	                         const char *key, size_t key_sz,
+	                         const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                         enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_del), strlen(XSTR(cond_del)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, NULL, 0, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_group_del(struct hyperdex_client *_cl,
+	                          const char *space,
+	                          const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                          enum hyperdex_client_returncode *status,
+	                          uint64_t *count)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_del), strlen(XSTR(group_del)));
+		    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, NULL, 0, NULL, 0, status, count);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_atomic_add(struct hyperdex_client *_cl,
+	                           const char *space,
+	                           const char *key, size_t key_sz,
+	                           const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                           enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(atomic_add), strlen(XSTR(atomic_add)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_uxact_atomic_add(struct hyperdex_client *_cl,
+	                                 struct hyperdex_client_microtransaction *microtransaction,
+	                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz)
+	{
+		hyperdex::microtransaction *tx = reinterpret_cast<hyperdex::microtransaction *>(microtransaction);
+		hyperdex_client_returncode *status = tx->status;
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(atomic_add), strlen(XSTR(atomic_add)));
+		    return cl->uxact_add_funcall(tx, opinfo, attrs, attrs_sz, NULL, 0);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_cond_atomic_add(struct hyperdex_client *_cl,
+	                                const char *space,
+	                                const char *key, size_t key_sz,
+	                                const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_atomic_add), strlen(XSTR(cond_atomic_add)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_group_atomic_add(struct hyperdex_client *_cl,
+	                                 const char *space,
+	                                 const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                 enum hyperdex_client_returncode *status,
+	                                 uint64_t *count)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_atomic_add), strlen(XSTR(group_atomic_add)));
+		    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_atomic_sub(struct hyperdex_client *_cl,
+	                           const char *space,
+	                           const char *key, size_t key_sz,
+	                           const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                           enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(atomic_sub), strlen(XSTR(atomic_sub)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_uxact_atomic_sub(struct hyperdex_client *_cl,
+	                                 struct hyperdex_client_microtransaction *microtransaction,
+	                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz)
+	{
+		hyperdex::microtransaction *tx = reinterpret_cast<hyperdex::microtransaction *>(microtransaction);
+		hyperdex_client_returncode *status = tx->status;
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(atomic_sub), strlen(XSTR(atomic_sub)));
+		    return cl->uxact_add_funcall(tx, opinfo, attrs, attrs_sz, NULL, 0);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_cond_atomic_sub(struct hyperdex_client *_cl,
+	                                const char *space,
+	                                const char *key, size_t key_sz,
+	                                const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_atomic_sub), strlen(XSTR(cond_atomic_sub)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_group_atomic_sub(struct hyperdex_client *_cl,
+	                                 const char *space,
+	                                 const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                 enum hyperdex_client_returncode *status,
+	                                 uint64_t *count)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_atomic_sub), strlen(XSTR(group_atomic_sub)));
+		    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_atomic_mul(struct hyperdex_client *_cl,
+	                           const char *space,
+	                           const char *key, size_t key_sz,
+	                           const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                           enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(atomic_mul), strlen(XSTR(atomic_mul)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_uxact_atomic_mul(struct hyperdex_client *_cl,
+	                                 struct hyperdex_client_microtransaction *microtransaction,
+	                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz)
+	{
+		hyperdex::microtransaction *tx = reinterpret_cast<hyperdex::microtransaction *>(microtransaction);
+		hyperdex_client_returncode *status = tx->status;
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(atomic_mul), strlen(XSTR(atomic_mul)));
+		    return cl->uxact_add_funcall(tx, opinfo, attrs, attrs_sz, NULL, 0);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_cond_atomic_mul(struct hyperdex_client *_cl,
+	                                const char *space,
+	                                const char *key, size_t key_sz,
+	                                const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_atomic_mul), strlen(XSTR(cond_atomic_mul)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_group_atomic_mul(struct hyperdex_client *_cl,
+	                                 const char *space,
+	                                 const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                 enum hyperdex_client_returncode *status,
+	                                 uint64_t *count)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_atomic_mul), strlen(XSTR(group_atomic_mul)));
+		    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_atomic_div(struct hyperdex_client *_cl,
+	                           const char *space,
+	                           const char *key, size_t key_sz,
+	                           const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                           enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(atomic_div), strlen(XSTR(atomic_div)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_uxact_atomic_div(struct hyperdex_client *_cl,
+	                                 struct hyperdex_client_microtransaction *microtransaction,
+	                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz)
+	{
+		hyperdex::microtransaction *tx = reinterpret_cast<hyperdex::microtransaction *>(microtransaction);
+		hyperdex_client_returncode *status = tx->status;
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(atomic_div), strlen(XSTR(atomic_div)));
+		    return cl->uxact_add_funcall(tx, opinfo, attrs, attrs_sz, NULL, 0);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_cond_atomic_div(struct hyperdex_client *_cl,
+	                                const char *space,
+	                                const char *key, size_t key_sz,
+	                                const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_atomic_div), strlen(XSTR(cond_atomic_div)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_group_atomic_div(struct hyperdex_client *_cl,
+	                                 const char *space,
+	                                 const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                 enum hyperdex_client_returncode *status,
+	                                 uint64_t *count)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_atomic_div), strlen(XSTR(group_atomic_div)));
+		    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_atomic_mod(struct hyperdex_client *_cl,
+	                           const char *space,
+	                           const char *key, size_t key_sz,
+	                           const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                           enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(atomic_mod), strlen(XSTR(atomic_mod)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_cond_atomic_mod(struct hyperdex_client *_cl,
+	                                const char *space,
+	                                const char *key, size_t key_sz,
+	                                const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_atomic_mod), strlen(XSTR(cond_atomic_mod)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_group_atomic_mod(struct hyperdex_client *_cl,
+	                                 const char *space,
+	                                 const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                 enum hyperdex_client_returncode *status,
+	                                 uint64_t *count)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_atomic_mod), strlen(XSTR(group_atomic_mod)));
+		    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_atomic_and(struct hyperdex_client *_cl,
+	                           const char *space,
+	                           const char *key, size_t key_sz,
+	                           const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                           enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(atomic_and), strlen(XSTR(atomic_and)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_uxact_atomic_and(struct hyperdex_client *_cl,
+	                                 struct hyperdex_client_microtransaction *microtransaction,
+	                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz)
+	{
+		hyperdex::microtransaction *tx = reinterpret_cast<hyperdex::microtransaction *>(microtransaction);
+		hyperdex_client_returncode *status = tx->status;
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(atomic_and), strlen(XSTR(atomic_and)));
+		    return cl->uxact_add_funcall(tx, opinfo, attrs, attrs_sz, NULL, 0);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_cond_atomic_and(struct hyperdex_client *_cl,
+	                                const char *space,
+	                                const char *key, size_t key_sz,
+	                                const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_atomic_and), strlen(XSTR(cond_atomic_and)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_group_atomic_and(struct hyperdex_client *_cl,
+	                                 const char *space,
+	                                 const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                 enum hyperdex_client_returncode *status,
+	                                 uint64_t *count)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_atomic_and), strlen(XSTR(group_atomic_and)));
+		    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_atomic_or(struct hyperdex_client *_cl,
+	                          const char *space,
+	                          const char *key, size_t key_sz,
+	                          const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                          enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(atomic_or), strlen(XSTR(atomic_or)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_uxact_atomic_or(struct hyperdex_client *_cl,
+	                                struct hyperdex_client_microtransaction *microtransaction,
+	                                const struct hyperdex_client_attribute *attrs, size_t attrs_sz)
+	{
+		hyperdex::microtransaction *tx = reinterpret_cast<hyperdex::microtransaction *>(microtransaction);
+		hyperdex_client_returncode *status = tx->status;
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(atomic_or), strlen(XSTR(atomic_or)));
+		    return cl->uxact_add_funcall(tx, opinfo, attrs, attrs_sz, NULL, 0);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_cond_atomic_or(struct hyperdex_client *_cl,
+	                               const char *space,
+	                               const char *key, size_t key_sz,
+	                               const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                               const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                               enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_atomic_or), strlen(XSTR(cond_atomic_or)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_group_atomic_or(struct hyperdex_client *_cl,
+	                                const char *space,
+	                                const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                enum hyperdex_client_returncode *status,
+	                                uint64_t *count)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_atomic_or), strlen(XSTR(group_atomic_or)));
+		    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_atomic_xor(struct hyperdex_client *_cl,
+	                           const char *space,
+	                           const char *key, size_t key_sz,
+	                           const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                           enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(atomic_xor), strlen(XSTR(atomic_xor)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_cond_atomic_xor(struct hyperdex_client *_cl,
+	                                const char *space,
+	                                const char *key, size_t key_sz,
+	                                const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_atomic_xor), strlen(XSTR(cond_atomic_xor)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_group_atomic_xor(struct hyperdex_client *_cl,
+	                                 const char *space,
+	                                 const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                 enum hyperdex_client_returncode *status,
+	                                 uint64_t *count)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_atomic_xor), strlen(XSTR(group_atomic_xor)));
+		    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_atomic_min(struct hyperdex_client *_cl,
+	                           const char *space,
+	                           const char *key, size_t key_sz,
+	                           const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                           enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(atomic_min), strlen(XSTR(atomic_min)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_cond_atomic_min(struct hyperdex_client *_cl,
+	                                const char *space,
+	                                const char *key, size_t key_sz,
+	                                const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_atomic_min), strlen(XSTR(cond_atomic_min)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_group_atomic_min(struct hyperdex_client *_cl,
+	                                 const char *space,
+	                                 const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                 enum hyperdex_client_returncode *status,
+	                                 uint64_t *count)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_atomic_min), strlen(XSTR(group_atomic_min)));
+		    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_atomic_max(struct hyperdex_client *_cl,
+	                           const char *space,
+	                           const char *key, size_t key_sz,
+	                           const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                           enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(atomic_max), strlen(XSTR(atomic_max)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_cond_atomic_max(struct hyperdex_client *_cl,
+	                                const char *space,
+	                                const char *key, size_t key_sz,
+	                                const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_atomic_max), strlen(XSTR(cond_atomic_max)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_group_atomic_max(struct hyperdex_client *_cl,
+	                                 const char *space,
+	                                 const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                 enum hyperdex_client_returncode *status,
+	                                 uint64_t *count)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_atomic_max), strlen(XSTR(group_atomic_max)));
+		    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_string_prepend(struct hyperdex_client *_cl,
+	                               const char *space,
+	                               const char *key, size_t key_sz,
+	                               const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                               enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(string_prepend), strlen(XSTR(string_prepend)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_uxact_string_prepend(struct hyperdex_client *_cl,
+	                                     struct hyperdex_client_microtransaction *microtransaction,
+	                                     const struct hyperdex_client_attribute *attrs, size_t attrs_sz)
+	{
+		hyperdex::microtransaction *tx = reinterpret_cast<hyperdex::microtransaction *>(microtransaction);
+		hyperdex_client_returncode *status = tx->status;
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(string_prepend), strlen(XSTR(string_prepend)));
+		    return cl->uxact_add_funcall(tx, opinfo, attrs, attrs_sz, NULL, 0);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_cond_string_prepend(struct hyperdex_client *_cl,
+	                                    const char *space,
+	                                    const char *key, size_t key_sz,
+	                                    const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                    const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                    enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_string_prepend), strlen(XSTR(cond_string_prepend)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_group_string_prepend(struct hyperdex_client *_cl,
+	                                     const char *space,
+	                                     const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                     const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                     enum hyperdex_client_returncode *status,
+	                                     uint64_t *count)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_string_prepend), strlen(XSTR(group_string_prepend)));
+		    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_string_append(struct hyperdex_client *_cl,
+	                              const char *space,
+	                              const char *key, size_t key_sz,
+	                              const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                              enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(string_append), strlen(XSTR(string_append)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_uxact_string_append(struct hyperdex_client *_cl,
+	                                    struct hyperdex_client_microtransaction *microtransaction,
+	                                    const struct hyperdex_client_attribute *attrs, size_t attrs_sz)
+	{
+		hyperdex::microtransaction *tx = reinterpret_cast<hyperdex::microtransaction *>(microtransaction);
+		hyperdex_client_returncode *status = tx->status;
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(string_append), strlen(XSTR(string_append)));
+		    return cl->uxact_add_funcall(tx, opinfo, attrs, attrs_sz, NULL, 0);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_cond_string_append(struct hyperdex_client *_cl,
+	                                   const char *space,
+	                                   const char *key, size_t key_sz,
+	                                   const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                   const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                   enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_string_append), strlen(XSTR(cond_string_append)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_group_string_append(struct hyperdex_client *_cl,
+	                                    const char *space,
+	                                    const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                    const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                    enum hyperdex_client_returncode *status,
+	                                    uint64_t *count)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_string_append), strlen(XSTR(group_string_append)));
+		    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_string_ltrim(struct hyperdex_client *_cl,
+	                             const char *space,
+	                             const char *key, size_t key_sz,
+	                             const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                             enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(string_ltrim), strlen(XSTR(string_ltrim)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_uxact_string_ltrim(struct hyperdex_client *_cl,
+	                                   struct hyperdex_client_microtransaction *microtransaction,
+	                                   const struct hyperdex_client_attribute *attrs, size_t attrs_sz)
+	{
+		hyperdex::microtransaction *tx = reinterpret_cast<hyperdex::microtransaction *>(microtransaction);
+		hyperdex_client_returncode *status = tx->status;
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(string_ltrim), strlen(XSTR(string_ltrim)));
+		    return cl->uxact_add_funcall(tx, opinfo, attrs, attrs_sz, NULL, 0);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_cond_string_ltrim(struct hyperdex_client *_cl,
+	                                  const char *space,
+	                                  const char *key, size_t key_sz,
+	                                  const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                  const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                  enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_string_ltrim), strlen(XSTR(cond_string_ltrim)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_group_string_ltrim(struct hyperdex_client *_cl,
+	                                   const char *space,
+	                                   const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                   const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                   enum hyperdex_client_returncode *status,
+	                                   uint64_t *count)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_string_ltrim), strlen(XSTR(group_string_ltrim)));
+		    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_string_rtrim(struct hyperdex_client *_cl,
+	                             const char *space,
+	                             const char *key, size_t key_sz,
+	                             const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                             enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(string_rtrim), strlen(XSTR(string_rtrim)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_uxact_string_rtrim(struct hyperdex_client *_cl,
+	                                   struct hyperdex_client_microtransaction *microtransaction,
+	                                   const struct hyperdex_client_attribute *attrs, size_t attrs_sz)
+	{
+		hyperdex::microtransaction *tx = reinterpret_cast<hyperdex::microtransaction *>(microtransaction);
+		hyperdex_client_returncode *status = tx->status;
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(string_rtrim), strlen(XSTR(string_rtrim)));
+		    return cl->uxact_add_funcall(tx, opinfo, attrs, attrs_sz, NULL, 0);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_cond_string_rtrim(struct hyperdex_client *_cl,
+	                                  const char *space,
+	                                  const char *key, size_t key_sz,
+	                                  const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                  const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                  enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_string_rtrim), strlen(XSTR(cond_string_rtrim)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_group_string_rtrim(struct hyperdex_client *_cl,
+	                                   const char *space,
+	                                   const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                   const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                   enum hyperdex_client_returncode *status,
+	                                   uint64_t *count)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_string_rtrim), strlen(XSTR(group_string_rtrim)));
+		    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_list_lpush(struct hyperdex_client *_cl,
+	                           const char *space,
+	                           const char *key, size_t key_sz,
+	                           const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                           enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(list_lpush), strlen(XSTR(list_lpush)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_uxact_list_lpush(struct hyperdex_client *_cl,
+	                                 struct hyperdex_client_microtransaction *microtransaction,
+	                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz)
+	{
+		hyperdex::microtransaction *tx = reinterpret_cast<hyperdex::microtransaction *>(microtransaction);
+		hyperdex_client_returncode *status = tx->status;
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(list_lpush), strlen(XSTR(list_lpush)));
+		    return cl->uxact_add_funcall(tx, opinfo, attrs, attrs_sz, NULL, 0);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_cond_list_lpush(struct hyperdex_client *_cl,
+	                                const char *space,
+	                                const char *key, size_t key_sz,
+	                                const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_list_lpush), strlen(XSTR(cond_list_lpush)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_group_list_lpush(struct hyperdex_client *_cl,
+	                                 const char *space,
+	                                 const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                 enum hyperdex_client_returncode *status,
+	                                 uint64_t *count)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_list_lpush), strlen(XSTR(group_list_lpush)));
+		    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_list_rpush(struct hyperdex_client *_cl,
+	                           const char *space,
+	                           const char *key, size_t key_sz,
+	                           const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                           enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(list_rpush), strlen(XSTR(list_rpush)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_uxact_list_rpush(struct hyperdex_client *_cl,
+	                                 struct hyperdex_client_microtransaction *microtransaction,
+	                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz)
+	{
+		hyperdex::microtransaction *tx = reinterpret_cast<hyperdex::microtransaction *>(microtransaction);
+		hyperdex_client_returncode *status = tx->status;
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(list_rpush), strlen(XSTR(list_rpush)));
+		    return cl->uxact_add_funcall(tx, opinfo, attrs, attrs_sz, NULL, 0);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_cond_list_rpush(struct hyperdex_client *_cl,
+	                                const char *space,
+	                                const char *key, size_t key_sz,
+	                                const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_list_rpush), strlen(XSTR(cond_list_rpush)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_group_list_rpush(struct hyperdex_client *_cl,
+	                                 const char *space,
+	                                 const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                 enum hyperdex_client_returncode *status,
+	                                 uint64_t *count)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_list_rpush), strlen(XSTR(group_list_rpush)));
+		    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_set_add(struct hyperdex_client *_cl,
+	                        const char *space,
+	                        const char *key, size_t key_sz,
+	                        const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                        enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(set_add), strlen(XSTR(set_add)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_cond_set_add(struct hyperdex_client *_cl,
+	                             const char *space,
+	                             const char *key, size_t key_sz,
+	                             const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                             const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                             enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_set_add), strlen(XSTR(cond_set_add)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_group_set_add(struct hyperdex_client *_cl,
+	                              const char *space,
+	                              const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                              const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                              enum hyperdex_client_returncode *status,
+	                              uint64_t *count)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_set_add), strlen(XSTR(group_set_add)));
+		    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_set_remove(struct hyperdex_client *_cl,
+	                           const char *space,
+	                           const char *key, size_t key_sz,
+	                           const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                           enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(set_remove), strlen(XSTR(set_remove)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_cond_set_remove(struct hyperdex_client *_cl,
+	                                const char *space,
+	                                const char *key, size_t key_sz,
+	                                const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_set_remove), strlen(XSTR(cond_set_remove)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_group_set_remove(struct hyperdex_client *_cl,
+	                                 const char *space,
+	                                 const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                 enum hyperdex_client_returncode *status,
+	                                 uint64_t *count)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_set_remove), strlen(XSTR(group_set_remove)));
+		    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_set_intersect(struct hyperdex_client *_cl,
+	                              const char *space,
+	                              const char *key, size_t key_sz,
+	                              const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                              enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(set_intersect), strlen(XSTR(set_intersect)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_cond_set_intersect(struct hyperdex_client *_cl,
+	                                   const char *space,
+	                                   const char *key, size_t key_sz,
+	                                   const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                   const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                   enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_set_intersect), strlen(XSTR(cond_set_intersect)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_group_set_intersect(struct hyperdex_client *_cl,
+	                                    const char *space,
+	                                    const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                    const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                    enum hyperdex_client_returncode *status,
+	                                    uint64_t *count)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_set_intersect), strlen(XSTR(group_set_intersect)));
+		    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_set_union(struct hyperdex_client *_cl,
+	                          const char *space,
+	                          const char *key, size_t key_sz,
+	                          const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                          enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(set_union), strlen(XSTR(set_union)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_cond_set_union(struct hyperdex_client *_cl,
+	                               const char *space,
+	                               const char *key, size_t key_sz,
+	                               const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                               const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                               enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_set_union), strlen(XSTR(cond_set_union)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_group_set_union(struct hyperdex_client *_cl,
+	                                const char *space,
+	                                const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                enum hyperdex_client_returncode *status,
+	                                uint64_t *count)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_set_union), strlen(XSTR(group_set_union)));
+		    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_document_rename(struct hyperdex_client *_cl,
+	                                const char *space,
+	                                const char *key, size_t key_sz,
+	                                const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(document_rename), strlen(XSTR(document_rename)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_uxact_document_rename(struct hyperdex_client *_cl,
+	                                      struct hyperdex_client_microtransaction *microtransaction,
+	                                      const struct hyperdex_client_attribute *attrs, size_t attrs_sz)
+	{
+		hyperdex::microtransaction *tx = reinterpret_cast<hyperdex::microtransaction *>(microtransaction);
+		hyperdex_client_returncode *status = tx->status;
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(document_rename), strlen(XSTR(document_rename)));
+		    return cl->uxact_add_funcall(tx, opinfo, attrs, attrs_sz, NULL, 0);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_cond_document_rename(struct hyperdex_client *_cl,
+	                                     const char *space,
+	                                     const char *key, size_t key_sz,
+	                                     const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                     const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                     enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_document_rename), strlen(XSTR(cond_document_rename)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_group_document_rename(struct hyperdex_client *_cl,
+	                                      const char *space,
+	                                      const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                      const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                      enum hyperdex_client_returncode *status,
+	                                      uint64_t *count)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_document_rename), strlen(XSTR(group_document_rename)));
+		    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_document_unset(struct hyperdex_client *_cl,
+	                               const char *space,
+	                               const char *key, size_t key_sz,
+	                               const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                               enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(document_unset), strlen(XSTR(document_unset)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_uxact_document_unset(struct hyperdex_client *_cl,
+	                                     struct hyperdex_client_microtransaction *microtransaction,
+	                                     const struct hyperdex_client_attribute *attrs, size_t attrs_sz)
+	{
+		hyperdex::microtransaction *tx = reinterpret_cast<hyperdex::microtransaction *>(microtransaction);
+		hyperdex_client_returncode *status = tx->status;
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(document_unset), strlen(XSTR(document_unset)));
+		    return cl->uxact_add_funcall(tx, opinfo, attrs, attrs_sz, NULL, 0);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_cond_document_unset(struct hyperdex_client *_cl,
+	                                    const char *space,
+	                                    const char *key, size_t key_sz,
+	                                    const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                    const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                    enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_document_unset), strlen(XSTR(cond_document_unset)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_group_document_unset(struct hyperdex_client *_cl,
+	                                     const char *space,
+	                                     const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                     const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                     enum hyperdex_client_returncode *status,
+	                                     uint64_t *count)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_document_unset), strlen(XSTR(group_document_unset)));
+		    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_map_add(struct hyperdex_client *_cl,
+	                        const char *space,
+	                        const char *key, size_t key_sz,
+	                        const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                        enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(map_add), strlen(XSTR(map_add)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, NULL, 0, mapattrs, mapattrs_sz, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_cond_map_add(struct hyperdex_client *_cl,
+	                             const char *space,
+	                             const char *key, size_t key_sz,
+	                             const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                             const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                             enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_map_add), strlen(XSTR(cond_map_add)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_group_map_add(struct hyperdex_client *_cl,
+	                              const char *space,
+	                              const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                              const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                              enum hyperdex_client_returncode *status,
+	                              uint64_t *count)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_map_add), strlen(XSTR(group_map_add)));
+		    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status, count);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_map_remove(struct hyperdex_client *_cl,
+	                           const char *space,
+	                           const char *key, size_t key_sz,
+	                           const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                           enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(map_remove), strlen(XSTR(map_remove)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_cond_map_remove(struct hyperdex_client *_cl,
+	                                const char *space,
+	                                const char *key, size_t key_sz,
+	                                const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_map_remove), strlen(XSTR(cond_map_remove)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, NULL, 0, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_group_map_remove(struct hyperdex_client *_cl,
+	                                 const char *space,
+	                                 const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                                 enum hyperdex_client_returncode *status,
+	                                 uint64_t *count)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_map_remove), strlen(XSTR(group_map_remove)));
+		    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, attrs, attrs_sz, NULL, 0, status, count);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_map_atomic_add(struct hyperdex_client *_cl,
+	                               const char *space,
+	                               const char *key, size_t key_sz,
+	                               const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                               enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(map_atomic_add), strlen(XSTR(map_atomic_add)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, NULL, 0, mapattrs, mapattrs_sz, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_cond_map_atomic_add(struct hyperdex_client *_cl,
+	                                    const char *space,
+	                                    const char *key, size_t key_sz,
+	                                    const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                    const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                                    enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_map_atomic_add), strlen(XSTR(cond_map_atomic_add)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_group_map_atomic_add(struct hyperdex_client *_cl,
+	                                     const char *space,
+	                                     const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                     const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                                     enum hyperdex_client_returncode *status,
+	                                     uint64_t *count)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_map_atomic_add), strlen(XSTR(group_map_atomic_add)));
+		    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status, count);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_map_atomic_sub(struct hyperdex_client *_cl,
+	                               const char *space,
+	                               const char *key, size_t key_sz,
+	                               const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                               enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(map_atomic_sub), strlen(XSTR(map_atomic_sub)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, NULL, 0, mapattrs, mapattrs_sz, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_cond_map_atomic_sub(struct hyperdex_client *_cl,
+	                                    const char *space,
+	                                    const char *key, size_t key_sz,
+	                                    const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                    const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                                    enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_map_atomic_sub), strlen(XSTR(cond_map_atomic_sub)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_group_map_atomic_sub(struct hyperdex_client *_cl,
+	                                     const char *space,
+	                                     const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                     const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                                     enum hyperdex_client_returncode *status,
+	                                     uint64_t *count)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_map_atomic_sub), strlen(XSTR(group_map_atomic_sub)));
+		    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status, count);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_map_atomic_mul(struct hyperdex_client *_cl,
+	                               const char *space,
+	                               const char *key, size_t key_sz,
+	                               const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                               enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(map_atomic_mul), strlen(XSTR(map_atomic_mul)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, NULL, 0, mapattrs, mapattrs_sz, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_cond_map_atomic_mul(struct hyperdex_client *_cl,
+	                                    const char *space,
+	                                    const char *key, size_t key_sz,
+	                                    const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                    const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                                    enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_map_atomic_mul), strlen(XSTR(cond_map_atomic_mul)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_group_map_atomic_mul(struct hyperdex_client *_cl,
+	                                     const char *space,
+	                                     const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                     const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                                     enum hyperdex_client_returncode *status,
+	                                     uint64_t *count)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_map_atomic_mul), strlen(XSTR(group_map_atomic_mul)));
+		    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status, count);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_map_atomic_div(struct hyperdex_client *_cl,
+	                               const char *space,
+	                               const char *key, size_t key_sz,
+	                               const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                               enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(map_atomic_div), strlen(XSTR(map_atomic_div)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, NULL, 0, mapattrs, mapattrs_sz, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_cond_map_atomic_div(struct hyperdex_client *_cl,
+	                                    const char *space,
+	                                    const char *key, size_t key_sz,
+	                                    const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                    const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                                    enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_map_atomic_div), strlen(XSTR(cond_map_atomic_div)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_group_map_atomic_div(struct hyperdex_client *_cl,
+	                                     const char *space,
+	                                     const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                     const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                                     enum hyperdex_client_returncode *status,
+	                                     uint64_t *count)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_map_atomic_div), strlen(XSTR(group_map_atomic_div)));
+		    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status, count);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_map_atomic_mod(struct hyperdex_client *_cl,
+	                               const char *space,
+	                               const char *key, size_t key_sz,
+	                               const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                               enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(map_atomic_mod), strlen(XSTR(map_atomic_mod)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, NULL, 0, mapattrs, mapattrs_sz, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_cond_map_atomic_mod(struct hyperdex_client *_cl,
+	                                    const char *space,
+	                                    const char *key, size_t key_sz,
+	                                    const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                    const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                                    enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_map_atomic_mod), strlen(XSTR(cond_map_atomic_mod)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_group_map_atomic_mod(struct hyperdex_client *_cl,
+	                                     const char *space,
+	                                     const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                     const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                                     enum hyperdex_client_returncode *status,
+	                                     uint64_t *count)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_map_atomic_mod), strlen(XSTR(group_map_atomic_mod)));
+		    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status, count);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_map_atomic_and(struct hyperdex_client *_cl,
+	                               const char *space,
+	                               const char *key, size_t key_sz,
+	                               const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                               enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(map_atomic_and), strlen(XSTR(map_atomic_and)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, NULL, 0, mapattrs, mapattrs_sz, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_cond_map_atomic_and(struct hyperdex_client *_cl,
+	                                    const char *space,
+	                                    const char *key, size_t key_sz,
+	                                    const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                    const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                                    enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_map_atomic_and), strlen(XSTR(cond_map_atomic_and)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_group_map_atomic_and(struct hyperdex_client *_cl,
+	                                     const char *space,
+	                                     const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                     const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                                     enum hyperdex_client_returncode *status,
+	                                     uint64_t *count)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_map_atomic_and), strlen(XSTR(group_map_atomic_and)));
+		    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status, count);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_map_atomic_or(struct hyperdex_client *_cl,
+	                              const char *space,
+	                              const char *key, size_t key_sz,
+	                              const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                              enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(map_atomic_or), strlen(XSTR(map_atomic_or)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, NULL, 0, mapattrs, mapattrs_sz, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_cond_map_atomic_or(struct hyperdex_client *_cl,
+	                                   const char *space,
+	                                   const char *key, size_t key_sz,
+	                                   const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                   const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                                   enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_map_atomic_or), strlen(XSTR(cond_map_atomic_or)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_group_map_atomic_or(struct hyperdex_client *_cl,
+	                                    const char *space,
+	                                    const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                    const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                                    enum hyperdex_client_returncode *status,
+	                                    uint64_t *count)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_map_atomic_or), strlen(XSTR(group_map_atomic_or)));
+		    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status, count);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_map_atomic_xor(struct hyperdex_client *_cl,
+	                               const char *space,
+	                               const char *key, size_t key_sz,
+	                               const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                               enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(map_atomic_xor), strlen(XSTR(map_atomic_xor)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, NULL, 0, mapattrs, mapattrs_sz, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_cond_map_atomic_xor(struct hyperdex_client *_cl,
+	                                    const char *space,
+	                                    const char *key, size_t key_sz,
+	                                    const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                    const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                                    enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_map_atomic_xor), strlen(XSTR(cond_map_atomic_xor)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_group_map_atomic_xor(struct hyperdex_client *_cl,
+	                                     const char *space,
+	                                     const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                     const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                                     enum hyperdex_client_returncode *status,
+	                                     uint64_t *count)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_map_atomic_xor), strlen(XSTR(group_map_atomic_xor)));
+		    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status, count);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_map_string_prepend(struct hyperdex_client *_cl,
+	                                   const char *space,
+	                                   const char *key, size_t key_sz,
+	                                   const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                                   enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(map_string_prepend), strlen(XSTR(map_string_prepend)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, NULL, 0, mapattrs, mapattrs_sz, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_cond_map_string_prepend(struct hyperdex_client *_cl,
+	                                        const char *space,
+	                                        const char *key, size_t key_sz,
+	                                        const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                        const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                                        enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_map_string_prepend), strlen(XSTR(cond_map_string_prepend)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_group_map_string_prepend(struct hyperdex_client *_cl,
+	                                         const char *space,
+	                                         const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                         const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                                         enum hyperdex_client_returncode *status,
+	                                         uint64_t *count)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_map_string_prepend), strlen(XSTR(group_map_string_prepend)));
+		    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status, count);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_map_string_append(struct hyperdex_client *_cl,
+	                                  const char *space,
+	                                  const char *key, size_t key_sz,
+	                                  const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                                  enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(map_string_append), strlen(XSTR(map_string_append)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, NULL, 0, mapattrs, mapattrs_sz, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_cond_map_string_append(struct hyperdex_client *_cl,
+	                                       const char *space,
+	                                       const char *key, size_t key_sz,
+	                                       const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                       const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                                       enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_map_string_append), strlen(XSTR(cond_map_string_append)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_group_map_string_append(struct hyperdex_client *_cl,
+	                                        const char *space,
+	                                        const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                        const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                                        enum hyperdex_client_returncode *status,
+	                                        uint64_t *count)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_map_string_append), strlen(XSTR(group_map_string_append)));
+		    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status, count);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_map_atomic_min(struct hyperdex_client *_cl,
+	                               const char *space,
+	                               const char *key, size_t key_sz,
+	                               const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                               enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(map_atomic_min), strlen(XSTR(map_atomic_min)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, NULL, 0, mapattrs, mapattrs_sz, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_cond_map_atomic_min(struct hyperdex_client *_cl,
+	                                    const char *space,
+	                                    const char *key, size_t key_sz,
+	                                    const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                    const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                                    enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_map_atomic_min), strlen(XSTR(cond_map_atomic_min)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_group_map_atomic_min(struct hyperdex_client *_cl,
+	                                     const char *space,
+	                                     const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                     const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                                     enum hyperdex_client_returncode *status,
+	                                     uint64_t *count)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_map_atomic_min), strlen(XSTR(group_map_atomic_min)));
+		    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status, count);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_uxact_atomic_min(struct hyperdex_client *_cl,
+	                                 struct hyperdex_client_microtransaction *microtransaction,
+	                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz)
+	{
+		hyperdex::microtransaction *tx = reinterpret_cast<hyperdex::microtransaction *>(microtransaction);
+		hyperdex_client_returncode *status = tx->status;
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(atomic_min), strlen(XSTR(atomic_min)));
+		    return cl->uxact_add_funcall(tx, opinfo, attrs, attrs_sz, NULL, 0);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_map_atomic_max(struct hyperdex_client *_cl,
+	                               const char *space,
+	                               const char *key, size_t key_sz,
+	                               const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                               enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(map_atomic_max), strlen(XSTR(map_atomic_max)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, NULL, 0, NULL, 0, mapattrs, mapattrs_sz, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_cond_map_atomic_max(struct hyperdex_client *_cl,
+	                                    const char *space,
+	                                    const char *key, size_t key_sz,
+	                                    const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                    const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                                    enum hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(cond_map_atomic_max), strlen(XSTR(cond_map_atomic_max)));
+		    return cl->perform_funcall(opinfo, space, key, key_sz, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_group_map_atomic_max(struct hyperdex_client *_cl,
+	                                     const char *space,
+	                                     const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                     const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                                     enum hyperdex_client_returncode *status,
+	                                     uint64_t *count)
+	{
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(group_map_atomic_max), strlen(XSTR(group_map_atomic_max)));
+		    return cl->perform_group_funcall(opinfo, space, checks, checks_sz, NULL, 0, mapattrs, mapattrs_sz, status, count);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_uxact_atomic_max(struct hyperdex_client *_cl,
+	                                 struct hyperdex_client_microtransaction *microtransaction,
+	                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz)
+	{
+		hyperdex::microtransaction *tx = reinterpret_cast<hyperdex::microtransaction *>(microtransaction);
+		hyperdex_client_returncode *status = tx->status;
+		C_WRAP_EXCEPT(
+		    const hyperdex_client_keyop_info * opinfo;
+		    opinfo = hyperdex_client_keyop_info_lookup(XSTR(atomic_max), strlen(XSTR(atomic_max)));
+		    return cl->uxact_add_funcall(tx, opinfo, attrs, attrs_sz, NULL, 0);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_search(struct hyperdex_client *_cl,
+	                       const char *space,
+	                       const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                       enum hyperdex_client_returncode *status,
+	                       const struct hyperdex_client_attribute **attrs, size_t *attrs_sz)
+	{
+		C_WRAP_EXCEPT(
+		    return cl->search(space, checks, checks_sz, status, attrs, attrs_sz);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_search_describe(struct hyperdex_client *_cl,
+	                                const char *space,
+	                                const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                enum hyperdex_client_returncode *status,
+	                                const char **description)
+	{
+		C_WRAP_EXCEPT(
+		    return cl->search_describe(space, checks, checks_sz, status, description);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_sorted_search(struct hyperdex_client *_cl,
+	                              const char *space,
+	                              const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                              const char *sort_by,
+	                              uint64_t limit,
+	                              int maxmin,
+	                              enum hyperdex_client_returncode *status,
+	                              const struct hyperdex_client_attribute **attrs, size_t *attrs_sz)
+	{
+		C_WRAP_EXCEPT(
+		    return cl->sorted_search(space, checks, checks_sz, sort_by, limit, maxmin, status, attrs, attrs_sz);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_count(struct hyperdex_client *_cl,
+	                      const char *space,
+	                      const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                      enum hyperdex_client_returncode *status,
+	                      uint64_t *count)
+	{
+		C_WRAP_EXCEPT(
+		    return cl->count(space, checks, checks_sz, status, count);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_sum(struct hyperdex_client *_cl,
+	                    const char *space,
+	                    const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                    const char *sum_key,
+	                    enum hyperdex_client_returncode *status,
+	                    uint64_t *total)
+	{
+		C_WRAP_EXCEPT(
+		    return cl->sum(space, checks, checks_sz, sum_key, status, total);
+		);
+	}
+
+	HYPERDEX_API int64_t
+	hyperdex_client_loop(hyperdex_client *_cl, int timeout,
+	                     hyperdex_client_returncode *status)
+	{
+		C_WRAP_EXCEPT(
+		    return cl->loop(timeout, status);
+		);
+	}
+
+	HYPERDEX_API int
+	hyperdex_client_poll_fd(hyperdex_client *_cl)
+	{
+		FAKE_STATUS;
+		C_WRAP_EXCEPT(
+		    return cl->poll_fd();
+		);
+	}
+
+	HYPERDEX_API int
+	hyperdex_client_block(hyperdex_client *_cl, int timeout)
+	{
+		FAKE_STATUS;
+		C_WRAP_EXCEPT(
+		    return cl->block(timeout);
+		);
+	}
+
+	HYPERDEX_API void
+	hyperdex_client_set_type_conversion(hyperdex_client *_cl, bool enabled)
+	{
+		hyperdex::client *cl = reinterpret_cast<hyperdex::client *>(_cl);
+		cl->set_type_conversion(enabled);
+	}
 
 #ifdef __cplusplus
-} // extern "C"
+	} // extern "C"
 #endif // __cplusplus
diff --git a/client/client.cc b/client/client.cc
index 0d858daeb..3aae4ad80 100644
--- a/client/client.cc
+++ b/client/client.cc
@@ -55,6 +55,7 @@
 #include "client/pending_atomic.h"
 #include "client/pending_group_atomic.h"
 #include "client/pending_count.h"
+#include "client/pending_sum.h"
 #include "client/pending_get.h"
 #include "client/pending_get_partial.h"
 #include "client/pending_search.h"
@@ -62,1479 +63,1345 @@
 #include "client/pending_sorted_search.h"
 
 #define ERROR(CODE) \
-    *status = HYPERDEX_CLIENT_ ## CODE; \
-    m_last_error.set_loc(__FILE__, __LINE__); \
-    m_last_error.set_msg()
+	*status = HYPERDEX_CLIENT_ ## CODE; \
+	m_last_error.set_loc(__FILE__, __LINE__); \
+	m_last_error.set_msg()
 
 #define _BUSYBEE_ERROR(BBRC) \
-    case BUSYBEE_ ## BBRC: \
-        ERROR(INTERNAL) << "internal error: BusyBee unexpectedly returned " XSTR(BBRC) << ": please file a bug"
+	case BUSYBEE_ ## BBRC: \
+	ERROR(INTERNAL) << "internal error: BusyBee unexpectedly returned " XSTR(BBRC) << ": please file a bug"
 
 #define BUSYBEE_ERROR_CASE(BBRC) \
-    _BUSYBEE_ERROR(BBRC); \
-    return -1;
+	_BUSYBEE_ERROR(BBRC); \
+	return -1;
 
 #define BUSYBEE_ERROR_CASE_FALSE(BBRC) \
-    _BUSYBEE_ERROR(BBRC); \
-    return false;
+	_BUSYBEE_ERROR(BBRC); \
+	return false;
 
 using hyperdex::client;
 using hyperdex::microtransaction;
 
-client :: client(const char* coordinator, uint16_t port)
-    : m_coord(replicant_client_create(coordinator, port))
-    , m_busybee_mapper(&m_config)
-    , m_busybee(&m_busybee_mapper, 0)
-    , m_config()
-    , m_config_id(-1)
-    , m_config_status()
-    , m_config_state(0)
-    , m_config_data(NULL)
-    , m_config_data_sz(0)
-    , m_next_client_id(1)
-    , m_next_server_nonce(1)
-    , m_flagfd()
-    , m_pending_ops()
-    , m_failed()
-    , m_yieldable()
-    , m_yielding()
-    , m_yielded()
-    , m_last_error()
-    , m_macaroons(NULL)
-    , m_macaroons_sz(0)
-    , m_convert_types(true)
+client :: client(const char *coordinator, uint16_t port)
+	: m_coord(replicant_client_create(coordinator, port))
+	, m_busybee_mapper(&m_config)
+	, m_busybee(&m_busybee_mapper, 0)
+	, m_config()
+	, m_config_id(-1)
+	, m_config_status()
+	, m_config_state(0)
+	, m_config_data(NULL)
+	, m_config_data_sz(0)
+	, m_next_client_id(1)
+	, m_next_server_nonce(1)
+	, m_flagfd()
+	, m_pending_ops()
+	, m_failed()
+	, m_yieldable()
+	, m_yielding()
+	, m_yielded()
+	, m_last_error()
+	, m_macaroons(NULL)
+	, m_macaroons_sz(0)
+	, m_convert_types(true)
 {
-    if (!m_coord)
-    {
-        throw std::bad_alloc();
-    }
-
-    m_busybee.set_external_fd(replicant_client_poll_fd(m_coord));
-    m_busybee.set_external_fd(m_flagfd.poll_fd());
+	if (!m_coord)
+	{
+		throw std::bad_alloc();
+	}
+	m_busybee.set_external_fd(replicant_client_poll_fd(m_coord));
+	m_busybee.set_external_fd(m_flagfd.poll_fd());
 }
 
-client :: client(const char* conn_str)
-    : m_coord(replicant_client_create_conn_str(conn_str))
-    , m_busybee_mapper(&m_config)
-    , m_busybee(&m_busybee_mapper, 0)
-    , m_config()
-    , m_config_id(-1)
-    , m_config_status()
-    , m_config_state(0)
-    , m_config_data(NULL)
-    , m_config_data_sz(0)
-    , m_next_client_id(1)
-    , m_next_server_nonce(1)
-    , m_flagfd()
-    , m_pending_ops()
-    , m_failed()
-    , m_yieldable()
-    , m_yielding()
-    , m_yielded()
-    , m_last_error()
-    , m_macaroons(NULL)
-    , m_macaroons_sz(0)
-    , m_convert_types(true)
+client :: client(const char *conn_str)
+	: m_coord(replicant_client_create_conn_str(conn_str))
+	, m_busybee_mapper(&m_config)
+	, m_busybee(&m_busybee_mapper, 0)
+	, m_config()
+	, m_config_id(-1)
+	, m_config_status()
+	, m_config_state(0)
+	, m_config_data(NULL)
+	, m_config_data_sz(0)
+	, m_next_client_id(1)
+	, m_next_server_nonce(1)
+	, m_flagfd()
+	, m_pending_ops()
+	, m_failed()
+	, m_yieldable()
+	, m_yielding()
+	, m_yielded()
+	, m_last_error()
+	, m_macaroons(NULL)
+	, m_macaroons_sz(0)
+	, m_convert_types(true)
 {
-    if (!m_coord)
-    {
-        throw std::bad_alloc();
-    }
-
-    m_busybee.set_external_fd(replicant_client_poll_fd(m_coord));
-    m_busybee.set_external_fd(m_flagfd.poll_fd());
+	if (!m_coord)
+	{
+		throw std::bad_alloc();
+	}
+	m_busybee.set_external_fd(replicant_client_poll_fd(m_coord));
+	m_busybee.set_external_fd(m_flagfd.poll_fd());
 }
 
 client :: ~client() throw ()
 {
-    replicant_client_destroy(m_coord);
+	replicant_client_destroy(m_coord);
 }
 
 int64_t
-client :: get(const char* space, const char* _key, size_t _key_sz,
-              hyperdex_client_returncode* status,
-              const hyperdex_client_attribute** attrs, size_t* attrs_sz)
+client :: get(const char *space, const char *_key, size_t _key_sz,
+              hyperdex_client_returncode *status,
+              const hyperdex_client_attribute **attrs, size_t *attrs_sz)
 {
-    if (!maintain_coord_connection(status))
-    {
-        return -1;
-    }
-
-    const schema* sc = m_config.get_schema(space);
-
-    if (!sc)
-    {
-        ERROR(UNKNOWNSPACE) << "space \"" << e::strescape(space) << "\" does not exist";
-        return -1;
-    }
-
-    datatype_info* di = datatype_info::lookup(sc->attrs[0].type);
-    assert(di);
-    e::slice key(_key, _key_sz);
-
-    if (!di->validate(key))
-    {
-        ERROR(WRONGTYPE) << "key must be type " << sc->attrs[0].type;
-        return -1;
-    }
-
-    e::intrusive_ptr<pending> op;
-    op = new pending_get(m_next_client_id++, status, attrs, attrs_sz);
-    size_t sz = HYPERDEX_CLIENT_HEADER_SIZE_REQ + pack_size(key);
-    auth_wallet aw(m_macaroons, m_macaroons_sz);
-
-    if (m_macaroons_sz)
-    {
-        sz += pack_size(aw);
-    }
-
-    std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
-    e::packer pa = msg->pack_at(HYPERDEX_CLIENT_HEADER_SIZE_REQ) << key;
-
-    if (m_macaroons_sz)
-    {
-        pa = pa << aw;
-    }
-
-    return send_keyop(space, key, REQ_GET, msg, op, status);
+	if (!maintain_coord_connection(status))
+	{
+		return -1;
+	}
+	const schema *sc = m_config.get_schema(space);
+	if (!sc)
+	{
+		ERROR(UNKNOWNSPACE) << "space \"" << e::strescape(space) << "\" does not exist";
+		return -1;
+	}
+	datatype_info *di = datatype_info::lookup(sc->attrs[0].type);
+	assert(di);
+	e::slice key(_key, _key_sz);
+	if (!di->validate(key))
+	{
+		ERROR(WRONGTYPE) << "key must be type " << sc->attrs[0].type;
+		return -1;
+	}
+	e::intrusive_ptr<pending> op;
+	op = new pending_get(m_next_client_id++, status, attrs, attrs_sz);
+	size_t sz = HYPERDEX_CLIENT_HEADER_SIZE_REQ + pack_size(key);
+	auth_wallet aw(m_macaroons, m_macaroons_sz);
+	if (m_macaroons_sz)
+	{
+		sz += pack_size(aw);
+	}
+	std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
+	e::packer pa = msg->pack_at(HYPERDEX_CLIENT_HEADER_SIZE_REQ) << key;
+	if (m_macaroons_sz)
+	{
+		pa = pa << aw;
+	}
+	return send_keyop(space, key, REQ_GET, msg, op, status);
 }
 
 int64_t
-client :: get_partial(const char* space, const char* _key, size_t _key_sz,
-                      const char** attrnames, size_t attrnames_sz,
-                      hyperdex_client_returncode* status,
-                      const hyperdex_client_attribute** attrs, size_t* attrs_sz)
+client :: get_partial(const char *space, const char *_key, size_t _key_sz,
+                      const char **attrnames, size_t attrnames_sz,
+                      hyperdex_client_returncode *status,
+                      const hyperdex_client_attribute **attrs, size_t *attrs_sz)
 {
-    if (!maintain_coord_connection(status))
-    {
-        return -1;
-    }
-
-    const schema* sc = m_config.get_schema(space);
-
-    if (!sc)
-    {
-        ERROR(UNKNOWNSPACE) << "space \"" << e::strescape(space) << "\" does not exist";
-        return -1;
-    }
-
-    std::vector<uint16_t> attrnums;
-
-    for (size_t i = 0; i < attrnames_sz; ++i)
-    {
-        uint16_t attr = sc->lookup_attr(attrnames[i]);
-
-        if (attr == UINT16_MAX)
-        {
-            ERROR(UNKNOWNATTR) << "attribute \"" << e::strescape(attrnames[i])
-                               << "\" is not an attribute in space \""
-                               << e::strescape(space) << "\"";
-            return -1;
-        }
-
-        if (attr == 0)
-        {
-            ERROR(DONTUSEKEY) << "don't specify the key (\"" << e::strescape(attrnames[i])
-                              << "\") when doing get_partial on space \""
-                               << e::strescape(space) << "\"";
-            return -1;
-        }
-
-        attrnums.push_back(attr);
-    }
-
-    datatype_info* di = datatype_info::lookup(sc->attrs[0].type);
-    assert(di);
-    e::slice key(_key, _key_sz);
-
-    if (!di->validate(key))
-    {
-        ERROR(WRONGTYPE) << "key must be type " << sc->attrs[0].type;
-        return -1;
-    }
-
-    e::intrusive_ptr<pending> op;
-    op = new pending_get_partial(m_next_client_id++, status, attrs, attrs_sz);
-    size_t sz = HYPERDEX_CLIENT_HEADER_SIZE_REQ
-              + pack_size(key)
-              + sizeof(uint64_t) + attrnums.size() * sizeof(uint16_t);
-    auth_wallet aw(m_macaroons, m_macaroons_sz);
-
-    if (m_macaroons_sz)
-    {
-        sz += pack_size(aw);
-    }
-
-    std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
-    e::packer pa = msg->pack_at(HYPERDEX_CLIENT_HEADER_SIZE_REQ);
-    pa = pa << key << attrnums;
-
-    if (m_macaroons_sz)
-    {
-        pa = pa << aw;
-    }
-
-    return send_keyop(space, key, REQ_GET_PARTIAL, msg, op, status);
+	if (!maintain_coord_connection(status))
+	{
+		return -1;
+	}
+	const schema *sc = m_config.get_schema(space);
+	if (!sc)
+	{
+		ERROR(UNKNOWNSPACE) << "space \"" << e::strescape(space) << "\" does not exist";
+		return -1;
+	}
+	std::vector<uint16_t> attrnums;
+	for (size_t i = 0; i < attrnames_sz; ++i)
+	{
+		uint16_t attr = sc->lookup_attr(attrnames[i]);
+		if (attr == UINT16_MAX)
+		{
+			ERROR(UNKNOWNATTR) << "attribute \"" << e::strescape(attrnames[i])
+			                   << "\" is not an attribute in space \""
+			                   << e::strescape(space) << "\"";
+			return -1;
+		}
+		if (attr == 0)
+		{
+			ERROR(DONTUSEKEY) << "don't specify the key (\"" << e::strescape(attrnames[i])
+			                  << "\") when doing get_partial on space \""
+			                  << e::strescape(space) << "\"";
+			return -1;
+		}
+		attrnums.push_back(attr);
+	}
+	datatype_info *di = datatype_info::lookup(sc->attrs[0].type);
+	assert(di);
+	e::slice key(_key, _key_sz);
+	if (!di->validate(key))
+	{
+		ERROR(WRONGTYPE) << "key must be type " << sc->attrs[0].type;
+		return -1;
+	}
+	e::intrusive_ptr<pending> op;
+	op = new pending_get_partial(m_next_client_id++, status, attrs, attrs_sz);
+	size_t sz = HYPERDEX_CLIENT_HEADER_SIZE_REQ
+	            + pack_size(key)
+	            + sizeof(uint64_t) + attrnums.size() * sizeof(uint16_t);
+	auth_wallet aw(m_macaroons, m_macaroons_sz);
+	if (m_macaroons_sz)
+	{
+		sz += pack_size(aw);
+	}
+	std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
+	e::packer pa = msg->pack_at(HYPERDEX_CLIENT_HEADER_SIZE_REQ);
+	pa = pa << key << attrnums;
+	if (m_macaroons_sz)
+	{
+		pa = pa << aw;
+	}
+	return send_keyop(space, key, REQ_GET_PARTIAL, msg, op, status);
 }
 
 #define SEARCH_BOILERPLATE \
-    if (!maintain_coord_connection(status)) \
-    { \
-        return -1; \
-    } \
-    const schema* sc = m_config.get_schema(space); \
-    if (!sc) \
-    { \
-        ERROR(UNKNOWNSPACE) << "space \"" << e::strescape(space) << "\" does not exist"; \
-        return -1; \
-    } \
-    std::vector<attribute_check> checks; \
-    std::vector<virtual_server_id> servers; \
-    e::arena memory; \
-    int64_t ret = prepare_searchop(*sc, space, chks, chks_sz, &memory, status, &checks, &servers); \
-    if (ret < 0) \
-    { \
-        return ret; \
-    }
+	if (!maintain_coord_connection(status)) \
+	{ \
+		return -1; \
+	} \
+	const schema* sc = m_config.get_schema(space); \
+	if (!sc) \
+	{ \
+		ERROR(UNKNOWNSPACE) << "space \"" << e::strescape(space) << "\" does not exist"; \
+		return -1; \
+	} \
+	std::vector<attribute_check> checks; \
+	std::vector<virtual_server_id> servers; \
+	e::arena memory; \
+	int64_t ret = prepare_searchop(*sc, space, chks, chks_sz, &memory, status, &checks, &servers); \
+	if (ret < 0) \
+	{ \
+		return ret; \
+	}
 
 int64_t
-client :: search(const char* space,
-                 const hyperdex_client_attribute_check* chks, size_t chks_sz,
-                 hyperdex_client_returncode* status,
-                 const hyperdex_client_attribute** attrs, size_t* attrs_sz)
+client :: search(const char *space,
+                 const hyperdex_client_attribute_check *chks, size_t chks_sz,
+                 hyperdex_client_returncode *status,
+                 const hyperdex_client_attribute **attrs, size_t *attrs_sz)
 {
-    SEARCH_BOILERPLATE
-    int64_t client_id = m_next_client_id++;
-    e::intrusive_ptr<pending_aggregation> op;
-    op = new pending_search(client_id, status, attrs, attrs_sz);
-    size_t sz = HYPERDEX_CLIENT_HEADER_SIZE_REQ
-              + sizeof(uint64_t)
-              + pack_size(checks);
-    std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
-    msg->pack_at(HYPERDEX_CLIENT_HEADER_SIZE_REQ) << client_id << checks;
-    return perform_aggregation(servers, op, REQ_SEARCH_START, msg, status);
+	SEARCH_BOILERPLATE
+	int64_t client_id = m_next_client_id++;
+	e::intrusive_ptr<pending_aggregation> op;
+	op = new pending_search(client_id, status, attrs, attrs_sz);
+	size_t sz = HYPERDEX_CLIENT_HEADER_SIZE_REQ
+	            + sizeof(uint64_t)
+	            + pack_size(checks);
+	std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
+	msg->pack_at(HYPERDEX_CLIENT_HEADER_SIZE_REQ) << client_id << checks;
+	return perform_aggregation(servers, op, REQ_SEARCH_START, msg, status);
 }
 
 int64_t
-client :: search_describe(const char* space,
-                          const hyperdex_client_attribute_check* chks, size_t chks_sz,
-                          hyperdex_client_returncode* status, const char** description)
+client :: search_describe(const char *space,
+                          const hyperdex_client_attribute_check *chks, size_t chks_sz,
+                          hyperdex_client_returncode *status, const char **description)
 {
-    SEARCH_BOILERPLATE
-    int64_t client_id = m_next_client_id++;
-    e::intrusive_ptr<pending_aggregation> op;
-    op = new pending_search_describe(client_id, status, description);
-    size_t sz = HYPERDEX_CLIENT_HEADER_SIZE_REQ
-              + pack_size(checks);
-    std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
-    msg->pack_at(HYPERDEX_CLIENT_HEADER_SIZE_REQ) << checks;
-    return perform_aggregation(servers, op, REQ_SEARCH_DESCRIBE, msg, status);
+	SEARCH_BOILERPLATE
+	int64_t client_id = m_next_client_id++;
+	e::intrusive_ptr<pending_aggregation> op;
+	op = new pending_search_describe(client_id, status, description);
+	size_t sz = HYPERDEX_CLIENT_HEADER_SIZE_REQ
+	            + pack_size(checks);
+	std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
+	msg->pack_at(HYPERDEX_CLIENT_HEADER_SIZE_REQ) << checks;
+	return perform_aggregation(servers, op, REQ_SEARCH_DESCRIBE, msg, status);
 }
 
 int64_t
-client :: sorted_search(const char* space,
-                        const hyperdex_client_attribute_check* chks, size_t chks_sz,
-                        const char* sort_by,
+client :: sorted_search(const char *space,
+                        const hyperdex_client_attribute_check *chks, size_t chks_sz,
+                        const char *sort_by,
                         uint64_t limit,
                         bool maximize,
-                        hyperdex_client_returncode* status,
-                        const hyperdex_client_attribute** attrs, size_t* attrs_sz)
+                        hyperdex_client_returncode *status,
+                        const hyperdex_client_attribute **attrs, size_t *attrs_sz)
 {
-    SEARCH_BOILERPLATE
-    uint16_t sort_by_num = sc->lookup_attr(sort_by);
-
-    if (sort_by_num == sc->attrs_sz)
-    {
-        ERROR(UNKNOWNATTR) << "\"" << e::strescape(sort_by)
-                           << "\" is not an attribute of space \""
-                           << e::strescape(space) << "\"";
-        return -1 - chks_sz;
-    }
-
-    datatype_info* di = datatype_info::lookup(sc->attrs[sort_by_num].type);
-
-    if (!di->comparable())
-    {
-        ERROR(WRONGTYPE) << "cannot sort by attribute \""
-                         << e::strescape(sort_by)
-                         << "\": it is not comparable";
-        return -1 - chks_sz;
-    }
-
-    int64_t client_id = m_next_client_id++;
-    e::intrusive_ptr<pending_aggregation> op;
-    op = new pending_sorted_search(this, client_id, maximize, limit, sort_by_num, di, status, attrs, attrs_sz);
-    int8_t max = maximize ? 1 : 0;
-    size_t sz = HYPERDEX_CLIENT_HEADER_SIZE_REQ
-              + pack_size(checks)
-              + sizeof(limit)
-              + sizeof(sort_by_num)
-              + sizeof(max);
-    std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
-    msg->pack_at(HYPERDEX_CLIENT_HEADER_SIZE_REQ) << checks << limit << sort_by_num << max;
-    return perform_aggregation(servers, op, REQ_SORTED_SEARCH, msg, status);
+	SEARCH_BOILERPLATE
+	uint16_t sort_by_num = sc->lookup_attr(sort_by);
+	if (sort_by_num == sc->attrs_sz)
+	{
+		ERROR(UNKNOWNATTR) << "\"" << e::strescape(sort_by)
+		                   << "\" is not an attribute of space \""
+		                   << e::strescape(space) << "\"";
+		return -1 - chks_sz;
+	}
+	datatype_info *di = datatype_info::lookup(sc->attrs[sort_by_num].type);
+	if (!di->comparable())
+	{
+		ERROR(WRONGTYPE) << "cannot sort by attribute \""
+		                 << e::strescape(sort_by)
+		                 << "\": it is not comparable";
+		return -1 - chks_sz;
+	}
+	int64_t client_id = m_next_client_id++;
+	e::intrusive_ptr<pending_aggregation> op;
+	op = new pending_sorted_search(this, client_id, maximize, limit, sort_by_num, di, status, attrs, attrs_sz);
+	int8_t max = maximize ? 1 : 0;
+	size_t sz = HYPERDEX_CLIENT_HEADER_SIZE_REQ
+	            + pack_size(checks)
+	            + sizeof(limit)
+	            + sizeof(sort_by_num)
+	            + sizeof(max);
+	std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
+	msg->pack_at(HYPERDEX_CLIENT_HEADER_SIZE_REQ) << checks << limit << sort_by_num << max;
+	return perform_aggregation(servers, op, REQ_SORTED_SEARCH, msg, status);
 }
 
 int64_t
-client :: count(const char* space,
-                const hyperdex_client_attribute_check* chks, size_t chks_sz,
-                hyperdex_client_returncode* status,
-                uint64_t* result)
+client :: count(const char *space,
+                const hyperdex_client_attribute_check *chks, size_t chks_sz,
+                hyperdex_client_returncode *status,
+                uint64_t *result)
 {
-    SEARCH_BOILERPLATE
-    int64_t client_id = m_next_client_id++;
-    e::intrusive_ptr<pending_aggregation> op;
-    op = new pending_count(client_id, status, result);
-    size_t sz = HYPERDEX_CLIENT_HEADER_SIZE_REQ
-              + pack_size(checks);
-    std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
-    msg->pack_at(HYPERDEX_CLIENT_HEADER_SIZE_REQ) << checks;
-    return perform_aggregation(servers, op, REQ_COUNT, msg, status);
+	SEARCH_BOILERPLATE
+	int64_t client_id = m_next_client_id++;
+	e::intrusive_ptr<pending_aggregation> op;
+	op = new pending_count(client_id, status, result);
+	size_t sz = HYPERDEX_CLIENT_HEADER_SIZE_REQ
+	            + pack_size(checks);
+	std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
+	msg->pack_at(HYPERDEX_CLIENT_HEADER_SIZE_REQ) << checks;
+	return perform_aggregation(servers, op, REQ_COUNT, msg, status);
 }
 
 int64_t
-client :: perform_funcall(const hyperdex_client_keyop_info* opinfo,
-                          const char* space, const char* _key, size_t _key_sz,
-                          const hyperdex_client_attribute_check* chks, size_t chks_sz,
-                          const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                          const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                          hyperdex_client_returncode* status)
+client :: sum(const char *space,
+              const hyperdex_client_attribute_check *chks, size_t chks_sz,
+              const char *sum_key,
+              hyperdex_client_returncode *status,
+              uint64_t *result)
 {
-    if (!maintain_coord_connection(status))
-    {
-        return -1;
-    }
-
-    const schema* sc = m_config.get_schema(space);
-
-    if (!sc)
-    {
-        ERROR(UNKNOWNSPACE) << "space \"" << e::strescape(space) << "\" does not exist";
-        return -1;
-    }
-
-    datatype_info* di = datatype_info::lookup(sc->attrs[0].type);
-    assert(di);
-    e::slice key(_key, _key_sz);
-
-    if (!di->validate(key))
-    {
-        ERROR(WRONGTYPE) << "key must be type " << sc->attrs[0].type;
-        return -1;
-    }
-
-    e::intrusive_ptr<pending> op;
-    op = new pending_atomic(m_next_client_id++, status);
-    std::auto_ptr<e::buffer> msg;
-    auth_wallet aw(m_macaroons, m_macaroons_sz);
-    size_t header_sz = HYPERDEX_CLIENT_HEADER_SIZE_REQ
-                     + pack_size(key);
-    size_t footer_sz = 0;
-
-    if (m_macaroons_sz)
-    {
-        footer_sz += pack_size(aw);
-    }
-
-    int64_t ret = perform_funcall(space, sc, opinfo,
-                                  chks, chks_sz,
-                                  attrs, attrs_sz,
-                                  mapattrs, mapattrs_sz,
-                                  header_sz, footer_sz,
-                                  status, &msg);
-
-    if (ret < 0)
-    {
-        return ret;
-    }
-
-    msg->pack_at(HYPERDEX_CLIENT_HEADER_SIZE_REQ) << key;
-
-    if (m_macaroons_sz)
-    {
-        msg->pack_at(msg->capacity() - footer_sz) << aw;
-    }
-
-    return send_keyop(space, key, REQ_ATOMIC, msg, op, status);
+	SEARCH_BOILERPLATE
+	uint16_t sum_idx = sc->lookup_attr(sum_key);
+	if (sum_idx == sc->attrs_sz)
+	{
+		ERROR(UNKNOWNATTR) << "\"" << e::strescape(sum_key)
+		                   << "\" is not an attribute of space \""
+		                   << e::strescape(space) << "\"";
+		return -1 - chks_sz;
+	}
+	datatype_info *di = datatype_info::lookup(sc->attrs[sum_idx].type);
+	if (!di->comparable())
+	{
+		ERROR(WRONGTYPE) << "cannot sort by attribute \""
+		                 << e::strescape(sum_key)
+		                 << "\": it is not comparable";
+		return -1 - chks_sz;
+	}
+	int64_t client_id = m_next_client_id++;
+	e::intrusive_ptr<pending_aggregation> op;
+	op = new pending_sum(client_id, sum_idx, di, status, result);
+	size_t sz = HYPERDEX_CLIENT_HEADER_SIZE_REQ
+	            + pack_size(checks)
+	            + sizeof(sum_idx);
+	std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
+	msg->pack_at(HYPERDEX_CLIENT_HEADER_SIZE_REQ) << checks << sum_idx;
+	return perform_aggregation(servers, op, REQ_SUM, msg, status);
 }
 
 int64_t
-client :: perform_group_funcall(const hyperdex_client_keyop_info* opinfo,
-                                const char* space,
-                                const hyperdex_client_attribute_check* chks, size_t chks_sz,
-                                const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                hyperdex_client_returncode* status,
-                                uint64_t* update_count)
+client :: perform_funcall(const hyperdex_client_keyop_info *opinfo,
+                          const char *space, const char *_key, size_t _key_sz,
+                          const hyperdex_client_attribute_check *chks, size_t chks_sz,
+                          const hyperdex_client_attribute *attrs, size_t attrs_sz,
+                          const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+                          hyperdex_client_returncode *status)
 {
-    SEARCH_BOILERPLATE
-    int64_t client_id = m_next_client_id++;
-    e::intrusive_ptr<pending_aggregation> op;
-    op = new pending_group_atomic(client_id, status, update_count);
-    std::auto_ptr<e::buffer> inner_msg;
-    ret = perform_funcall(space, sc, opinfo,
-                          chks, chks_sz,
-                          attrs, attrs_sz,
-                          mapattrs, mapattrs_sz,
-                          0, 0, status, &inner_msg);
-
-    if (ret < 0)
-    {
-        return ret;
-    }
-
-    size_t sz = HYPERDEX_CLIENT_HEADER_SIZE_REQ
-              + sizeof(uint64_t)
-              + pack_size(checks)
-              + inner_msg->size();
-    std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
-    e::packer pa = msg->pack_at(HYPERDEX_CLIENT_HEADER_SIZE_REQ);
-    e::slice ims = inner_msg->as_slice();
-    pa = pa << checks << e::pack_memmove(ims.data(), ims.size());
-    return perform_aggregation(servers, op, REQ_GROUP_ATOMIC, msg, status);
+	if (!maintain_coord_connection(status))
+	{
+		return -1;
+	}
+	const schema *sc = m_config.get_schema(space);
+	if (!sc)
+	{
+		ERROR(UNKNOWNSPACE) << "space \"" << e::strescape(space) << "\" does not exist";
+		return -1;
+	}
+	datatype_info *di = datatype_info::lookup(sc->attrs[0].type);
+	assert(di);
+	e::slice key(_key, _key_sz);
+	if (!di->validate(key))
+	{
+		ERROR(WRONGTYPE) << "key must be type " << sc->attrs[0].type;
+		return -1;
+	}
+	e::intrusive_ptr<pending> op;
+	op = new pending_atomic(m_next_client_id++, status);
+	std::auto_ptr<e::buffer> msg;
+	auth_wallet aw(m_macaroons, m_macaroons_sz);
+	size_t header_sz = HYPERDEX_CLIENT_HEADER_SIZE_REQ
+	                   + pack_size(key);
+	size_t footer_sz = 0;
+	if (m_macaroons_sz)
+	{
+		footer_sz += pack_size(aw);
+	}
+	int64_t ret = perform_funcall(space, sc, opinfo,
+	                              chks, chks_sz,
+	                              attrs, attrs_sz,
+	                              mapattrs, mapattrs_sz,
+	                              header_sz, footer_sz,
+	                              status, &msg);
+	if (ret < 0)
+	{
+		return ret;
+	}
+	msg->pack_at(HYPERDEX_CLIENT_HEADER_SIZE_REQ) << key;
+	if (m_macaroons_sz)
+	{
+		msg->pack_at(msg->capacity() - footer_sz) << aw;
+	}
+	return send_keyop(space, key, REQ_ATOMIC, msg, op, status);
 }
 
 int64_t
-client :: loop(int timeout, hyperdex_client_returncode* status)
+client :: perform_group_funcall(const hyperdex_client_keyop_info *opinfo,
+                                const char *space,
+                                const hyperdex_client_attribute_check *chks, size_t chks_sz,
+                                const hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+                                hyperdex_client_returncode *status,
+                                uint64_t *update_count)
 {
-    *status = HYPERDEX_CLIENT_SUCCESS;
-    m_last_error = e::error();
-
-    while (m_yielding ||
-           !m_failed.empty() ||
-           !m_yieldable.empty() ||
-           !m_pending_ops.empty())
-    {
-        if (m_yielding)
-        {
-            if (!m_yielding->can_yield())
-            {
-                m_yielding = NULL;
-                continue;
-            }
-
-            if (!m_yielding->yield(status, &m_last_error))
-            {
-                return -1;
-            }
-
-            int64_t client_id = m_yielding->client_visible_id();
-            m_last_error = m_yielding->error();
-
-            if (!m_yielding->can_yield())
-            {
-                m_yielded = m_yielding;
-                m_yielding = NULL;
-            }
-
-            return client_id;
-        }
-        else if (!m_yieldable.empty())
-        {
-            m_yielding = m_yieldable.front();
-            m_yieldable.pop_front();
-            continue;
-        }
-        else if (!m_failed.empty())
-        {
-            const pending_server_pair& psp(m_failed.front());
-            psp.op->handle_failure(psp.si, psp.vsi);
-            m_yielding = psp.op;
-            m_failed.pop_front();
-            continue;
-        }
-
-        m_flagfd.clear();
-        m_yielded = NULL;
-        assert(!m_pending_ops.empty());
-
-        if (!maintain_coord_connection(status))
-        {
-            return -1;
-        }
-
-        uint64_t sid_num;
-        std::auto_ptr<e::buffer> msg;
-        m_busybee.set_timeout(timeout);
-        busybee_returncode rc = m_busybee.recv(&sid_num, &msg);
-        server_id id(sid_num);
-
-        switch (rc)
-        {
-            case BUSYBEE_SUCCESS:
-                break;
-            case BUSYBEE_INTERRUPTED:
-                ERROR(INTERRUPTED) << "signal received";
-                return -1;
-            case BUSYBEE_TIMEOUT:
-                ERROR(TIMEOUT) << "operation timed out";
-                return -1;
-            case BUSYBEE_DISRUPTED:
-                handle_disruption(id);
-                continue;
-            case BUSYBEE_EXTERNAL:
-                continue;
-            BUSYBEE_ERROR_CASE(POLLFAILED);
-            BUSYBEE_ERROR_CASE(ADDFDFAIL);
-            BUSYBEE_ERROR_CASE(SHUTDOWN);
-            default:
-                ERROR(INTERNAL) << "internal error: BusyBee unexpectedly returned "
-                                << (unsigned) rc << ": please file a bug";
-                return -1;
-        }
-
-        e::unpacker up = msg->unpack_from(BUSYBEE_HEADER_SIZE);
-        uint8_t mt;
-        virtual_server_id vfrom;
-        int64_t nonce;
-        up = up >> mt >> vfrom >> nonce;
-
-        if (up.error())
-        {
-            ERROR(SERVERERROR) << "communication error: server "
-                               << sid_num << " sent message="
-                               << msg->as_slice().hex()
-                               << " with invalid header";
-            return -1;
-        }
-
-        network_msgtype msg_type = static_cast<network_msgtype>(mt);
-        pending_map_t::iterator it = m_pending_ops.find(nonce);
-
-        if (it == m_pending_ops.end())
-        {
-            continue;
-        }
-
-        const pending_server_pair psp(it->second);
-        e::intrusive_ptr<pending> op = psp.op;
-        m_pending_ops.erase(it);
-
-        if (msg_type == CONFIGMISMATCH)
-        {
-            m_failed.push_back(psp);
-            continue;
-        }
-
-        if (vfrom == psp.vsi &&
-            id == psp.si &&
-            m_config.get_server_id(vfrom) == id)
-        {
-            if (!op->handle_message(this, id, vfrom, msg_type, msg, up, status, &m_last_error))
-            {
-                return -1;
-            }
-
-            m_yielding = psp.op;
-        }
-        else
-        {
-            ERROR(SERVERERROR) << "wrong server replied for nonce=" << nonce
-                               << ": expected it to come from "
-                               << psp.vsi << "/" << psp.si
-                               << "; it came from "
-                               << vfrom << "/" << id
-                               << "; our config says that virtual_id should map to "
-                               << m_config.get_server_id(vfrom);
-            return -1;
-        }
-    }
-
-    uint64_t sid_num;
-    m_busybee.set_timeout(0);
-    busybee_returncode rc = m_busybee.recv_no_msg(&sid_num);
-
-    switch (rc)
-    {
-        case BUSYBEE_SUCCESS:
-        case BUSYBEE_TIMEOUT:
-            break;
-        case BUSYBEE_INTERRUPTED:
-            ERROR(INTERRUPTED) << "signal received";
-            return -1;
-        case BUSYBEE_DISRUPTED:
-            handle_disruption(server_id(sid_num));
-            break;
-        case BUSYBEE_EXTERNAL:
-            if (!maintain_coord_connection(status))
-            {
-                return -1;
-            }
-            break;
-        BUSYBEE_ERROR_CASE(POLLFAILED);
-        BUSYBEE_ERROR_CASE(ADDFDFAIL);
-        BUSYBEE_ERROR_CASE(SHUTDOWN);
-        default:
-            ERROR(INTERNAL) << "internal error: BusyBee unexpectedly returned "
-                            << (unsigned) rc << ": please file a bug";
-            return -1;
-    }
+	SEARCH_BOILERPLATE
+	int64_t client_id = m_next_client_id++;
+	e::intrusive_ptr<pending_aggregation> op;
+	op = new pending_group_atomic(client_id, status, update_count);
+	std::auto_ptr<e::buffer> inner_msg;
+	ret = perform_funcall(space, sc, opinfo,
+	                      chks, chks_sz,
+	                      attrs, attrs_sz,
+	                      mapattrs, mapattrs_sz,
+	                      0, 0, status, &inner_msg);
+	if (ret < 0)
+	{
+		return ret;
+	}
+	size_t sz = HYPERDEX_CLIENT_HEADER_SIZE_REQ
+	            + sizeof(uint64_t)
+	            + pack_size(checks)
+	            + inner_msg->size();
+	std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
+	e::packer pa = msg->pack_at(HYPERDEX_CLIENT_HEADER_SIZE_REQ);
+	e::slice ims = inner_msg->as_slice();
+	pa = pa << checks << e::pack_memmove(ims.data(), ims.size());
+	return perform_aggregation(servers, op, REQ_GROUP_ATOMIC, msg, status);
+}
 
-    ERROR(NONEPENDING) << "no outstanding operations to process";
-    return -1;
+int64_t
+client :: loop(int timeout, hyperdex_client_returncode *status)
+{
+	*status = HYPERDEX_CLIENT_SUCCESS;
+	m_last_error = e::error();
+	while (m_yielding ||
+	       !m_failed.empty() ||
+	       !m_yieldable.empty() ||
+	       !m_pending_ops.empty())
+	{
+		if (m_yielding)
+		{
+			if (!m_yielding->can_yield())
+			{
+				m_yielding = NULL;
+				continue;
+			}
+			if (!m_yielding->yield(status, &m_last_error))
+			{
+				return -1;
+			}
+			int64_t client_id = m_yielding->client_visible_id();
+			m_last_error = m_yielding->error();
+			if (!m_yielding->can_yield())
+			{
+				m_yielded = m_yielding;
+				m_yielding = NULL;
+			}
+			return client_id;
+		}
+		else if (!m_yieldable.empty())
+		{
+			m_yielding = m_yieldable.front();
+			m_yieldable.pop_front();
+			continue;
+		}
+		else if (!m_failed.empty())
+		{
+			const pending_server_pair &psp(m_failed.front());
+			psp.op->handle_failure(psp.si, psp.vsi);
+			m_yielding = psp.op;
+			m_failed.pop_front();
+			continue;
+		}
+		m_flagfd.clear();
+		m_yielded = NULL;
+		assert(!m_pending_ops.empty());
+		if (!maintain_coord_connection(status))
+		{
+			return -1;
+		}
+		uint64_t sid_num;
+		std::auto_ptr<e::buffer> msg;
+		m_busybee.set_timeout(timeout);
+		busybee_returncode rc = m_busybee.recv(&sid_num, &msg);
+		server_id id(sid_num);
+		switch (rc)
+		{
+		case BUSYBEE_SUCCESS:
+			break;
+		case BUSYBEE_INTERRUPTED:
+			ERROR(INTERRUPTED) << "signal received";
+			return -1;
+		case BUSYBEE_TIMEOUT:
+			ERROR(TIMEOUT) << "operation timed out";
+			return -1;
+		case BUSYBEE_DISRUPTED:
+			handle_disruption(id);
+			continue;
+		case BUSYBEE_EXTERNAL:
+			continue;
+			BUSYBEE_ERROR_CASE(POLLFAILED);
+			BUSYBEE_ERROR_CASE(ADDFDFAIL);
+			BUSYBEE_ERROR_CASE(SHUTDOWN);
+		default:
+			ERROR(INTERNAL) << "internal error: BusyBee unexpectedly returned "
+			                << (unsigned) rc << ": please file a bug";
+			return -1;
+		}
+		e::unpacker up = msg->unpack_from(BUSYBEE_HEADER_SIZE);
+		uint8_t mt;
+		virtual_server_id vfrom;
+		int64_t nonce;
+		up = up >> mt >> vfrom >> nonce;
+		if (up.error())
+		{
+			ERROR(SERVERERROR) << "communication error: server "
+			                   << sid_num << " sent message="
+			                   << msg->as_slice().hex()
+			                   << " with invalid header";
+			return -1;
+		}
+		network_msgtype msg_type = static_cast<network_msgtype>(mt);
+		pending_map_t::iterator it = m_pending_ops.find(nonce);
+		if (it == m_pending_ops.end())
+		{
+			continue;
+		}
+		const pending_server_pair psp(it->second);
+		e::intrusive_ptr<pending> op = psp.op;
+		m_pending_ops.erase(it);
+		if (msg_type == CONFIGMISMATCH)
+		{
+			m_failed.push_back(psp);
+			continue;
+		}
+		if (vfrom == psp.vsi &&
+		    id == psp.si &&
+		    m_config.get_server_id(vfrom) == id)
+		{
+			if (!op->handle_message(this, id, vfrom, msg_type, msg, up, status, &m_last_error))
+			{
+				return -1;
+			}
+			m_yielding = psp.op;
+		}
+		else
+		{
+			ERROR(SERVERERROR) << "wrong server replied for nonce=" << nonce
+			                   << ": expected it to come from "
+			                   << psp.vsi << "/" << psp.si
+			                   << "; it came from "
+			                   << vfrom << "/" << id
+			                   << "; our config says that virtual_id should map to "
+			                   << m_config.get_server_id(vfrom);
+			return -1;
+		}
+	}
+	uint64_t sid_num;
+	m_busybee.set_timeout(0);
+	busybee_returncode rc = m_busybee.recv_no_msg(&sid_num);
+	switch (rc)
+	{
+	case BUSYBEE_SUCCESS:
+	case BUSYBEE_TIMEOUT:
+		break;
+	case BUSYBEE_INTERRUPTED:
+		ERROR(INTERRUPTED) << "signal received";
+		return -1;
+	case BUSYBEE_DISRUPTED:
+		handle_disruption(server_id(sid_num));
+		break;
+	case BUSYBEE_EXTERNAL:
+		if (!maintain_coord_connection(status))
+		{
+			return -1;
+		}
+		break;
+		BUSYBEE_ERROR_CASE(POLLFAILED);
+		BUSYBEE_ERROR_CASE(ADDFDFAIL);
+		BUSYBEE_ERROR_CASE(SHUTDOWN);
+	default:
+		ERROR(INTERNAL) << "internal error: BusyBee unexpectedly returned "
+		                << (unsigned) rc << ": please file a bug";
+		return -1;
+	}
+	ERROR(NONEPENDING) << "no outstanding operations to process";
+	return -1;
 }
 
 int
 client :: poll_fd()
 {
-    return m_busybee.poll_fd();
+	return m_busybee.poll_fd();
 }
 
 void
 client :: adjust_flagfd()
 {
-    if (!m_failed.empty() ||
-        !m_yieldable.empty() ||
-        m_yielding.get())
-    {
-        m_flagfd.set();
-    }
-
-    assert(m_yieldable.empty() || m_flagfd.isset());
+	if (!m_failed.empty() ||
+	    !m_yieldable.empty() ||
+	    m_yielding.get())
+	{
+		m_flagfd.set();
+	}
+	assert(m_yieldable.empty() || m_flagfd.isset());
 }
 
 int
 client :: block(int timeout)
 {
-    pollfd pfd;
-    pfd.fd = m_busybee.poll_fd();
-    pfd.events = POLLIN|POLLHUP;
-    pfd.revents = 0;
-    return ::poll(&pfd, 1, timeout) >= 0 ? 0 : -1;
+	pollfd pfd;
+	pfd.fd = m_busybee.poll_fd();
+	pfd.events = POLLIN | POLLHUP;
+	pfd.revents = 0;
+	return ::poll(&pfd, 1, timeout) >= 0 ? 0 : -1;
 }
 
-const char*
+const char *
 client :: error_message()
 {
-    return m_last_error.msg();
+	return m_last_error.msg();
 }
 
-const char*
+const char *
 client :: error_location()
 {
-    return m_last_error.loc();
+	return m_last_error.loc();
 }
 
 void
-client :: set_error_message(const char* msg)
+client :: set_error_message(const char *msg)
 {
-    m_last_error = e::error();
-    m_last_error.set_loc(__FILE__, __LINE__);
-    m_last_error.set_msg() << msg;
+	m_last_error = e::error();
+	m_last_error.set_loc(__FILE__, __LINE__);
+	m_last_error.set_msg() << msg;
 }
 
 hyperdatatype
-client :: attribute_type(const char* space, const char* name,
-                         hyperdex_client_returncode* status)
+client :: attribute_type(const char *space, const char *name,
+                         hyperdex_client_returncode *status)
 {
-    if (maintain_coord_connection(status) < 0)
-    {
-        return HYPERDATATYPE_GARBAGE;
-    }
-
-    const hyperdex::schema* sc = m_config.get_schema(space);
-
-    if (!sc)
-    {
-        ERROR(UNKNOWNSPACE) << "space \"" << e::strescape(space) << "\" does not exist";
-        return HYPERDATATYPE_GARBAGE;
-    }
-
-    uint16_t attrnum = sc->lookup_attr(name);
-
-    if (attrnum == sc->attrs_sz)
-    {
-        ERROR(UNKNOWNATTR) << "\"" << e::strescape(name)
-                           << "\" is not an attribute of space \""
-                           << e::strescape(space) << "\"";
-        return HYPERDATATYPE_GARBAGE;
-    }
-
-    return sc->attrs[attrnum].type;
+	if (maintain_coord_connection(status) < 0)
+	{
+		return HYPERDATATYPE_GARBAGE;
+	}
+	const hyperdex::schema *sc = m_config.get_schema(space);
+	if (!sc)
+	{
+		ERROR(UNKNOWNSPACE) << "space \"" << e::strescape(space) << "\" does not exist";
+		return HYPERDATATYPE_GARBAGE;
+	}
+	uint16_t attrnum = sc->lookup_attr(name);
+	if (attrnum == sc->attrs_sz)
+	{
+		ERROR(UNKNOWNATTR) << "\"" << e::strescape(name)
+		                   << "\" is not an attribute of space \""
+		                   << e::strescape(space) << "\"";
+		return HYPERDATATYPE_GARBAGE;
+	}
+	return sc->attrs[attrnum].type;
 }
 
 size_t
-client :: prepare_checks(const char* space, const schema& sc,
-                         const hyperdex_client_attribute_check* chks, size_t chks_sz,
-                         e::arena* memory,
-                         hyperdex_client_returncode* status,
-                         std::vector<attribute_check>* checks)
+client :: prepare_checks(const char *space, const schema &sc,
+                         const hyperdex_client_attribute_check *chks, size_t chks_sz,
+                         e::arena *memory,
+                         hyperdex_client_returncode *status,
+                         std::vector<attribute_check> *checks)
 {
-    checks->reserve(checks->size() + chks_sz);
-
-    for (size_t i = 0; i < chks_sz; ++i)
-    {
-        std::string scratch;
-        const char* attr;
-        const char* path;
-        parse_document_path(chks[i].attr, &attr, &path, &scratch);
-        uint16_t attrnum = sc.lookup_attr(attr);
-
-        if (attrnum >= sc.attrs_sz)
-        {
-            ERROR(UNKNOWNATTR) << "\"" << e::strescape(attr)
-                               << "\" is not an attribute of space \""
-                               << e::strescape(space) << "\"";
-            return i;
-        }
-
-        hyperdatatype datatype = chks[i].datatype;
-
-        if (datatype == CONTAINER_TYPE(datatype) &&
-            CONTAINER_TYPE(datatype) == CONTAINER_TYPE(sc.attrs[attrnum].type) &&
-            (chks[i].value_sz == 0 || datatype == HYPERDATATYPE_TIMESTAMP_GENERIC))
-        {
-            datatype = sc.attrs[attrnum].type;
-        }
-
-        attribute_check c;
-        c.attr = attrnum;
-        c.value = e::slice(chks[i].value, chks[i].value_sz);
-        c.datatype = datatype;
-        c.predicate = chks[i].predicate;
-        datatype_info* vtype = datatype_info::lookup(c.datatype);
-
-        if (!vtype->client_to_server(c.value, memory, &c.value))
-        {
-            ERROR(WRONGTYPE) << "check[" << i << "], which is on attribute \""
-                             << e::strescape(sc.attrs[attrnum].name)
-                             << "\", does not meet the constraints of its type";
-            return i;
-        }
-
-        if (!path && datatype == HYPERDATATYPE_DOCUMENT)
-        {
-            // Document datatype always requires a path. Empty means root.
-            path = "";
-        }
-
-        if (path)
-        {
-            size_t path_sz = strlen(path) + 1;
-            size_t sz = path_sz + c.value.size();
-            unsigned char* tmp = NULL;
-            memory->allocate(path_sz + c.value.size(), &tmp);
-            memmove(tmp, path, path_sz);
-            memmove(tmp + path_sz, c.value.data(), c.value.size());
-
-            c.value = e::slice(tmp, sz);
-        }
-
-        if (!validate_attribute_check(sc.attrs[attrnum].type, c))
-        {
-            ERROR(WRONGTYPE) << "invalid predicate on \""
-                             << e::strescape(attr) << "\"";
-            return i;
-        }
-
-        checks->push_back(c);
-    }
-
-    return chks_sz;
+	checks->reserve(checks->size() + chks_sz);
+	for (size_t i = 0; i < chks_sz; ++i)
+	{
+		std::string scratch;
+		const char *attr;
+		const char *path;
+		parse_document_path(chks[i].attr, &attr, &path, &scratch);
+		uint16_t attrnum = sc.lookup_attr(attr);
+		if (attrnum >= sc.attrs_sz)
+		{
+			ERROR(UNKNOWNATTR) << "\"" << e::strescape(attr)
+			                   << "\" is not an attribute of space \""
+			                   << e::strescape(space) << "\"";
+			return i;
+		}
+		hyperdatatype datatype = chks[i].datatype;
+		if (datatype == CONTAINER_TYPE(datatype) &&
+		    CONTAINER_TYPE(datatype) == CONTAINER_TYPE(sc.attrs[attrnum].type) &&
+		    (chks[i].value_sz == 0 || datatype == HYPERDATATYPE_TIMESTAMP_GENERIC))
+		{
+			datatype = sc.attrs[attrnum].type;
+		}
+		attribute_check c;
+		c.attr = attrnum;
+		c.value = e::slice(chks[i].value, chks[i].value_sz);
+		c.datatype = datatype;
+		c.predicate = chks[i].predicate;
+		datatype_info *vtype = datatype_info::lookup(c.datatype);
+		if (!vtype->client_to_server(c.value, memory, &c.value))
+		{
+			ERROR(WRONGTYPE) << "check[" << i << "], which is on attribute \""
+			                 << e::strescape(sc.attrs[attrnum].name)
+			                 << "\", does not meet the constraints of its type";
+			return i;
+		}
+		if (!path && datatype == HYPERDATATYPE_DOCUMENT)
+		{
+			// Document datatype always requires a path. Empty means root.
+			path = "";
+		}
+		if (path)
+		{
+			size_t path_sz = strlen(path) + 1;
+			size_t sz = path_sz + c.value.size();
+			unsigned char *tmp = NULL;
+			memory->allocate(path_sz + c.value.size(), &tmp);
+			memmove(tmp, path, path_sz);
+			memmove(tmp + path_sz, c.value.data(), c.value.size());
+			c.value = e::slice(tmp, sz);
+		}
+		if (!validate_attribute_check(sc.attrs[attrnum].type, c))
+		{
+			ERROR(WRONGTYPE) << "invalid predicate on \""
+			                 << e::strescape(attr) << "\"";
+			return i;
+		}
+		checks->push_back(c);
+	}
+	return chks_sz;
 }
 
 size_t
-client :: prepare_funcs(const char* space, const schema& sc,
-                        const hyperdex_client_keyop_info* opinfo,
-                        const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                        e::arena* memory,
-                        hyperdex_client_returncode* status,
-                        std::vector<funcall>* funcs)
+client :: prepare_funcs(const char *space, const schema &sc,
+                        const hyperdex_client_keyop_info *opinfo,
+                        const hyperdex_client_attribute *attrs, size_t attrs_sz,
+                        e::arena *memory,
+                        hyperdex_client_returncode *status,
+                        std::vector<funcall> *funcs)
 {
-    funcs->reserve(funcs->size() + attrs_sz);
-
-    for (size_t i = 0; i < attrs_sz; ++i)
-    {
-        std::string scratch;
-        const char* attr;
-        const char* path;
-        parse_document_path(attrs[i].attr, &attr, &path, &scratch);
-        uint16_t attrnum = sc.lookup_attr(attr);
-
-        if (attrnum == sc.attrs_sz)
-        {
-            ERROR(UNKNOWNATTR) << "\"" << e::strescape(attr)
-                               << "\" is not an attribute of space \""
-                               << e::strescape(space) << "\"";
-            return i;
-        }
-
-        if (attrnum == 0)
-        {
-            ERROR(DONTUSEKEY) << "attribute \""
-                              << e::strescape(attrs[i].attr)
-                              << "\" is the key and cannot be changed";
-            return i;
-        }
-
-        hyperdatatype datatype = attrs[i].datatype;
-
-        if (datatype == CONTAINER_TYPE(datatype) &&
-            CONTAINER_TYPE(datatype) == CONTAINER_TYPE(sc.attrs[attrnum].type) &&
-            (attrs[i].value_sz == 0 || datatype == HYPERDATATYPE_TIMESTAMP_GENERIC))
-        {
-            datatype = sc.attrs[attrnum].type;
-        }
-
-        if (sc.attrs[attrnum].type == HYPERDATATYPE_MACAROON_SECRET)
-        {
-            datatype = HYPERDATATYPE_MACAROON_SECRET;
-        }
-
-        funcall o;
-        o.attr = attrnum;
-        o.name = opinfo->fname;
-        o.arg1 = e::slice(attrs[i].value, attrs[i].value_sz);
-        o.arg1_datatype = datatype;
-        datatype_info* type = datatype_info::lookup(sc.attrs[attrnum].type);
-        datatype_info* a1type = datatype_info::lookup(o.arg1_datatype);
-
-        if (m_convert_types)
-        {
-            if (!a1type->client_to_server(o.arg1, memory, &o.arg1))
-            {
-                ERROR(WRONGTYPE) << "attribute \""
-                             << e::strescape(attrs[i].attr)
-                             << "\" does not meet the constraints of its type";
-                return i;
-            }
-        }
-
-        if (path != NULL)
-        {
-            o.arg2 = e::slice(path, strlen(path) + 1);
-            o.arg2_datatype = HYPERDATATYPE_STRING;
-        }
-
-        if (!type->check_args(o))
-        {
-            ERROR(WRONGTYPE) << "invalid attribute \""
-                             << e::strescape(attrs[i].attr)
-                             << "\": attribute has the wrong type";
-            return i;
-        }
-
-        funcs->push_back(o);
-    }
-
-    return attrs_sz;
+	funcs->reserve(funcs->size() + attrs_sz);
+	for (size_t i = 0; i < attrs_sz; ++i)
+	{
+		std::string scratch;
+		const char *attr;
+		const char *path;
+		parse_document_path(attrs[i].attr, &attr, &path, &scratch);
+		uint16_t attrnum = sc.lookup_attr(attr);
+		if (attrnum == sc.attrs_sz)
+		{
+			ERROR(UNKNOWNATTR) << "\"" << e::strescape(attr)
+			                   << "\" is not an attribute of space \""
+			                   << e::strescape(space) << "\"";
+			return i;
+		}
+		if (attrnum == 0)
+		{
+			ERROR(DONTUSEKEY) << "attribute \""
+			                  << e::strescape(attrs[i].attr)
+			                  << "\" is the key and cannot be changed";
+			return i;
+		}
+		hyperdatatype datatype = attrs[i].datatype;
+		if (datatype == CONTAINER_TYPE(datatype) &&
+		    CONTAINER_TYPE(datatype) == CONTAINER_TYPE(sc.attrs[attrnum].type) &&
+		    (attrs[i].value_sz == 0 || datatype == HYPERDATATYPE_TIMESTAMP_GENERIC))
+		{
+			datatype = sc.attrs[attrnum].type;
+		}
+		if (sc.attrs[attrnum].type == HYPERDATATYPE_MACAROON_SECRET)
+		{
+			datatype = HYPERDATATYPE_MACAROON_SECRET;
+		}
+		funcall o;
+		o.attr = attrnum;
+		o.name = opinfo->fname;
+		o.arg1 = e::slice(attrs[i].value, attrs[i].value_sz);
+		o.arg1_datatype = datatype;
+		datatype_info *type = datatype_info::lookup(sc.attrs[attrnum].type);
+		datatype_info *a1type = datatype_info::lookup(o.arg1_datatype);
+		if (m_convert_types)
+		{
+			if (!a1type->client_to_server(o.arg1, memory, &o.arg1))
+			{
+				ERROR(WRONGTYPE) << "attribute \""
+				                 << e::strescape(attrs[i].attr)
+				                 << "\" does not meet the constraints of its type";
+				return i;
+			}
+		}
+		if (path != NULL)
+		{
+			o.arg2 = e::slice(path, strlen(path) + 1);
+			o.arg2_datatype = HYPERDATATYPE_STRING;
+		}
+		if (!type->check_args(o))
+		{
+			ERROR(WRONGTYPE) << "invalid attribute \""
+			                 << e::strescape(attrs[i].attr)
+			                 << "\": attribute has the wrong type";
+			return i;
+		}
+		funcs->push_back(o);
+	}
+	return attrs_sz;
 }
 
 size_t
-client :: prepare_funcs(const char* space, const schema& sc,
-                        const hyperdex_client_keyop_info* opinfo,
-                        const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                        e::arena* memory,
-                        hyperdex_client_returncode* status,
-                        std::vector<funcall>* funcs)
+client :: prepare_funcs(const char *space, const schema &sc,
+                        const hyperdex_client_keyop_info *opinfo,
+                        const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+                        e::arena *memory,
+                        hyperdex_client_returncode *status,
+                        std::vector<funcall> *funcs)
 {
-    funcs->reserve(funcs->size() + mapattrs_sz);
-
-    for (size_t i = 0; i < mapattrs_sz; ++i)
-    {
-        uint16_t attrnum = sc.lookup_attr(mapattrs[i].attr);
-
-        if (attrnum == sc.attrs_sz)
-        {
-            ERROR(UNKNOWNATTR) << "\"" << e::strescape(mapattrs[i].attr)
-                               << "\" is not an attribute of space \""
-                               << e::strescape(space) << "\"";
-            return i;
-        }
-
-        if (attrnum == 0)
-        {
-            ERROR(DONTUSEKEY) << "attribute \""
-                              << e::strescape(mapattrs[i].attr)
-                              << "\" is the key and cannot be changed";
-            return i;
-        }
-
-        hyperdatatype k_datatype = mapattrs[i].map_key_datatype;
-
-        if (k_datatype == CONTAINER_TYPE(k_datatype) &&
-            CONTAINER_TYPE(k_datatype) == CONTAINER_TYPE(sc.attrs[attrnum].type) &&
-            mapattrs[i].value_sz == 0)
-        {
-            k_datatype = sc.attrs[attrnum].type;
-        }
-
-        hyperdatatype v_datatype = mapattrs[i].value_datatype;
-
-        if (v_datatype == CONTAINER_TYPE(v_datatype) &&
-            CONTAINER_TYPE(v_datatype) == CONTAINER_TYPE(sc.attrs[attrnum].type) &&
-            mapattrs[i].value_sz == 0)
-        {
-            v_datatype = sc.attrs[attrnum].type;
-        }
-
-        funcall o;
-        o.attr = attrnum;
-        o.name = opinfo->fname;
-        o.arg2 = e::slice(mapattrs[i].map_key, mapattrs[i].map_key_sz);
-        o.arg2_datatype = k_datatype;
-        o.arg1 = e::slice(mapattrs[i].value, mapattrs[i].value_sz);
-        o.arg1_datatype = v_datatype;
-        datatype_info* type = datatype_info::lookup(sc.attrs[attrnum].type);
-        datatype_info* ktype = datatype_info::lookup(k_datatype);
-        datatype_info* vtype = datatype_info::lookup(k_datatype);
-
-        if (!ktype->client_to_server(o.arg2, memory, &o.arg2))
-        {
-            ERROR(WRONGTYPE) << "key of [" << i << "], which modifies attribute \""
-                             << e::strescape(mapattrs[i].attr)
-                             << "\", does not meet the constraints of its type";
-            return i;
-        }
-
-        if (!vtype->client_to_server(o.arg1, memory, &o.arg1))
-        {
-            ERROR(WRONGTYPE) << "value of [" << i << "], which modifies attribute \""
-                             << e::strescape(mapattrs[i].attr)
-                             << "\", does not meet the constraints of its type";
-            return i;
-        }
-
-        if (!type->check_args(o))
-        {
-            ERROR(WRONGTYPE) << "invalid attribute \""
-                             << e::strescape(mapattrs[i].attr)
-                             << "\": attribute has the wrong type";
-            return i;
-        }
-
-        funcs->push_back(o);
-    }
-
-    return mapattrs_sz;
+	funcs->reserve(funcs->size() + mapattrs_sz);
+	for (size_t i = 0; i < mapattrs_sz; ++i)
+	{
+		uint16_t attrnum = sc.lookup_attr(mapattrs[i].attr);
+		if (attrnum == sc.attrs_sz)
+		{
+			ERROR(UNKNOWNATTR) << "\"" << e::strescape(mapattrs[i].attr)
+			                   << "\" is not an attribute of space \""
+			                   << e::strescape(space) << "\"";
+			return i;
+		}
+		if (attrnum == 0)
+		{
+			ERROR(DONTUSEKEY) << "attribute \""
+			                  << e::strescape(mapattrs[i].attr)
+			                  << "\" is the key and cannot be changed";
+			return i;
+		}
+		hyperdatatype k_datatype = mapattrs[i].map_key_datatype;
+		if (k_datatype == CONTAINER_TYPE(k_datatype) &&
+		    CONTAINER_TYPE(k_datatype) == CONTAINER_TYPE(sc.attrs[attrnum].type) &&
+		    mapattrs[i].value_sz == 0)
+		{
+			k_datatype = sc.attrs[attrnum].type;
+		}
+		hyperdatatype v_datatype = mapattrs[i].value_datatype;
+		if (v_datatype == CONTAINER_TYPE(v_datatype) &&
+		    CONTAINER_TYPE(v_datatype) == CONTAINER_TYPE(sc.attrs[attrnum].type) &&
+		    mapattrs[i].value_sz == 0)
+		{
+			v_datatype = sc.attrs[attrnum].type;
+		}
+		funcall o;
+		o.attr = attrnum;
+		o.name = opinfo->fname;
+		o.arg2 = e::slice(mapattrs[i].map_key, mapattrs[i].map_key_sz);
+		o.arg2_datatype = k_datatype;
+		o.arg1 = e::slice(mapattrs[i].value, mapattrs[i].value_sz);
+		o.arg1_datatype = v_datatype;
+		datatype_info *type = datatype_info::lookup(sc.attrs[attrnum].type);
+		datatype_info *ktype = datatype_info::lookup(k_datatype);
+		datatype_info *vtype = datatype_info::lookup(k_datatype);
+		if (!ktype->client_to_server(o.arg2, memory, &o.arg2))
+		{
+			ERROR(WRONGTYPE) << "key of [" << i << "], which modifies attribute \""
+			                 << e::strescape(mapattrs[i].attr)
+			                 << "\", does not meet the constraints of its type";
+			return i;
+		}
+		if (!vtype->client_to_server(o.arg1, memory, &o.arg1))
+		{
+			ERROR(WRONGTYPE) << "value of [" << i << "], which modifies attribute \""
+			                 << e::strescape(mapattrs[i].attr)
+			                 << "\", does not meet the constraints of its type";
+			return i;
+		}
+		if (!type->check_args(o))
+		{
+			ERROR(WRONGTYPE) << "invalid attribute \""
+			                 << e::strescape(mapattrs[i].attr)
+			                 << "\": attribute has the wrong type";
+			return i;
+		}
+		funcs->push_back(o);
+	}
+	return mapattrs_sz;
 }
 
 size_t
-client :: prepare_searchop(const schema& sc,
-                           const char* space,
-                           const hyperdex_client_attribute_check* chks, size_t chks_sz,
-                           e::arena* memory,
-                           hyperdex_client_returncode* status,
-                           std::vector<attribute_check>* checks,
-                           std::vector<virtual_server_id>* servers)
+client :: prepare_searchop(const schema &sc,
+                           const char *space,
+                           const hyperdex_client_attribute_check *chks, size_t chks_sz,
+                           e::arena *memory,
+                           hyperdex_client_returncode *status,
+                           std::vector<attribute_check> *checks,
+                           std::vector<virtual_server_id> *servers)
 {
-    size_t num_checks = prepare_checks(space, sc, chks, chks_sz, memory, status, checks);
-
-    if (num_checks != chks_sz)
-    {
-        return -1 - num_checks;
-    }
-
-    std::stable_sort(checks->begin(), checks->end());
-    m_config.lookup_search(space, *checks, servers); // XXX search guaranteed empty vs. search encounters offline server
-
-    if (servers->empty())
-    {
-        // XXX NOCOMMIT
-        ERROR(INTERNAL) << "there are no servers for the search";
-        *status = HYPERDEX_CLIENT_INTERNAL;
-        return -1;
-    }
-
-    return 0;
+	size_t num_checks = prepare_checks(space, sc, chks, chks_sz, memory, status, checks);
+	if (num_checks != chks_sz)
+	{
+		return -1 - num_checks;
+	}
+	std::stable_sort(checks->begin(), checks->end());
+	m_config.lookup_search(space, *checks, servers); // XXX search guaranteed empty vs. search encounters offline server
+	if (servers->empty())
+	{
+		// XXX NOCOMMIT
+		ERROR(INTERNAL) << "there are no servers for the search";
+		*status = HYPERDEX_CLIENT_INTERNAL;
+		return -1;
+	}
+	return 0;
 }
 
 int64_t
-client :: perform_funcall(const char* space, const schema* sc,
-                          const hyperdex_client_keyop_info* opinfo,
-                          const hyperdex_client_attribute_check* chks, size_t chks_sz,
-                          const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                          const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
+client :: perform_funcall(const char *space, const schema *sc,
+                          const hyperdex_client_keyop_info *opinfo,
+                          const hyperdex_client_attribute_check *chks, size_t chks_sz,
+                          const hyperdex_client_attribute *attrs, size_t attrs_sz,
+                          const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
                           size_t header_sz,
                           size_t footer_sz,
-                          hyperdex_client_returncode* status,
-                          std::auto_ptr<e::buffer>* msg)
+                          hyperdex_client_returncode *status,
+                          std::auto_ptr<e::buffer> *msg)
 {
-    std::vector<attribute_check> checks;
-    std::vector<funcall> funcs;
-    size_t idx = 0;
-    e::arena memory;
-
-    // Prepare the checks
-    idx = prepare_checks(space, *sc, chks, chks_sz, &memory, status, &checks);
-
-    if (idx < chks_sz)
-    {
-        return -2 - idx;
-    }
-
-    // Prepare the attrs
-    idx = prepare_funcs(space, *sc, opinfo, attrs, attrs_sz, &memory, status, &funcs);
-
-    if (idx < attrs_sz)
-    {
-        return -2 - chks_sz - idx;
-    }
-
-    // Prepare the mapattrs
-    idx = prepare_funcs(space, *sc, opinfo, mapattrs, mapattrs_sz, &memory, status, &funcs);
-
-    if (idx < mapattrs_sz)
-    {
-        return -2 - chks_sz - attrs_sz - idx;
-    }
-
-    std::stable_sort(checks.begin(), checks.end());
-    std::stable_sort(funcs.begin(), funcs.end());
-    size_t sz = header_sz + footer_sz
-              + sizeof(uint8_t)
-              + pack_size(checks)
-              + pack_size(funcs);
-    msg->reset(e::buffer::create(sz));
-    uint8_t flags = (opinfo->fail_if_not_found ? 1 : 0)
-                  | (opinfo->fail_if_found ? 2 : 0)
-                  | (opinfo->erase ? 0 : 128)
-                  | (m_macaroons_sz ? 64 : 0);
-    (*msg)->pack_at(header_sz) << flags << checks << funcs;
-    return 0;
+	std::vector<attribute_check> checks;
+	std::vector<funcall> funcs;
+	size_t idx = 0;
+	e::arena memory;
+	// Prepare the checks
+	idx = prepare_checks(space, *sc, chks, chks_sz, &memory, status, &checks);
+	if (idx < chks_sz)
+	{
+		return -2 - idx;
+	}
+	// Prepare the attrs
+	idx = prepare_funcs(space, *sc, opinfo, attrs, attrs_sz, &memory, status, &funcs);
+	if (idx < attrs_sz)
+	{
+		return -2 - chks_sz - idx;
+	}
+	// Prepare the mapattrs
+	idx = prepare_funcs(space, *sc, opinfo, mapattrs, mapattrs_sz, &memory, status, &funcs);
+	if (idx < mapattrs_sz)
+	{
+		return -2 - chks_sz - attrs_sz - idx;
+	}
+	std::stable_sort(checks.begin(), checks.end());
+	std::stable_sort(funcs.begin(), funcs.end());
+	size_t sz = header_sz + footer_sz
+	            + sizeof(uint8_t)
+	            + pack_size(checks)
+	            + pack_size(funcs);
+	msg->reset(e::buffer::create(sz));
+	uint8_t flags = (opinfo->fail_if_not_found ? 1 : 0)
+	                | (opinfo->fail_if_found ? 2 : 0)
+	                | (opinfo->erase ? 0 : 128)
+	                | (m_macaroons_sz ? 64 : 0);
+	(*msg)->pack_at(header_sz) << flags << checks << funcs;
+	return 0;
 }
 
 int64_t
-client :: perform_aggregation(const std::vector<virtual_server_id>& servers,
+client :: perform_aggregation(const std::vector<virtual_server_id> &servers,
                               e::intrusive_ptr<pending_aggregation> _op,
                               network_msgtype mt,
                               std::auto_ptr<e::buffer> msg,
-                              hyperdex_client_returncode* status)
+                              hyperdex_client_returncode *status)
 {
-    e::intrusive_ptr<pending> op(_op.get());
-
-    for (size_t i = 0; i < servers.size(); ++i)
-    {
-        uint64_t nonce = m_next_server_nonce++;
-        pending_server_pair psp(m_config.get_server_id(servers[i]), servers[i], op);
-        std::auto_ptr<e::buffer> msg_copy(msg->copy());
-
-        if (!send(mt, psp.vsi, nonce, msg_copy, op, status))
-        {
-            m_failed.push_back(psp);
-        }
-    }
-
-    return op->client_visible_id();
+	e::intrusive_ptr<pending> op(_op.get());
+	for (size_t i = 0; i < servers.size(); ++i)
+	{
+		uint64_t nonce = m_next_server_nonce++;
+		pending_server_pair psp(m_config.get_server_id(servers[i]), servers[i], op);
+		std::auto_ptr<e::buffer> msg_copy(msg->copy());
+		if (!send(mt, psp.vsi, nonce, msg_copy, op, status))
+		{
+			m_failed.push_back(psp);
+		}
+	}
+	return op->client_visible_id();
 }
 
 bool
-client :: maintain_coord_connection(hyperdex_client_returncode* status)
+client :: maintain_coord_connection(hyperdex_client_returncode *status)
 {
-    if (m_config_status != REPLICANT_SUCCESS)
-    {
-        replicant_client_kill(m_coord, m_config_id);
-        m_config_id = -1;
-    }
-
-    replicant_returncode rc;
-
-    if (m_config_id < 0)
-    {
-        m_config_status = REPLICANT_SUCCESS;
-        m_config_id = replicant_client_cond_follow(m_coord, "hyperdex", "config",
-                                                   &m_config_status, &m_config_state,
-                                                   &m_config_data, &m_config_data_sz);
-        if (replicant_client_wait(m_coord, m_config_id, -1, &rc) < 0)
-        {
-            ERROR(COORDFAIL) << "coordinator failure: " << replicant_client_error_message(m_coord);
-            return false;
-        }
-    }
-
-    if (replicant_client_loop(m_coord, 0, &rc) < 0)
-    {
-        if (rc == REPLICANT_INTERRUPTED)
-        {
-            ERROR(INTERRUPTED) << "interrupted by a signal";
-            return false;
-        }
-        else if (rc != REPLICANT_NONE_PENDING && rc != REPLICANT_TIMEOUT)
-        {
-            ERROR(COORDFAIL) << "coordinator failure: " << replicant_client_error_message(m_coord);
-            return false;
-        }
-    }
-
-    if (m_config.version() < m_config_state)
-    {
-        configuration new_config;
-        e::unpacker up(m_config_data, m_config_data_sz);
-        up = up >> new_config;
-
-        if (!up.error())
-        {
-            m_config = new_config;
-        }
-
-        pending_map_t::iterator it = m_pending_ops.begin();
-
-        while (it != m_pending_ops.end())
-        {
-            // If the mapping that was true when the operation started is no
-            // longer true, we fail the operation with a RECONFIGURE.
-            if (m_config.get_server_id(it->second.vsi) != it->second.si)
-            {
-                m_failed.push_back(it->second);
-                m_pending_ops.erase(it);
-                it = m_pending_ops.begin();
-            }
-            else
-            {
-                ++it;
-            }
-        }
-    }
-
-    return true;
+	if (m_config_status != REPLICANT_SUCCESS)
+	{
+		replicant_client_kill(m_coord, m_config_id);
+		m_config_id = -1;
+	}
+	replicant_returncode rc;
+	if (m_config_id < 0)
+	{
+		m_config_status = REPLICANT_SUCCESS;
+		m_config_id = replicant_client_cond_follow(m_coord, "hyperdex", "config",
+		                                           &m_config_status, &m_config_state,
+		                                           &m_config_data, &m_config_data_sz);
+		if (replicant_client_wait(m_coord, m_config_id, -1, &rc) < 0)
+		{
+			ERROR(COORDFAIL) << "coordinator failure: " << replicant_client_error_message(m_coord);
+			return false;
+		}
+	}
+	if (replicant_client_loop(m_coord, 0, &rc) < 0)
+	{
+		if (rc == REPLICANT_INTERRUPTED)
+		{
+			ERROR(INTERRUPTED) << "interrupted by a signal";
+			return false;
+		}
+		else if (rc != REPLICANT_NONE_PENDING && rc != REPLICANT_TIMEOUT)
+		{
+			ERROR(COORDFAIL) << "coordinator failure: " << replicant_client_error_message(m_coord);
+			return false;
+		}
+	}
+	if (m_config.version() < m_config_state)
+	{
+		configuration new_config;
+		e::unpacker up(m_config_data, m_config_data_sz);
+		up = up >> new_config;
+		if (!up.error())
+		{
+			m_config = new_config;
+		}
+		pending_map_t::iterator it = m_pending_ops.begin();
+		while (it != m_pending_ops.end())
+		{
+			// If the mapping that was true when the operation started is no
+			// longer true, we fail the operation with a RECONFIGURE.
+			if (m_config.get_server_id(it->second.vsi) != it->second.si)
+			{
+				m_failed.push_back(it->second);
+				m_pending_ops.erase(it);
+				it = m_pending_ops.begin();
+			}
+			else
+			{
+				++it;
+			}
+		}
+	}
+	return true;
 }
 
 bool
 client :: send(network_msgtype mt,
-               const virtual_server_id& to,
+               const virtual_server_id &to,
                uint64_t nonce,
                std::auto_ptr<e::buffer> msg,
                e::intrusive_ptr<pending> op,
-               hyperdex_client_returncode* status)
+               hyperdex_client_returncode *status)
 {
-    const uint8_t type = static_cast<uint8_t>(mt);
-    const uint8_t flags = 0;
-    const uint64_t version = m_config.version();
-    msg->pack_at(BUSYBEE_HEADER_SIZE)
-        << type << flags << version << to << nonce;
-    server_id id = m_config.get_server_id(to);
-    m_busybee.set_timeout(-1);
-    busybee_returncode rc = m_busybee.send(id.get(), msg);
-
-    switch (rc)
-    {
-        case BUSYBEE_SUCCESS:
-            op->handle_sent_to(id, to);
-            m_pending_ops.insert(std::make_pair(nonce, pending_server_pair(id, to, op)));
-            return true;
-        case BUSYBEE_DISRUPTED:
-            handle_disruption(id);
-            ERROR(SERVERERROR) << "server " << id.get() << " had a communication disruption";
-            return false;
-        BUSYBEE_ERROR_CASE_FALSE(SHUTDOWN);
-        BUSYBEE_ERROR_CASE_FALSE(POLLFAILED);
-        BUSYBEE_ERROR_CASE_FALSE(ADDFDFAIL);
-        BUSYBEE_ERROR_CASE_FALSE(TIMEOUT);
-        BUSYBEE_ERROR_CASE_FALSE(EXTERNAL);
-        BUSYBEE_ERROR_CASE_FALSE(INTERRUPTED);
-        default:
-            ERROR(INTERNAL) << "internal error: BusyBee unexpectedly returned "
-                                << (unsigned) rc << ": please file a bug";
-            return false;
-    }
+	const uint8_t type = static_cast<uint8_t>(mt);
+	const uint8_t flags = 0;
+	const uint64_t version = m_config.version();
+	msg->pack_at(BUSYBEE_HEADER_SIZE)
+	        << type << flags << version << to << nonce;
+	server_id id = m_config.get_server_id(to);
+	m_busybee.set_timeout(-1);
+	busybee_returncode rc = m_busybee.send(id.get(), msg);
+	switch (rc)
+	{
+	case BUSYBEE_SUCCESS:
+		op->handle_sent_to(id, to);
+		m_pending_ops.insert(std::make_pair(nonce, pending_server_pair(id, to, op)));
+		return true;
+	case BUSYBEE_DISRUPTED:
+		handle_disruption(id);
+		ERROR(SERVERERROR) << "server " << id.get() << " had a communication disruption";
+		return false;
+		BUSYBEE_ERROR_CASE_FALSE(SHUTDOWN);
+		BUSYBEE_ERROR_CASE_FALSE(POLLFAILED);
+		BUSYBEE_ERROR_CASE_FALSE(ADDFDFAIL);
+		BUSYBEE_ERROR_CASE_FALSE(TIMEOUT);
+		BUSYBEE_ERROR_CASE_FALSE(EXTERNAL);
+		BUSYBEE_ERROR_CASE_FALSE(INTERRUPTED);
+	default:
+		ERROR(INTERNAL) << "internal error: BusyBee unexpectedly returned "
+		                << (unsigned) rc << ": please file a bug";
+		return false;
+	}
 }
 
 int64_t
-client :: send_keyop(const char* space,
-                     const e::slice& key,
+client :: send_keyop(const char *space,
+                     const e::slice &key,
                      network_msgtype mt,
                      std::auto_ptr<e::buffer> msg,
                      e::intrusive_ptr<pending> op,
-                     hyperdex_client_returncode* status)
+                     hyperdex_client_returncode *status)
 {
-    virtual_server_id vsi = m_config.point_leader(space, key);
-
-    if (vsi == virtual_server_id())
-    {
-        ERROR(OFFLINE) << "all servers for key \""
-                       << e::strescape(std::string(reinterpret_cast<const char*>(key.data()), key.size()))
-                       << "\" in space \"" << e::strescape(space)
-                       << "\" are offline: bring one or more online to remedy the issue";
-        return -1;
-    }
-
-    int64_t nonce = m_next_server_nonce++;
-
-    if (send(mt, vsi, nonce, msg, op, status))
-    {
-        return op->client_visible_id();
-    }
-    else
-    {
-        ERROR(RECONFIGURE) << "could not send " << mt << " to " << vsi;
-        return -1;
-    }
+	virtual_server_id vsi = m_config.point_leader(space, key);
+	if (vsi == virtual_server_id())
+	{
+		ERROR(OFFLINE) << "all servers for key \""
+		               << e::strescape(std::string(reinterpret_cast<const char *>(key.data()), key.size()))
+		               << "\" in space \"" << e::strescape(space)
+		               << "\" are offline: bring one or more online to remedy the issue";
+		return -1;
+	}
+	int64_t nonce = m_next_server_nonce++;
+	if (send(mt, vsi, nonce, msg, op, status))
+	{
+		return op->client_visible_id();
+	}
+	else
+	{
+		ERROR(RECONFIGURE) << "could not send " << mt << " to " << vsi;
+		return -1;
+	}
 }
 
 void
-client :: handle_disruption(const server_id& si)
+client :: handle_disruption(const server_id &si)
 {
-    pending_map_t::iterator it = m_pending_ops.begin();
-
-    while (it != m_pending_ops.end())
-    {
-        if (it->second.si == si)
-        {
-            m_failed.push_back(it->second);
-            pending_map_t::iterator tmp = it;
-            ++it;
-            m_pending_ops.erase(tmp);
-        }
-        else
-        {
-            ++it;
-        }
-    }
-
-    m_busybee.drop(si.get());
+	pending_map_t::iterator it = m_pending_ops.begin();
+	while (it != m_pending_ops.end())
+	{
+		if (it->second.si == si)
+		{
+			m_failed.push_back(it->second);
+			pending_map_t::iterator tmp = it;
+			++it;
+			m_pending_ops.erase(tmp);
+		}
+		else
+		{
+			++it;
+		}
+	}
+	m_busybee.drop(si.get());
 }
 
-microtransaction* client::uxact_init(const char* space, hyperdex_client_returncode *status)
+microtransaction *client::uxact_init(const char *space, hyperdex_client_returncode *status)
 {
-    if (!maintain_coord_connection(status))
-    {
-        return NULL;
-    }
-
-    const schema* sc = m_config.get_schema(space);
-
-    if (!sc)
-    {
-        ERROR(UNKNOWNSPACE) << "space \"" << e::strescape(space) << "\" does not exist";
-        return NULL;
-    }
-
-    return new microtransaction(space, *sc, status);
+	if (!maintain_coord_connection(status))
+	{
+		return NULL;
+	}
+	const schema *sc = m_config.get_schema(space);
+	if (!sc)
+	{
+		ERROR(UNKNOWNSPACE) << "space \"" << e::strescape(space) << "\" does not exist";
+		return NULL;
+	}
+	return new microtransaction(space, *sc, status);
 }
 
 int64_t client::uxact_add_funcall(microtransaction *transaction,
-                                  const hyperdex_client_keyop_info* opinfo,
-                                  const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                  const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz)
+                                  const hyperdex_client_keyop_info *opinfo,
+                                  const hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                  const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz)
 {
-    size_t idx = 0;
-
-    // Prepare the attrs
-    idx = prepare_funcs(transaction->space, transaction->sc, opinfo, attrs, attrs_sz, &transaction->memory, transaction->status, &transaction->funcalls);
-
-    if (idx < attrs_sz)
-    {
-        return -2 - idx;
-    }
-
-    // Prepare the mapattrs
-    idx = prepare_funcs(transaction->space, transaction->sc, opinfo, mapattrs, mapattrs_sz, &transaction->memory, transaction->status, &transaction->funcalls);
-
-    if (idx < mapattrs_sz)
-    {
-        return -2 - attrs_sz - idx;
-    }
-
-    return 0;
+	size_t idx = 0;
+	// Prepare the attrs
+	idx = prepare_funcs(transaction->space, transaction->sc, opinfo, attrs, attrs_sz, &transaction->memory, transaction->status, &transaction->funcalls);
+	if (idx < attrs_sz)
+	{
+		return -2 - idx;
+	}
+	// Prepare the mapattrs
+	idx = prepare_funcs(transaction->space, transaction->sc, opinfo, mapattrs, mapattrs_sz, &transaction->memory, transaction->status, &transaction->funcalls);
+	if (idx < mapattrs_sz)
+	{
+		return -2 - attrs_sz - idx;
+	}
+	return 0;
 }
 
 int64_t client::uxact_commit(microtransaction *transaction,
-                                const char* _key, size_t _key_sz)
+                             const char *_key, size_t _key_sz)
 {
-    hyperdex_client_returncode *status = transaction->status;
-
-    datatype_info* di = datatype_info::lookup(transaction->sc.attrs[0].type);
-    assert(di);
-    e::slice key(_key, _key_sz);
-
-    if (!di->validate(key))
-    {
-        ERROR(WRONGTYPE) << "key must be type " << transaction->sc.attrs[0].type;
-        return -1;
-    }
-
-    e::intrusive_ptr<pending> op;
-    op = new pending_atomic(m_next_client_id++, status);
-    std::auto_ptr<e::buffer> msg;
-    auth_wallet aw(m_macaroons, m_macaroons_sz);
-    size_t header_sz = HYPERDEX_CLIENT_HEADER_SIZE_REQ
-                     + pack_size(key);
-    size_t footer_sz = 0;
-
-    if (m_macaroons_sz)
-    {
-        footer_sz += pack_size(aw);
-    }
-
-    const std::vector<hyperdex::attribute_check> checks;
-    int ret = transaction->generate_message(header_sz, footer_sz, checks, &msg);
-
-    if (ret < 0)
-    {
-        return ret;
-    }
-
-    msg->pack_at(HYPERDEX_CLIENT_HEADER_SIZE_REQ) << key;
-
-    if (m_macaroons_sz)
-    {
-        msg->pack_at(msg->capacity() - footer_sz) << aw;
-    }
-
-    int64_t result = send_keyop(transaction->space, key, REQ_ATOMIC, msg, op, status);
-    delete transaction;
-    return result;
+	hyperdex_client_returncode *status = transaction->status;
+	datatype_info *di = datatype_info::lookup(transaction->sc.attrs[0].type);
+	assert(di);
+	e::slice key(_key, _key_sz);
+	if (!di->validate(key))
+	{
+		ERROR(WRONGTYPE) << "key must be type " << transaction->sc.attrs[0].type;
+		return -1;
+	}
+	e::intrusive_ptr<pending> op;
+	op = new pending_atomic(m_next_client_id++, status);
+	std::auto_ptr<e::buffer> msg;
+	auth_wallet aw(m_macaroons, m_macaroons_sz);
+	size_t header_sz = HYPERDEX_CLIENT_HEADER_SIZE_REQ
+	                   + pack_size(key);
+	size_t footer_sz = 0;
+	if (m_macaroons_sz)
+	{
+		footer_sz += pack_size(aw);
+	}
+	const std::vector<hyperdex::attribute_check> checks;
+	int ret = transaction->generate_message(header_sz, footer_sz, checks, &msg);
+	if (ret < 0)
+	{
+		return ret;
+	}
+	msg->pack_at(HYPERDEX_CLIENT_HEADER_SIZE_REQ) << key;
+	if (m_macaroons_sz)
+	{
+		msg->pack_at(msg->capacity() - footer_sz) << aw;
+	}
+	int64_t result = send_keyop(transaction->space, key, REQ_ATOMIC, msg, op, status);
+	delete transaction;
+	return result;
 }
 
 int64_t
 client :: uxact_cond_commit(microtransaction *transaction,
-                          const char* _key, size_t _key_sz,
-                          const hyperdex_client_attribute_check* chks, size_t chks_sz)
+                            const char *_key, size_t _key_sz,
+                            const hyperdex_client_attribute_check *chks, size_t chks_sz)
 {
-    hyperdex_client_returncode *status = transaction->status;
-
-    datatype_info* di = datatype_info::lookup(transaction->sc.attrs[0].type);
-    assert(di);
-    e::slice key(_key, _key_sz);
-
-    if (!di->validate(key))
-    {
-        ERROR(WRONGTYPE) << "key must be type " << transaction->sc.attrs[0].type;
-        return -2;
-    }
-
-    e::intrusive_ptr<pending> op;
-    op = new pending_atomic(m_next_client_id++, status);
-    std::auto_ptr<e::buffer> msg;
-    auth_wallet aw(m_macaroons, m_macaroons_sz);
-    size_t header_sz = HYPERDEX_CLIENT_HEADER_SIZE_REQ
-                     + pack_size(key);
-    size_t footer_sz = 0;
-
-    if (m_macaroons_sz)
-    {
-        footer_sz += pack_size(aw);
-    }
-
-    // Prepare the checks
-    std::vector<hyperdex::attribute_check> checks;
-    uint64_t idx = prepare_checks(transaction->space, transaction->sc, chks, chks_sz, &transaction->memory, status, &checks);
-
-    if (idx < chks_sz)
-    {
-        return -2 - idx;
-    }
-
-    int ret = transaction->generate_message(header_sz, footer_sz, checks, &msg);
-
-    if (ret < 0)
-    {
-        return ret;
-    }
-
-    msg->pack_at(HYPERDEX_CLIENT_HEADER_SIZE_REQ) << key;
-
-    if (m_macaroons_sz)
-    {
-        msg->pack_at(msg->capacity() - footer_sz) << aw;
-    }
-
-    int64_t result = send_keyop(transaction->space, key, REQ_ATOMIC, msg, op, status);
-    delete transaction;
-    return result;
+	hyperdex_client_returncode *status = transaction->status;
+	datatype_info *di = datatype_info::lookup(transaction->sc.attrs[0].type);
+	assert(di);
+	e::slice key(_key, _key_sz);
+	if (!di->validate(key))
+	{
+		ERROR(WRONGTYPE) << "key must be type " << transaction->sc.attrs[0].type;
+		return -2;
+	}
+	e::intrusive_ptr<pending> op;
+	op = new pending_atomic(m_next_client_id++, status);
+	std::auto_ptr<e::buffer> msg;
+	auth_wallet aw(m_macaroons, m_macaroons_sz);
+	size_t header_sz = HYPERDEX_CLIENT_HEADER_SIZE_REQ
+	                   + pack_size(key);
+	size_t footer_sz = 0;
+	if (m_macaroons_sz)
+	{
+		footer_sz += pack_size(aw);
+	}
+	// Prepare the checks
+	std::vector<hyperdex::attribute_check> checks;
+	uint64_t idx = prepare_checks(transaction->space, transaction->sc, chks, chks_sz, &transaction->memory, status, &checks);
+	if (idx < chks_sz)
+	{
+		return -2 - idx;
+	}
+	int ret = transaction->generate_message(header_sz, footer_sz, checks, &msg);
+	if (ret < 0)
+	{
+		return ret;
+	}
+	msg->pack_at(HYPERDEX_CLIENT_HEADER_SIZE_REQ) << key;
+	if (m_macaroons_sz)
+	{
+		msg->pack_at(msg->capacity() - footer_sz) << aw;
+	}
+	int64_t result = send_keyop(transaction->space, key, REQ_ATOMIC, msg, op, status);
+	delete transaction;
+	return result;
 }
 
 int64_t
 client :: uxact_group_commit(microtransaction *transaction,
-                           const hyperdex_client_attribute_check* chks, size_t chks_sz,
-                           uint64_t *update_count)
+                             const hyperdex_client_attribute_check *chks, size_t chks_sz,
+                             uint64_t *update_count)
 {
-    hyperdex_client_returncode *status = transaction->status;
-    const char *space = transaction->space;
-
-    SEARCH_BOILERPLATE
-
-    int64_t client_id = m_next_client_id++;
-    e::intrusive_ptr<pending_aggregation> op;
-    op = new pending_group_atomic(client_id, status, update_count);
-
-    std::auto_ptr<e::buffer> inner_msg;
-    const std::vector<hyperdex::attribute_check> checks_;
-    ret = transaction->generate_message(0, 0, checks_, &inner_msg);
-
-    if (ret < 0)
-    {
-        return ret;
-    }
-
-    size_t sz = HYPERDEX_CLIENT_HEADER_SIZE_REQ
-              + sizeof(uint64_t)
-              + pack_size(checks)
-              + inner_msg->size();
-    std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
-    e::packer pa = msg->pack_at(HYPERDEX_CLIENT_HEADER_SIZE_REQ);
-    e::slice ims = inner_msg->as_slice();
-    pa = pa << checks << e::pack_memmove(ims.data(), ims.size());
-
-    int64_t result = perform_aggregation(servers, op, REQ_GROUP_ATOMIC, msg, status);
-    delete transaction;
-    return result;
+	hyperdex_client_returncode *status = transaction->status;
+	const char *space = transaction->space;
+	SEARCH_BOILERPLATE
+	int64_t client_id = m_next_client_id++;
+	e::intrusive_ptr<pending_aggregation> op;
+	op = new pending_group_atomic(client_id, status, update_count);
+	std::auto_ptr<e::buffer> inner_msg;
+	const std::vector<hyperdex::attribute_check> checks_;
+	ret = transaction->generate_message(0, 0, checks_, &inner_msg);
+	if (ret < 0)
+	{
+		return ret;
+	}
+	size_t sz = HYPERDEX_CLIENT_HEADER_SIZE_REQ
+	            + sizeof(uint64_t)
+	            + pack_size(checks)
+	            + inner_msg->size();
+	std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
+	e::packer pa = msg->pack_at(HYPERDEX_CLIENT_HEADER_SIZE_REQ);
+	e::slice ims = inner_msg->as_slice();
+	pa = pa << checks << e::pack_memmove(ims.data(), ims.size());
+	int64_t result = perform_aggregation(servers, op, REQ_GROUP_ATOMIC, msg, status);
+	delete transaction;
+	return result;
 }
 
 
-HYPERDEX_API std::ostream&
-operator << (std::ostream& lhs, hyperdex_client_returncode rhs)
+HYPERDEX_API std::ostream &
+operator << (std::ostream &lhs, hyperdex_client_returncode rhs)
 {
-    switch (rhs)
-    {
-        STRINGIFY(HYPERDEX_CLIENT_SUCCESS);
-        STRINGIFY(HYPERDEX_CLIENT_NOTFOUND);
-        STRINGIFY(HYPERDEX_CLIENT_SEARCHDONE);
-        STRINGIFY(HYPERDEX_CLIENT_CMPFAIL);
-        STRINGIFY(HYPERDEX_CLIENT_READONLY);
-        STRINGIFY(HYPERDEX_CLIENT_UNKNOWNSPACE);
-        STRINGIFY(HYPERDEX_CLIENT_COORDFAIL);
-        STRINGIFY(HYPERDEX_CLIENT_SERVERERROR);
-        STRINGIFY(HYPERDEX_CLIENT_POLLFAILED);
-        STRINGIFY(HYPERDEX_CLIENT_OVERFLOW);
-        STRINGIFY(HYPERDEX_CLIENT_RECONFIGURE);
-        STRINGIFY(HYPERDEX_CLIENT_TIMEOUT);
-        STRINGIFY(HYPERDEX_CLIENT_UNKNOWNATTR);
-        STRINGIFY(HYPERDEX_CLIENT_DUPEATTR);
-        STRINGIFY(HYPERDEX_CLIENT_NONEPENDING);
-        STRINGIFY(HYPERDEX_CLIENT_DONTUSEKEY);
-        STRINGIFY(HYPERDEX_CLIENT_WRONGTYPE);
-        STRINGIFY(HYPERDEX_CLIENT_NOMEM);
-        STRINGIFY(HYPERDEX_CLIENT_INTERRUPTED);
-        STRINGIFY(HYPERDEX_CLIENT_CLUSTER_JUMP);
-        STRINGIFY(HYPERDEX_CLIENT_OFFLINE);
-        STRINGIFY(HYPERDEX_CLIENT_UNAUTHORIZED);
-        STRINGIFY(HYPERDEX_CLIENT_INTERNAL);
-        STRINGIFY(HYPERDEX_CLIENT_EXCEPTION);
-        STRINGIFY(HYPERDEX_CLIENT_GARBAGE);
-        default:
-            lhs << "unknown hyperdex_client_returncode";
-            return lhs;
-    }
-
-    return lhs;
+	switch (rhs)
+	{
+		STRINGIFY(HYPERDEX_CLIENT_SUCCESS);
+		STRINGIFY(HYPERDEX_CLIENT_NOTFOUND);
+		STRINGIFY(HYPERDEX_CLIENT_SEARCHDONE);
+		STRINGIFY(HYPERDEX_CLIENT_CMPFAIL);
+		STRINGIFY(HYPERDEX_CLIENT_READONLY);
+		STRINGIFY(HYPERDEX_CLIENT_UNKNOWNSPACE);
+		STRINGIFY(HYPERDEX_CLIENT_COORDFAIL);
+		STRINGIFY(HYPERDEX_CLIENT_SERVERERROR);
+		STRINGIFY(HYPERDEX_CLIENT_POLLFAILED);
+		STRINGIFY(HYPERDEX_CLIENT_OVERFLOW);
+		STRINGIFY(HYPERDEX_CLIENT_RECONFIGURE);
+		STRINGIFY(HYPERDEX_CLIENT_TIMEOUT);
+		STRINGIFY(HYPERDEX_CLIENT_UNKNOWNATTR);
+		STRINGIFY(HYPERDEX_CLIENT_DUPEATTR);
+		STRINGIFY(HYPERDEX_CLIENT_NONEPENDING);
+		STRINGIFY(HYPERDEX_CLIENT_DONTUSEKEY);
+		STRINGIFY(HYPERDEX_CLIENT_WRONGTYPE);
+		STRINGIFY(HYPERDEX_CLIENT_NOMEM);
+		STRINGIFY(HYPERDEX_CLIENT_INTERRUPTED);
+		STRINGIFY(HYPERDEX_CLIENT_CLUSTER_JUMP);
+		STRINGIFY(HYPERDEX_CLIENT_OFFLINE);
+		STRINGIFY(HYPERDEX_CLIENT_UNAUTHORIZED);
+		STRINGIFY(HYPERDEX_CLIENT_INTERNAL);
+		STRINGIFY(HYPERDEX_CLIENT_EXCEPTION);
+		STRINGIFY(HYPERDEX_CLIENT_GARBAGE);
+	default:
+		lhs << "unknown hyperdex_client_returncode";
+		return lhs;
+	}
+	return lhs;
 }
 
 // enable or disable type conversion on the client-side
 void
 client :: set_type_conversion(bool enabled)
 {
-    m_convert_types = enabled;
+	m_convert_types = enabled;
 }
 
 int64_t
 microtransaction::generate_message(size_t header_sz, size_t footer_sz,
-                                   const std::vector<attribute_check>& checks,
-                                   std::auto_ptr<e::buffer>* msg)
+                                   const std::vector<attribute_check> &checks,
+                                   std::auto_ptr<e::buffer> *msg)
 {
-    const bool fail_if_not_found = false;
-    const bool fail_if_found = false;
-    const bool erase = false;
-
-    std::stable_sort(funcalls.begin(), funcalls.end());
-    size_t sz = header_sz + footer_sz
-              + sizeof(uint8_t)
-              + pack_size(checks)
-              + pack_size(funcalls);
-    msg->reset(e::buffer::create(sz));
-    uint8_t flags = (fail_if_not_found ? 1 : 0)
-            | (fail_if_found ? 2 : 0)
-            | (erase ? 0 : 128);
-    (*msg)->pack_at(header_sz) << flags << checks << funcalls;
-    return 0;
+	const bool fail_if_not_found = false;
+	const bool fail_if_found = false;
+	const bool erase = false;
+	std::stable_sort(funcalls.begin(), funcalls.end());
+	size_t sz = header_sz + footer_sz
+	            + sizeof(uint8_t)
+	            + pack_size(checks)
+	            + pack_size(funcalls);
+	msg->reset(e::buffer::create(sz));
+	uint8_t flags = (fail_if_not_found ? 1 : 0)
+	                | (fail_if_found ? 2 : 0)
+	                | (erase ? 0 : 128);
+	(*msg)->pack_at(header_sz) << flags << checks << funcalls;
+	return 0;
 }
diff --git a/client/client.h b/client/client.h
index b3f9252ce..a3c6c8115 100644
--- a/client/client.h
+++ b/client/client.h
@@ -53,235 +53,238 @@ BEGIN_HYPERDEX_NAMESPACE
 
 struct microtransaction
 {
-    microtransaction(const char* space_, const schema& sc_,
-                              hyperdex_client_returncode *status_)
-        : space(space_), sc(sc_), status(status_), funcalls(), memory()
-    {}
+	microtransaction(const char *space_, const schema &sc_,
+	                 hyperdex_client_returncode *status_)
+		: space(space_), sc(sc_), status(status_), funcalls(), memory()
+	{}
 
-    int64_t generate_message(size_t header_sz, size_t footer_sz,
-                             const std::vector<attribute_check>& checks,
-                             std::auto_ptr<e::buffer>* msg);
+	int64_t generate_message(size_t header_sz, size_t footer_sz,
+	                         const std::vector<attribute_check> &checks,
+	                         std::auto_ptr<e::buffer> *msg);
 
-    const char* space;
-    const schema& sc;
-    hyperdex_client_returncode* status;
-    std::vector<funcall> funcalls;
-    e::arena memory;
+	const char *space;
+	const schema &sc;
+	hyperdex_client_returncode *status;
+	std::vector<funcall> funcalls;
+	e::arena memory;
 
-    private:
-        microtransaction(const microtransaction&);
-        microtransaction& operator = (const microtransaction&);
+private:
+	microtransaction(const microtransaction &);
+	microtransaction &operator = (const microtransaction &);
 };
 
 class client
 {
-    public:
-        client(const char* coordinator, uint16_t port);
-        client(const char* conn_str);
-        ~client() throw ();
+public:
+	client(const char *coordinator, uint16_t port);
+	client(const char *conn_str);
+	~client() throw ();
 
-    public:
-        void clear_auth_context() { m_macaroons = NULL; m_macaroons_sz = 0; }
-        void set_auth_context(const char** macaroons, size_t macaroons_sz)
-        { m_macaroons = macaroons; m_macaroons_sz = macaroons_sz; }
+public:
+	void clear_auth_context() { m_macaroons = NULL; m_macaroons_sz = 0; }
+	void set_auth_context(const char **macaroons, size_t macaroons_sz)
+	{ m_macaroons = macaroons; m_macaroons_sz = macaroons_sz; }
 
-    public:
-        // specific calls
-        int64_t get(const char* space, const char* key, size_t key_sz,
-                    hyperdex_client_returncode* status,
-                    const hyperdex_client_attribute** attrs, size_t* attrs_sz);
-        int64_t get_partial(const char* space, const char* key, size_t key_sz,
-                            const char** attrnames, size_t attrnames_sz,
-                            hyperdex_client_returncode* status,
-                            const hyperdex_client_attribute** attrs, size_t* attrs_sz);
-        int64_t search(const char* space,
-                       const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                       hyperdex_client_returncode* status,
-                       const hyperdex_client_attribute** attrs, size_t* attrs_sz);
-        int64_t search_describe(const char* space,
-                                const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                hyperdex_client_returncode* status, const char** description);
-        int64_t sorted_search(const char* space,
-                              const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                              const char* sort_by,
-                              uint64_t limit,
-                              bool maximize,
-                              hyperdex_client_returncode* status,
-                              const hyperdex_client_attribute** attrs, size_t* attrs_sz);
-        int64_t group_del(const char* space,
-                          const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                          hyperdex_client_returncode* status);
-        int64_t count(const char* space,
-                      const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                      hyperdex_client_returncode* status, uint64_t* result);
+public:
+	// specific calls
+	int64_t get(const char *space, const char *key, size_t key_sz,
+	            hyperdex_client_returncode *status,
+	            const hyperdex_client_attribute **attrs, size_t *attrs_sz);
+	int64_t get_partial(const char *space, const char *key, size_t key_sz,
+	                    const char **attrnames, size_t attrnames_sz,
+	                    hyperdex_client_returncode *status,
+	                    const hyperdex_client_attribute **attrs, size_t *attrs_sz);
+	int64_t search(const char *space,
+	               const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	               hyperdex_client_returncode *status,
+	               const hyperdex_client_attribute **attrs, size_t *attrs_sz);
+	int64_t search_describe(const char *space,
+	                        const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                        hyperdex_client_returncode *status, const char **description);
+	int64_t sorted_search(const char *space,
+	                      const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                      const char *sort_by,
+	                      uint64_t limit,
+	                      bool maximize,
+	                      hyperdex_client_returncode *status,
+	                      const hyperdex_client_attribute **attrs, size_t *attrs_sz);
+	int64_t group_del(const char *space,
+	                  const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                  hyperdex_client_returncode *status);
+	int64_t count(const char *space,
+	              const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	              hyperdex_client_returncode *status, uint64_t *result);
+	int64_t sum(const char *space,
+	            const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	            const char *sum_key, hyperdex_client_returncode *status, uint64_t *result);
 
-        // General keyop call
-        // This will be called by the bindings from c.cc
-        int64_t perform_funcall(const hyperdex_client_keyop_info* opinfo,
-                                const char* space, const char* key, size_t key_sz,
-                                const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                hyperdex_client_returncode* status);
+	// General keyop call
+	// This will be called by the bindings from c.cc
+	int64_t perform_funcall(const hyperdex_client_keyop_info *opinfo,
+	                        const char *space, const char *key, size_t key_sz,
+	                        const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                        const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                        const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                        hyperdex_client_returncode *status);
 
-        // General keyop call for group operations
-        // This will be called by the bindings from c.cc
-        int64_t perform_group_funcall(const hyperdex_client_keyop_info* opinfo,
-                                      const char* space,
-                                      const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                      const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                      const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                      hyperdex_client_returncode* status,
-                                      uint64_t* update_count);
+	// General keyop call for group operations
+	// This will be called by the bindings from c.cc
+	int64_t perform_group_funcall(const hyperdex_client_keyop_info *opinfo,
+	                              const char *space,
+	                              const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                              const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                              const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                              hyperdex_client_returncode *status,
+	                              uint64_t *update_count);
 
-        // Initiate a microtransaction
-        // Status and transaction object must remain valid until the operation has completed
-        microtransaction *uxact_init(const char* space,
-                                   hyperdex_client_returncode *status);
+	// Initiate a microtransaction
+	// Status and transaction object must remain valid until the operation has completed
+	microtransaction *uxact_init(const char *space,
+	                             hyperdex_client_returncode *status);
 
-        // Add a new funcall to the microstransaction
-        int64_t uxact_add_funcall(microtransaction *transaction,
-                                          const hyperdex_client_keyop_info* opinfo,
-                                          const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                          const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz);
+	// Add a new funcall to the microstransaction
+	int64_t uxact_add_funcall(microtransaction *transaction,
+	                          const hyperdex_client_keyop_info *opinfo,
+	                          const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                          const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz);
 
-        // Issue a microtransaction to a specific key
-        int64_t uxact_commit(microtransaction *transaction,
-                             const char* key, size_t key_sz);
+	// Issue a microtransaction to a specific key
+	int64_t uxact_commit(microtransaction *transaction,
+	                     const char *key, size_t key_sz);
 
-        // Issue a microtransaction to a specific key only if checks passs
-        int64_t uxact_cond_commit(microtransaction *transaction,
-                                  const char* key, size_t key_sz,
-                                  const hyperdex_client_attribute_check* checks, size_t checks_sz);
+	// Issue a microtransaction to a specific key only if checks passs
+	int64_t uxact_cond_commit(microtransaction *transaction,
+	                          const char *key, size_t key_sz,
+	                          const hyperdex_client_attribute_check *checks, size_t checks_sz);
 
-        // Issue a mircotransaction to a all entries matching the checks
-        int64_t uxact_group_commit(microtransaction *transaction,
-                                   const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                   uint64_t *update_count);
+	// Issue a mircotransaction to a all entries matching the checks
+	int64_t uxact_group_commit(microtransaction *transaction,
+	                           const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                           uint64_t *update_count);
 
-        // looping/polling
-        int64_t loop(int timeout, hyperdex_client_returncode* status);
-        // Return the fildescriptor that hyperdex uses for networking
-        int poll_fd();
-        // Ensure the flagfd is set correctly
-        void adjust_flagfd();
-        // Block unitl there is incoming data or the timeout is reached
-        int block(int timeout);
-        // error handling
-        const char* error_message();
-        const char* error_location();
-        void set_error_message(const char* msg);
-        // helpers for bindings
-        hyperdatatype attribute_type(const char* space, const char* name,
-                                     hyperdex_client_returncode* status);
-        // enable or disable type conversion on the client-side
-        void set_type_conversion(bool enabled);
+	// looping/polling
+	int64_t loop(int timeout, hyperdex_client_returncode *status);
+	// Return the fildescriptor that hyperdex uses for networking
+	int poll_fd();
+	// Ensure the flagfd is set correctly
+	void adjust_flagfd();
+	// Block unitl there is incoming data or the timeout is reached
+	int block(int timeout);
+	// error handling
+	const char *error_message();
+	const char *error_location();
+	void set_error_message(const char *msg);
+	// helpers for bindings
+	hyperdatatype attribute_type(const char *space, const char *name,
+	                             hyperdex_client_returncode *status);
+	// enable or disable type conversion on the client-side
+	void set_type_conversion(bool enabled);
 
-    private:
-        struct pending_server_pair
-        {
-            pending_server_pair()
-                : si(), vsi(), op() {}
-            pending_server_pair(const server_id& s,
-                                const virtual_server_id& v,
-                                const e::intrusive_ptr<pending>& o)
-                : si(s), vsi(v), op(o) {}
-            ~pending_server_pair() throw () {}
-            server_id si;
-            virtual_server_id vsi;
-            e::intrusive_ptr<pending> op;
-        };
-        typedef std::map<uint64_t, pending_server_pair> pending_map_t;
-        typedef std::list<pending_server_pair> pending_queue_t;
-        friend class pending_get;
-        friend class pending_get_partial;
-        friend class pending_search;
-        friend class pending_sorted_search;
+private:
+	struct pending_server_pair
+	{
+		pending_server_pair()
+			: si(), vsi(), op() {}
+		pending_server_pair(const server_id &s,
+		                    const virtual_server_id &v,
+		                    const e::intrusive_ptr<pending> &o)
+			: si(s), vsi(v), op(o) {}
+		~pending_server_pair() throw () {}
+		server_id si;
+		virtual_server_id vsi;
+		e::intrusive_ptr<pending> op;
+	};
+	typedef std::map<uint64_t, pending_server_pair> pending_map_t;
+	typedef std::list<pending_server_pair> pending_queue_t;
+	friend class pending_get;
+	friend class pending_get_partial;
+	friend class pending_search;
+	friend class pending_sorted_search;
 
-    private:
-        size_t prepare_checks(const char* space, const schema& sc,
-                              const hyperdex_client_attribute_check* chks, size_t chks_sz,
-                              e::arena* memory,
-                              hyperdex_client_returncode* status,
-                              std::vector<attribute_check>* checks);
-        size_t prepare_funcs(const char* space, const schema& sc,
-                             const hyperdex_client_keyop_info* opinfo,
-                             const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                             e::arena* memory,
-                             hyperdex_client_returncode* status,
-                             std::vector<funcall>* funcs);
-        size_t prepare_funcs(const char* space, const schema& sc,
-                             const hyperdex_client_keyop_info* opinfo,
-                             const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                             e::arena* memory,
-                             hyperdex_client_returncode* status,
-                             std::vector<funcall>* funcs);
-        size_t prepare_searchop(const schema& sc,
-                                const char* space,
-                                const hyperdex_client_attribute_check* chks, size_t chks_sz,
-                                e::arena* memory,
-                                hyperdex_client_returncode* status,
-                                std::vector<attribute_check>* checks,
-                                std::vector<virtual_server_id>* servers);
-        int64_t perform_funcall(const char* space, const schema* sc,
-                                const hyperdex_client_keyop_info* opinfo,
-                                const hyperdex_client_attribute_check* chks, size_t chks_sz,
-                                const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                size_t header_sz,
-                                size_t footer_sz,
-                                hyperdex_client_returncode* status,
-                                std::auto_ptr<e::buffer>* msg);
-        int64_t perform_aggregation(const std::vector<virtual_server_id>& servers,
-                                    e::intrusive_ptr<pending_aggregation> op,
-                                    network_msgtype mt,
-                                    std::auto_ptr<e::buffer> msg,
-                                    hyperdex_client_returncode* status);
-        bool maintain_coord_connection(hyperdex_client_returncode* status);
-        bool send(network_msgtype mt,
-                  const virtual_server_id& to,
-                  uint64_t nonce,
-                  std::auto_ptr<e::buffer> msg,
-                  e::intrusive_ptr<pending> op,
-                  hyperdex_client_returncode* status);
-        int64_t send_keyop(const char* space,
-                           const e::slice& key,
-                           network_msgtype mt,
-                           std::auto_ptr<e::buffer> msg,
-                           e::intrusive_ptr<pending> op,
-                           hyperdex_client_returncode* status);
-        void handle_disruption(const server_id& si);
+private:
+	size_t prepare_checks(const char *space, const schema &sc,
+	                      const hyperdex_client_attribute_check *chks, size_t chks_sz,
+	                      e::arena *memory,
+	                      hyperdex_client_returncode *status,
+	                      std::vector<attribute_check> *checks);
+	size_t prepare_funcs(const char *space, const schema &sc,
+	                     const hyperdex_client_keyop_info *opinfo,
+	                     const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                     e::arena *memory,
+	                     hyperdex_client_returncode *status,
+	                     std::vector<funcall> *funcs);
+	size_t prepare_funcs(const char *space, const schema &sc,
+	                     const hyperdex_client_keyop_info *opinfo,
+	                     const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                     e::arena *memory,
+	                     hyperdex_client_returncode *status,
+	                     std::vector<funcall> *funcs);
+	size_t prepare_searchop(const schema &sc,
+	                        const char *space,
+	                        const hyperdex_client_attribute_check *chks, size_t chks_sz,
+	                        e::arena *memory,
+	                        hyperdex_client_returncode *status,
+	                        std::vector<attribute_check> *checks,
+	                        std::vector<virtual_server_id> *servers);
+	int64_t perform_funcall(const char *space, const schema *sc,
+	                        const hyperdex_client_keyop_info *opinfo,
+	                        const hyperdex_client_attribute_check *chks, size_t chks_sz,
+	                        const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                        const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                        size_t header_sz,
+	                        size_t footer_sz,
+	                        hyperdex_client_returncode *status,
+	                        std::auto_ptr<e::buffer> *msg);
+	int64_t perform_aggregation(const std::vector<virtual_server_id> &servers,
+	                            e::intrusive_ptr<pending_aggregation> op,
+	                            network_msgtype mt,
+	                            std::auto_ptr<e::buffer> msg,
+	                            hyperdex_client_returncode *status);
+	bool maintain_coord_connection(hyperdex_client_returncode *status);
+	bool send(network_msgtype mt,
+	          const virtual_server_id &to,
+	          uint64_t nonce,
+	          std::auto_ptr<e::buffer> msg,
+	          e::intrusive_ptr<pending> op,
+	          hyperdex_client_returncode *status);
+	int64_t send_keyop(const char *space,
+	                   const e::slice &key,
+	                   network_msgtype mt,
+	                   std::auto_ptr<e::buffer> msg,
+	                   e::intrusive_ptr<pending> op,
+	                   hyperdex_client_returncode *status);
+	void handle_disruption(const server_id &si);
 
-    private:
-        replicant_client* m_coord;
-        mapper m_busybee_mapper;
-        busybee_st m_busybee;
-        // configuration
-        configuration m_config;
-        int64_t m_config_id;
-        replicant_returncode m_config_status;
-        uint64_t m_config_state;
-        char* m_config_data;
-        size_t m_config_data_sz;
-        // nonces
-        int64_t m_next_client_id;
-        uint64_t m_next_server_nonce;
-        e::flagfd m_flagfd;
-        // operations
-        pending_map_t m_pending_ops;
-        pending_queue_t m_failed;
-        std::list<e::intrusive_ptr<pending> > m_yieldable;
-        e::intrusive_ptr<pending> m_yielding;
-        e::intrusive_ptr<pending> m_yielded;
-        // misc
-        e::error m_last_error;
-        const char** m_macaroons;
-        size_t m_macaroons_sz;
-        bool m_convert_types;
+private:
+	replicant_client *m_coord;
+	mapper m_busybee_mapper;
+	busybee_st m_busybee;
+	// configuration
+	configuration m_config;
+	int64_t m_config_id;
+	replicant_returncode m_config_status;
+	uint64_t m_config_state;
+	char *m_config_data;
+	size_t m_config_data_sz;
+	// nonces
+	int64_t m_next_client_id;
+	uint64_t m_next_server_nonce;
+	e::flagfd m_flagfd;
+	// operations
+	pending_map_t m_pending_ops;
+	pending_queue_t m_failed;
+	std::list<e::intrusive_ptr<pending> > m_yieldable;
+	e::intrusive_ptr<pending> m_yielding;
+	e::intrusive_ptr<pending> m_yielded;
+	// misc
+	e::error m_last_error;
+	const char **m_macaroons;
+	size_t m_macaroons_sz;
+	bool m_convert_types;
 
-    private:
-        client(const client&);
-        client& operator = (const client&);
+private:
+	client(const client &);
+	client &operator = (const client &);
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/client/constants.h b/client/constants.h
index 5589f33c3..df7157157 100644
--- a/client/constants.h
+++ b/client/constants.h
@@ -32,14 +32,14 @@
 #include <busybee_constants.h>
 
 #define HYPERDEX_CLIENT_HEADER_SIZE_REQ (BUSYBEE_HEADER_SIZE \
-                                     + sizeof(uint8_t) /*mt*/ \
-                                     + sizeof(uint8_t) /*flags*/ \
-                                     + sizeof(uint64_t) /*version*/ \
-                                     + sizeof(uint64_t) /*vidt*/ \
-                                     + sizeof(uint64_t) /*nonce*/)
+                                         + sizeof(uint8_t) /*mt*/ \
+                                         + sizeof(uint8_t) /*flags*/ \
+                                         + sizeof(uint64_t) /*version*/ \
+                                         + sizeof(uint64_t) /*vidt*/ \
+                                         + sizeof(uint64_t) /*nonce*/)
 #define HYPERDEX_CLIENT_HEADER_SIZE_RESP (BUSYBEE_HEADER_SIZE \
-                                      + sizeof(uint8_t) /*mt*/ \
-                                      + sizeof(uint64_t) /*vidt*/ \
-                                      + sizeof(uint64_t) /*nonce*/)
+                                          + sizeof(uint8_t) /*mt*/ \
+                                          + sizeof(uint64_t) /*vidt*/ \
+                                          + sizeof(uint64_t) /*nonce*/)
 
 #endif // hyperdex_client_constants_h_
diff --git a/client/datastructures.cc b/client/datastructures.cc
index dcae0d20e..ab0dea324 100644
--- a/client/datastructures.cc
+++ b/client/datastructures.cc
@@ -52,194 +52,189 @@ using hyperdex::datatype_info;
 
 class hyperdex_ds_arena
 {
-    public:
-        hyperdex_ds_arena();
-        ~hyperdex_ds_arena() throw ();
-
-    public:
-        void* allocate(size_t bytes);
-        hyperdex_ds_list* allocate_list();
-        hyperdex_ds_set* allocate_set();
-        hyperdex_ds_map* allocate_map();
-
-    private:
-        std::list<void*> m_voids;
-        std::list<hyperdex_ds_list*> m_lists;
-        std::list<hyperdex_ds_set*> m_sets;
-        std::list<hyperdex_ds_map*> m_maps;
+public:
+	hyperdex_ds_arena();
+	~hyperdex_ds_arena() throw ();
+
+public:
+	void *allocate(size_t bytes);
+	hyperdex_ds_list *allocate_list();
+	hyperdex_ds_set *allocate_set();
+	hyperdex_ds_map *allocate_map();
+
+private:
+	std::list<void *> m_voids;
+	std::list<hyperdex_ds_list *> m_lists;
+	std::list<hyperdex_ds_set *> m_sets;
+	std::list<hyperdex_ds_map *> m_maps;
 };
 
 class hyperdex_ds_list
 {
-    public:
-        hyperdex_ds_list();
-        ~hyperdex_ds_list() throw ();
+public:
+	hyperdex_ds_list();
+	~hyperdex_ds_list() throw ();
 
-    public:
-        hyperdatatype type;
-        std::string elems;
+public:
+	hyperdatatype type;
+	std::string elems;
 };
 
 class hyperdex_ds_set
 {
-    public:
-        hyperdex_ds_set();
-        ~hyperdex_ds_set() throw ();
+public:
+	hyperdex_ds_set();
+	~hyperdex_ds_set() throw ();
 
-    public:
-        hyperdatatype type;
-        std::string elems;
+public:
+	hyperdatatype type;
+	std::string elems;
 };
 
 class hyperdex_ds_map
 {
-    public:
-        hyperdex_ds_map();
-        ~hyperdex_ds_map() throw ();
-
-    public:
-        hyperdatatype type;
-        std::string pairs;
-        enum { EXPECT_KEY, EXPECT_VAL } state;
+public:
+	hyperdex_ds_map();
+	~hyperdex_ds_map() throw ();
+
+public:
+	hyperdatatype type;
+	std::string pairs;
+	enum { EXPECT_KEY, EXPECT_VAL } state;
 };
 
 hyperdex_ds_arena :: hyperdex_ds_arena()
-    : m_voids()
-    , m_lists()
-    , m_sets()
-    , m_maps()
+	: m_voids()
+	, m_lists()
+	, m_sets()
+	, m_maps()
 {
 }
 
 hyperdex_ds_arena :: ~hyperdex_ds_arena() throw ()
 {
-    for (std::list<void*>::iterator it = m_voids.begin();
-            it != m_voids.end(); ++it)
-    {
-        if (*it)
-        {
-            free(*it);
-        }
-    }
-
-    for (std::list<hyperdex_ds_list*>::iterator it = m_lists.begin();
-            it != m_lists.end(); ++it)
-    {
-        if (*it)
-        {
-            delete *it;
-        }
-    }
-
-    for (std::list<hyperdex_ds_set*>::iterator it = m_sets.begin();
-            it != m_sets.end(); ++it)
-    {
-        if (*it)
-        {
-            delete *it;
-        }
-    }
-
-    for (std::list<hyperdex_ds_map*>::iterator it = m_maps.begin();
-            it != m_maps.end(); ++it)
-    {
-        if (*it)
-        {
-            delete *it;
-        }
-    }
+	for (std::list<void *>::iterator it = m_voids.begin();
+	     it != m_voids.end(); ++it)
+	{
+		if (*it)
+		{
+			free(*it);
+		}
+	}
+	for (std::list<hyperdex_ds_list *>::iterator it = m_lists.begin();
+	     it != m_lists.end(); ++it)
+	{
+		if (*it)
+		{
+			delete *it;
+		}
+	}
+	for (std::list<hyperdex_ds_set *>::iterator it = m_sets.begin();
+	     it != m_sets.end(); ++it)
+	{
+		if (*it)
+		{
+			delete *it;
+		}
+	}
+	for (std::list<hyperdex_ds_map *>::iterator it = m_maps.begin();
+	     it != m_maps.end(); ++it)
+	{
+		if (*it)
+		{
+			delete *it;
+		}
+	}
 }
 
-void*
+void *
 hyperdex_ds_arena :: allocate(size_t bytes)
 {
-    try
-    {
-        m_voids.push_back(NULL);
-        m_voids.back() = malloc(bytes);
-
-        if (m_voids.back() == NULL)
-        {
-            m_voids.pop_back();
-            return NULL;
-        }
-
-        return m_voids.back();
-    }
-    catch (std::bad_alloc& ba)
-    {
-        errno = ENOMEM;
-        return NULL;
-    }
-    catch (...)
-    {
-        abort();
-    }
+	try
+	{
+		m_voids.push_back(NULL);
+		m_voids.back() = malloc(bytes);
+		if (m_voids.back() == NULL)
+		{
+			m_voids.pop_back();
+			return NULL;
+		}
+		return m_voids.back();
+	}
+	catch (std::bad_alloc &ba)
+	{
+		errno = ENOMEM;
+		return NULL;
+	}
+	catch (...)
+	{
+		abort();
+	}
 }
 
-hyperdex_ds_list*
+hyperdex_ds_list *
 hyperdex_ds_arena :: allocate_list()
 {
-    try
-    {
-        std::auto_ptr<hyperdex_ds_list> list(new hyperdex_ds_list());
-        m_lists.push_back(list.get());
-        return list.release();
-    }
-    catch (std::bad_alloc& ba)
-    {
-        errno = ENOMEM;
-        return NULL;
-    }
-    catch (...)
-    {
-        abort();
-    }
+	try
+	{
+		std::auto_ptr<hyperdex_ds_list> list(new hyperdex_ds_list());
+		m_lists.push_back(list.get());
+		return list.release();
+	}
+	catch (std::bad_alloc &ba)
+	{
+		errno = ENOMEM;
+		return NULL;
+	}
+	catch (...)
+	{
+		abort();
+	}
 }
 
-hyperdex_ds_set*
+hyperdex_ds_set *
 hyperdex_ds_arena :: allocate_set()
 {
-    try
-    {
-        std::auto_ptr<hyperdex_ds_set> set(new hyperdex_ds_set());
-        m_sets.push_back(set.get());
-        return set.release();
-    }
-    catch (std::bad_alloc& ba)
-    {
-        errno = ENOMEM;
-        return NULL;
-    }
-    catch (...)
-    {
-        abort();
-    }
+	try
+	{
+		std::auto_ptr<hyperdex_ds_set> set(new hyperdex_ds_set());
+		m_sets.push_back(set.get());
+		return set.release();
+	}
+	catch (std::bad_alloc &ba)
+	{
+		errno = ENOMEM;
+		return NULL;
+	}
+	catch (...)
+	{
+		abort();
+	}
 }
 
-hyperdex_ds_map*
+hyperdex_ds_map *
 hyperdex_ds_arena :: allocate_map()
 {
-    try
-    {
-        std::auto_ptr<hyperdex_ds_map> map(new hyperdex_ds_map());
-        m_maps.push_back(map.get());
-        return map.release();
-    }
-    catch (std::bad_alloc& ba)
-    {
-        errno = ENOMEM;
-        return NULL;
-    }
-    catch (...)
-    {
-        abort();
-    }
+	try
+	{
+		std::auto_ptr<hyperdex_ds_map> map(new hyperdex_ds_map());
+		m_maps.push_back(map.get());
+		return map.release();
+	}
+	catch (std::bad_alloc &ba)
+	{
+		errno = ENOMEM;
+		return NULL;
+	}
+	catch (...)
+	{
+		abort();
+	}
 }
 
 hyperdex_ds_list :: hyperdex_ds_list()
-    : type(HYPERDATATYPE_LIST_GENERIC)
-    , elems()
+	: type(HYPERDATATYPE_LIST_GENERIC)
+	, elems()
 {
 }
 
@@ -248,8 +243,8 @@ hyperdex_ds_list :: ~hyperdex_ds_list() throw ()
 }
 
 hyperdex_ds_set :: hyperdex_ds_set()
-    : type(HYPERDATATYPE_SET_GENERIC)
-    , elems()
+	: type(HYPERDATATYPE_SET_GENERIC)
+	, elems()
 {
 }
 
@@ -258,9 +253,9 @@ hyperdex_ds_set :: ~hyperdex_ds_set() throw ()
 }
 
 hyperdex_ds_map :: hyperdex_ds_map()
-    : type(HYPERDATATYPE_MAP_GENERIC)
-    , pairs()
-    , state(EXPECT_KEY)
+	: type(HYPERDATATYPE_MAP_GENERIC)
+	, pairs()
+	, state(EXPECT_KEY)
 {
 }
 
@@ -275,1328 +270,1227 @@ hyperdex_ds_map :: ~hyperdex_ds_map() throw ()
 extern "C"
 {
 
-///////////////////////////////////// Arena ////////////////////////////////////
-
-HYPERDEX_API struct hyperdex_ds_arena*
-hyperdex_ds_arena_create()
-{
-    return new (std::nothrow) hyperdex_ds_arena();
-}
-
-HYPERDEX_API void
-hyperdex_ds_arena_destroy(struct hyperdex_ds_arena* arena)
-{
-    if (arena)
-    {
-        delete arena;
-    }
-}
-
-HYPERDEX_API void*
-hyperdex_ds_malloc(struct hyperdex_ds_arena* arena, size_t sz)
-{
-    return reinterpret_cast<void*>(arena->allocate(sz));
-}
-
-//////////////////////////////// Client Structs ////////////////////////////////
-
-HYPERDEX_API struct hyperdex_client_attribute*
-hyperdex_ds_allocate_attribute(struct hyperdex_ds_arena* arena, size_t sz)
-{
-    size_t bytes = sizeof(struct hyperdex_client_attribute) * sz;
-    return reinterpret_cast<struct hyperdex_client_attribute*>(arena->allocate(bytes));
-}
-
-HYPERDEX_API struct hyperdex_client_attribute_check*
-hyperdex_ds_allocate_attribute_check(struct hyperdex_ds_arena* arena, size_t sz)
-{
-    size_t bytes = sizeof(struct hyperdex_client_attribute_check) * sz;
-    return reinterpret_cast<struct hyperdex_client_attribute_check*>(arena->allocate(bytes));
-}
-
-HYPERDEX_API struct hyperdex_client_map_attribute*
-hyperdex_ds_allocate_map_attribute(struct hyperdex_ds_arena* arena, size_t sz)
-{
-    size_t bytes = sizeof(struct hyperdex_client_map_attribute) * sz;
-    return reinterpret_cast<struct hyperdex_client_map_attribute*>(arena->allocate(bytes));
-}
-
-//////////////////////////// pack/unpack ints/floats ///////////////////////////
-
-HYPERDEX_API void
-hyperdex_ds_pack_int(int64_t num, char* buf)
-{
-    e::pack64le(num, buf);
-}
-
-HYPERDEX_API int
-hyperdex_ds_unpack_int(const char* value, size_t value_sz, int64_t* num)
-{
-    if (value_sz == 0)
-    {
-        *num = 0;
-        return 0;
-    }
-    else if (value_sz != sizeof(int64_t))
-    {
-        return -1;
-    }
-
-    e::unpack64le(value, num);
-    return 0;
-}
-
-HYPERDEX_API void
-hyperdex_ds_pack_float(double num, char* buf)
-{
-    e::packdoublele(num, buf);
-}
-
-HYPERDEX_API int
-hyperdex_ds_unpack_float(const char* value, size_t value_sz, double* num)
-{
-    if (value_sz == 0)
-    {
-        *num = 0;
-        return 0;
-    }
-    else if (value_sz != sizeof(double))
-    {
-        return -1;
-    }
-
-    e::unpackdoublele(value, num);
-    return 0;
-}
-
-HYPERDEX_API int
-hyperdex_ds_copy_string(struct hyperdex_ds_arena* arena,
-                        const char* str, size_t str_sz,
-                        enum hyperdex_ds_returncode* status,
-                        const char** value, size_t* value_sz)
-{
-    char* x = reinterpret_cast<char*>(arena->allocate(str_sz));
-
-    if (!x)
-    {
-        *status = HYPERDEX_DS_NOMEM;
-        return -1;
-    }
-
-    memmove(x, str, str_sz);
-    *value = x;
-    *value_sz = str_sz;
-    *status = HYPERDEX_DS_SUCCESS;
-    return 0;
-}
-
-HYPERDEX_API int
-hyperdex_ds_copy_int(struct hyperdex_ds_arena* arena, int64_t num,
-                     enum hyperdex_ds_returncode* status,
-                     const char** value, size_t* value_sz)
-{
-    char* x = reinterpret_cast<char*>(arena->allocate(sizeof(int64_t)));
-
-    if (!x)
-    {
-        *status = HYPERDEX_DS_NOMEM;
-        return -1;
-    }
-
-    e::pack64le(num, x);
-    *value = x;
-    *value_sz = sizeof(int64_t);
-    *status = HYPERDEX_DS_SUCCESS;
-    return 0;
-}
-
-HYPERDEX_API int
-hyperdex_ds_copy_float(struct hyperdex_ds_arena* arena, double num,
-                       enum hyperdex_ds_returncode* status,
-                       const char** value, size_t* value_sz)
-{
-    char* x = reinterpret_cast<char*>(arena->allocate(sizeof(double)));
-
-    if (!x)
-    {
-        *status = HYPERDEX_DS_NOMEM;
-        return -1;
-    }
-
-    e::packdoublele(num, x);
-    *value = x;
-    *value_sz = sizeof(double);
-    *status = HYPERDEX_DS_SUCCESS;
-    return 0;
-}
-
-////////////////////////////////// pack lists //////////////////////////////////
-
-HYPERDEX_API struct hyperdex_ds_list*
-hyperdex_ds_allocate_list(struct hyperdex_ds_arena* arena)
-{
-    return arena->allocate_list();
-}
-
-HYPERDEX_API int
-hyperdex_ds_list_append_string(struct hyperdex_ds_list* list,
-                               const char* str, size_t str_sz,
-                               enum hyperdex_ds_returncode* status)
-{
-    try
-    {
-        if (list->type == HYPERDATATYPE_LIST_GENERIC)
-        {
-            list->type = HYPERDATATYPE_LIST_STRING;
-        }
-        else if (list->type != HYPERDATATYPE_LIST_STRING)
-        {
-            *status = HYPERDEX_DS_MIXED_TYPES;
-            return -1;
-        }
-
-        if (str_sz >= UINT32_MAX)
-        {
-            *status = HYPERDEX_DS_STRING_TOO_LONG;
-            return -1;
-        }
-
-        char buf[sizeof(uint32_t)];
-        e::pack32le(str_sz, buf);
-        list->elems += std::string(buf, sizeof(uint32_t));
-        list->elems += std::string(str, str_sz);
-        *status = HYPERDEX_DS_SUCCESS;
-        return 0;
-    }
-    catch (std::bad_alloc& ba)
-    {
-        errno = ENOMEM;
-        *status = HYPERDEX_DS_NOMEM;
-        return -1;
-    }
-    catch (...)
-    {
-        abort();
-    }
-}
-
-HYPERDEX_API int
-hyperdex_ds_list_append_int(struct hyperdex_ds_list* list,
-                            int64_t num,
-                            enum hyperdex_ds_returncode* status)
-{
-    try
-    {
-        if (list->type == HYPERDATATYPE_LIST_GENERIC)
-        {
-            list->type = HYPERDATATYPE_LIST_INT64;
-        }
-        else if (list->type != HYPERDATATYPE_LIST_INT64)
-        {
-            *status = HYPERDEX_DS_MIXED_TYPES;
-            return -1;
-        }
-
-        char buf[sizeof(int64_t)];
-        e::pack64le(num, buf);
-        list->elems += std::string(buf, buf + sizeof(int64_t));
-        *status = HYPERDEX_DS_SUCCESS;
-        return 0;
-    }
-    catch (std::bad_alloc& ba)
-    {
-        errno = ENOMEM;
-        *status = HYPERDEX_DS_NOMEM;
-        return -1;
-    }
-    catch (...)
-    {
-        abort();
-    }
-}
-
-HYPERDEX_API int
-hyperdex_ds_list_append_float(struct hyperdex_ds_list* list,
-                              double num,
-                              enum hyperdex_ds_returncode* status)
-{
-    try
-    {
-        if (list->type == HYPERDATATYPE_LIST_GENERIC)
-        {
-            list->type = HYPERDATATYPE_LIST_FLOAT;
-        }
-        else if (list->type != HYPERDATATYPE_LIST_FLOAT)
-        {
-            *status = HYPERDEX_DS_MIXED_TYPES;
-            return -1;
-        }
-
-        char buf[sizeof(double)];
-        e::packdoublele(num, buf);
-        list->elems += std::string(buf, buf + sizeof(double));
-        *status = HYPERDEX_DS_SUCCESS;
-        return 0;
-    }
-    catch (std::bad_alloc& ba)
-    {
-        errno = ENOMEM;
-        *status = HYPERDEX_DS_NOMEM;
-        return -1;
-    }
-    catch (...)
-    {
-        abort();
-    }
-}
-
-HYPERDEX_API int
-hyperdex_ds_list_finalize(struct hyperdex_ds_list* list,
-                          enum hyperdex_ds_returncode* status,
-                          const char** value, size_t* value_sz,
-                          enum hyperdatatype* datatype)
-{
-    *status = HYPERDEX_DS_SUCCESS;
-    *value = list->elems.data();
-    *value_sz = list->elems.size();
-    *datatype = list->type;
-    return 0;
-}
-
-/////////////////////////////////// pack sets //////////////////////////////////
-
-HYPERDEX_API struct hyperdex_ds_set*
-hyperdex_ds_allocate_set(struct hyperdex_ds_arena* arena)
-{
-    return arena->allocate_set();
-}
-
-HYPERDEX_API int
-hyperdex_ds_set_insert_string(struct hyperdex_ds_set* set,
-                              const char* str, size_t str_sz,
-                              enum hyperdex_ds_returncode* status)
-{
-    try
-    {
-        if (set->type == HYPERDATATYPE_SET_GENERIC)
-        {
-            set->type = HYPERDATATYPE_SET_STRING;
-        }
-        else if (set->type != HYPERDATATYPE_SET_STRING)
-        {
-            *status = HYPERDEX_DS_MIXED_TYPES;
-            return -1;
-        }
-
-        if (str_sz >= UINT32_MAX)
-        {
-            *status = HYPERDEX_DS_STRING_TOO_LONG;
-            return -1;
-        }
-
-        char buf[sizeof(uint32_t)];
-        e::pack32le(str_sz, buf);
-        set->elems += std::string(buf, sizeof(uint32_t));
-        set->elems += std::string(str, str_sz);
-        *status = HYPERDEX_DS_SUCCESS;
-        return 0;
-    }
-    catch (std::bad_alloc& ba)
-    {
-        errno = ENOMEM;
-        *status = HYPERDEX_DS_NOMEM;
-        return -1;
-    }
-    catch (...)
-    {
-        abort();
-    }
-}
-
-HYPERDEX_API int
-hyperdex_ds_set_insert_int(struct hyperdex_ds_set* set, int64_t num,
-                           enum hyperdex_ds_returncode* status)
-{
-    try
-    {
-        if (set->type == HYPERDATATYPE_SET_GENERIC)
-        {
-            set->type = HYPERDATATYPE_SET_INT64;
-        }
-        else if (set->type != HYPERDATATYPE_SET_INT64)
-        {
-            *status = HYPERDEX_DS_MIXED_TYPES;
-            return -1;
-        }
-
-        char buf[sizeof(int64_t)];
-        e::pack64le(num, buf);
-        set->elems += std::string(buf, buf + sizeof(int64_t));
-        *status = HYPERDEX_DS_SUCCESS;
-        return 0;
-    }
-    catch (std::bad_alloc& ba)
-    {
-        errno = ENOMEM;
-        *status = HYPERDEX_DS_NOMEM;
-        return -1;
-    }
-    catch (...)
-    {
-        abort();
-    }
-}
-
-HYPERDEX_API int
-hyperdex_ds_set_insert_float(struct hyperdex_ds_set* set, double num,
-                             enum hyperdex_ds_returncode* status)
-{
-    try
-    {
-        if (set->type == HYPERDATATYPE_SET_GENERIC)
-        {
-            set->type = HYPERDATATYPE_SET_FLOAT;
-        }
-        else if (set->type != HYPERDATATYPE_SET_FLOAT)
-        {
-            *status = HYPERDEX_DS_MIXED_TYPES;
-            return -1;
-        }
-
-        char buf[sizeof(double)];
-        e::packdoublele(num, buf);
-        set->elems += std::string(buf, buf + sizeof(double));
-        *status = HYPERDEX_DS_SUCCESS;
-        return 0;
-    }
-    catch (std::bad_alloc& ba)
-    {
-        errno = ENOMEM;
-        *status = HYPERDEX_DS_NOMEM;
-        return -1;
-    }
-    catch (...)
-    {
-        abort();
-    }
-}
-
-HYPERDEX_API int
-hyperdex_ds_set_finalize(struct hyperdex_ds_set* set,
-                         enum hyperdex_ds_returncode* status,
-                         const char** value, size_t* value_sz,
-                         enum hyperdatatype* datatype)
-{
-    if (set->type == HYPERDATATYPE_SET_GENERIC)
-    {
-        assert(set->elems.empty());
-        *status = HYPERDEX_DS_SUCCESS;
-        *value = set->elems.data();
-        *value_sz = set->elems.size();
-        *datatype = set->type;
-        return 0;
-    }
-
-    datatype_info* di = datatype_info::lookup(CONTAINER_ELEM(set->type));
-    assert(di);
-    const uint8_t* ptr = reinterpret_cast<const uint8_t*>(set->elems.data());
-    const uint8_t* end = ptr + set->elems.size();
-    e::slice elem;
-    std::vector<e::slice> elems;
-
-    while (ptr < end)
-    {
-        bool stepped = di->step(&ptr, end, &elem);
-        assert(stepped);
-        elems.push_back(elem);
-    }
-
-    assert(ptr == end);
-    std::sort(elems.begin(), elems.end(), di->compare_less());
-    std::vector<char> tmp(set->elems.size());
-    uint8_t* wr = reinterpret_cast<uint8_t*>(&tmp[0]);
-
-    for (size_t i = 0; i < elems.size(); ++i)
-    {
-        wr = di->write(elems[i], wr);
-    }
-
-    set->elems = std::string(tmp.begin(), tmp.end());
-    *status = HYPERDEX_DS_SUCCESS;
-    *value = set->elems.data();
-    *value_sz = set->elems.size();
-    *datatype = set->type;
-    return 0;
-}
-
-/////////////////////////////////// pack maps //////////////////////////////////
-
-HYPERDEX_API struct hyperdex_ds_map*
-hyperdex_ds_allocate_map(struct hyperdex_ds_arena* arena)
-{
-    return arena->allocate_map();
-}
-
-HYPERDEX_API int
-hyperdex_ds_map_insert_key_string(struct hyperdex_ds_map* map,
-                                  const char* str, size_t str_sz,
-                                  enum hyperdex_ds_returncode* status)
-{
-    if (map->state != hyperdex_ds_map::EXPECT_KEY)
-    {
-        *status = HYPERDEX_DS_WRONG_STATE;
-        return -1;
-    }
-
-    try
-    {
-        if (CONTAINER_KEY(map->type) == HYPERDATATYPE_GENERIC)
-        {
-            map->type = HYPERDATATYPE_MAP_STRING_KEYONLY;
-        }
-        else if (CONTAINER_KEY(map->type) != HYPERDATATYPE_STRING)
-        {
-            *status = HYPERDEX_DS_MIXED_TYPES;
-            return -1;
-        }
-
-        if (str_sz >= UINT32_MAX)
-        {
-            *status = HYPERDEX_DS_STRING_TOO_LONG;
-            return -1;
-        }
-
-        char buf[sizeof(uint32_t)];
-        e::pack32le(str_sz, buf);
-        map->pairs += std::string(buf, sizeof(uint32_t));
-        map->pairs += std::string(str, str_sz);
-        *status = HYPERDEX_DS_SUCCESS;
-        map->state = hyperdex_ds_map::EXPECT_VAL;
-        return 0;
-    }
-    catch (std::bad_alloc& ba)
-    {
-        errno = ENOMEM;
-        *status = HYPERDEX_DS_NOMEM;
-        return -1;
-    }
-    catch (...)
-    {
-        abort();
-    }
-}
-
-HYPERDEX_API int
-hyperdex_ds_map_insert_val_string(struct hyperdex_ds_map* map,
-                                  const char* str, size_t str_sz,
-                                  enum hyperdex_ds_returncode* status)
-{
-    if (map->state != hyperdex_ds_map::EXPECT_VAL)
-    {
-        *status = HYPERDEX_DS_WRONG_STATE;
-        return -1;
-    }
-
-    try
-    {
-        if (CONTAINER_VAL(map->type) == HYPERDATATYPE_GENERIC)
-        {
-            map->type = RESTRICT_CONTAINER(map->type, HYPERDATATYPE_STRING);
-        }
-        else if (CONTAINER_VAL(map->type) != HYPERDATATYPE_STRING)
-        {
-            *status = HYPERDEX_DS_MIXED_TYPES;
-            return -1;
-        }
-
-        if (str_sz >= UINT32_MAX)
-        {
-            *status = HYPERDEX_DS_STRING_TOO_LONG;
-            return -1;
-        }
-
-        char buf[sizeof(uint32_t)];
-        e::pack32le(str_sz, buf);
-        map->pairs += std::string(buf, sizeof(uint32_t));
-        map->pairs += std::string(str, str_sz);
-        *status = HYPERDEX_DS_SUCCESS;
-        map->state = hyperdex_ds_map::EXPECT_KEY;
-        return 0;
-    }
-    catch (std::bad_alloc& ba)
-    {
-        errno = ENOMEM;
-        *status = HYPERDEX_DS_NOMEM;
-        return -1;
-    }
-    catch (...)
-    {
-        abort();
-    }
-}
-
-HYPERDEX_API int
-hyperdex_ds_map_insert_key_int(struct hyperdex_ds_map* map, int64_t num,
-                               enum hyperdex_ds_returncode* status)
-{
-    if (map->state != hyperdex_ds_map::EXPECT_KEY)
-    {
-        *status = HYPERDEX_DS_WRONG_STATE;
-        return -1;
-    }
-
-    try
-    {
-        if (CONTAINER_KEY(map->type) == HYPERDATATYPE_GENERIC)
-        {
-            map->type = HYPERDATATYPE_MAP_INT64_KEYONLY;
-        }
-        else if (CONTAINER_KEY(map->type) != HYPERDATATYPE_INT64)
-        {
-            *status = HYPERDEX_DS_MIXED_TYPES;
-            return -1;
-        }
-
-        char buf[sizeof(int64_t)];
-        e::pack64le(num, buf);
-        map->pairs += std::string(buf, buf + sizeof(int64_t));
-        *status = HYPERDEX_DS_SUCCESS;
-        map->state = hyperdex_ds_map::EXPECT_VAL;
-        return 0;
-    }
-    catch (std::bad_alloc& ba)
-    {
-        errno = ENOMEM;
-        *status = HYPERDEX_DS_NOMEM;
-        return -1;
-    }
-    catch (...)
-    {
-        abort();
-    }
-}
-
-HYPERDEX_API int
-hyperdex_ds_map_insert_val_int(struct hyperdex_ds_map* map, int64_t num,
-                               enum hyperdex_ds_returncode* status)
-{
-    if (map->state != hyperdex_ds_map::EXPECT_VAL)
-    {
-        *status = HYPERDEX_DS_WRONG_STATE;
-        return -1;
-    }
-
-    try
-    {
-        if (CONTAINER_VAL(map->type) == HYPERDATATYPE_GENERIC)
-        {
-            map->type = RESTRICT_CONTAINER(map->type, HYPERDATATYPE_INT64);
-        }
-        else if (CONTAINER_VAL(map->type) != HYPERDATATYPE_INT64)
-        {
-            *status = HYPERDEX_DS_MIXED_TYPES;
-            return -1;
-        }
-
-        char buf[sizeof(int64_t)];
-        e::pack64le(num, buf);
-        map->pairs += std::string(buf, buf + sizeof(int64_t));
-        *status = HYPERDEX_DS_SUCCESS;
-        map->state = hyperdex_ds_map::EXPECT_KEY;
-        return 0;
-    }
-    catch (std::bad_alloc& ba)
-    {
-        errno = ENOMEM;
-        *status = HYPERDEX_DS_NOMEM;
-        return -1;
-    }
-    catch (...)
-    {
-        abort();
-    }
-}
-
-HYPERDEX_API int
-hyperdex_ds_map_insert_key_float(struct hyperdex_ds_map* map, double num,
-                                 enum hyperdex_ds_returncode* status)
-{
-    if (map->state != hyperdex_ds_map::EXPECT_KEY)
-    {
-        *status = HYPERDEX_DS_WRONG_STATE;
-        return -1;
-    }
-
-    try
-    {
-        if (CONTAINER_KEY(map->type) == HYPERDATATYPE_GENERIC)
-        {
-            map->type = HYPERDATATYPE_MAP_FLOAT_KEYONLY;
-        }
-        else if (CONTAINER_KEY(map->type) != HYPERDATATYPE_FLOAT)
-        {
-            *status = HYPERDEX_DS_MIXED_TYPES;
-            return -1;
-        }
-
-        char buf[sizeof(double)];
-        e::packdoublele(num, buf);
-        map->pairs += std::string(buf, buf + sizeof(double));
-        *status = HYPERDEX_DS_SUCCESS;
-        map->state = hyperdex_ds_map::EXPECT_VAL;
-        return 0;
-    }
-    catch (std::bad_alloc& ba)
-    {
-        errno = ENOMEM;
-        *status = HYPERDEX_DS_NOMEM;
-        return -1;
-    }
-    catch (...)
-    {
-        abort();
-    }
-}
-
-HYPERDEX_API int
-hyperdex_ds_map_insert_val_float(struct hyperdex_ds_map* map, double num,
-                                 enum hyperdex_ds_returncode* status)
-{
-    if (map->state != hyperdex_ds_map::EXPECT_VAL)
-    {
-        *status = HYPERDEX_DS_WRONG_STATE;
-        return -1;
-    }
-
-    try
-    {
-        if (CONTAINER_VAL(map->type) == HYPERDATATYPE_GENERIC)
-        {
-            map->type = RESTRICT_CONTAINER(map->type, HYPERDATATYPE_FLOAT);
-        }
-        else if (CONTAINER_VAL(map->type) != HYPERDATATYPE_FLOAT)
-        {
-            *status = HYPERDEX_DS_MIXED_TYPES;
-            return -1;
-        }
-
-        char buf[sizeof(double)];
-        e::packdoublele(num, buf);
-        map->pairs += std::string(buf, buf + sizeof(double));
-        *status = HYPERDEX_DS_SUCCESS;
-        map->state = hyperdex_ds_map::EXPECT_KEY;
-        return 0;
-    }
-    catch (std::bad_alloc& ba)
-    {
-        errno = ENOMEM;
-        *status = HYPERDEX_DS_NOMEM;
-        return -1;
-    }
-    catch (...)
-    {
-        abort();
-    }
-}
-
-namespace
-{
-
-class map_comparator
-{
-    public:
-        map_comparator(datatype_info* di) : m_di(di) {}
-        map_comparator(const map_comparator& other) : m_di(other.m_di) {}
-
-    public:
-        map_comparator& operator = (const map_comparator& rhs)
-        { m_di = rhs.m_di; return *this; }
-        bool operator () (const std::pair<e::slice, e::slice>& lhs,
-                          const std::pair<e::slice, e::slice>& rhs)
-        { return m_di->compare_less()(lhs.first, rhs.first); }
-
-    private:
-        datatype_info* m_di;
-};
-
-} // namespace
-
-HYPERDEX_API int
-hyperdex_ds_map_finalize(struct hyperdex_ds_map* map,
-                         enum hyperdex_ds_returncode* status,
-                         const char** value, size_t* value_sz,
-                         enum hyperdatatype* datatype)
-{
-    if (map->state != hyperdex_ds_map::EXPECT_KEY)
-    {
-        *status = HYPERDEX_DS_WRONG_STATE;
-        return -1;
-    }
-    if (map->type == HYPERDATATYPE_MAP_GENERIC)
-    {
-        assert(map->pairs.empty());
-        *status = HYPERDEX_DS_SUCCESS;
-        *value = map->pairs.data();
-        *value_sz = map->pairs.size();
-        *datatype = map->type;
-        return 0;
-    }
-
-    datatype_info* dik = datatype_info::lookup(CONTAINER_KEY(map->type));
-    datatype_info* div = datatype_info::lookup(CONTAINER_VAL(map->type));
-    assert(dik);
-    assert(div);
-    const uint8_t* ptr = reinterpret_cast<const uint8_t*>(map->pairs.data());
-    const uint8_t* end = ptr + map->pairs.size();
-    e::slice key;
-    e::slice val;
-    std::vector<std::pair<e::slice, e::slice> > pairs;
-
-    while (ptr < end)
-    {
-        bool stepped;
-        stepped = dik->step(&ptr, end, &key);
-        assert(stepped);
-        stepped = div->step(&ptr, end, &val);
-        assert(stepped);
-        pairs.push_back(std::make_pair(key, val));
-    }
-
-    assert(ptr == end);
-    std::sort(pairs.begin(), pairs.end(), map_comparator(dik));
-    std::vector<char> tmp(map->pairs.size());
-    uint8_t* wr = reinterpret_cast<uint8_t*>(&tmp[0]);
-
-    for (size_t i = 0; i < pairs.size(); ++i)
-    {
-        wr = dik->write(pairs[i].first, wr);
-        wr = div->write(pairs[i].second, wr);
-    }
-
-    map->pairs = std::string(tmp.begin(), tmp.end());
-    *status = HYPERDEX_DS_SUCCESS;
-    *value = map->pairs.data();
-    *value_sz = map->pairs.size();
-    *datatype = map->type;
-    return 0;
-}
-
-HYPERDEX_API void
-hyperdex_ds_iterator_init(struct hyperdex_ds_iterator* iter,
-                          enum hyperdatatype datatype,
-                          const char* value,
-                          size_t value_sz)
-{
-    iter->datatype = datatype;
-    iter->value = value;
-    iter->value_end = value + value_sz;
-    iter->progress = value;
-}
-
-HYPERDEX_API int
-hyperdex_ds_iterate_list_string_next(struct hyperdex_ds_iterator* iter,
-                                     const char** str, size_t* str_sz)
-{
-    if (iter->datatype != HYPERDATATYPE_LIST_STRING)
-    {
-        return -1;
-    }
-
-    datatype_info* di = datatype_info::lookup(HYPERDATATYPE_STRING);
-    e::slice elem;
-
-    if (iter->progress < iter->value_end)
-    {
-        if (!di->step(reinterpret_cast<const uint8_t**>(&iter->progress),
-                      reinterpret_cast<const uint8_t*>(iter->value_end), &elem))
-        {
-            iter->progress = iter->value_end + 1;
-            return -1;
-        }
-
-        *str = reinterpret_cast<const char*>(elem.data());
-        *str_sz = elem.size();
-        return 1;
-    }
-
-    return iter->progress == iter->value_end ? 0 : -1;
-}
-
-HYPERDEX_API int
-hyperdex_ds_iterate_list_int_next(struct hyperdex_ds_iterator* iter, int64_t* num)
-{
-    if (iter->datatype != HYPERDATATYPE_LIST_INT64)
-    {
-        return -1;
-    }
-
-    datatype_info* di = datatype_info::lookup(HYPERDATATYPE_INT64);
-    e::slice elem;
-
-    if (iter->progress < iter->value_end)
-    {
-        if (!di->step(reinterpret_cast<const uint8_t**>(&iter->progress),
-                      reinterpret_cast<const uint8_t*>(iter->value_end), &elem) ||
-            elem.size() != sizeof(int64_t))
-        {
-            iter->progress = iter->value_end + 1;
-            return -1;
-        }
-
-        e::unpack64le(elem.data(), num);
-        return 1;
-    }
-
-    return iter->progress == iter->value_end ? 0 : -1;
-}
-
-HYPERDEX_API int
-hyperdex_ds_iterate_list_float_next(struct hyperdex_ds_iterator* iter, double* num)
-{
-    if (iter->datatype != HYPERDATATYPE_LIST_FLOAT)
-    {
-        return -1;
-    }
-
-    datatype_info* di = datatype_info::lookup(HYPERDATATYPE_FLOAT);
-    e::slice elem;
-
-    if (iter->progress < iter->value_end)
-    {
-        if (!di->step(reinterpret_cast<const uint8_t**>(&iter->progress),
-                      reinterpret_cast<const uint8_t*>(iter->value_end), &elem) ||
-            elem.size() != sizeof(double))
-        {
-            iter->progress = iter->value_end + 1;
-            return -1;
-        }
-
-        e::unpackdoublele(elem.data(), num);
-        return 1;
-    }
-
-    return iter->progress == iter->value_end ? 0 : -1;
-}
-
-HYPERDEX_API int
-hyperdex_ds_iterate_set_string_next(struct hyperdex_ds_iterator* iter,
-                                    const char** str, size_t* str_sz)
-{
-    if (iter->datatype != HYPERDATATYPE_SET_STRING)
-    {
-        return -1;
-    }
-
-    datatype_info* di = datatype_info::lookup(HYPERDATATYPE_STRING);
-    e::slice elem;
-
-    if (iter->progress < iter->value_end)
-    {
-        if (!di->step(reinterpret_cast<const uint8_t**>(&iter->progress),
-                      reinterpret_cast<const uint8_t*>(iter->value_end), &elem))
-        {
-            iter->progress = iter->value_end + 1;
-            return -1;
-        }
-
-        *str = reinterpret_cast<const char*>(elem.data());
-        *str_sz = elem.size();
-        return 1;
-    }
-
-    return iter->progress == iter->value_end ? 0 : -1;
-}
-
-HYPERDEX_API int
-hyperdex_ds_iterate_set_int_next(struct hyperdex_ds_iterator* iter, int64_t* num)
-{
-    if (iter->datatype != HYPERDATATYPE_SET_INT64)
-    {
-        return -1;
-    }
-
-    datatype_info* di = datatype_info::lookup(HYPERDATATYPE_INT64);
-    e::slice elem;
-
-    if (iter->progress < iter->value_end)
-    {
-        if (!di->step(reinterpret_cast<const uint8_t**>(&iter->progress),
-                      reinterpret_cast<const uint8_t*>(iter->value_end), &elem) ||
-            elem.size() != sizeof(int64_t))
-        {
-            iter->progress = iter->value_end + 1;
-            return -1;
-        }
-
-        e::unpack64le(elem.data(), num);
-        return 1;
-    }
-
-    return iter->progress == iter->value_end ? 0 : -1;
-}
-
-HYPERDEX_API int
-hyperdex_ds_iterate_set_float_next(struct hyperdex_ds_iterator* iter, double* num)
-{
-    if (iter->datatype != HYPERDATATYPE_SET_FLOAT)
-    {
-        return -1;
-    }
-
-    datatype_info* di = datatype_info::lookup(HYPERDATATYPE_FLOAT);
-    e::slice elem;
-
-    if (iter->progress < iter->value_end)
-    {
-        if (!di->step(reinterpret_cast<const uint8_t**>(&iter->progress),
-                      reinterpret_cast<const uint8_t*>(iter->value_end), &elem) ||
-            elem.size() != sizeof(double))
-        {
-            iter->progress = iter->value_end + 1;
-            return -1;
-        }
-
-        e::unpackdoublele(elem.data(), num);
-        return 1;
-    }
-
-    return iter->progress == iter->value_end ? 0 : -1;
-}
-
-HYPERDEX_API int
-hyperdex_ds_iterate_map_string_string_next(struct hyperdex_ds_iterator* iter,
-                                           const char** key, size_t* key_sz,
-                                           const char** val, size_t* val_sz)
-{
-    if (iter->datatype != HYPERDATATYPE_MAP_STRING_STRING)
-    {
-        return -1;
-    }
-
-    datatype_info* dik = datatype_info::lookup(HYPERDATATYPE_STRING);
-    datatype_info* div = datatype_info::lookup(HYPERDATATYPE_STRING);
-    e::slice mkey;
-    e::slice mval;
-
-    if (iter->progress < iter->value_end)
-    {
-        if (!dik->step(reinterpret_cast<const uint8_t**>(&iter->progress),
-                       reinterpret_cast<const uint8_t*>(iter->value_end), &mkey) ||
-            !div->step(reinterpret_cast<const uint8_t**>(&iter->progress),
-                       reinterpret_cast<const uint8_t*>(iter->value_end), &mval))
-        {
-            iter->progress = iter->value_end + 1;
-            return -1;
-        }
-
-        *key = reinterpret_cast<const char*>(mkey.data());
-        *key_sz = mkey.size();
-        *val = reinterpret_cast<const char*>(mval.data());
-        *val_sz = mval.size();
-        return 1;
-    }
-
-    return iter->progress == iter->value_end ? 0 : -1;
-}
-
-HYPERDEX_API int
-hyperdex_ds_iterate_map_string_int_next(struct hyperdex_ds_iterator* iter,
-                                        const char** key, size_t* key_sz,
-                                        int64_t* val)
-{
-    if (iter->datatype != HYPERDATATYPE_MAP_STRING_INT64)
-    {
-        return -1;
-    }
-
-    datatype_info* dik = datatype_info::lookup(HYPERDATATYPE_STRING);
-    datatype_info* div = datatype_info::lookup(HYPERDATATYPE_INT64);
-    e::slice mkey;
-    e::slice mval;
-
-    if (iter->progress < iter->value_end)
-    {
-        if (!dik->step(reinterpret_cast<const uint8_t**>(&iter->progress),
-                       reinterpret_cast<const uint8_t*>(iter->value_end), &mkey) ||
-            !div->step(reinterpret_cast<const uint8_t**>(&iter->progress),
-                       reinterpret_cast<const uint8_t*>(iter->value_end), &mval) ||
-            mval.size() != sizeof(int64_t))
-        {
-            iter->progress = iter->value_end + 1;
-            return -1;
-        }
-
-        *key = reinterpret_cast<const char*>(mkey.data());
-        *key_sz = mkey.size();
-        e::unpack64le(mval.data(), val);
-        return 1;
-    }
-
-    return iter->progress == iter->value_end ? 0 : -1;
-}
-
-HYPERDEX_API int
-hyperdex_ds_iterate_map_string_float_next(struct hyperdex_ds_iterator* iter,
-                                          const char** key, size_t* key_sz,
-                                          double* val)
-{
-    if (iter->datatype != HYPERDATATYPE_MAP_STRING_FLOAT)
-    {
-        return -1;
-    }
-
-    datatype_info* dik = datatype_info::lookup(HYPERDATATYPE_STRING);
-    datatype_info* div = datatype_info::lookup(HYPERDATATYPE_FLOAT);
-    e::slice mkey;
-    e::slice mval;
-
-    if (iter->progress < iter->value_end)
-    {
-        if (!dik->step(reinterpret_cast<const uint8_t**>(&iter->progress),
-                       reinterpret_cast<const uint8_t*>(iter->value_end), &mkey) ||
-            !div->step(reinterpret_cast<const uint8_t**>(&iter->progress),
-                       reinterpret_cast<const uint8_t*>(iter->value_end), &mval) ||
-            mval.size() != sizeof(double))
-        {
-            iter->progress = iter->value_end + 1;
-            return -1;
-        }
-
-        *key = reinterpret_cast<const char*>(mkey.data());
-        *key_sz = mkey.size();
-        e::unpackdoublele(mval.data(), val);
-        return 1;
-    }
-
-    return iter->progress == iter->value_end ? 0 : -1;
-}
-
-HYPERDEX_API int
-hyperdex_ds_iterate_map_int_string_next(struct hyperdex_ds_iterator* iter,
-                                        int64_t* key, const char** val, size_t* val_sz)
-{
-    if (iter->datatype != HYPERDATATYPE_MAP_INT64_STRING)
-    {
-        return -1;
-    }
-
-    datatype_info* dik = datatype_info::lookup(HYPERDATATYPE_INT64);
-    datatype_info* div = datatype_info::lookup(HYPERDATATYPE_STRING);
-    e::slice mkey;
-    e::slice mval;
-
-    if (iter->progress < iter->value_end)
-    {
-        if (!dik->step(reinterpret_cast<const uint8_t**>(&iter->progress),
-                       reinterpret_cast<const uint8_t*>(iter->value_end), &mkey) ||
-            !div->step(reinterpret_cast<const uint8_t**>(&iter->progress),
-                       reinterpret_cast<const uint8_t*>(iter->value_end), &mval) ||
-            mkey.size() != sizeof(int64_t))
-        {
-            iter->progress = iter->value_end + 1;
-            return -1;
-        }
-
-        e::unpack64le(mkey.data(), key);
-        *val = reinterpret_cast<const char*>(mval.data());
-        *val_sz = mval.size();
-        return 1;
-    }
-
-    return iter->progress == iter->value_end ? 0 : -1;
-}
-
-HYPERDEX_API int
-hyperdex_ds_iterate_map_int_int_next(struct hyperdex_ds_iterator* iter,
-                                     int64_t* key, int64_t* val)
-{
-    if (iter->datatype != HYPERDATATYPE_MAP_INT64_INT64)
-    {
-        return -1;
-    }
-
-    datatype_info* dik = datatype_info::lookup(HYPERDATATYPE_INT64);
-    datatype_info* div = datatype_info::lookup(HYPERDATATYPE_INT64);
-    e::slice mkey;
-    e::slice mval;
-
-    if (iter->progress < iter->value_end)
-    {
-        if (!dik->step(reinterpret_cast<const uint8_t**>(&iter->progress),
-                       reinterpret_cast<const uint8_t*>(iter->value_end), &mkey) ||
-            !div->step(reinterpret_cast<const uint8_t**>(&iter->progress),
-                       reinterpret_cast<const uint8_t*>(iter->value_end), &mval) ||
-            mkey.size() != sizeof(int64_t) ||
-            mval.size() != sizeof(int64_t))
-        {
-            iter->progress = iter->value_end + 1;
-            return -1;
-        }
-
-        e::unpack64le(mkey.data(), key);
-        e::unpack64le(mval.data(), val);
-        return 1;
-    }
-
-    return iter->progress == iter->value_end ? 0 : -1;
-}
-
-HYPERDEX_API int
-hyperdex_ds_iterate_map_int_float_next(struct hyperdex_ds_iterator* iter,
-                                       int64_t* key, double* val)
-{
-    if (iter->datatype != HYPERDATATYPE_MAP_INT64_FLOAT)
-    {
-        return -1;
-    }
-
-    datatype_info* dik = datatype_info::lookup(HYPERDATATYPE_INT64);
-    datatype_info* div = datatype_info::lookup(HYPERDATATYPE_FLOAT);
-    e::slice mkey;
-    e::slice mval;
-
-    if (iter->progress < iter->value_end)
-    {
-        if (!dik->step(reinterpret_cast<const uint8_t**>(&iter->progress),
-                       reinterpret_cast<const uint8_t*>(iter->value_end), &mkey) ||
-            !div->step(reinterpret_cast<const uint8_t**>(&iter->progress),
-                       reinterpret_cast<const uint8_t*>(iter->value_end), &mval) ||
-            mkey.size() != sizeof(int64_t) ||
-            mval.size() != sizeof(double))
-        {
-            iter->progress = iter->value_end + 1;
-            return -1;
-        }
-
-        e::unpack64le(mkey.data(), key);
-        e::unpackdoublele(mval.data(), val);
-        return 1;
-    }
-
-    return iter->progress == iter->value_end ? 0 : -1;
-}
-
-HYPERDEX_API int
-hyperdex_ds_iterate_map_float_string_next(struct hyperdex_ds_iterator* iter,
-                                          double* key, const char** val, size_t* val_sz)
-{
-    if (iter->datatype != HYPERDATATYPE_MAP_FLOAT_STRING)
-    {
-        return -1;
-    }
-
-    datatype_info* dik = datatype_info::lookup(HYPERDATATYPE_FLOAT);
-    datatype_info* div = datatype_info::lookup(HYPERDATATYPE_STRING);
-    e::slice mkey;
-    e::slice mval;
-
-    if (iter->progress < iter->value_end)
-    {
-        if (!dik->step(reinterpret_cast<const uint8_t**>(&iter->progress),
-                       reinterpret_cast<const uint8_t*>(iter->value_end), &mkey) ||
-            !div->step(reinterpret_cast<const uint8_t**>(&iter->progress),
-                       reinterpret_cast<const uint8_t*>(iter->value_end), &mval) ||
-            mkey.size() != sizeof(double))
-        {
-            iter->progress = iter->value_end + 1;
-            return -1;
-        }
-
-        e::unpackdoublele(mkey.data(), key);
-        *val = reinterpret_cast<const char*>(mval.data());
-        *val_sz = mval.size();
-        return 1;
-    }
-
-    return iter->progress == iter->value_end ? 0 : -1;
-}
-
-HYPERDEX_API int
-hyperdex_ds_iterate_map_float_int_next(struct hyperdex_ds_iterator* iter,
-                                       double* key, int64_t* val)
-{
-    if (iter->datatype != HYPERDATATYPE_MAP_FLOAT_INT64)
-    {
-        return -1;
-    }
-
-    datatype_info* dik = datatype_info::lookup(HYPERDATATYPE_FLOAT);
-    datatype_info* div = datatype_info::lookup(HYPERDATATYPE_INT64);
-    e::slice mkey;
-    e::slice mval;
-
-    if (iter->progress < iter->value_end)
-    {
-        if (!dik->step(reinterpret_cast<const uint8_t**>(&iter->progress),
-                       reinterpret_cast<const uint8_t*>(iter->value_end), &mkey) ||
-            !div->step(reinterpret_cast<const uint8_t**>(&iter->progress),
-                       reinterpret_cast<const uint8_t*>(iter->value_end), &mval) ||
-            mkey.size() != sizeof(double) ||
-            mval.size() != sizeof(int64_t))
-        {
-            iter->progress = iter->value_end + 1;
-            return -1;
-        }
-
-        e::unpackdoublele(mkey.data(), key);
-        e::unpack64le(mval.data(), val);
-        return 1;
-    }
-
-    return iter->progress == iter->value_end ? 0 : -1;
-}
-
-HYPERDEX_API int
-hyperdex_ds_iterate_map_float_float_next(struct hyperdex_ds_iterator* iter,
-                                         double* key, double* val)
-{
-    if (iter->datatype != HYPERDATATYPE_MAP_FLOAT_FLOAT)
-    {
-        return -1;
-    }
-
-    datatype_info* dik = datatype_info::lookup(HYPERDATATYPE_FLOAT);
-    datatype_info* div = datatype_info::lookup(HYPERDATATYPE_FLOAT);
-    e::slice mkey;
-    e::slice mval;
-
-    if (iter->progress < iter->value_end)
-    {
-        if (!dik->step(reinterpret_cast<const uint8_t**>(&iter->progress),
-                       reinterpret_cast<const uint8_t*>(iter->value_end), &mkey) ||
-            !div->step(reinterpret_cast<const uint8_t**>(&iter->progress),
-                       reinterpret_cast<const uint8_t*>(iter->value_end), &mval) ||
-            mkey.size() != sizeof(double) ||
-            mval.size() != sizeof(double))
-        {
-            iter->progress = iter->value_end + 1;
-            return -1;
-        }
-
-        e::unpackdoublele(mkey.data(), key);
-        e::unpackdoublele(mval.data(), val);
-        return 1;
-    }
-
-    return iter->progress == iter->value_end ? 0 : -1;
-}
+	///////////////////////////////////// Arena ////////////////////////////////////
+
+	HYPERDEX_API struct hyperdex_ds_arena *
+	hyperdex_ds_arena_create()
+	{
+		return new (std::nothrow) hyperdex_ds_arena();
+	}
+
+	HYPERDEX_API void
+	hyperdex_ds_arena_destroy(struct hyperdex_ds_arena *arena)
+	{
+		if (arena)
+		{
+			delete arena;
+		}
+	}
+
+	HYPERDEX_API void *
+	hyperdex_ds_malloc(struct hyperdex_ds_arena *arena, size_t sz)
+	{
+		return reinterpret_cast<void *>(arena->allocate(sz));
+	}
+
+	//////////////////////////////// Client Structs ////////////////////////////////
+
+	HYPERDEX_API struct hyperdex_client_attribute *
+	hyperdex_ds_allocate_attribute(struct hyperdex_ds_arena *arena, size_t sz)
+	{
+		size_t bytes = sizeof(struct hyperdex_client_attribute) * sz;
+		return reinterpret_cast<struct hyperdex_client_attribute *>(arena->allocate(bytes));
+	}
+
+	HYPERDEX_API struct hyperdex_client_attribute_check *
+	hyperdex_ds_allocate_attribute_check(struct hyperdex_ds_arena *arena, size_t sz)
+	{
+		size_t bytes = sizeof(struct hyperdex_client_attribute_check) * sz;
+		return reinterpret_cast<struct hyperdex_client_attribute_check *>(arena->allocate(bytes));
+	}
+
+	HYPERDEX_API struct hyperdex_client_map_attribute *
+	hyperdex_ds_allocate_map_attribute(struct hyperdex_ds_arena *arena, size_t sz)
+	{
+		size_t bytes = sizeof(struct hyperdex_client_map_attribute) * sz;
+		return reinterpret_cast<struct hyperdex_client_map_attribute *>(arena->allocate(bytes));
+	}
+
+	//////////////////////////// pack/unpack ints/floats ///////////////////////////
+
+	HYPERDEX_API void
+	hyperdex_ds_pack_int(int64_t num, char *buf)
+	{
+		e::pack64le(num, buf);
+	}
+
+	HYPERDEX_API int
+	hyperdex_ds_unpack_int(const char *value, size_t value_sz, int64_t *num)
+	{
+		if (value_sz == 0)
+		{
+			*num = 0;
+			return 0;
+		}
+		else if (value_sz != sizeof(int64_t))
+		{
+			return -1;
+		}
+		e::unpack64le(value, num);
+		return 0;
+	}
+
+	HYPERDEX_API void
+	hyperdex_ds_pack_float(double num, char *buf)
+	{
+		e::packdoublele(num, buf);
+	}
+
+	HYPERDEX_API int
+	hyperdex_ds_unpack_float(const char *value, size_t value_sz, double *num)
+	{
+		if (value_sz == 0)
+		{
+			*num = 0;
+			return 0;
+		}
+		else if (value_sz != sizeof(double))
+		{
+			return -1;
+		}
+		e::unpackdoublele(value, num);
+		return 0;
+	}
+
+	HYPERDEX_API int
+	hyperdex_ds_copy_string(struct hyperdex_ds_arena *arena,
+	                        const char *str, size_t str_sz,
+	                        enum hyperdex_ds_returncode *status,
+	                        const char **value, size_t *value_sz)
+	{
+		char *x = reinterpret_cast<char *>(arena->allocate(str_sz));
+		if (!x)
+		{
+			*status = HYPERDEX_DS_NOMEM;
+			return -1;
+		}
+		memmove(x, str, str_sz);
+		*value = x;
+		*value_sz = str_sz;
+		*status = HYPERDEX_DS_SUCCESS;
+		return 0;
+	}
+
+	HYPERDEX_API int
+	hyperdex_ds_copy_int(struct hyperdex_ds_arena *arena, int64_t num,
+	                     enum hyperdex_ds_returncode *status,
+	                     const char **value, size_t *value_sz)
+	{
+		char *x = reinterpret_cast<char *>(arena->allocate(sizeof(int64_t)));
+		if (!x)
+		{
+			*status = HYPERDEX_DS_NOMEM;
+			return -1;
+		}
+		e::pack64le(num, x);
+		*value = x;
+		*value_sz = sizeof(int64_t);
+		*status = HYPERDEX_DS_SUCCESS;
+		return 0;
+	}
+
+	HYPERDEX_API int
+	hyperdex_ds_copy_float(struct hyperdex_ds_arena *arena, double num,
+	                       enum hyperdex_ds_returncode *status,
+	                       const char **value, size_t *value_sz)
+	{
+		char *x = reinterpret_cast<char *>(arena->allocate(sizeof(double)));
+		if (!x)
+		{
+			*status = HYPERDEX_DS_NOMEM;
+			return -1;
+		}
+		e::packdoublele(num, x);
+		*value = x;
+		*value_sz = sizeof(double);
+		*status = HYPERDEX_DS_SUCCESS;
+		return 0;
+	}
+
+	////////////////////////////////// pack lists //////////////////////////////////
+
+	HYPERDEX_API struct hyperdex_ds_list *
+	hyperdex_ds_allocate_list(struct hyperdex_ds_arena *arena)
+	{
+		return arena->allocate_list();
+	}
+
+	HYPERDEX_API int
+	hyperdex_ds_list_append_string(struct hyperdex_ds_list *list,
+	                               const char *str, size_t str_sz,
+	                               enum hyperdex_ds_returncode *status)
+	{
+		try
+		{
+			if (list->type == HYPERDATATYPE_LIST_GENERIC)
+			{
+				list->type = HYPERDATATYPE_LIST_STRING;
+			}
+			else if (list->type != HYPERDATATYPE_LIST_STRING)
+			{
+				*status = HYPERDEX_DS_MIXED_TYPES;
+				return -1;
+			}
+			if (str_sz >= UINT32_MAX)
+			{
+				*status = HYPERDEX_DS_STRING_TOO_LONG;
+				return -1;
+			}
+			char buf[sizeof(uint32_t)];
+			e::pack32le(str_sz, buf);
+			list->elems += std::string(buf, sizeof(uint32_t));
+			list->elems += std::string(str, str_sz);
+			*status = HYPERDEX_DS_SUCCESS;
+			return 0;
+		}
+		catch (std::bad_alloc &ba)
+		{
+			errno = ENOMEM;
+			*status = HYPERDEX_DS_NOMEM;
+			return -1;
+		}
+		catch (...)
+		{
+			abort();
+		}
+	}
+
+	HYPERDEX_API int
+	hyperdex_ds_list_append_int(struct hyperdex_ds_list *list,
+	                            int64_t num,
+	                            enum hyperdex_ds_returncode *status)
+	{
+		try
+		{
+			if (list->type == HYPERDATATYPE_LIST_GENERIC)
+			{
+				list->type = HYPERDATATYPE_LIST_INT64;
+			}
+			else if (list->type != HYPERDATATYPE_LIST_INT64)
+			{
+				*status = HYPERDEX_DS_MIXED_TYPES;
+				return -1;
+			}
+			char buf[sizeof(int64_t)];
+			e::pack64le(num, buf);
+			list->elems += std::string(buf, buf + sizeof(int64_t));
+			*status = HYPERDEX_DS_SUCCESS;
+			return 0;
+		}
+		catch (std::bad_alloc &ba)
+		{
+			errno = ENOMEM;
+			*status = HYPERDEX_DS_NOMEM;
+			return -1;
+		}
+		catch (...)
+		{
+			abort();
+		}
+	}
+
+	HYPERDEX_API int
+	hyperdex_ds_list_append_float(struct hyperdex_ds_list *list,
+	                              double num,
+	                              enum hyperdex_ds_returncode *status)
+	{
+		try
+		{
+			if (list->type == HYPERDATATYPE_LIST_GENERIC)
+			{
+				list->type = HYPERDATATYPE_LIST_FLOAT;
+			}
+			else if (list->type != HYPERDATATYPE_LIST_FLOAT)
+			{
+				*status = HYPERDEX_DS_MIXED_TYPES;
+				return -1;
+			}
+			char buf[sizeof(double)];
+			e::packdoublele(num, buf);
+			list->elems += std::string(buf, buf + sizeof(double));
+			*status = HYPERDEX_DS_SUCCESS;
+			return 0;
+		}
+		catch (std::bad_alloc &ba)
+		{
+			errno = ENOMEM;
+			*status = HYPERDEX_DS_NOMEM;
+			return -1;
+		}
+		catch (...)
+		{
+			abort();
+		}
+	}
+
+	HYPERDEX_API int
+	hyperdex_ds_list_finalize(struct hyperdex_ds_list *list,
+	                          enum hyperdex_ds_returncode *status,
+	                          const char **value, size_t *value_sz,
+	                          enum hyperdatatype *datatype)
+	{
+		*status = HYPERDEX_DS_SUCCESS;
+		*value = list->elems.data();
+		*value_sz = list->elems.size();
+		*datatype = list->type;
+		return 0;
+	}
+
+	/////////////////////////////////// pack sets //////////////////////////////////
+
+	HYPERDEX_API struct hyperdex_ds_set *
+	hyperdex_ds_allocate_set(struct hyperdex_ds_arena *arena)
+	{
+		return arena->allocate_set();
+	}
+
+	HYPERDEX_API int
+	hyperdex_ds_set_insert_string(struct hyperdex_ds_set *set,
+	                              const char *str, size_t str_sz,
+	                              enum hyperdex_ds_returncode *status)
+	{
+		try
+		{
+			if (set->type == HYPERDATATYPE_SET_GENERIC)
+			{
+				set->type = HYPERDATATYPE_SET_STRING;
+			}
+			else if (set->type != HYPERDATATYPE_SET_STRING)
+			{
+				*status = HYPERDEX_DS_MIXED_TYPES;
+				return -1;
+			}
+			if (str_sz >= UINT32_MAX)
+			{
+				*status = HYPERDEX_DS_STRING_TOO_LONG;
+				return -1;
+			}
+			char buf[sizeof(uint32_t)];
+			e::pack32le(str_sz, buf);
+			set->elems += std::string(buf, sizeof(uint32_t));
+			set->elems += std::string(str, str_sz);
+			*status = HYPERDEX_DS_SUCCESS;
+			return 0;
+		}
+		catch (std::bad_alloc &ba)
+		{
+			errno = ENOMEM;
+			*status = HYPERDEX_DS_NOMEM;
+			return -1;
+		}
+		catch (...)
+		{
+			abort();
+		}
+	}
+
+	HYPERDEX_API int
+	hyperdex_ds_set_insert_int(struct hyperdex_ds_set *set, int64_t num,
+	                           enum hyperdex_ds_returncode *status)
+	{
+		try
+		{
+			if (set->type == HYPERDATATYPE_SET_GENERIC)
+			{
+				set->type = HYPERDATATYPE_SET_INT64;
+			}
+			else if (set->type != HYPERDATATYPE_SET_INT64)
+			{
+				*status = HYPERDEX_DS_MIXED_TYPES;
+				return -1;
+			}
+			char buf[sizeof(int64_t)];
+			e::pack64le(num, buf);
+			set->elems += std::string(buf, buf + sizeof(int64_t));
+			*status = HYPERDEX_DS_SUCCESS;
+			return 0;
+		}
+		catch (std::bad_alloc &ba)
+		{
+			errno = ENOMEM;
+			*status = HYPERDEX_DS_NOMEM;
+			return -1;
+		}
+		catch (...)
+		{
+			abort();
+		}
+	}
+
+	HYPERDEX_API int
+	hyperdex_ds_set_insert_float(struct hyperdex_ds_set *set, double num,
+	                             enum hyperdex_ds_returncode *status)
+	{
+		try
+		{
+			if (set->type == HYPERDATATYPE_SET_GENERIC)
+			{
+				set->type = HYPERDATATYPE_SET_FLOAT;
+			}
+			else if (set->type != HYPERDATATYPE_SET_FLOAT)
+			{
+				*status = HYPERDEX_DS_MIXED_TYPES;
+				return -1;
+			}
+			char buf[sizeof(double)];
+			e::packdoublele(num, buf);
+			set->elems += std::string(buf, buf + sizeof(double));
+			*status = HYPERDEX_DS_SUCCESS;
+			return 0;
+		}
+		catch (std::bad_alloc &ba)
+		{
+			errno = ENOMEM;
+			*status = HYPERDEX_DS_NOMEM;
+			return -1;
+		}
+		catch (...)
+		{
+			abort();
+		}
+	}
+
+	HYPERDEX_API int
+	hyperdex_ds_set_finalize(struct hyperdex_ds_set *set,
+	                         enum hyperdex_ds_returncode *status,
+	                         const char **value, size_t *value_sz,
+	                         enum hyperdatatype *datatype)
+	{
+		if (set->type == HYPERDATATYPE_SET_GENERIC)
+		{
+			assert(set->elems.empty());
+			*status = HYPERDEX_DS_SUCCESS;
+			*value = set->elems.data();
+			*value_sz = set->elems.size();
+			*datatype = set->type;
+			return 0;
+		}
+		datatype_info *di = datatype_info::lookup(CONTAINER_ELEM(set->type));
+		assert(di);
+		const uint8_t *ptr = reinterpret_cast<const uint8_t *>(set->elems.data());
+		const uint8_t *end = ptr + set->elems.size();
+		e::slice elem;
+		std::vector<e::slice> elems;
+		while (ptr < end)
+		{
+			bool stepped = di->step(&ptr, end, &elem);
+			assert(stepped);
+			elems.push_back(elem);
+		}
+		assert(ptr == end);
+		std::sort(elems.begin(), elems.end(), di->compare_less());
+		std::vector<char> tmp(set->elems.size());
+		uint8_t *wr = reinterpret_cast<uint8_t *>(&tmp[0]);
+		for (size_t i = 0; i < elems.size(); ++i)
+		{
+			wr = di->write(elems[i], wr);
+		}
+		set->elems = std::string(tmp.begin(), tmp.end());
+		*status = HYPERDEX_DS_SUCCESS;
+		*value = set->elems.data();
+		*value_sz = set->elems.size();
+		*datatype = set->type;
+		return 0;
+	}
+
+	/////////////////////////////////// pack maps //////////////////////////////////
+
+	HYPERDEX_API struct hyperdex_ds_map *
+	hyperdex_ds_allocate_map(struct hyperdex_ds_arena *arena)
+	{
+		return arena->allocate_map();
+	}
+
+	HYPERDEX_API int
+	hyperdex_ds_map_insert_key_string(struct hyperdex_ds_map *map,
+	                                  const char *str, size_t str_sz,
+	                                  enum hyperdex_ds_returncode *status)
+	{
+		if (map->state != hyperdex_ds_map::EXPECT_KEY)
+		{
+			*status = HYPERDEX_DS_WRONG_STATE;
+			return -1;
+		}
+		try
+		{
+			if (CONTAINER_KEY(map->type) == HYPERDATATYPE_GENERIC)
+			{
+				map->type = HYPERDATATYPE_MAP_STRING_KEYONLY;
+			}
+			else if (CONTAINER_KEY(map->type) != HYPERDATATYPE_STRING)
+			{
+				*status = HYPERDEX_DS_MIXED_TYPES;
+				return -1;
+			}
+			if (str_sz >= UINT32_MAX)
+			{
+				*status = HYPERDEX_DS_STRING_TOO_LONG;
+				return -1;
+			}
+			char buf[sizeof(uint32_t)];
+			e::pack32le(str_sz, buf);
+			map->pairs += std::string(buf, sizeof(uint32_t));
+			map->pairs += std::string(str, str_sz);
+			*status = HYPERDEX_DS_SUCCESS;
+			map->state = hyperdex_ds_map::EXPECT_VAL;
+			return 0;
+		}
+		catch (std::bad_alloc &ba)
+		{
+			errno = ENOMEM;
+			*status = HYPERDEX_DS_NOMEM;
+			return -1;
+		}
+		catch (...)
+		{
+			abort();
+		}
+	}
+
+	HYPERDEX_API int
+	hyperdex_ds_map_insert_val_string(struct hyperdex_ds_map *map,
+	                                  const char *str, size_t str_sz,
+	                                  enum hyperdex_ds_returncode *status)
+	{
+		if (map->state != hyperdex_ds_map::EXPECT_VAL)
+		{
+			*status = HYPERDEX_DS_WRONG_STATE;
+			return -1;
+		}
+		try
+		{
+			if (CONTAINER_VAL(map->type) == HYPERDATATYPE_GENERIC)
+			{
+				map->type = RESTRICT_CONTAINER(map->type, HYPERDATATYPE_STRING);
+			}
+			else if (CONTAINER_VAL(map->type) != HYPERDATATYPE_STRING)
+			{
+				*status = HYPERDEX_DS_MIXED_TYPES;
+				return -1;
+			}
+			if (str_sz >= UINT32_MAX)
+			{
+				*status = HYPERDEX_DS_STRING_TOO_LONG;
+				return -1;
+			}
+			char buf[sizeof(uint32_t)];
+			e::pack32le(str_sz, buf);
+			map->pairs += std::string(buf, sizeof(uint32_t));
+			map->pairs += std::string(str, str_sz);
+			*status = HYPERDEX_DS_SUCCESS;
+			map->state = hyperdex_ds_map::EXPECT_KEY;
+			return 0;
+		}
+		catch (std::bad_alloc &ba)
+		{
+			errno = ENOMEM;
+			*status = HYPERDEX_DS_NOMEM;
+			return -1;
+		}
+		catch (...)
+		{
+			abort();
+		}
+	}
+
+	HYPERDEX_API int
+	hyperdex_ds_map_insert_key_int(struct hyperdex_ds_map *map, int64_t num,
+	                               enum hyperdex_ds_returncode *status)
+	{
+		if (map->state != hyperdex_ds_map::EXPECT_KEY)
+		{
+			*status = HYPERDEX_DS_WRONG_STATE;
+			return -1;
+		}
+		try
+		{
+			if (CONTAINER_KEY(map->type) == HYPERDATATYPE_GENERIC)
+			{
+				map->type = HYPERDATATYPE_MAP_INT64_KEYONLY;
+			}
+			else if (CONTAINER_KEY(map->type) != HYPERDATATYPE_INT64)
+			{
+				*status = HYPERDEX_DS_MIXED_TYPES;
+				return -1;
+			}
+			char buf[sizeof(int64_t)];
+			e::pack64le(num, buf);
+			map->pairs += std::string(buf, buf + sizeof(int64_t));
+			*status = HYPERDEX_DS_SUCCESS;
+			map->state = hyperdex_ds_map::EXPECT_VAL;
+			return 0;
+		}
+		catch (std::bad_alloc &ba)
+		{
+			errno = ENOMEM;
+			*status = HYPERDEX_DS_NOMEM;
+			return -1;
+		}
+		catch (...)
+		{
+			abort();
+		}
+	}
+
+	HYPERDEX_API int
+	hyperdex_ds_map_insert_val_int(struct hyperdex_ds_map *map, int64_t num,
+	                               enum hyperdex_ds_returncode *status)
+	{
+		if (map->state != hyperdex_ds_map::EXPECT_VAL)
+		{
+			*status = HYPERDEX_DS_WRONG_STATE;
+			return -1;
+		}
+		try
+		{
+			if (CONTAINER_VAL(map->type) == HYPERDATATYPE_GENERIC)
+			{
+				map->type = RESTRICT_CONTAINER(map->type, HYPERDATATYPE_INT64);
+			}
+			else if (CONTAINER_VAL(map->type) != HYPERDATATYPE_INT64)
+			{
+				*status = HYPERDEX_DS_MIXED_TYPES;
+				return -1;
+			}
+			char buf[sizeof(int64_t)];
+			e::pack64le(num, buf);
+			map->pairs += std::string(buf, buf + sizeof(int64_t));
+			*status = HYPERDEX_DS_SUCCESS;
+			map->state = hyperdex_ds_map::EXPECT_KEY;
+			return 0;
+		}
+		catch (std::bad_alloc &ba)
+		{
+			errno = ENOMEM;
+			*status = HYPERDEX_DS_NOMEM;
+			return -1;
+		}
+		catch (...)
+		{
+			abort();
+		}
+	}
+
+	HYPERDEX_API int
+	hyperdex_ds_map_insert_key_float(struct hyperdex_ds_map *map, double num,
+	                                 enum hyperdex_ds_returncode *status)
+	{
+		if (map->state != hyperdex_ds_map::EXPECT_KEY)
+		{
+			*status = HYPERDEX_DS_WRONG_STATE;
+			return -1;
+		}
+		try
+		{
+			if (CONTAINER_KEY(map->type) == HYPERDATATYPE_GENERIC)
+			{
+				map->type = HYPERDATATYPE_MAP_FLOAT_KEYONLY;
+			}
+			else if (CONTAINER_KEY(map->type) != HYPERDATATYPE_FLOAT)
+			{
+				*status = HYPERDEX_DS_MIXED_TYPES;
+				return -1;
+			}
+			char buf[sizeof(double)];
+			e::packdoublele(num, buf);
+			map->pairs += std::string(buf, buf + sizeof(double));
+			*status = HYPERDEX_DS_SUCCESS;
+			map->state = hyperdex_ds_map::EXPECT_VAL;
+			return 0;
+		}
+		catch (std::bad_alloc &ba)
+		{
+			errno = ENOMEM;
+			*status = HYPERDEX_DS_NOMEM;
+			return -1;
+		}
+		catch (...)
+		{
+			abort();
+		}
+	}
+
+	HYPERDEX_API int
+	hyperdex_ds_map_insert_val_float(struct hyperdex_ds_map *map, double num,
+	                                 enum hyperdex_ds_returncode *status)
+	{
+		if (map->state != hyperdex_ds_map::EXPECT_VAL)
+		{
+			*status = HYPERDEX_DS_WRONG_STATE;
+			return -1;
+		}
+		try
+		{
+			if (CONTAINER_VAL(map->type) == HYPERDATATYPE_GENERIC)
+			{
+				map->type = RESTRICT_CONTAINER(map->type, HYPERDATATYPE_FLOAT);
+			}
+			else if (CONTAINER_VAL(map->type) != HYPERDATATYPE_FLOAT)
+			{
+				*status = HYPERDEX_DS_MIXED_TYPES;
+				return -1;
+			}
+			char buf[sizeof(double)];
+			e::packdoublele(num, buf);
+			map->pairs += std::string(buf, buf + sizeof(double));
+			*status = HYPERDEX_DS_SUCCESS;
+			map->state = hyperdex_ds_map::EXPECT_KEY;
+			return 0;
+		}
+		catch (std::bad_alloc &ba)
+		{
+			errno = ENOMEM;
+			*status = HYPERDEX_DS_NOMEM;
+			return -1;
+		}
+		catch (...)
+		{
+			abort();
+		}
+	}
+
+	namespace
+	{
+
+	class map_comparator
+	{
+	public:
+		map_comparator(datatype_info *di) : m_di(di) {}
+		map_comparator(const map_comparator &other) : m_di(other.m_di) {}
+
+	public:
+		map_comparator &operator = (const map_comparator &rhs)
+		{ m_di = rhs.m_di; return *this; }
+		bool operator () (const std::pair<e::slice, e::slice> &lhs,
+		                  const std::pair<e::slice, e::slice> &rhs)
+		{ return m_di->compare_less()(lhs.first, rhs.first); }
+
+	private:
+		datatype_info *m_di;
+	};
+
+	} // namespace
+
+	HYPERDEX_API int
+	hyperdex_ds_map_finalize(struct hyperdex_ds_map *map,
+	                         enum hyperdex_ds_returncode *status,
+	                         const char **value, size_t *value_sz,
+	                         enum hyperdatatype *datatype)
+	{
+		if (map->state != hyperdex_ds_map::EXPECT_KEY)
+		{
+			*status = HYPERDEX_DS_WRONG_STATE;
+			return -1;
+		}
+		if (map->type == HYPERDATATYPE_MAP_GENERIC)
+		{
+			assert(map->pairs.empty());
+			*status = HYPERDEX_DS_SUCCESS;
+			*value = map->pairs.data();
+			*value_sz = map->pairs.size();
+			*datatype = map->type;
+			return 0;
+		}
+		datatype_info *dik = datatype_info::lookup(CONTAINER_KEY(map->type));
+		datatype_info *div = datatype_info::lookup(CONTAINER_VAL(map->type));
+		assert(dik);
+		assert(div);
+		const uint8_t *ptr = reinterpret_cast<const uint8_t *>(map->pairs.data());
+		const uint8_t *end = ptr + map->pairs.size();
+		e::slice key;
+		e::slice val;
+		std::vector<std::pair<e::slice, e::slice> > pairs;
+		while (ptr < end)
+		{
+			bool stepped;
+			stepped = dik->step(&ptr, end, &key);
+			assert(stepped);
+			stepped = div->step(&ptr, end, &val);
+			assert(stepped);
+			pairs.push_back(std::make_pair(key, val));
+		}
+		assert(ptr == end);
+		std::sort(pairs.begin(), pairs.end(), map_comparator(dik));
+		std::vector<char> tmp(map->pairs.size());
+		uint8_t *wr = reinterpret_cast<uint8_t *>(&tmp[0]);
+		for (size_t i = 0; i < pairs.size(); ++i)
+		{
+			wr = dik->write(pairs[i].first, wr);
+			wr = div->write(pairs[i].second, wr);
+		}
+		map->pairs = std::string(tmp.begin(), tmp.end());
+		*status = HYPERDEX_DS_SUCCESS;
+		*value = map->pairs.data();
+		*value_sz = map->pairs.size();
+		*datatype = map->type;
+		return 0;
+	}
+
+	HYPERDEX_API void
+	hyperdex_ds_iterator_init(struct hyperdex_ds_iterator *iter,
+	                          enum hyperdatatype datatype,
+	                          const char *value,
+	                          size_t value_sz)
+	{
+		iter->datatype = datatype;
+		iter->value = value;
+		iter->value_end = value + value_sz;
+		iter->progress = value;
+	}
+
+	HYPERDEX_API int
+	hyperdex_ds_iterate_list_string_next(struct hyperdex_ds_iterator *iter,
+	                                     const char **str, size_t *str_sz)
+	{
+		if (iter->datatype != HYPERDATATYPE_LIST_STRING)
+		{
+			return -1;
+		}
+		datatype_info *di = datatype_info::lookup(HYPERDATATYPE_STRING);
+		e::slice elem;
+		if (iter->progress < iter->value_end)
+		{
+			if (!di->step(reinterpret_cast<const uint8_t **>(&iter->progress),
+			              reinterpret_cast<const uint8_t *>(iter->value_end), &elem))
+			{
+				iter->progress = iter->value_end + 1;
+				return -1;
+			}
+			*str = reinterpret_cast<const char *>(elem.data());
+			*str_sz = elem.size();
+			return 1;
+		}
+		return iter->progress == iter->value_end ? 0 : -1;
+	}
+
+	HYPERDEX_API int
+	hyperdex_ds_iterate_list_int_next(struct hyperdex_ds_iterator *iter, int64_t *num)
+	{
+		if (iter->datatype != HYPERDATATYPE_LIST_INT64)
+		{
+			return -1;
+		}
+		datatype_info *di = datatype_info::lookup(HYPERDATATYPE_INT64);
+		e::slice elem;
+		if (iter->progress < iter->value_end)
+		{
+			if (!di->step(reinterpret_cast<const uint8_t **>(&iter->progress),
+			              reinterpret_cast<const uint8_t *>(iter->value_end), &elem) ||
+			    elem.size() != sizeof(int64_t))
+			{
+				iter->progress = iter->value_end + 1;
+				return -1;
+			}
+			e::unpack64le(elem.data(), num);
+			return 1;
+		}
+		return iter->progress == iter->value_end ? 0 : -1;
+	}
+
+	HYPERDEX_API int
+	hyperdex_ds_iterate_list_float_next(struct hyperdex_ds_iterator *iter, double *num)
+	{
+		if (iter->datatype != HYPERDATATYPE_LIST_FLOAT)
+		{
+			return -1;
+		}
+		datatype_info *di = datatype_info::lookup(HYPERDATATYPE_FLOAT);
+		e::slice elem;
+		if (iter->progress < iter->value_end)
+		{
+			if (!di->step(reinterpret_cast<const uint8_t **>(&iter->progress),
+			              reinterpret_cast<const uint8_t *>(iter->value_end), &elem) ||
+			    elem.size() != sizeof(double))
+			{
+				iter->progress = iter->value_end + 1;
+				return -1;
+			}
+			e::unpackdoublele(elem.data(), num);
+			return 1;
+		}
+		return iter->progress == iter->value_end ? 0 : -1;
+	}
+
+	HYPERDEX_API int
+	hyperdex_ds_iterate_set_string_next(struct hyperdex_ds_iterator *iter,
+	                                    const char **str, size_t *str_sz)
+	{
+		if (iter->datatype != HYPERDATATYPE_SET_STRING)
+		{
+			return -1;
+		}
+		datatype_info *di = datatype_info::lookup(HYPERDATATYPE_STRING);
+		e::slice elem;
+		if (iter->progress < iter->value_end)
+		{
+			if (!di->step(reinterpret_cast<const uint8_t **>(&iter->progress),
+			              reinterpret_cast<const uint8_t *>(iter->value_end), &elem))
+			{
+				iter->progress = iter->value_end + 1;
+				return -1;
+			}
+			*str = reinterpret_cast<const char *>(elem.data());
+			*str_sz = elem.size();
+			return 1;
+		}
+		return iter->progress == iter->value_end ? 0 : -1;
+	}
+
+	HYPERDEX_API int
+	hyperdex_ds_iterate_set_int_next(struct hyperdex_ds_iterator *iter, int64_t *num)
+	{
+		if (iter->datatype != HYPERDATATYPE_SET_INT64)
+		{
+			return -1;
+		}
+		datatype_info *di = datatype_info::lookup(HYPERDATATYPE_INT64);
+		e::slice elem;
+		if (iter->progress < iter->value_end)
+		{
+			if (!di->step(reinterpret_cast<const uint8_t **>(&iter->progress),
+			              reinterpret_cast<const uint8_t *>(iter->value_end), &elem) ||
+			    elem.size() != sizeof(int64_t))
+			{
+				iter->progress = iter->value_end + 1;
+				return -1;
+			}
+			e::unpack64le(elem.data(), num);
+			return 1;
+		}
+		return iter->progress == iter->value_end ? 0 : -1;
+	}
+
+	HYPERDEX_API int
+	hyperdex_ds_iterate_set_float_next(struct hyperdex_ds_iterator *iter, double *num)
+	{
+		if (iter->datatype != HYPERDATATYPE_SET_FLOAT)
+		{
+			return -1;
+		}
+		datatype_info *di = datatype_info::lookup(HYPERDATATYPE_FLOAT);
+		e::slice elem;
+		if (iter->progress < iter->value_end)
+		{
+			if (!di->step(reinterpret_cast<const uint8_t **>(&iter->progress),
+			              reinterpret_cast<const uint8_t *>(iter->value_end), &elem) ||
+			    elem.size() != sizeof(double))
+			{
+				iter->progress = iter->value_end + 1;
+				return -1;
+			}
+			e::unpackdoublele(elem.data(), num);
+			return 1;
+		}
+		return iter->progress == iter->value_end ? 0 : -1;
+	}
+
+	HYPERDEX_API int
+	hyperdex_ds_iterate_map_string_string_next(struct hyperdex_ds_iterator *iter,
+	                                           const char **key, size_t *key_sz,
+	                                           const char **val, size_t *val_sz)
+	{
+		if (iter->datatype != HYPERDATATYPE_MAP_STRING_STRING)
+		{
+			return -1;
+		}
+		datatype_info *dik = datatype_info::lookup(HYPERDATATYPE_STRING);
+		datatype_info *div = datatype_info::lookup(HYPERDATATYPE_STRING);
+		e::slice mkey;
+		e::slice mval;
+		if (iter->progress < iter->value_end)
+		{
+			if (!dik->step(reinterpret_cast<const uint8_t **>(&iter->progress),
+			               reinterpret_cast<const uint8_t *>(iter->value_end), &mkey) ||
+			    !div->step(reinterpret_cast<const uint8_t **>(&iter->progress),
+			               reinterpret_cast<const uint8_t *>(iter->value_end), &mval))
+			{
+				iter->progress = iter->value_end + 1;
+				return -1;
+			}
+			*key = reinterpret_cast<const char *>(mkey.data());
+			*key_sz = mkey.size();
+			*val = reinterpret_cast<const char *>(mval.data());
+			*val_sz = mval.size();
+			return 1;
+		}
+		return iter->progress == iter->value_end ? 0 : -1;
+	}
+
+	HYPERDEX_API int
+	hyperdex_ds_iterate_map_string_int_next(struct hyperdex_ds_iterator *iter,
+	                                        const char **key, size_t *key_sz,
+	                                        int64_t *val)
+	{
+		if (iter->datatype != HYPERDATATYPE_MAP_STRING_INT64)
+		{
+			return -1;
+		}
+		datatype_info *dik = datatype_info::lookup(HYPERDATATYPE_STRING);
+		datatype_info *div = datatype_info::lookup(HYPERDATATYPE_INT64);
+		e::slice mkey;
+		e::slice mval;
+		if (iter->progress < iter->value_end)
+		{
+			if (!dik->step(reinterpret_cast<const uint8_t **>(&iter->progress),
+			               reinterpret_cast<const uint8_t *>(iter->value_end), &mkey) ||
+			    !div->step(reinterpret_cast<const uint8_t **>(&iter->progress),
+			               reinterpret_cast<const uint8_t *>(iter->value_end), &mval) ||
+			    mval.size() != sizeof(int64_t))
+			{
+				iter->progress = iter->value_end + 1;
+				return -1;
+			}
+			*key = reinterpret_cast<const char *>(mkey.data());
+			*key_sz = mkey.size();
+			e::unpack64le(mval.data(), val);
+			return 1;
+		}
+		return iter->progress == iter->value_end ? 0 : -1;
+	}
+
+	HYPERDEX_API int
+	hyperdex_ds_iterate_map_string_float_next(struct hyperdex_ds_iterator *iter,
+	                                          const char **key, size_t *key_sz,
+	                                          double *val)
+	{
+		if (iter->datatype != HYPERDATATYPE_MAP_STRING_FLOAT)
+		{
+			return -1;
+		}
+		datatype_info *dik = datatype_info::lookup(HYPERDATATYPE_STRING);
+		datatype_info *div = datatype_info::lookup(HYPERDATATYPE_FLOAT);
+		e::slice mkey;
+		e::slice mval;
+		if (iter->progress < iter->value_end)
+		{
+			if (!dik->step(reinterpret_cast<const uint8_t **>(&iter->progress),
+			               reinterpret_cast<const uint8_t *>(iter->value_end), &mkey) ||
+			    !div->step(reinterpret_cast<const uint8_t **>(&iter->progress),
+			               reinterpret_cast<const uint8_t *>(iter->value_end), &mval) ||
+			    mval.size() != sizeof(double))
+			{
+				iter->progress = iter->value_end + 1;
+				return -1;
+			}
+			*key = reinterpret_cast<const char *>(mkey.data());
+			*key_sz = mkey.size();
+			e::unpackdoublele(mval.data(), val);
+			return 1;
+		}
+		return iter->progress == iter->value_end ? 0 : -1;
+	}
+
+	HYPERDEX_API int
+	hyperdex_ds_iterate_map_int_string_next(struct hyperdex_ds_iterator *iter,
+	                                        int64_t *key, const char **val, size_t *val_sz)
+	{
+		if (iter->datatype != HYPERDATATYPE_MAP_INT64_STRING)
+		{
+			return -1;
+		}
+		datatype_info *dik = datatype_info::lookup(HYPERDATATYPE_INT64);
+		datatype_info *div = datatype_info::lookup(HYPERDATATYPE_STRING);
+		e::slice mkey;
+		e::slice mval;
+		if (iter->progress < iter->value_end)
+		{
+			if (!dik->step(reinterpret_cast<const uint8_t **>(&iter->progress),
+			               reinterpret_cast<const uint8_t *>(iter->value_end), &mkey) ||
+			    !div->step(reinterpret_cast<const uint8_t **>(&iter->progress),
+			               reinterpret_cast<const uint8_t *>(iter->value_end), &mval) ||
+			    mkey.size() != sizeof(int64_t))
+			{
+				iter->progress = iter->value_end + 1;
+				return -1;
+			}
+			e::unpack64le(mkey.data(), key);
+			*val = reinterpret_cast<const char *>(mval.data());
+			*val_sz = mval.size();
+			return 1;
+		}
+		return iter->progress == iter->value_end ? 0 : -1;
+	}
+
+	HYPERDEX_API int
+	hyperdex_ds_iterate_map_int_int_next(struct hyperdex_ds_iterator *iter,
+	                                     int64_t *key, int64_t *val)
+	{
+		if (iter->datatype != HYPERDATATYPE_MAP_INT64_INT64)
+		{
+			return -1;
+		}
+		datatype_info *dik = datatype_info::lookup(HYPERDATATYPE_INT64);
+		datatype_info *div = datatype_info::lookup(HYPERDATATYPE_INT64);
+		e::slice mkey;
+		e::slice mval;
+		if (iter->progress < iter->value_end)
+		{
+			if (!dik->step(reinterpret_cast<const uint8_t **>(&iter->progress),
+			               reinterpret_cast<const uint8_t *>(iter->value_end), &mkey) ||
+			    !div->step(reinterpret_cast<const uint8_t **>(&iter->progress),
+			               reinterpret_cast<const uint8_t *>(iter->value_end), &mval) ||
+			    mkey.size() != sizeof(int64_t) ||
+			    mval.size() != sizeof(int64_t))
+			{
+				iter->progress = iter->value_end + 1;
+				return -1;
+			}
+			e::unpack64le(mkey.data(), key);
+			e::unpack64le(mval.data(), val);
+			return 1;
+		}
+		return iter->progress == iter->value_end ? 0 : -1;
+	}
+
+	HYPERDEX_API int
+	hyperdex_ds_iterate_map_int_float_next(struct hyperdex_ds_iterator *iter,
+	                                       int64_t *key, double *val)
+	{
+		if (iter->datatype != HYPERDATATYPE_MAP_INT64_FLOAT)
+		{
+			return -1;
+		}
+		datatype_info *dik = datatype_info::lookup(HYPERDATATYPE_INT64);
+		datatype_info *div = datatype_info::lookup(HYPERDATATYPE_FLOAT);
+		e::slice mkey;
+		e::slice mval;
+		if (iter->progress < iter->value_end)
+		{
+			if (!dik->step(reinterpret_cast<const uint8_t **>(&iter->progress),
+			               reinterpret_cast<const uint8_t *>(iter->value_end), &mkey) ||
+			    !div->step(reinterpret_cast<const uint8_t **>(&iter->progress),
+			               reinterpret_cast<const uint8_t *>(iter->value_end), &mval) ||
+			    mkey.size() != sizeof(int64_t) ||
+			    mval.size() != sizeof(double))
+			{
+				iter->progress = iter->value_end + 1;
+				return -1;
+			}
+			e::unpack64le(mkey.data(), key);
+			e::unpackdoublele(mval.data(), val);
+			return 1;
+		}
+		return iter->progress == iter->value_end ? 0 : -1;
+	}
+
+	HYPERDEX_API int
+	hyperdex_ds_iterate_map_float_string_next(struct hyperdex_ds_iterator *iter,
+	                                          double *key, const char **val, size_t *val_sz)
+	{
+		if (iter->datatype != HYPERDATATYPE_MAP_FLOAT_STRING)
+		{
+			return -1;
+		}
+		datatype_info *dik = datatype_info::lookup(HYPERDATATYPE_FLOAT);
+		datatype_info *div = datatype_info::lookup(HYPERDATATYPE_STRING);
+		e::slice mkey;
+		e::slice mval;
+		if (iter->progress < iter->value_end)
+		{
+			if (!dik->step(reinterpret_cast<const uint8_t **>(&iter->progress),
+			               reinterpret_cast<const uint8_t *>(iter->value_end), &mkey) ||
+			    !div->step(reinterpret_cast<const uint8_t **>(&iter->progress),
+			               reinterpret_cast<const uint8_t *>(iter->value_end), &mval) ||
+			    mkey.size() != sizeof(double))
+			{
+				iter->progress = iter->value_end + 1;
+				return -1;
+			}
+			e::unpackdoublele(mkey.data(), key);
+			*val = reinterpret_cast<const char *>(mval.data());
+			*val_sz = mval.size();
+			return 1;
+		}
+		return iter->progress == iter->value_end ? 0 : -1;
+	}
+
+	HYPERDEX_API int
+	hyperdex_ds_iterate_map_float_int_next(struct hyperdex_ds_iterator *iter,
+	                                       double *key, int64_t *val)
+	{
+		if (iter->datatype != HYPERDATATYPE_MAP_FLOAT_INT64)
+		{
+			return -1;
+		}
+		datatype_info *dik = datatype_info::lookup(HYPERDATATYPE_FLOAT);
+		datatype_info *div = datatype_info::lookup(HYPERDATATYPE_INT64);
+		e::slice mkey;
+		e::slice mval;
+		if (iter->progress < iter->value_end)
+		{
+			if (!dik->step(reinterpret_cast<const uint8_t **>(&iter->progress),
+			               reinterpret_cast<const uint8_t *>(iter->value_end), &mkey) ||
+			    !div->step(reinterpret_cast<const uint8_t **>(&iter->progress),
+			               reinterpret_cast<const uint8_t *>(iter->value_end), &mval) ||
+			    mkey.size() != sizeof(double) ||
+			    mval.size() != sizeof(int64_t))
+			{
+				iter->progress = iter->value_end + 1;
+				return -1;
+			}
+			e::unpackdoublele(mkey.data(), key);
+			e::unpack64le(mval.data(), val);
+			return 1;
+		}
+		return iter->progress == iter->value_end ? 0 : -1;
+	}
+
+	HYPERDEX_API int
+	hyperdex_ds_iterate_map_float_float_next(struct hyperdex_ds_iterator *iter,
+	                                         double *key, double *val)
+	{
+		if (iter->datatype != HYPERDATATYPE_MAP_FLOAT_FLOAT)
+		{
+			return -1;
+		}
+		datatype_info *dik = datatype_info::lookup(HYPERDATATYPE_FLOAT);
+		datatype_info *div = datatype_info::lookup(HYPERDATATYPE_FLOAT);
+		e::slice mkey;
+		e::slice mval;
+		if (iter->progress < iter->value_end)
+		{
+			if (!dik->step(reinterpret_cast<const uint8_t **>(&iter->progress),
+			               reinterpret_cast<const uint8_t *>(iter->value_end), &mkey) ||
+			    !div->step(reinterpret_cast<const uint8_t **>(&iter->progress),
+			               reinterpret_cast<const uint8_t *>(iter->value_end), &mval) ||
+			    mkey.size() != sizeof(double) ||
+			    mval.size() != sizeof(double))
+			{
+				iter->progress = iter->value_end + 1;
+				return -1;
+			}
+			e::unpackdoublele(mkey.data(), key);
+			e::unpackdoublele(mval.data(), val);
+			return 1;
+		}
+		return iter->progress == iter->value_end ? 0 : -1;
+	}
 
 } // extern "C"
 
-HYPERDEX_API std::ostream&
-operator << (std::ostream& lhs, hyperdex_ds_returncode rhs)
-{
-    switch (rhs)
-    {
-        STRINGIFY(HYPERDEX_DS_SUCCESS);
-        STRINGIFY(HYPERDEX_DS_NOMEM);
-        STRINGIFY(HYPERDEX_DS_MIXED_TYPES);
-        STRINGIFY(HYPERDEX_DS_WRONG_STATE);
-        STRINGIFY(HYPERDEX_DS_STRING_TOO_LONG);
-        default:
-            lhs << "unknown hyperdex_ds_returncode";
-            break;
-    }
-
-    return lhs;
+HYPERDEX_API std::ostream &
+operator << (std::ostream &lhs, hyperdex_ds_returncode rhs)
+{
+	switch (rhs)
+	{
+		STRINGIFY(HYPERDEX_DS_SUCCESS);
+		STRINGIFY(HYPERDEX_DS_NOMEM);
+		STRINGIFY(HYPERDEX_DS_MIXED_TYPES);
+		STRINGIFY(HYPERDEX_DS_WRONG_STATE);
+		STRINGIFY(HYPERDEX_DS_STRING_TOO_LONG);
+	default:
+		lhs << "unknown hyperdex_ds_returncode";
+		break;
+	}
+	return lhs;
 }
diff --git a/client/keyop_info.h b/client/keyop_info.h
index e3a3a45b6..775d75976 100644
--- a/client/keyop_info.h
+++ b/client/keyop_info.h
@@ -38,14 +38,14 @@
 // This corresponds to the values given in keyop_info.gperf
 struct hyperdex_client_keyop_info
 {
-    int name; // hash of the function name
-    bool erase;
-    bool fail_if_not_found;
-    bool fail_if_found;
-    hyperdex::funcall_t fname;
+	int name; // hash of the function name
+	bool erase;
+	bool fail_if_not_found;
+	bool fail_if_found;
+	hyperdex::funcall_t fname;
 };
 
-const struct hyperdex_client_keyop_info*
-hyperdex_client_keyop_info_lookup(const char* str, unsigned int len);
+const struct hyperdex_client_keyop_info *
+hyperdex_client_keyop_info_lookup(const char *str, unsigned int len);
 
 #endif // hyperdex_client_keyop_info_h_
diff --git a/client/pending.cc b/client/pending.cc
index 5956329e5..63ee6a317 100644
--- a/client/pending.cc
+++ b/client/pending.cc
@@ -30,11 +30,11 @@
 
 using hyperdex::pending;
 
-pending :: pending(uint64_t id, hyperdex_client_returncode* status)
-    : m_ref(0)
-    , m_client_visible_id(id)
-    , m_status(status)
-    , m_error()
+pending :: pending(uint64_t id, hyperdex_client_returncode *status)
+	: m_ref(0)
+	, m_client_visible_id(id)
+	, m_status(status)
+	, m_error()
 {
 }
 
@@ -42,15 +42,15 @@ pending :: ~pending() throw ()
 {
 }
 
-std::ostream&
-pending :: error(const char* file, size_t line)
+std::ostream &
+pending :: error(const char *file, size_t line)
 {
-    m_error.set_loc(file, line);
-    return m_error.set_msg();
+	m_error.set_loc(file, line);
+	return m_error.set_msg();
 }
 
 void
-pending :: set_error(const e::error& err)
+pending :: set_error(const e::error &err)
 {
-    m_error = err;
+	m_error = err;
 }
diff --git a/client/pending.h b/client/pending.h
index dc1dbb6df..efe2701c3 100644
--- a/client/pending.h
+++ b/client/pending.h
@@ -47,62 +47,62 @@ class client;
 
 class pending
 {
-    public:
-        pending(uint64_t client_visible_id,
-                hyperdex_client_returncode* status);
-        virtual ~pending() throw ();
-
-    public:
-        int64_t client_visible_id() const { return m_client_visible_id; }
-        void set_status(hyperdex_client_returncode status) { *m_status = status; }
-        e::error error() const { return m_error; }
-
-    // return to client
-    public:
-        virtual bool can_yield() = 0;
-        virtual bool yield(hyperdex_client_returncode* status, e::error* error) = 0;
-
-    // events
-    public:
-        virtual void handle_sent_to(const server_id& si,
-                                    const virtual_server_id& vsi) = 0;
-        virtual void handle_failure(const server_id& si,
-                                    const virtual_server_id& vsi) = 0;
-        virtual bool handle_message(client* cl,
-                                    const server_id& si,
-                                    const virtual_server_id& vsi,
-                                    network_msgtype mt,
-                                    std::auto_ptr<e::buffer> msg,
-                                    e::unpacker up,
-                                    hyperdex_client_returncode* status,
-                                    e::error* error) = 0;
-
-    // refcount
-    protected:
-        friend class e::intrusive_ptr<pending>;
-        void inc() { ++m_ref; }
-        void dec() { if (--m_ref == 0) delete this; }
-        size_t m_ref;
-
-    protected:
-        std::ostream& error(const char* file, size_t line);
-        void set_error(const e::error& err);
-
-    // noncopyable
-    private:
-        pending(const pending& other);
-        pending& operator = (const pending& rhs);
-
-    // operation state
-    private:
-        int64_t m_client_visible_id;
-        hyperdex_client_returncode* m_status;
-        e::error m_error;
+public:
+	pending(uint64_t client_visible_id,
+	        hyperdex_client_returncode *status);
+	virtual ~pending() throw ();
+
+public:
+	int64_t client_visible_id() const { return m_client_visible_id; }
+	void set_status(hyperdex_client_returncode status) { *m_status = status; }
+	e::error error() const { return m_error; }
+
+	// return to client
+public:
+	virtual bool can_yield() = 0;
+	virtual bool yield(hyperdex_client_returncode *status, e::error *error) = 0;
+
+	// events
+public:
+	virtual void handle_sent_to(const server_id &si,
+	                            const virtual_server_id &vsi) = 0;
+	virtual void handle_failure(const server_id &si,
+	                            const virtual_server_id &vsi) = 0;
+	virtual bool handle_message(client *cl,
+	                            const server_id &si,
+	                            const virtual_server_id &vsi,
+	                            network_msgtype mt,
+	                            std::auto_ptr<e::buffer> msg,
+	                            e::unpacker up,
+	                            hyperdex_client_returncode *status,
+	                            e::error *error) = 0;
+
+	// refcount
+protected:
+	friend class e::intrusive_ptr<pending>;
+	void inc() { ++m_ref; }
+	void dec() { if (--m_ref == 0) delete this; }
+	size_t m_ref;
+
+protected:
+	std::ostream &error(const char *file, size_t line);
+	void set_error(const e::error &err);
+
+	// noncopyable
+private:
+	pending(const pending &other);
+	pending &operator = (const pending &rhs);
+
+	// operation state
+private:
+	int64_t m_client_visible_id;
+	hyperdex_client_returncode *m_status;
+	e::error m_error;
 };
 
 #define PENDING_ERROR(CODE) \
-    this->set_status(HYPERDEX_CLIENT_ ## CODE); \
-    this->error(__FILE__, __LINE__)
+	this->set_status(HYPERDEX_CLIENT_ ## CODE); \
+	this->error(__FILE__, __LINE__)
 
 END_HYPERDEX_NAMESPACE
 
diff --git a/client/pending_aggregation.cc b/client/pending_aggregation.cc
index 505a16341..533dc5719 100644
--- a/client/pending_aggregation.cc
+++ b/client/pending_aggregation.cc
@@ -31,9 +31,9 @@
 using hyperdex::pending_aggregation;
 
 pending_aggregation :: pending_aggregation(uint64_t id,
-                                           hyperdex_client_returncode* status)
-    : pending(id, status)
-    , m_outstanding()
+                                           hyperdex_client_returncode *status)
+	: pending(id, status)
+	, m_outstanding()
 {
 }
 
@@ -44,55 +44,53 @@ pending_aggregation :: ~pending_aggregation() throw ()
 bool
 pending_aggregation :: aggregation_done()
 {
-    return m_outstanding.empty();
+	return m_outstanding.empty();
 }
 
 void
-pending_aggregation :: handle_sent_to(const server_id& si,
-                                      const virtual_server_id& vsi)
+pending_aggregation :: handle_sent_to(const server_id &si,
+                                      const virtual_server_id &vsi)
 {
-    m_outstanding.push_back(std::make_pair(si, vsi));
+	m_outstanding.push_back(std::make_pair(si, vsi));
 }
 
 void
-pending_aggregation :: handle_failure(const server_id& si,
-                                      const virtual_server_id& vsi)
+pending_aggregation :: handle_failure(const server_id &si,
+                                      const virtual_server_id &vsi)
 {
-    remove(si, vsi);
+	remove(si, vsi);
 }
 
 bool
-pending_aggregation :: handle_message(client*,
-                                      const server_id& si,
-                                      const virtual_server_id& vsi,
+pending_aggregation :: handle_message(client *,
+                                      const server_id &si,
+                                      const virtual_server_id &vsi,
                                       network_msgtype,
                                       std::auto_ptr<e::buffer>,
                                       e::unpacker,
-                                      hyperdex_client_returncode*,
-                                      e::error*)
+                                      hyperdex_client_returncode *,
+                                      e::error *)
 {
-    remove(si, vsi);
-    return true;
+	remove(si, vsi);
+	return true;
 }
 
 void
-pending_aggregation :: remove(const server_id& si,
-                              const virtual_server_id& vsi)
+pending_aggregation :: remove(const server_id &si,
+                              const virtual_server_id &vsi)
 {
-    for (size_t i = 0; i < m_outstanding.size(); ++i)
-    {
-        if (m_outstanding[i].first != si ||
-            m_outstanding[i].second != vsi)
-        {
-            continue;
-        }
-
-        for (size_t j = i; j + 1 < m_outstanding.size(); ++j)
-        {
-            m_outstanding[j] = m_outstanding[j + 1];
-        }
-
-        m_outstanding.pop_back();
-        return;
-    }
+	for (size_t i = 0; i < m_outstanding.size(); ++i)
+	{
+		if (m_outstanding[i].first != si ||
+		    m_outstanding[i].second != vsi)
+		{
+			continue;
+		}
+		for (size_t j = i; j + 1 < m_outstanding.size(); ++j)
+		{
+			m_outstanding[j] = m_outstanding[j + 1];
+		}
+		m_outstanding.pop_back();
+		return;
+	}
 }
diff --git a/client/pending_aggregation.h b/client/pending_aggregation.h
index 8984a3ce9..f82130104 100644
--- a/client/pending_aggregation.h
+++ b/client/pending_aggregation.h
@@ -40,46 +40,46 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class pending_aggregation : public pending
 {
-    public:
-        pending_aggregation(uint64_t client_visible_id,
-                            hyperdex_client_returncode* status);
-        virtual ~pending_aggregation() throw ();
+public:
+	pending_aggregation(uint64_t client_visible_id,
+	                    hyperdex_client_returncode *status);
+	virtual ~pending_aggregation() throw ();
 
-    // handle aggregation across servers; must call handle_* messages from
-    // subclasses for this to work
-    public:
-        bool aggregation_done();
+	// handle aggregation across servers; must call handle_* messages from
+	// subclasses for this to work
+public:
+	bool aggregation_done();
 
-    // events
-    public:
-        virtual void handle_sent_to(const server_id& si,
-                                    const virtual_server_id& vsi);
-        virtual void handle_failure(const server_id& si,
-                                    const virtual_server_id& vsi);
-        // pass NULL for msg; we don't need it
-        virtual bool handle_message(client*,
-                                    const server_id& si,
-                                    const virtual_server_id& vsi,
-                                    network_msgtype mt,
-                                    std::auto_ptr<e::buffer> msg,
-                                    e::unpacker up,
-                                    hyperdex_client_returncode* status,
-                                    e::error* error);
+	// events
+public:
+	virtual void handle_sent_to(const server_id &si,
+	                            const virtual_server_id &vsi);
+	virtual void handle_failure(const server_id &si,
+	                            const virtual_server_id &vsi);
+	// pass NULL for msg; we don't need it
+	virtual bool handle_message(client *,
+	                            const server_id &si,
+	                            const virtual_server_id &vsi,
+	                            network_msgtype mt,
+	                            std::auto_ptr<e::buffer> msg,
+	                            e::unpacker up,
+	                            hyperdex_client_returncode *status,
+	                            e::error *error);
 
-    // refcount
-    protected:
-        friend class e::intrusive_ptr<pending_aggregation>;
+	// refcount
+protected:
+	friend class e::intrusive_ptr<pending_aggregation>;
 
-    // noncopyable
-    private:
-        pending_aggregation(const pending_aggregation& other);
-        pending_aggregation& operator = (const pending_aggregation& rhs);
+	// noncopyable
+private:
+	pending_aggregation(const pending_aggregation &other);
+	pending_aggregation &operator = (const pending_aggregation &rhs);
 
-    private:
-        virtual void remove(const server_id& si, const virtual_server_id& vsi);
+private:
+	virtual void remove(const server_id &si, const virtual_server_id &vsi);
 
-    private:
-        std::vector<std::pair<server_id, virtual_server_id> > m_outstanding;
+private:
+	std::vector<std::pair<server_id, virtual_server_id> > m_outstanding;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/client/pending_atomic.cc b/client/pending_atomic.cc
index 7ce2859e2..d5a21ac49 100644
--- a/client/pending_atomic.cc
+++ b/client/pending_atomic.cc
@@ -32,9 +32,9 @@
 using hyperdex::pending_atomic;
 
 pending_atomic :: pending_atomic(uint64_t id,
-                                 hyperdex_client_returncode* status)
-    : pending(id, status)
-    , m_state(INITIALIZED)
+                                 hyperdex_client_returncode *status)
+	: pending(id, status)
+	, m_state(INITIALIZED)
 {
 }
 
@@ -45,114 +45,110 @@ pending_atomic :: ~pending_atomic() throw ()
 bool
 pending_atomic :: can_yield()
 {
-    assert(m_state == RECV || m_state == YIELDED);
-    return m_state == RECV;
+	assert(m_state == RECV || m_state == YIELDED);
+	return m_state == RECV;
 }
 
 bool
-pending_atomic :: yield(hyperdex_client_returncode* status, e::error* err)
+pending_atomic :: yield(hyperdex_client_returncode *status, e::error *err)
 {
-    *status = HYPERDEX_CLIENT_SUCCESS;
-    *err = e::error();
-    m_state = YIELDED;
-    return true;
+	*status = HYPERDEX_CLIENT_SUCCESS;
+	*err = e::error();
+	m_state = YIELDED;
+	return true;
 }
 
 void
-pending_atomic :: handle_sent_to(const server_id&,
-                                 const virtual_server_id&)
+pending_atomic :: handle_sent_to(const server_id &,
+                                 const virtual_server_id &)
 {
-    assert(m_state == INITIALIZED);
-    m_state = SENT;
+	assert(m_state == INITIALIZED);
+	m_state = SENT;
 }
 
 void
-pending_atomic :: handle_failure(const server_id& si,
-                                 const virtual_server_id& vsi)
+pending_atomic :: handle_failure(const server_id &si,
+                                 const virtual_server_id &vsi)
 {
-    assert(m_state == SENT);
-    m_state = RECV;
-    PENDING_ERROR(RECONFIGURE) << "reconfiguration affecting "
-                               << vsi << "/" << si;
+	assert(m_state == SENT);
+	m_state = RECV;
+	PENDING_ERROR(RECONFIGURE) << "reconfiguration affecting "
+	                           << vsi << "/" << si;
 }
 
 bool
-pending_atomic :: handle_message(client*,
-                                 const server_id& si,
-                                 const virtual_server_id& vsi,
+pending_atomic :: handle_message(client *,
+                                 const server_id &si,
+                                 const virtual_server_id &vsi,
                                  network_msgtype mt,
                                  std::auto_ptr<e::buffer> msg,
                                  e::unpacker up,
-                                 hyperdex_client_returncode* status,
-                                 e::error* err)
+                                 hyperdex_client_returncode *status,
+                                 e::error *err)
 {
-    m_state = RECV;
-    *status = HYPERDEX_CLIENT_SUCCESS;
-    *err = e::error();
-
-    if (mt != RESP_ATOMIC)
-    {
-        PENDING_ERROR(SERVERERROR) << "server " << vsi << " responded to ATOMIC with " << mt;
-        return true;
-    }
-
-    uint16_t response;
-    up = up >> response;
-
-    if (up.error())
-    {
-        PENDING_ERROR(SERVERERROR) << "communication error: server "
-                                   << vsi << " sent corrupt message="
-                                   << msg->as_slice().hex()
-                                   << " in response to an ATOMIC";
-        return true;
-    }
-
-    switch (static_cast<network_returncode>(response))
-    {
-        case NET_SUCCESS:
-            set_status(HYPERDEX_CLIENT_SUCCESS);
-            set_error(e::error());
-            return true;
-        case NET_NOTFOUND:
-            set_status(HYPERDEX_CLIENT_NOTFOUND);
-            set_error(e::error());
-            return true;
-        case NET_CMPFAIL:
-            set_status(HYPERDEX_CLIENT_CMPFAIL);
-            set_error(e::error());
-            return true;
-        case NET_BADDIMSPEC:
-            PENDING_ERROR(SERVERERROR) << "server " << si
-                                       << " reports that our request was invalid;"
-                                       << " check its log for details";
-            return true;
-        case NET_NOTUS:
-            PENDING_ERROR(RECONFIGURE) << "server " << si
-                                       << " reports that it is no longer reponsible"
-                                       << " for the requested object";
-            return true;
-        case NET_OVERFLOW:
-            PENDING_ERROR(OVERFLOW) << "server " << si
-                                    << " reports that the operation would"
-                                    << " cause a number overflow";
-            return true;
-        case NET_READONLY:
-            PENDING_ERROR(READONLY) << "cluster is in read-only mode";
-            return true;
-        case NET_SERVERERROR:
-            PENDING_ERROR(SERVERERROR) << "server " << si
-                                       << " reports a server error;"
-                                       << " check its log for details";
-            return true;
-        case NET_UNAUTHORIZED:
-            PENDING_ERROR(UNAUTHORIZED) << "server " << si
-                                        << " denied the request because it is unauthorized";
-            return true;
-        default:
-            PENDING_ERROR(SERVERERROR) << "server " << si
-                                       << " returned non-sensical returncode "
-                                       << response;
-            return true;
-    }
+	m_state = RECV;
+	*status = HYPERDEX_CLIENT_SUCCESS;
+	*err = e::error();
+	if (mt != RESP_ATOMIC)
+	{
+		PENDING_ERROR(SERVERERROR) << "server " << vsi << " responded to ATOMIC with " << mt;
+		return true;
+	}
+	uint16_t response;
+	up = up >> response;
+	if (up.error())
+	{
+		PENDING_ERROR(SERVERERROR) << "communication error: server "
+		                           << vsi << " sent corrupt message="
+		                           << msg->as_slice().hex()
+		                           << " in response to an ATOMIC";
+		return true;
+	}
+	switch (static_cast<network_returncode>(response))
+	{
+	case NET_SUCCESS:
+		set_status(HYPERDEX_CLIENT_SUCCESS);
+		set_error(e::error());
+		return true;
+	case NET_NOTFOUND:
+		set_status(HYPERDEX_CLIENT_NOTFOUND);
+		set_error(e::error());
+		return true;
+	case NET_CMPFAIL:
+		set_status(HYPERDEX_CLIENT_CMPFAIL);
+		set_error(e::error());
+		return true;
+	case NET_BADDIMSPEC:
+		PENDING_ERROR(SERVERERROR) << "server " << si
+		                           << " reports that our request was invalid;"
+		                           << " check its log for details";
+		return true;
+	case NET_NOTUS:
+		PENDING_ERROR(RECONFIGURE) << "server " << si
+		                           << " reports that it is no longer reponsible"
+		                           << " for the requested object";
+		return true;
+	case NET_OVERFLOW:
+		PENDING_ERROR(OVERFLOW) << "server " << si
+		                        << " reports that the operation would"
+		                        << " cause a number overflow";
+		return true;
+	case NET_READONLY:
+		PENDING_ERROR(READONLY) << "cluster is in read-only mode";
+		return true;
+	case NET_SERVERERROR:
+		PENDING_ERROR(SERVERERROR) << "server " << si
+		                           << " reports a server error;"
+		                           << " check its log for details";
+		return true;
+	case NET_UNAUTHORIZED:
+		PENDING_ERROR(UNAUTHORIZED) << "server " << si
+		                            << " denied the request because it is unauthorized";
+		return true;
+	default:
+		PENDING_ERROR(SERVERERROR) << "server " << si
+		                           << " returned non-sensical returncode "
+		                           << response;
+		return true;
+	}
 }
diff --git a/client/pending_atomic.h b/client/pending_atomic.h
index cd53d9ec4..3508690d6 100644
--- a/client/pending_atomic.h
+++ b/client/pending_atomic.h
@@ -36,33 +36,33 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class pending_atomic : public pending
 {
-    public:
-        pending_atomic(uint64_t client_visible_id,
-                       hyperdex_client_returncode* status);
-        virtual ~pending_atomic() throw ();
+public:
+	pending_atomic(uint64_t client_visible_id,
+	               hyperdex_client_returncode *status);
+	virtual ~pending_atomic() throw ();
 
-    // return to client
-    public:
-        virtual bool can_yield();
-        virtual bool yield(hyperdex_client_returncode* status, e::error* error);
+	// return to client
+public:
+	virtual bool can_yield();
+	virtual bool yield(hyperdex_client_returncode *status, e::error *error);
 
-    // events
-    public:
-        virtual void handle_sent_to(const server_id& si,
-                                    const virtual_server_id& vsi);
-        virtual void handle_failure(const server_id& si,
-                                    const virtual_server_id& vsi);
-        virtual bool handle_message(client*,
-                                    const server_id& si,
-                                    const virtual_server_id& vsi,
-                                    network_msgtype mt,
-                                    std::auto_ptr<e::buffer> msg,
-                                    e::unpacker up,
-                                    hyperdex_client_returncode* status,
-                                    e::error* error);
+	// events
+public:
+	virtual void handle_sent_to(const server_id &si,
+	                            const virtual_server_id &vsi);
+	virtual void handle_failure(const server_id &si,
+	                            const virtual_server_id &vsi);
+	virtual bool handle_message(client *,
+	                            const server_id &si,
+	                            const virtual_server_id &vsi,
+	                            network_msgtype mt,
+	                            std::auto_ptr<e::buffer> msg,
+	                            e::unpacker up,
+	                            hyperdex_client_returncode *status,
+	                            e::error *error);
 
-    private:
-        enum { INITIALIZED, SENT, RECV, YIELDED } m_state;
+private:
+	enum { INITIALIZED, SENT, RECV, YIELDED } m_state;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/client/pending_count.cc b/client/pending_count.cc
index 57265bb07..66e8bd185 100644
--- a/client/pending_count.cc
+++ b/client/pending_count.cc
@@ -31,14 +31,14 @@
 using hyperdex::pending_count;
 
 pending_count :: pending_count(uint64_t id,
-                               hyperdex_client_returncode* status,
-                               uint64_t* count)
-    : pending_aggregation(id, status)
-    , m_count(count)
-    , m_done(false)
+                               hyperdex_client_returncode *status,
+                               uint64_t *count)
+	: pending_aggregation(id, status)
+	, m_count(count)
+	, m_done(false)
 {
-    set_status(HYPERDEX_CLIENT_SUCCESS);
-    set_error(e::error());
+	set_status(HYPERDEX_CLIENT_SUCCESS);
+	set_error(e::error());
 }
 
 pending_count :: ~pending_count() throw ()
@@ -48,64 +48,59 @@ pending_count :: ~pending_count() throw ()
 bool
 pending_count :: can_yield()
 {
-    return this->aggregation_done() && !m_done;
+	return this->aggregation_done() && !m_done;
 }
 
 bool
-pending_count :: yield(hyperdex_client_returncode* status, e::error* err)
+pending_count :: yield(hyperdex_client_returncode *status, e::error *err)
 {
-    *status = HYPERDEX_CLIENT_SUCCESS;
-    *err = e::error();
-    assert(this->can_yield());
-    m_done = true;
-    return true;
+	*status = HYPERDEX_CLIENT_SUCCESS;
+	*err = e::error();
+	assert(this->can_yield());
+	m_done = true;
+	return true;
 }
 
 void
-pending_count :: handle_failure(const server_id& si,
-                                const virtual_server_id& vsi)
+pending_count :: handle_failure(const server_id &si,
+                                const virtual_server_id &vsi)
 {
-    PENDING_ERROR(RECONFIGURE) << "reconfiguration affecting "
-                               << vsi << "/" << si;
-    return pending_aggregation::handle_failure(si, vsi);
+	PENDING_ERROR(RECONFIGURE) << "reconfiguration affecting "
+	                           << vsi << "/" << si;
+	return pending_aggregation::handle_failure(si, vsi);
 }
 
 bool
-pending_count :: handle_message(client* cl,
-                                const server_id& si,
-                                const virtual_server_id& vsi,
+pending_count :: handle_message(client *cl,
+                                const server_id &si,
+                                const virtual_server_id &vsi,
                                 network_msgtype mt,
                                 std::auto_ptr<e::buffer> msg,
                                 e::unpacker up,
-                                hyperdex_client_returncode* status,
-                                e::error* err)
+                                hyperdex_client_returncode *status,
+                                e::error *err)
 {
-    bool handled = pending_aggregation::handle_message(cl, si, vsi, mt, std::auto_ptr<e::buffer>(), up, status, err);
-    assert(handled);
-
-    *status = HYPERDEX_CLIENT_SUCCESS;
-    *err = e::error();
-
-    if (mt != RESP_COUNT)
-    {
-        PENDING_ERROR(SERVERERROR) << "server " << vsi << " responded to COUNT with " << mt;
-        return true;
-    }
-
-    uint64_t local_count;
-    up = up >> local_count;
-
-    if (up.error())
-    {
-        PENDING_ERROR(SERVERERROR) << "communication error: server "
-                                   << vsi << " sent corrupt message="
-                                   << msg->as_slice().hex()
-                                   << " in response to a COUNT";
-        return true;
-    }
-
-    *m_count += local_count;
-    // Don't set the status or error so that errors will carry through.  It was
-    // set to the success state in the constructor
-    return true;
+	bool handled = pending_aggregation::handle_message(cl, si, vsi, mt, std::auto_ptr<e::buffer>(), up, status, err);
+	assert(handled);
+	*status = HYPERDEX_CLIENT_SUCCESS;
+	*err = e::error();
+	if (mt != RESP_COUNT)
+	{
+		PENDING_ERROR(SERVERERROR) << "server " << vsi << " responded to COUNT with " << mt;
+		return true;
+	}
+	uint64_t local_count;
+	up = up >> local_count;
+	if (up.error())
+	{
+		PENDING_ERROR(SERVERERROR) << "communication error: server "
+		                           << vsi << " sent corrupt message="
+		                           << msg->as_slice().hex()
+		                           << " in response to a COUNT";
+		return true;
+	}
+	*m_count += local_count;
+	// Don't set the status or error so that errors will carry through.  It was
+	// set to the success state in the constructor
+	return true;
 }
diff --git a/client/pending_count.h b/client/pending_count.h
index 0819b0bef..fb9a9449b 100644
--- a/client/pending_count.h
+++ b/client/pending_count.h
@@ -36,38 +36,38 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class pending_count : public pending_aggregation
 {
-    public:
-        pending_count(uint64_t client_visible_id,
-                      hyperdex_client_returncode* status,
-                      uint64_t* count);
-        virtual ~pending_count() throw ();
+public:
+	pending_count(uint64_t client_visible_id,
+	              hyperdex_client_returncode *status,
+	              uint64_t *count);
+	virtual ~pending_count() throw ();
 
-    // return to client
-    public:
-        virtual bool can_yield();
-        virtual bool yield(hyperdex_client_returncode* status, e::error* error);
+	// return to client
+public:
+	virtual bool can_yield();
+	virtual bool yield(hyperdex_client_returncode *status, e::error *error);
 
-    // events
-    public:
-        virtual void handle_failure(const server_id& si,
-                                    const virtual_server_id& vsi);
-        virtual bool handle_message(client*,
-                                    const server_id& si,
-                                    const virtual_server_id& vsi,
-                                    network_msgtype mt,
-                                    std::auto_ptr<e::buffer> msg,
-                                    e::unpacker up,
-                                    hyperdex_client_returncode* status,
-                                    e::error* error);
+	// events
+public:
+	virtual void handle_failure(const server_id &si,
+	                            const virtual_server_id &vsi);
+	virtual bool handle_message(client *,
+	                            const server_id &si,
+	                            const virtual_server_id &vsi,
+	                            network_msgtype mt,
+	                            std::auto_ptr<e::buffer> msg,
+	                            e::unpacker up,
+	                            hyperdex_client_returncode *status,
+	                            e::error *error);
 
-    // noncopyable
-    private:
-        pending_count(const pending_count& other);
-        pending_count& operator = (const pending_count& rhs);
+	// noncopyable
+private:
+	pending_count(const pending_count &other);
+	pending_count &operator = (const pending_count &rhs);
 
-    private:
-        uint64_t* m_count;
-        bool m_done;
+private:
+	uint64_t *m_count;
+	bool m_done;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/client/pending_get.cc b/client/pending_get.cc
index 41ad8b7e5..72a6ff5f7 100644
--- a/client/pending_get.cc
+++ b/client/pending_get.cc
@@ -34,13 +34,13 @@
 using hyperdex::pending_get;
 
 pending_get :: pending_get(uint64_t id,
-                           hyperdex_client_returncode* status,
-                           const hyperdex_client_attribute** attrs,
-                           size_t* attrs_sz)
-    : pending(id, status)
-    , m_state(INITIALIZED)
-    , m_attrs(attrs)
-    , m_attrs_sz(attrs_sz)
+                           hyperdex_client_returncode *status,
+                           const hyperdex_client_attribute **attrs,
+                           size_t *attrs_sz)
+	: pending(id, status)
+	, m_state(INITIALIZED)
+	, m_attrs(attrs)
+	, m_attrs_sz(attrs_sz)
 {
 }
 
@@ -51,143 +51,134 @@ pending_get :: ~pending_get() throw ()
 bool
 pending_get :: can_yield()
 {
-    assert(m_state == RECV || m_state == YIELDED);
-    return m_state == RECV;
+	assert(m_state == RECV || m_state == YIELDED);
+	return m_state == RECV;
 }
 
 bool
-pending_get :: yield(hyperdex_client_returncode* status, e::error* err)
+pending_get :: yield(hyperdex_client_returncode *status, e::error *err)
 {
-    *status = HYPERDEX_CLIENT_SUCCESS;
-    *err = e::error();
-    m_state = YIELDED;
-    return true;
+	*status = HYPERDEX_CLIENT_SUCCESS;
+	*err = e::error();
+	m_state = YIELDED;
+	return true;
 }
 
 void
-pending_get :: handle_sent_to(const server_id&,
-                              const virtual_server_id&)
+pending_get :: handle_sent_to(const server_id &,
+                              const virtual_server_id &)
 {
-    assert(m_state == INITIALIZED);
-    m_state = SENT;
+	assert(m_state == INITIALIZED);
+	m_state = SENT;
 }
 
 void
-pending_get :: handle_failure(const server_id& si,
-                              const virtual_server_id& vsi)
+pending_get :: handle_failure(const server_id &si,
+                              const virtual_server_id &vsi)
 {
-    assert(m_state == SENT);
-    m_state = RECV;
-    PENDING_ERROR(RECONFIGURE) << "reconfiguration affecting "
-                               << vsi << "/" << si;
+	assert(m_state == SENT);
+	m_state = RECV;
+	PENDING_ERROR(RECONFIGURE) << "reconfiguration affecting "
+	                           << vsi << "/" << si;
 }
 
 bool
-pending_get :: handle_message(client* cl,
-                              const server_id& si,
-                              const virtual_server_id& vsi,
+pending_get :: handle_message(client *cl,
+                              const server_id &si,
+                              const virtual_server_id &vsi,
                               network_msgtype mt,
                               std::auto_ptr<e::buffer> msg,
                               e::unpacker up,
-                              hyperdex_client_returncode* status,
-                              e::error* err)
+                              hyperdex_client_returncode *status,
+                              e::error *err)
 {
-    m_state = RECV;
-    *status = HYPERDEX_CLIENT_SUCCESS;
-    *err = e::error();
-
-    if (mt != RESP_GET)
-    {
-        PENDING_ERROR(SERVERERROR) << "server " << vsi << " responded to GET with " << mt;
-        return true;
-    }
-
-    uint16_t response;
-    up = up >> response;
-
-    if (up.error())
-    {
-        PENDING_ERROR(SERVERERROR) << "communication error: server "
-                                   << vsi << " sent corrupt message="
-                                   << msg->as_slice().hex()
-                                   << " in response to a GET";
-        return true;
-    }
-
-    switch (static_cast<network_returncode>(response))
-    {
-        case NET_SUCCESS:
-            break;
-        case NET_NOTFOUND:
-            set_status(HYPERDEX_CLIENT_NOTFOUND);
-            set_error(e::error());
-            return true;
-        case NET_BADDIMSPEC:
-            PENDING_ERROR(SERVERERROR) << "server " << si
-                                       << " reports that our request was invalid;"
-                                       << " check its log for details";
-            return true;
-        case NET_NOTUS:
-            PENDING_ERROR(RECONFIGURE) << "server " << si
-                                       << " reports that it is no longer reponsible"
-                                       << " for the requested object";
-            return true;
-        case NET_READONLY:
-            PENDING_ERROR(READONLY) << "cluster is in read-only mode, but this was a read:"
-                                    << " please file a bug";
-            return true;
-        case NET_SERVERERROR:
-            PENDING_ERROR(SERVERERROR) << "server " << si
-                                       << " reports a server error;"
-                                       << " check its log for details";
-            return true;
-        case NET_CMPFAIL:
-            PENDING_ERROR(SERVERERROR) << "server " << si
-                                       << " unexpectedly reports that a comparison failed;"
-                                       << " check its log for details";
-            return true;
-        case NET_OVERFLOW:
-            PENDING_ERROR(OVERFLOW) << "server " << si
-                                    << " reports that the operation would"
-                                    << " cause a number overflow";
-            return true;
-        case NET_UNAUTHORIZED:
-            PENDING_ERROR(UNAUTHORIZED) << "server " << si
-                                        << " denied the request because it is unauthorized";
-            return true;
-        default:
-            PENDING_ERROR(SERVERERROR) << "server " << si
-                                       << " returned non-sensical returncode"
-                                       << response;
-            return true;
-    }
-
-    std::vector<e::slice> value;
-    up = up >> value;
-
-    if (up.error())
-    {
-        PENDING_ERROR(SERVERERROR) << "communication error: server "
-                                   << vsi << " sent corrupt message="
-                                   << msg->as_slice().hex()
-                                   << " in response to a GET";
-        return true;
-    }
-
-    hyperdex_client_returncode op_status;
-    e::error op_error;
-
-    if (!value_to_attributes(cl->m_config,
-                             cl->m_config.get_region_id(vsi),
-                             NULL, 0, value, &op_status, &op_error,
-                             m_attrs, m_attrs_sz, cl->m_convert_types))
-    {
-        set_status(op_status);
-        set_error(op_error);
-        return true;
-    }
-
-    set_status(HYPERDEX_CLIENT_SUCCESS);
-    set_error(e::error());
-    return true;
+	m_state = RECV;
+	*status = HYPERDEX_CLIENT_SUCCESS;
+	*err = e::error();
+	if (mt != RESP_GET)
+	{
+		PENDING_ERROR(SERVERERROR) << "server " << vsi << " responded to GET with " << mt;
+		return true;
+	}
+	uint16_t response;
+	up = up >> response;
+	if (up.error())
+	{
+		PENDING_ERROR(SERVERERROR) << "communication error: server "
+		                           << vsi << " sent corrupt message="
+		                           << msg->as_slice().hex()
+		                           << " in response to a GET";
+		return true;
+	}
+	switch (static_cast<network_returncode>(response))
+	{
+	case NET_SUCCESS:
+		break;
+	case NET_NOTFOUND:
+		set_status(HYPERDEX_CLIENT_NOTFOUND);
+		set_error(e::error());
+		return true;
+	case NET_BADDIMSPEC:
+		PENDING_ERROR(SERVERERROR) << "server " << si
+		                           << " reports that our request was invalid;"
+		                           << " check its log for details";
+		return true;
+	case NET_NOTUS:
+		PENDING_ERROR(RECONFIGURE) << "server " << si
+		                           << " reports that it is no longer reponsible"
+		                           << " for the requested object";
+		return true;
+	case NET_READONLY:
+		PENDING_ERROR(READONLY) << "cluster is in read-only mode, but this was a read:"
+		                        << " please file a bug";
+		return true;
+	case NET_SERVERERROR:
+		PENDING_ERROR(SERVERERROR) << "server " << si
+		                           << " reports a server error;"
+		                           << " check its log for details";
+		return true;
+	case NET_CMPFAIL:
+		PENDING_ERROR(SERVERERROR) << "server " << si
+		                           << " unexpectedly reports that a comparison failed;"
+		                           << " check its log for details";
+		return true;
+	case NET_OVERFLOW:
+		PENDING_ERROR(OVERFLOW) << "server " << si
+		                        << " reports that the operation would"
+		                        << " cause a number overflow";
+		return true;
+	case NET_UNAUTHORIZED:
+		PENDING_ERROR(UNAUTHORIZED) << "server " << si
+		                            << " denied the request because it is unauthorized";
+		return true;
+	default:
+		PENDING_ERROR(SERVERERROR) << "server " << si
+		                           << " returned non-sensical returncode"
+		                           << response;
+		return true;
+	}
+	std::vector<e::slice> value;
+	up = up >> value;
+	if (up.error())
+	{
+		PENDING_ERROR(SERVERERROR) << "communication error: server "
+		                           << vsi << " sent corrupt message="
+		                           << msg->as_slice().hex()
+		                           << " in response to a GET";
+		return true;
+	}
+	hyperdex_client_returncode op_status;
+	e::error op_error;
+	if (!value_to_attributes(cl->m_config,
+	                         cl->m_config.get_region_id(vsi),
+	                         NULL, 0, value, &op_status, &op_error,
+	                         m_attrs, m_attrs_sz, cl->m_convert_types))
+	{
+		set_status(op_status);
+		set_error(op_error);
+		return true;
+	}
+	set_status(HYPERDEX_CLIENT_SUCCESS);
+	set_error(e::error());
+	return true;
 }
diff --git a/client/pending_get.h b/client/pending_get.h
index 9c5159f75..7567cc383 100644
--- a/client/pending_get.h
+++ b/client/pending_get.h
@@ -36,41 +36,41 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class pending_get : public pending
 {
-    public:
-        pending_get(uint64_t client_visible_id,
-                    hyperdex_client_returncode* status,
-                    const hyperdex_client_attribute** attrs, size_t* attrs_sz);
-        virtual ~pending_get() throw ();
+public:
+	pending_get(uint64_t client_visible_id,
+	            hyperdex_client_returncode *status,
+	            const hyperdex_client_attribute **attrs, size_t *attrs_sz);
+	virtual ~pending_get() throw ();
 
-    // return to client
-    public:
-        virtual bool can_yield();
-        virtual bool yield(hyperdex_client_returncode* status, e::error* error);
+	// return to client
+public:
+	virtual bool can_yield();
+	virtual bool yield(hyperdex_client_returncode *status, e::error *error);
 
-    // events
-    public:
-        virtual void handle_sent_to(const server_id& si,
-                                    const virtual_server_id& vsi);
-        virtual void handle_failure(const server_id& si,
-                                    const virtual_server_id& vsi);
-        virtual bool handle_message(client*,
-                                    const server_id& si,
-                                    const virtual_server_id& vsi,
-                                    network_msgtype mt,
-                                    std::auto_ptr<e::buffer> msg,
-                                    e::unpacker up,
-                                    hyperdex_client_returncode* status,
-                                    e::error* error);
+	// events
+public:
+	virtual void handle_sent_to(const server_id &si,
+	                            const virtual_server_id &vsi);
+	virtual void handle_failure(const server_id &si,
+	                            const virtual_server_id &vsi);
+	virtual bool handle_message(client *,
+	                            const server_id &si,
+	                            const virtual_server_id &vsi,
+	                            network_msgtype mt,
+	                            std::auto_ptr<e::buffer> msg,
+	                            e::unpacker up,
+	                            hyperdex_client_returncode *status,
+	                            e::error *error);
 
-    // noncopyable
-    private:
-        pending_get(const pending_get& other);
-        pending_get& operator = (const pending_get& rhs);
+	// noncopyable
+private:
+	pending_get(const pending_get &other);
+	pending_get &operator = (const pending_get &rhs);
 
-    private:
-        enum { INITIALIZED, SENT, RECV, YIELDED } m_state;
-        const hyperdex_client_attribute** m_attrs;
-        size_t* m_attrs_sz;
+private:
+	enum { INITIALIZED, SENT, RECV, YIELDED } m_state;
+	const hyperdex_client_attribute **m_attrs;
+	size_t *m_attrs_sz;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/client/pending_get_partial.cc b/client/pending_get_partial.cc
index f35fa03a9..2baf87100 100644
--- a/client/pending_get_partial.cc
+++ b/client/pending_get_partial.cc
@@ -34,13 +34,13 @@
 using hyperdex::pending_get_partial;
 
 pending_get_partial :: pending_get_partial(uint64_t id,
-                                           hyperdex_client_returncode* status,
-                                           const hyperdex_client_attribute** attrs,
-                                           size_t* attrs_sz)
-    : pending(id, status)
-    , m_state(INITIALIZED)
-    , m_attrs(attrs)
-    , m_attrs_sz(attrs_sz)
+                                           hyperdex_client_returncode *status,
+                                           const hyperdex_client_attribute **attrs,
+                                           size_t *attrs_sz)
+	: pending(id, status)
+	, m_state(INITIALIZED)
+	, m_attrs(attrs)
+	, m_attrs_sz(attrs_sz)
 {
 }
 
@@ -51,150 +51,140 @@ pending_get_partial :: ~pending_get_partial() throw ()
 bool
 pending_get_partial :: can_yield()
 {
-    assert(m_state == RECV || m_state == YIELDED);
-    return m_state == RECV;
+	assert(m_state == RECV || m_state == YIELDED);
+	return m_state == RECV;
 }
 
 bool
-pending_get_partial :: yield(hyperdex_client_returncode* status, e::error* err)
+pending_get_partial :: yield(hyperdex_client_returncode *status, e::error *err)
 {
-    *status = HYPERDEX_CLIENT_SUCCESS;
-    *err = e::error();
-    m_state = YIELDED;
-    return true;
+	*status = HYPERDEX_CLIENT_SUCCESS;
+	*err = e::error();
+	m_state = YIELDED;
+	return true;
 }
 
 void
-pending_get_partial :: handle_sent_to(const server_id&,
-                                      const virtual_server_id&)
+pending_get_partial :: handle_sent_to(const server_id &,
+                                      const virtual_server_id &)
 {
-    assert(m_state == INITIALIZED);
-    m_state = SENT;
+	assert(m_state == INITIALIZED);
+	m_state = SENT;
 }
 
 void
-pending_get_partial :: handle_failure(const server_id& si,
-                                      const virtual_server_id& vsi)
+pending_get_partial :: handle_failure(const server_id &si,
+                                      const virtual_server_id &vsi)
 {
-    assert(m_state == SENT);
-    m_state = RECV;
-    PENDING_ERROR(RECONFIGURE) << "reconfiguration affecting "
-                               << vsi << "/" << si;
+	assert(m_state == SENT);
+	m_state = RECV;
+	PENDING_ERROR(RECONFIGURE) << "reconfiguration affecting "
+	                           << vsi << "/" << si;
 }
 
 bool
-pending_get_partial :: handle_message(client* cl,
-                                      const server_id& si,
-                                      const virtual_server_id& vsi,
+pending_get_partial :: handle_message(client *cl,
+                                      const server_id &si,
+                                      const virtual_server_id &vsi,
                                       network_msgtype mt,
                                       std::auto_ptr<e::buffer> msg,
                                       e::unpacker up,
-                                      hyperdex_client_returncode* status,
-                                      e::error* err)
+                                      hyperdex_client_returncode *status,
+                                      e::error *err)
 {
-    m_state = RECV;
-    *status = HYPERDEX_CLIENT_SUCCESS;
-    *err = e::error();
-
-    if (mt != RESP_GET_PARTIAL)
-    {
-        PENDING_ERROR(SERVERERROR) << "server vsi responded to GET with " << mt;
-        return true;
-    }
-
-    uint16_t response;
-    up = up >> response;
-
-    if (up.error())
-    {
-        PENDING_ERROR(SERVERERROR) << "communication error: server "
-                                   << vsi << " sent corrupt message="
-                                   << msg->as_slice().hex()
-                                   << " in response to a GET";
-        return true;
-    }
-
-    switch (static_cast<network_returncode>(response))
-    {
-        case NET_SUCCESS:
-            break;
-        case NET_NOTFOUND:
-            set_status(HYPERDEX_CLIENT_NOTFOUND);
-            set_error(e::error());
-            return true;
-        case NET_BADDIMSPEC:
-            PENDING_ERROR(SERVERERROR) << "server " << si
-                                       << " reports that our request was invalid;"
-                                       << " check its log for details";
-            return true;
-        case NET_NOTUS:
-            PENDING_ERROR(RECONFIGURE) << "server " << si
-                                       << " reports that it is no longer reponsible"
-                                       << " for the requested object";
-            return true;
-        case NET_READONLY:
-            PENDING_ERROR(READONLY) << "cluster is in read-only mode, but this was a read:"
-                                    << " please file a bug";
-            return true;
-        case NET_SERVERERROR:
-            PENDING_ERROR(SERVERERROR) << "server " << si
-                                       << " reports a server error;"
-                                       << " check its log for details";
-            return true;
-        case NET_CMPFAIL:
-            PENDING_ERROR(SERVERERROR) << "server " << si
-                                       << " unexpectedly reports that a comparison failed;"
-                                       << " check its log for details";
-            return true;
-        case NET_OVERFLOW:
-            PENDING_ERROR(OVERFLOW) << "server " << si
-                                    << " reports that the operation would"
-                                    << " cause a number overflow";
-            return true;
-        case NET_UNAUTHORIZED:
-            PENDING_ERROR(UNAUTHORIZED) << "server " << si
-                                        << " denied the request because it is unauthorized";
-            return true;
-        default:
-            PENDING_ERROR(SERVERERROR) << "server " << si
-                                       << " returned non-sensical returncode"
-                                       << response;
-            return true;
-    }
-
-    std::vector<std::pair<uint16_t, e::slice> > value;
-
-    while (up.remain() && !up.error())
-    {
-        uint16_t attr_n;
-        e::slice attr_s;
-        up = up >> attr_n >> attr_s;
-        value.push_back(std::make_pair(attr_n, attr_s));
-    }
-
-    if (up.error())
-    {
-        PENDING_ERROR(SERVERERROR) << "communication error: server "
-                                   << vsi << " sent corrupt message="
-                                   << msg->as_slice().hex()
-                                   << " in response to a GET_PARTIAL";
-        return true;
-    }
-
-    hyperdex_client_returncode op_status;
-    e::error op_error;
-
-    if (!value_to_attributes(cl->m_config,
-                             cl->m_config.get_region_id(vsi),
-                             value, &op_status, &op_error,
-                             m_attrs, m_attrs_sz, cl->m_convert_types))
-    {
-        set_status(op_status);
-        set_error(op_error);
-        return true;
-    }
-
-    set_status(HYPERDEX_CLIENT_SUCCESS);
-    set_error(e::error());
-    return true;
+	m_state = RECV;
+	*status = HYPERDEX_CLIENT_SUCCESS;
+	*err = e::error();
+	if (mt != RESP_GET_PARTIAL)
+	{
+		PENDING_ERROR(SERVERERROR) << "server vsi responded to GET with " << mt;
+		return true;
+	}
+	uint16_t response;
+	up = up >> response;
+	if (up.error())
+	{
+		PENDING_ERROR(SERVERERROR) << "communication error: server "
+		                           << vsi << " sent corrupt message="
+		                           << msg->as_slice().hex()
+		                           << " in response to a GET";
+		return true;
+	}
+	switch (static_cast<network_returncode>(response))
+	{
+	case NET_SUCCESS:
+		break;
+	case NET_NOTFOUND:
+		set_status(HYPERDEX_CLIENT_NOTFOUND);
+		set_error(e::error());
+		return true;
+	case NET_BADDIMSPEC:
+		PENDING_ERROR(SERVERERROR) << "server " << si
+		                           << " reports that our request was invalid;"
+		                           << " check its log for details";
+		return true;
+	case NET_NOTUS:
+		PENDING_ERROR(RECONFIGURE) << "server " << si
+		                           << " reports that it is no longer reponsible"
+		                           << " for the requested object";
+		return true;
+	case NET_READONLY:
+		PENDING_ERROR(READONLY) << "cluster is in read-only mode, but this was a read:"
+		                        << " please file a bug";
+		return true;
+	case NET_SERVERERROR:
+		PENDING_ERROR(SERVERERROR) << "server " << si
+		                           << " reports a server error;"
+		                           << " check its log for details";
+		return true;
+	case NET_CMPFAIL:
+		PENDING_ERROR(SERVERERROR) << "server " << si
+		                           << " unexpectedly reports that a comparison failed;"
+		                           << " check its log for details";
+		return true;
+	case NET_OVERFLOW:
+		PENDING_ERROR(OVERFLOW) << "server " << si
+		                        << " reports that the operation would"
+		                        << " cause a number overflow";
+		return true;
+	case NET_UNAUTHORIZED:
+		PENDING_ERROR(UNAUTHORIZED) << "server " << si
+		                            << " denied the request because it is unauthorized";
+		return true;
+	default:
+		PENDING_ERROR(SERVERERROR) << "server " << si
+		                           << " returned non-sensical returncode"
+		                           << response;
+		return true;
+	}
+	std::vector<std::pair<uint16_t, e::slice> > value;
+	while (up.remain() && !up.error())
+	{
+		uint16_t attr_n;
+		e::slice attr_s;
+		up = up >> attr_n >> attr_s;
+		value.push_back(std::make_pair(attr_n, attr_s));
+	}
+	if (up.error())
+	{
+		PENDING_ERROR(SERVERERROR) << "communication error: server "
+		                           << vsi << " sent corrupt message="
+		                           << msg->as_slice().hex()
+		                           << " in response to a GET_PARTIAL";
+		return true;
+	}
+	hyperdex_client_returncode op_status;
+	e::error op_error;
+	if (!value_to_attributes(cl->m_config,
+	                         cl->m_config.get_region_id(vsi),
+	                         value, &op_status, &op_error,
+	                         m_attrs, m_attrs_sz, cl->m_convert_types))
+	{
+		set_status(op_status);
+		set_error(op_error);
+		return true;
+	}
+	set_status(HYPERDEX_CLIENT_SUCCESS);
+	set_error(e::error());
+	return true;
 }
diff --git a/client/pending_get_partial.h b/client/pending_get_partial.h
index 792c47914..bedd30e41 100644
--- a/client/pending_get_partial.h
+++ b/client/pending_get_partial.h
@@ -36,41 +36,41 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class pending_get_partial : public pending
 {
-    public:
-        pending_get_partial(uint64_t client_visible_id,
-                            hyperdex_client_returncode* status,
-                            const hyperdex_client_attribute** attrs, size_t* attrs_sz);
-        virtual ~pending_get_partial() throw ();
+public:
+	pending_get_partial(uint64_t client_visible_id,
+	                    hyperdex_client_returncode *status,
+	                    const hyperdex_client_attribute **attrs, size_t *attrs_sz);
+	virtual ~pending_get_partial() throw ();
 
-    // return to client
-    public:
-        virtual bool can_yield();
-        virtual bool yield(hyperdex_client_returncode* status, e::error* error);
+	// return to client
+public:
+	virtual bool can_yield();
+	virtual bool yield(hyperdex_client_returncode *status, e::error *error);
 
-    // events
-    public:
-        virtual void handle_sent_to(const server_id& si,
-                                    const virtual_server_id& vsi);
-        virtual void handle_failure(const server_id& si,
-                                    const virtual_server_id& vsi);
-        virtual bool handle_message(client*,
-                                    const server_id& si,
-                                    const virtual_server_id& vsi,
-                                    network_msgtype mt,
-                                    std::auto_ptr<e::buffer> msg,
-                                    e::unpacker up,
-                                    hyperdex_client_returncode* status,
-                                    e::error* error);
+	// events
+public:
+	virtual void handle_sent_to(const server_id &si,
+	                            const virtual_server_id &vsi);
+	virtual void handle_failure(const server_id &si,
+	                            const virtual_server_id &vsi);
+	virtual bool handle_message(client *,
+	                            const server_id &si,
+	                            const virtual_server_id &vsi,
+	                            network_msgtype mt,
+	                            std::auto_ptr<e::buffer> msg,
+	                            e::unpacker up,
+	                            hyperdex_client_returncode *status,
+	                            e::error *error);
 
-    // noncopyable
-    private:
-        pending_get_partial(const pending_get_partial& other);
-        pending_get_partial& operator = (const pending_get_partial& rhs);
+	// noncopyable
+private:
+	pending_get_partial(const pending_get_partial &other);
+	pending_get_partial &operator = (const pending_get_partial &rhs);
 
-    private:
-        enum { INITIALIZED, SENT, RECV, YIELDED } m_state;
-        const hyperdex_client_attribute** m_attrs;
-        size_t* m_attrs_sz;
+private:
+	enum { INITIALIZED, SENT, RECV, YIELDED } m_state;
+	const hyperdex_client_attribute **m_attrs;
+	size_t *m_attrs_sz;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/client/pending_group_atomic.cc b/client/pending_group_atomic.cc
index 72254d3fa..60a0c4a00 100644
--- a/client/pending_group_atomic.cc
+++ b/client/pending_group_atomic.cc
@@ -32,13 +32,13 @@
 using hyperdex::pending_group_atomic;
 
 pending_group_atomic :: pending_group_atomic(uint64_t id,
-                                             hyperdex_client_returncode* status,
-                                             uint64_t* update_count)
-    : pending_aggregation(id, status)
-    , m_state(INITIALIZED)
-    , m_update_count(update_count)
+                                             hyperdex_client_returncode *status,
+                                             uint64_t *update_count)
+	: pending_aggregation(id, status)
+	, m_state(INITIALIZED)
+	, m_update_count(update_count)
 {
-    *m_update_count = 0;
+	*m_update_count = 0;
 }
 
 pending_group_atomic :: ~pending_group_atomic() throw ()
@@ -48,84 +48,76 @@ pending_group_atomic :: ~pending_group_atomic() throw ()
 bool
 pending_group_atomic :: can_yield()
 {
-    return m_state == DONE || m_state == FAILURE;
+	return m_state == DONE || m_state == FAILURE;
 }
 
 bool
-pending_group_atomic :: yield(hyperdex_client_returncode* status, e::error* err)
+pending_group_atomic :: yield(hyperdex_client_returncode *status, e::error *err)
 {
-    *status = HYPERDEX_CLIENT_SUCCESS;
-    *err = e::error();
-    assert(this->can_yield());
-    m_state = YIELDED;
-    return true;
+	*status = HYPERDEX_CLIENT_SUCCESS;
+	*err = e::error();
+	assert(this->can_yield());
+	m_state = YIELDED;
+	return true;
 }
 
 void
-pending_group_atomic :: handle_sent_to(const server_id& sid,
-                                 const virtual_server_id& vid)
+pending_group_atomic :: handle_sent_to(const server_id &sid,
+                                       const virtual_server_id &vid)
 {
-    pending_aggregation::handle_sent_to(sid, vid);
-
-    // We could already have received something
-    if(m_state == INITIALIZED)
-    {
-        m_state = SENT;
-    }
+	pending_aggregation::handle_sent_to(sid, vid);
+	// We could already have received something
+	if (m_state == INITIALIZED)
+	{
+		m_state = SENT;
+	}
 }
 
 void
-pending_group_atomic :: handle_failure(const server_id& si,
-                                       const virtual_server_id& vsi)
+pending_group_atomic :: handle_failure(const server_id &si,
+                                       const virtual_server_id &vsi)
 {
-    pending_aggregation::handle_failure(si, vsi);
-
-    assert(m_state == SENT);
-    m_state = RECV;
-    PENDING_ERROR(RECONFIGURE) << "reconfiguration affecting "
-                               << vsi << "/" << si;
+	pending_aggregation::handle_failure(si, vsi);
+	assert(m_state == SENT);
+	m_state = RECV;
+	PENDING_ERROR(RECONFIGURE) << "reconfiguration affecting "
+	                           << vsi << "/" << si;
 }
 
 bool
-pending_group_atomic :: handle_message(client* cl,
-                                       const server_id& si,
-                                       const virtual_server_id& vsi,
+pending_group_atomic :: handle_message(client *cl,
+                                       const server_id &si,
+                                       const virtual_server_id &vsi,
                                        network_msgtype mt,
                                        std::auto_ptr<e::buffer> msg,
                                        e::unpacker up,
-                                       hyperdex_client_returncode* status,
-                                       e::error* err)
+                                       hyperdex_client_returncode *status,
+                                       e::error *err)
 {
-    bool handled = pending_aggregation::handle_message(cl, si, vsi, mt, std::auto_ptr<e::buffer>(), up, status, err);
-    assert(handled);
-
-    if (mt != RESP_GROUP_ATOMIC)
-    {
-        PENDING_ERROR(SERVERERROR) << "server " << vsi << " responded to GROUP_ATOMIC with " << mt;
-        return true;
-    }
-
-    uint64_t response;
-    up = up >> response;
-
-    // Remember how many fields we updated
-    *m_update_count += response;
-
-    if (up.error())
-    {
-        PENDING_ERROR(SERVERERROR) << "communication error: server "
-                                   << vsi << " sent corrupt message="
-                                   << msg->as_slice().hex()
-                                   << " in response to a GROUP_ATOMIC";
-        return true;
-    }
-
-    if(this->aggregation_done())
-    {
-        m_state = DONE;
-        set_status(HYPERDEX_CLIENT_SUCCESS);
-        set_error(e::error());
-    }
-
-    return true;
+	bool handled = pending_aggregation::handle_message(cl, si, vsi, mt, std::auto_ptr<e::buffer>(), up, status, err);
+	assert(handled);
+	if (mt != RESP_GROUP_ATOMIC)
+	{
+		PENDING_ERROR(SERVERERROR) << "server " << vsi << " responded to GROUP_ATOMIC with " << mt;
+		return true;
+	}
+	uint64_t response;
+	up = up >> response;
+	// Remember how many fields we updated
+	*m_update_count += response;
+	if (up.error())
+	{
+		PENDING_ERROR(SERVERERROR) << "communication error: server "
+		                           << vsi << " sent corrupt message="
+		                           << msg->as_slice().hex()
+		                           << " in response to a GROUP_ATOMIC";
+		return true;
+	}
+	if (this->aggregation_done())
+	{
+		m_state = DONE;
+		set_status(HYPERDEX_CLIENT_SUCCESS);
+		set_error(e::error());
+	}
+	return true;
 }
diff --git a/client/pending_group_atomic.h b/client/pending_group_atomic.h
index ffe468e82..c0f5d8b01 100644
--- a/client/pending_group_atomic.h
+++ b/client/pending_group_atomic.h
@@ -36,39 +36,39 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class pending_group_atomic : public pending_aggregation
 {
-    public:
-        pending_group_atomic(uint64_t client_visible_id,
-                             hyperdex_client_returncode* status,
-                             uint64_t* update_count);
-        virtual ~pending_group_atomic() throw ();
+public:
+	pending_group_atomic(uint64_t client_visible_id,
+	                     hyperdex_client_returncode *status,
+	                     uint64_t *update_count);
+	virtual ~pending_group_atomic() throw ();
 
-    // return to client
-    public:
-        virtual bool can_yield();
-        virtual bool yield(hyperdex_client_returncode* status, e::error* error);
+	// return to client
+public:
+	virtual bool can_yield();
+	virtual bool yield(hyperdex_client_returncode *status, e::error *error);
 
-    // events
-    public:
-        virtual void handle_sent_to(const server_id& si,
-                                    const virtual_server_id& vsi);
-        virtual void handle_failure(const server_id& si,
-                                    const virtual_server_id& vsi);
-        virtual bool handle_message(client*,
-                                    const server_id& si,
-                                    const virtual_server_id& vsi,
-                                    network_msgtype mt,
-                                    std::auto_ptr<e::buffer> msg,
-                                    e::unpacker up,
-                                    hyperdex_client_returncode* status,
-                                    e::error* error);
+	// events
+public:
+	virtual void handle_sent_to(const server_id &si,
+	                            const virtual_server_id &vsi);
+	virtual void handle_failure(const server_id &si,
+	                            const virtual_server_id &vsi);
+	virtual bool handle_message(client *,
+	                            const server_id &si,
+	                            const virtual_server_id &vsi,
+	                            network_msgtype mt,
+	                            std::auto_ptr<e::buffer> msg,
+	                            e::unpacker up,
+	                            hyperdex_client_returncode *status,
+	                            e::error *error);
 
-    private:
-        enum { INITIALIZED, SENT, RECV, DONE, FAILURE, YIELDED } m_state;
-        uint64_t* m_update_count;
+private:
+	enum { INITIALIZED, SENT, RECV, DONE, FAILURE, YIELDED } m_state;
+	uint64_t *m_update_count;
 
-    private:
-        pending_group_atomic(const pending_group_atomic&);
-        pending_group_atomic& operator = (const pending_group_atomic&);
+private:
+	pending_group_atomic(const pending_group_atomic &);
+	pending_group_atomic &operator = (const pending_group_atomic &);
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/client/pending_search.cc b/client/pending_search.cc
index 155eea855..9baa9f69a 100644
--- a/client/pending_search.cc
+++ b/client/pending_search.cc
@@ -34,16 +34,16 @@
 using hyperdex::pending_search;
 
 pending_search :: pending_search(uint64_t id,
-                                 hyperdex_client_returncode* status,
-                                 const hyperdex_client_attribute** attrs, size_t* attrs_sz)
-    : pending_aggregation(id, status)
-    , m_attrs(attrs)
-    , m_attrs_sz(attrs_sz)
-    , m_yield(false)
-    , m_done(false)
+                                 hyperdex_client_returncode *status,
+                                 const hyperdex_client_attribute **attrs, size_t *attrs_sz)
+	: pending_aggregation(id, status)
+	, m_attrs(attrs)
+	, m_attrs_sz(attrs_sz)
+	, m_yield(false)
+	, m_done(false)
 {
-    *m_attrs = NULL;
-    *m_attrs_sz = 0;
+	*m_attrs = NULL;
+	*m_attrs_sz = 0;
 }
 
 pending_search :: ~pending_search() throw ()
@@ -53,112 +53,100 @@ pending_search :: ~pending_search() throw ()
 bool
 pending_search :: can_yield()
 {
-    return m_yield;
+	return m_yield;
 }
 
 bool
-pending_search :: yield(hyperdex_client_returncode* status, e::error* err)
+pending_search :: yield(hyperdex_client_returncode *status, e::error *err)
 {
-    *status = HYPERDEX_CLIENT_SUCCESS;
-    *err = e::error();
-    m_yield = false;
-
-    if (this->aggregation_done() && !m_done)
-    {
-        m_yield = true;
-        m_done = true;
-    }
-    else if (m_done)
-    {
-        set_status(HYPERDEX_CLIENT_SEARCHDONE);
-    }
-
-    return true;
+	*status = HYPERDEX_CLIENT_SUCCESS;
+	*err = e::error();
+	m_yield = false;
+	if (this->aggregation_done() && !m_done)
+	{
+		m_yield = true;
+		m_done = true;
+	}
+	else if (m_done)
+	{
+		set_status(HYPERDEX_CLIENT_SEARCHDONE);
+	}
+	return true;
 }
 
 void
-pending_search :: handle_failure(const server_id& si,
-                                 const virtual_server_id& vsi)
+pending_search :: handle_failure(const server_id &si,
+                                 const virtual_server_id &vsi)
 {
-    m_yield = true;
-    PENDING_ERROR(RECONFIGURE) << "reconfiguration affecting "
-                               << vsi << "/" << si;
-    return pending_aggregation::handle_failure(si, vsi);
+	m_yield = true;
+	PENDING_ERROR(RECONFIGURE) << "reconfiguration affecting "
+	                           << vsi << "/" << si;
+	return pending_aggregation::handle_failure(si, vsi);
 }
 
 bool
-pending_search :: handle_message(client* cl,
-                                 const server_id& si,
-                                 const virtual_server_id& vsi,
+pending_search :: handle_message(client *cl,
+                                 const server_id &si,
+                                 const virtual_server_id &vsi,
                                  network_msgtype mt,
                                  std::auto_ptr<e::buffer> msg,
                                  e::unpacker up,
-                                 hyperdex_client_returncode* status,
-                                 e::error* err)
+                                 hyperdex_client_returncode *status,
+                                 e::error *err)
 {
-    bool handled = pending_aggregation::handle_message(cl, si, vsi, mt, std::auto_ptr<e::buffer>(), up, status, err);
-    assert(handled);
-
-    *status = HYPERDEX_CLIENT_SUCCESS;
-    *err = e::error();
-
-    if (mt == RESP_SEARCH_DONE)
-    {
-        if (this->aggregation_done())
-        {
-            m_yield = true;
-            m_done = true;
-        }
-
-        return true;
-    }
-    else if (mt != RESP_SEARCH_ITEM)
-    {
-        PENDING_ERROR(SERVERERROR) << "server " << vsi << " responded to SEARCH with " << mt;
-        m_yield = true;
-        return true;
-    }
-
-    e::slice key;
-    std::vector<e::slice> value;
-    up = up >> key >> value;
-
-    if (up.error())
-    {
-        PENDING_ERROR(SERVERERROR) << "communication error: server "
-                                   << vsi << " sent corrupt message="
-                                   << msg->as_slice().hex()
-                                   << " in response to a SEARCH";
-        m_yield = true;
-        return true;
-    }
-
-    hyperdex_client_returncode op_status;
-    e::error op_error;
-
-    if (!value_to_attributes(cl->m_config,
-                             cl->m_config.get_region_id(vsi),
-                             key.data(), key.size(), value,
-                             &op_status, &op_error, m_attrs, m_attrs_sz, cl->m_convert_types))
-    {
-        set_status(op_status);
-        set_error(op_error);
-        m_yield = true;
-        return true;
-    }
-
-    std::auto_ptr<e::buffer> smsg(e::buffer::create(HYPERDEX_CLIENT_HEADER_SIZE_REQ + sizeof(uint64_t)));
-    smsg->pack_at(HYPERDEX_CLIENT_HEADER_SIZE_REQ) << static_cast<uint64_t>(client_visible_id());
-
-    if (!cl->send(REQ_SEARCH_NEXT, vsi, cl->m_next_server_nonce++, smsg, this, status))
-    {
-        PENDING_ERROR(RECONFIGURE) << "could not send SEARCH_NEXT to " << vsi;
-        m_yield = true;
-        return true;
-    }
-
-    set_status(HYPERDEX_CLIENT_SUCCESS);
-    set_error(e::error());
-    m_yield = true;
-    return true;
+	bool handled = pending_aggregation::handle_message(cl, si, vsi, mt, std::auto_ptr<e::buffer>(), up, status, err);
+	assert(handled);
+	*status = HYPERDEX_CLIENT_SUCCESS;
+	*err = e::error();
+	if (mt == RESP_SEARCH_DONE)
+	{
+		if (this->aggregation_done())
+		{
+			m_yield = true;
+			m_done = true;
+		}
+		return true;
+	}
+	else if (mt != RESP_SEARCH_ITEM)
+	{
+		PENDING_ERROR(SERVERERROR) << "server " << vsi << " responded to SEARCH with " << mt;
+		m_yield = true;
+		return true;
+	}
+	e::slice key;
+	std::vector<e::slice> value;
+	up = up >> key >> value;
+	if (up.error())
+	{
+		PENDING_ERROR(SERVERERROR) << "communication error: server "
+		                           << vsi << " sent corrupt message="
+		                           << msg->as_slice().hex()
+		                           << " in response to a SEARCH";
+		m_yield = true;
+		return true;
+	}
+	hyperdex_client_returncode op_status;
+	e::error op_error;
+	if (!value_to_attributes(cl->m_config,
+	                         cl->m_config.get_region_id(vsi),
+	                         key.data(), key.size(), value,
+	                         &op_status, &op_error, m_attrs, m_attrs_sz, cl->m_convert_types))
+	{
+		set_status(op_status);
+		set_error(op_error);
+		m_yield = true;
+		return true;
+	}
+	std::auto_ptr<e::buffer> smsg(e::buffer::create(HYPERDEX_CLIENT_HEADER_SIZE_REQ + sizeof(uint64_t)));
+	smsg->pack_at(HYPERDEX_CLIENT_HEADER_SIZE_REQ) << static_cast<uint64_t>(client_visible_id());
+	if (!cl->send(REQ_SEARCH_NEXT, vsi, cl->m_next_server_nonce++, smsg, this, status))
+	{
+		PENDING_ERROR(RECONFIGURE) << "could not send SEARCH_NEXT to " << vsi;
+		m_yield = true;
+		return true;
+	}
+	set_status(HYPERDEX_CLIENT_SUCCESS);
+	set_error(e::error());
+	m_yield = true;
+	return true;
 }
diff --git a/client/pending_search.h b/client/pending_search.h
index 5a965d018..fa7b06480 100644
--- a/client/pending_search.h
+++ b/client/pending_search.h
@@ -36,40 +36,40 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class pending_search : public pending_aggregation
 {
-    public:
-        pending_search(uint64_t client_visible_id,
-                       hyperdex_client_returncode* status,
-                       const hyperdex_client_attribute** attrs, size_t* attrs_sz);
-        virtual ~pending_search() throw ();
+public:
+	pending_search(uint64_t client_visible_id,
+	               hyperdex_client_returncode *status,
+	               const hyperdex_client_attribute **attrs, size_t *attrs_sz);
+	virtual ~pending_search() throw ();
 
-    // return to client
-    public:
-        virtual bool can_yield();
-        virtual bool yield(hyperdex_client_returncode* status, e::error* error);
+	// return to client
+public:
+	virtual bool can_yield();
+	virtual bool yield(hyperdex_client_returncode *status, e::error *error);
 
-    // events
-    public:
-        virtual void handle_failure(const server_id& si,
-                                    const virtual_server_id& vsi);
-        virtual bool handle_message(client*,
-                                    const server_id& si,
-                                    const virtual_server_id& vsi,
-                                    network_msgtype mt,
-                                    std::auto_ptr<e::buffer> msg,
-                                    e::unpacker up,
-                                    hyperdex_client_returncode* status,
-                                    e::error* error);
+	// events
+public:
+	virtual void handle_failure(const server_id &si,
+	                            const virtual_server_id &vsi);
+	virtual bool handle_message(client *,
+	                            const server_id &si,
+	                            const virtual_server_id &vsi,
+	                            network_msgtype mt,
+	                            std::auto_ptr<e::buffer> msg,
+	                            e::unpacker up,
+	                            hyperdex_client_returncode *status,
+	                            e::error *error);
 
-    // noncopyable
-    private:
-        pending_search(const pending_search& other);
-        pending_search& operator = (const pending_search& rhs);
+	// noncopyable
+private:
+	pending_search(const pending_search &other);
+	pending_search &operator = (const pending_search &rhs);
 
-    private:
-        const hyperdex_client_attribute** m_attrs;
-        size_t* m_attrs_sz;
-        bool m_yield;
-        bool m_done;
+private:
+	const hyperdex_client_attribute **m_attrs;
+	size_t *m_attrs_sz;
+	bool m_yield;
+	bool m_done;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/client/pending_search_describe.cc b/client/pending_search_describe.cc
index 2315e5293..ffd61ae4b 100644
--- a/client/pending_search_describe.cc
+++ b/client/pending_search_describe.cc
@@ -31,13 +31,13 @@
 using hyperdex::pending_search_describe;
 
 pending_search_describe :: pending_search_describe(uint64_t id,
-                                                   hyperdex_client_returncode* status,
-                                                   const char** description)
-    : pending_aggregation(id, status)
-    , m_description(description)
-    , m_done(false)
-    , m_msgs()
-    , m_text()
+        hyperdex_client_returncode *status,
+        const char **description)
+	: pending_aggregation(id, status)
+	, m_description(description)
+	, m_done(false)
+	, m_msgs()
+	, m_text()
 {
 }
 
@@ -48,83 +48,78 @@ pending_search_describe :: ~pending_search_describe() throw ()
 bool
 pending_search_describe :: can_yield()
 {
-    return this->aggregation_done() && !m_done;
+	return this->aggregation_done() && !m_done;
 }
 
 bool
-pending_search_describe :: yield(hyperdex_client_returncode* status, e::error* err)
+pending_search_describe :: yield(hyperdex_client_returncode *status, e::error *err)
 {
-    std::ostringstream ostr;
-
-    for (size_t i = 0; i < m_msgs.size(); ++i)
-    {
-        ostr << m_msgs[i].first << " " << m_msgs[i].second << "\n";
-    }
-
-    m_text = ostr.str();
-    *status = HYPERDEX_CLIENT_SUCCESS;
-    *m_description = m_text.c_str();
-    *err = e::error();
-    assert(this->can_yield());
-    m_done = true;
-    set_status(HYPERDEX_CLIENT_SUCCESS);
-    set_error(e::error());
-    return true;
+	std::ostringstream ostr;
+	for (size_t i = 0; i < m_msgs.size(); ++i)
+	{
+		ostr << m_msgs[i].first << " " << m_msgs[i].second << "\n";
+	}
+	m_text = ostr.str();
+	*status = HYPERDEX_CLIENT_SUCCESS;
+	*m_description = m_text.c_str();
+	*err = e::error();
+	assert(this->can_yield());
+	m_done = true;
+	set_status(HYPERDEX_CLIENT_SUCCESS);
+	set_error(e::error());
+	return true;
 }
 
 void
-pending_search_describe :: handle_sent_to(const server_id& si,
-                                          const virtual_server_id& vsi)
+pending_search_describe :: handle_sent_to(const server_id &si,
+                                          const virtual_server_id &vsi)
 {
-    add_text(vsi, "touched by search");
-    return pending_aggregation::handle_sent_to(si, vsi);
+	add_text(vsi, "touched by search");
+	return pending_aggregation::handle_sent_to(si, vsi);
 }
 
 void
-pending_search_describe :: handle_failure(const server_id& si,
-                                          const virtual_server_id& vsi)
+pending_search_describe :: handle_failure(const server_id &si,
+                                          const virtual_server_id &vsi)
 {
-    add_text(vsi, "failed");
-    return pending_aggregation::handle_sent_to(si, vsi);
+	add_text(vsi, "failed");
+	return pending_aggregation::handle_sent_to(si, vsi);
 }
 
 bool
-pending_search_describe :: handle_message(client* cl,
-                                          const server_id& si,
-                                          const virtual_server_id& vsi,
+pending_search_describe :: handle_message(client *cl,
+                                          const server_id &si,
+                                          const virtual_server_id &vsi,
                                           network_msgtype mt,
                                           std::auto_ptr<e::buffer>,
                                           e::unpacker up,
-                                          hyperdex_client_returncode* status,
-                                          e::error* err)
+                                          hyperdex_client_returncode *status,
+                                          e::error *err)
 {
-    bool handled = pending_aggregation::handle_message(cl, si, vsi, mt, std::auto_ptr<e::buffer>(), up, status, err);
-    assert(handled);
-
-    *status = HYPERDEX_CLIENT_SUCCESS;
-    *err = e::error();
-
-    if (mt != RESP_SEARCH_DESCRIBE)
-    {
-        add_text(vsi, "sent non-RESP_SEARCH_DESCRIBE message");
-        return true;
-    }
-
-    e::slice text = up.remainder();
-    add_text(vsi, text);
-    return true;
+	bool handled = pending_aggregation::handle_message(cl, si, vsi, mt, std::auto_ptr<e::buffer>(), up, status, err);
+	assert(handled);
+	*status = HYPERDEX_CLIENT_SUCCESS;
+	*err = e::error();
+	if (mt != RESP_SEARCH_DESCRIBE)
+	{
+		add_text(vsi, "sent non-RESP_SEARCH_DESCRIBE message");
+		return true;
+	}
+	e::slice text = up.remainder();
+	add_text(vsi, text);
+	return true;
 }
 
 void
-pending_search_describe :: add_text(const hyperdex::virtual_server_id& vid,
-                                    const e::slice& text)
+pending_search_describe :: add_text(const hyperdex::virtual_server_id &vid,
+                                    const e::slice &text)
 {
-    m_msgs.push_back(std::make_pair(vid, std::string(reinterpret_cast<const char*>(text.data()), text.size())));
+	m_msgs.push_back(std::make_pair(vid, std::string(reinterpret_cast<const char *>(text.data()), text.size())));
 }
 
 void
-pending_search_describe :: add_text(const hyperdex::virtual_server_id& vid,
-                                    const char* text)
+pending_search_describe :: add_text(const hyperdex::virtual_server_id &vid,
+                                    const char *text)
 {
-    m_msgs.push_back(std::make_pair(vid, std::string(text)));
+	m_msgs.push_back(std::make_pair(vid, std::string(text)));
 }
diff --git a/client/pending_search_describe.h b/client/pending_search_describe.h
index 1add91fd5..a79e6b1f2 100644
--- a/client/pending_search_describe.h
+++ b/client/pending_search_describe.h
@@ -36,47 +36,47 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class pending_search_describe : public pending_aggregation
 {
-    public:
-        pending_search_describe(uint64_t client_visible_id,
-                                hyperdex_client_returncode* status,
-                                const char** description);
-        virtual ~pending_search_describe() throw ();
+public:
+	pending_search_describe(uint64_t client_visible_id,
+	                        hyperdex_client_returncode *status,
+	                        const char **description);
+	virtual ~pending_search_describe() throw ();
 
-    // return to client
-    public:
-        virtual bool can_yield();
-        virtual bool yield(hyperdex_client_returncode* status, e::error* error);
+	// return to client
+public:
+	virtual bool can_yield();
+	virtual bool yield(hyperdex_client_returncode *status, e::error *error);
 
-    // events
-    public:
-        virtual void handle_sent_to(const server_id& si,
-                                    const virtual_server_id& vsi);
-        virtual void handle_failure(const server_id& si,
-                                    const virtual_server_id& vsi);
-        virtual bool handle_message(client*,
-                                    const server_id& si,
-                                    const virtual_server_id& vsi,
-                                    network_msgtype mt,
-                                    std::auto_ptr<e::buffer> msg,
-                                    e::unpacker up,
-                                    hyperdex_client_returncode* status,
-                                    e::error* error);
+	// events
+public:
+	virtual void handle_sent_to(const server_id &si,
+	                            const virtual_server_id &vsi);
+	virtual void handle_failure(const server_id &si,
+	                            const virtual_server_id &vsi);
+	virtual bool handle_message(client *,
+	                            const server_id &si,
+	                            const virtual_server_id &vsi,
+	                            network_msgtype mt,
+	                            std::auto_ptr<e::buffer> msg,
+	                            e::unpacker up,
+	                            hyperdex_client_returncode *status,
+	                            e::error *error);
 
-    // add text to description
-    private:
-        void add_text(const hyperdex::virtual_server_id& vid, const e::slice& text);
-        void add_text(const hyperdex::virtual_server_id& vid, const char* text);
+	// add text to description
+private:
+	void add_text(const hyperdex::virtual_server_id &vid, const e::slice &text);
+	void add_text(const hyperdex::virtual_server_id &vid, const char *text);
 
-    // noncopyable
-    private:
-        pending_search_describe(const pending_search_describe& other);
-        pending_search_describe& operator = (const pending_search_describe& rhs);
+	// noncopyable
+private:
+	pending_search_describe(const pending_search_describe &other);
+	pending_search_describe &operator = (const pending_search_describe &rhs);
 
-    private:
-        const char** m_description;
-        bool m_done;
-        std::vector<std::pair<hyperdex::virtual_server_id, std::string> > m_msgs;
-        std::string m_text;
+private:
+	const char **m_description;
+	bool m_done;
+	std::vector<std::pair<hyperdex::virtual_server_id, std::string> > m_msgs;
+	std::string m_text;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/client/pending_sorted_search.cc b/client/pending_sorted_search.cc
index 225fb3584..545bd7681 100644
--- a/client/pending_sorted_search.cc
+++ b/client/pending_sorted_search.cc
@@ -32,31 +32,32 @@
 #include "client/client.h"
 #include "client/pending_sorted_search.h"
 #include "client/util.h"
+#include <functional>
 
 using hyperdex::datatype_info;
 using hyperdex::pending_sorted_search;
 
-pending_sorted_search :: pending_sorted_search(client* cl,
+pending_sorted_search :: pending_sorted_search(client *cl,
                                                uint64_t id,
                                                bool maximize,
                                                uint64_t limit,
                                                uint16_t sort_by_idx,
-                                               datatype_info* sort_by_di,
-                                               hyperdex_client_returncode* status,
-                                               const hyperdex_client_attribute** attrs,
-                                               size_t* attrs_sz)
-    : pending_aggregation(id, status)
-    , m_cl(cl)
-    , m_yield(false)
-    , m_ri()
-    , m_maximize(maximize)
-    , m_limit(limit)
-    , m_sort_by_idx(sort_by_idx)
-    , m_sort_by_di(sort_by_di)
-    , m_attrs(attrs)
-    , m_attrs_sz(attrs_sz)
-    , m_results()
-    , m_results_idx()
+                                               datatype_info *sort_by_di,
+                                               hyperdex_client_returncode *status,
+                                               const hyperdex_client_attribute **attrs,
+                                               size_t *attrs_sz)
+	: pending_aggregation(id, status)
+	, m_cl(cl)
+	, m_yield(false)
+	, m_ri()
+	, m_maximize(maximize)
+	, m_limit(limit)
+	, m_sort_by_idx(sort_by_idx)
+	, m_sort_by_di(sort_by_di)
+	, m_attrs(attrs)
+	, m_attrs_sz(attrs_sz)
+	, m_results()
+	, m_results_idx(0)
 {
 }
 
@@ -67,216 +68,206 @@ pending_sorted_search :: ~pending_sorted_search() throw ()
 bool
 pending_sorted_search :: can_yield()
 {
-    return m_yield;
+	return m_yield;
 }
 
 bool
-pending_sorted_search :: yield(hyperdex_client_returncode* status, e::error* err)
+pending_sorted_search :: yield(hyperdex_client_returncode *status, e::error *err)
 {
-    *status = HYPERDEX_CLIENT_SUCCESS;
-    *err = e::error();
-    m_yield = false;
-
-    if (this->aggregation_done() && m_results_idx >= m_results.size())
-    {
-        set_status(HYPERDEX_CLIENT_SEARCHDONE);
-        set_error(e::error());
-        return true;
-    }
-
-    m_yield = true;
-
-    hyperdex_client_returncode op_status;
-    e::error op_error;
-    const e::slice& key(m_results[m_results_idx].key);
-    const std::vector<e::slice>& value(m_results[m_results_idx].value);
-    ++m_results_idx;
-
-    if (!value_to_attributes(m_cl->m_config, m_ri, key.data(), key.size(),
-                             value, &op_status, &op_error, m_attrs, m_attrs_sz, m_cl->m_convert_types))
-    {
-        set_status(op_status);
-        set_error(op_error);
-        return true;
-    }
-
-    set_status(HYPERDEX_CLIENT_SUCCESS);
-    set_error(e::error());
-    return true;
+	*status = HYPERDEX_CLIENT_SUCCESS;
+	*err = e::error();
+	m_yield = false;
+	if (this->aggregation_done() && m_results_idx >= m_results.size())
+	{
+		set_status(HYPERDEX_CLIENT_SEARCHDONE);
+		set_error(e::error());
+		return true;
+	}
+	m_yield = true;
+	hyperdex_client_returncode op_status;
+	e::error op_error;
+	const e::slice &key(m_results[m_results_idx].key);
+	const std::vector<e::slice> &value(m_results[m_results_idx].value);
+	++m_results_idx;
+	if (!value_to_attributes(m_cl->m_config, m_ri, key.data(), key.size(),
+	                         value, &op_status, &op_error, m_attrs, m_attrs_sz, m_cl->m_convert_types))
+	{
+		set_status(op_status);
+		set_error(op_error);
+		return true;
+	}
+	set_status(HYPERDEX_CLIENT_SUCCESS);
+	set_error(e::error());
+	return true;
 }
 
 void
-pending_sorted_search :: handle_sent_to(const server_id& si,
-                                        const virtual_server_id& vsi)
+pending_sorted_search :: handle_sent_to(const server_id &si,
+                                        const virtual_server_id &vsi)
 {
-    if (m_ri == region_id())
-    {
-        m_ri = m_cl->m_config.get_region_id(vsi);
-    }
-
-    return pending_aggregation::handle_sent_to(si, vsi);
+	if (m_ri == region_id())
+	{
+		m_ri = m_cl->m_config.get_region_id(vsi);
+	}
+	return pending_aggregation::handle_sent_to(si, vsi);
 }
 
 void
-pending_sorted_search :: handle_failure(const server_id& si,
-                                        const virtual_server_id& vsi)
+pending_sorted_search :: handle_failure(const server_id &si,
+                                        const virtual_server_id &vsi)
 {
-    m_yield = true;
-    PENDING_ERROR(RECONFIGURE) << "reconfiguration affecting "
-                               << vsi << "/" << si;
-    return pending_aggregation::handle_failure(si, vsi);
+	m_yield = true;
+	PENDING_ERROR(RECONFIGURE) << "reconfiguration affecting "
+	                           << vsi << "/" << si;
+	return pending_aggregation::handle_failure(si, vsi);
 }
 
-namespace
-{
-
-class sorted_search_comparator
+namespace hyperdex
 {
-    public:
-        sorted_search_comparator(bool maximize,
-                                 uint16_t sort_by_idx,
-                                 datatype_info* sort_by_di);
-
-    public:
-        bool operator () (const pending_sorted_search::item& lhs,
-                          const pending_sorted_search::item& rhs);
-
-    private:
-        bool m_maximize;
-        uint16_t m_sort_by_idx;
-        datatype_info* m_sort_by_di;
-};
-
-} // namespace
 
-sorted_search_comparator :: sorted_search_comparator(bool maximize,
-                                                     uint16_t sort_by_idx,
-                                                     datatype_info* sort_by_di)
-    : m_maximize(maximize)
-    , m_sort_by_idx(sort_by_idx)
-    , m_sort_by_di(sort_by_di)
+bool
+operator < (const pending_sorted_search::item &lhs, const pending_sorted_search::item &rhs)
 {
+	assert(lhs.ssc_ptr == rhs.ssc_ptr);
+	const sorted_search_comparator *ssc_ptr = lhs.ssc_ptr;
+	if (ssc_ptr->m_sort_by_idx > lhs.value.size() ||
+	    ssc_ptr->m_sort_by_idx > rhs.value.size() ||
+	    lhs.value.size() != rhs.value.size())
+	{
+		return false;
+	}
+	int cmp = 0;
+	if (ssc_ptr->m_sort_by_idx == 0)
+	{
+		cmp = ssc_ptr->m_sort_by_di->compare(lhs.key, rhs.key);
+	}
+	else
+	{
+		cmp = ssc_ptr->m_sort_by_di->compare(lhs.value[ssc_ptr->m_sort_by_idx - 1], rhs.value[ssc_ptr->m_sort_by_idx - 1]);
+	}
+	if (ssc_ptr->m_maximize)
+	{
+		return cmp < 0;
+	}
+	else
+	{
+		return cmp > 0;
+	}
 }
 
 bool
-sorted_search_comparator :: operator () (const pending_sorted_search::item& lhs,
-                                         const pending_sorted_search::item& rhs)
+operator > (const pending_sorted_search::item &lhs, const pending_sorted_search::item &rhs)
 {
-    if (m_sort_by_idx > lhs.value.size() ||
-        m_sort_by_idx > rhs.value.size() ||
-        lhs.value.size() != rhs.value.size())
-    {
-        return false;
-    }
-
-    e::slice lhs_attr;
-    e::slice rhs_attr;
-
-    if (m_sort_by_idx == 0)
-    {
-        lhs_attr = lhs.key;
-        rhs_attr = rhs.key;
-    }
-    else
-    {
-        lhs_attr = lhs.value[m_sort_by_idx - 1];
-        rhs_attr = rhs.value[m_sort_by_idx - 1];
-    }
+	assert(lhs.ssc_ptr == rhs.ssc_ptr);
+	const sorted_search_comparator *ssc_ptr = lhs.ssc_ptr;
+	if (ssc_ptr->m_sort_by_idx > lhs.value.size() ||
+	    ssc_ptr->m_sort_by_idx > rhs.value.size() ||
+	    lhs.value.size() != rhs.value.size())
+	{
+		return false;
+	}
+	int cmp = 0;
+	if (ssc_ptr->m_sort_by_idx == 0)
+	{
+		cmp = ssc_ptr->m_sort_by_di->compare(lhs.key, rhs.key);
+	}
+	else
+	{
+		cmp = ssc_ptr->m_sort_by_di->compare(lhs.value[ssc_ptr->m_sort_by_idx - 1], rhs.value[ssc_ptr->m_sort_by_idx - 1]);
+	}
+	if (ssc_ptr->m_maximize)
+	{
+		return cmp > 0;
+	}
+	else
+	{
+		return cmp < 0;
+	}
+}
 
-    int cmp = m_sort_by_di->compare(lhs_attr, rhs_attr);
-    return m_maximize ? (cmp > 0) : (cmp < 0);
 }
 
 bool
-pending_sorted_search :: handle_message(client* cl,
-                                        const server_id& si,
-                                        const virtual_server_id& vsi,
+pending_sorted_search :: handle_message(client *cl,
+                                        const server_id &si,
+                                        const virtual_server_id &vsi,
                                         network_msgtype mt,
                                         std::auto_ptr<e::buffer> msg,
                                         e::unpacker up,
-                                        hyperdex_client_returncode* status,
-                                        e::error* err)
+                                        hyperdex_client_returncode *status,
+                                        e::error *err)
 {
-    bool handled = pending_aggregation::handle_message(cl, si, vsi, mt, std::auto_ptr<e::buffer>(), up, status, err);
-    assert(handled);
-
-    *status = HYPERDEX_CLIENT_SUCCESS;
-    *err = e::error();
-
-    if (mt != RESP_SORTED_SEARCH)
-    {
-        PENDING_ERROR(SERVERERROR) << "server " << vsi << " responded to SORTED_SEARCH with " << mt;
-        m_yield = true;
-        return true;
-    }
-
-    uint64_t num_results = 0;
-    up = up >> num_results;
-
-    if (up.error())
-    {
-        PENDING_ERROR(SERVERERROR) << "communication error: server "
-                                   << vsi << " sent corrupt message="
-                                   << msg->as_slice().hex()
-                                   << " in response to a SORTED_SEARCH";
-        m_yield = true;
-        return true;
-    }
-
-    sorted_search_comparator ssc(m_maximize, m_sort_by_idx, m_sort_by_di);
-    e::compat::shared_ptr<e::buffer> backing(msg.release());
-
-    for (uint64_t i = 0; i < num_results; ++i)
-    {
-        e::slice key;
-        std::vector<e::slice> value;
-        up = up >> key >> value;
-
-        if (up.error())
-        {
-            PENDING_ERROR(SERVERERROR) << "communication error: server "
-                                       << vsi << " sent corrupt message="
-                                       << msg->as_slice().hex()
-                                       << " in response to a SORTED_SEARCH";
-            m_yield = true;
-            return true;
-        }
-
-        m_results.push_back(item(key, value, backing));
-        std::push_heap(m_results.begin(), m_results.end(), ssc);
-
-        if (m_results.size() > m_limit)
-        {
-            std::pop_heap(m_results.begin(), m_results.end(), ssc);
-            m_results.pop_back();
-        }
-    }
-
-    m_yield = this->aggregation_done();
-    set_status(HYPERDEX_CLIENT_SUCCESS);
-    set_error(e::error());
-
-    if (m_yield)
-    {
-        std::sort(m_results.begin(), m_results.end(), ssc);
-    }
-
-    return true;
+	bool handled = pending_aggregation::handle_message(cl, si, vsi, mt, std::auto_ptr<e::buffer>(), up, status, err);
+	assert(handled);
+	*status = HYPERDEX_CLIENT_SUCCESS;
+	*err = e::error();
+	if (mt != RESP_SORTED_SEARCH)
+	{
+		PENDING_ERROR(SERVERERROR) << "server " << vsi << " responded to SORTED_SEARCH with " << mt;
+		m_yield = true;
+		return true;
+	}
+	uint64_t num_results = 0;
+	up = up >> num_results;
+	if (up.error())
+	{
+		PENDING_ERROR(SERVERERROR) << "communication error: server "
+		                           << vsi << " sent corrupt message="
+		                           << msg->as_slice().hex()
+		                           << " in response to a SORTED_SEARCH";
+		m_yield = true;
+		return true;
+	}
+	sorted_search_comparator ssc(m_maximize, m_sort_by_idx, m_sort_by_di);
+	e::compat::shared_ptr<e::buffer> backing(msg.release());
+	for (uint64_t i = 0; i < num_results; ++i)
+	{
+		e::slice key;
+		std::vector<e::slice> value;
+		up = up >> key >> value;
+		if (up.error())
+		{
+			PENDING_ERROR(SERVERERROR) << "communication error: server "
+			                           << vsi << " sent corrupt message="
+			                           << msg->as_slice().hex()
+			                           << " in response to a SORTED_SEARCH";
+			m_yield = true;
+			return true;
+		}
+		m_results.push_back(item(&ssc, key, value, backing));
+		std::push_heap(m_results.begin(), m_results.end());
+		if (m_results.size() > m_limit)
+		{
+			std::pop_heap(m_results.begin(), m_results.end());
+			m_results.pop_back();
+		}
+	}
+	m_yield = this->aggregation_done();
+	set_status(HYPERDEX_CLIENT_SUCCESS);
+	set_error(e::error());
+	if (m_yield)
+	{
+		std::sort(m_results.begin(), m_results.end(), std::greater<pending_sorted_search::item>());
+	}
+	return true;
 }
 
-pending_sorted_search :: item :: item(const e::slice& _key,
-                                      const std::vector<e::slice>& _value,
+pending_sorted_search :: item :: item(const sorted_search_comparator *sscobj,
+                                      const e::slice &_key,
+                                      const std::vector<e::slice> &_value,
                                       e::compat::shared_ptr<e::buffer> _backing)
-    : key(_key)
-    , value(_value)
-    , backing(_backing)
+	: ssc_ptr(sscobj)
+	, key(_key)
+	, value(_value)
+	, backing(_backing)
 {
 }
 
-pending_sorted_search :: item :: item(const item& other)
-    : key(other.key)
-    , value(other.value)
-    , backing(other.backing)
+pending_sorted_search :: item :: item(const item &other)
+	: ssc_ptr(other.ssc_ptr)
+	, key(other.key)
+	, value(other.value)
+	, backing(other.backing)
 {
 }
 
@@ -284,15 +275,15 @@ pending_sorted_search :: item :: ~item() throw ()
 {
 }
 
-pending_sorted_search::item&
-pending_sorted_search :: item :: operator = (const item& other)
+pending_sorted_search::item &
+pending_sorted_search :: item :: operator = (const item &other)
 {
-    if (this != &other)
-    {
-        key = other.key;
-        value = other.value;
-        backing = other.backing;
-    }
-
-    return *this;
+	if (this != &other)
+	{
+		ssc_ptr = other.ssc_ptr;
+		key = other.key;
+		value = other.value;
+		backing = other.backing;
+	}
+	return *this;
 }
diff --git a/client/pending_sorted_search.h b/client/pending_sorted_search.h
index d5a2f4577..84c6a9140 100644
--- a/client/pending_sorted_search.h
+++ b/client/pending_sorted_search.h
@@ -40,80 +40,96 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class pending_sorted_search : public pending_aggregation
 {
-    public:
-        pending_sorted_search(client* cl,
-                              uint64_t id,
-                              bool maximize,
-                              uint64_t limit,
-                              uint16_t sort_by_idx,
-                              datatype_info* sort_by_di,
-                              hyperdex_client_returncode* status,
-                              const hyperdex_client_attribute** attrs,
-                              size_t* attrs_sz);
-        virtual ~pending_sorted_search() throw ();
-
-    // return to client
-    public:
-        virtual bool can_yield();
-        virtual bool yield(hyperdex_client_returncode* status, e::error* error);
-
-    // events
-    public:
-        virtual void handle_sent_to(const server_id& si,
-                                    const virtual_server_id& vsi);
-        virtual void handle_failure(const server_id& si,
-                                    const virtual_server_id& vsi);
-        virtual bool handle_message(client*,
-                                    const server_id& si,
-                                    const virtual_server_id& vsi,
-                                    network_msgtype mt,
-                                    std::auto_ptr<e::buffer> msg,
-                                    e::unpacker up,
-                                    hyperdex_client_returncode* status,
-                                    e::error* error);
-
-    public:
-        class item;
-
-    // noncopyable
-    private:
-        pending_sorted_search(const pending_sorted_search& other);
-        pending_sorted_search& operator = (const pending_sorted_search& rhs);
-
-    private:
-        client* m_cl;
-        bool m_yield;
-        region_id m_ri;
-        bool m_maximize;
-        const uint64_t m_limit;
-        const uint16_t m_sort_by_idx;
-        datatype_info* m_sort_by_di;
-        const hyperdex_client_attribute** m_attrs;
-        size_t* m_attrs_sz;
-        std::vector<item> m_results;
-        size_t m_results_idx;
+public:
+	pending_sorted_search(client *cl,
+	                      uint64_t id,
+	                      bool maximize,
+	                      uint64_t limit,
+	                      uint16_t sort_by_idx,
+	                      datatype_info *sort_by_di,
+	                      hyperdex_client_returncode *status,
+	                      const hyperdex_client_attribute **attrs,
+	                      size_t *attrs_sz);
+	virtual ~pending_sorted_search() throw ();
+
+	// return to client
+public:
+	virtual bool can_yield();
+	virtual bool yield(hyperdex_client_returncode *status, e::error *error);
+
+	// events
+public:
+	virtual void handle_sent_to(const server_id &si,
+	                            const virtual_server_id &vsi);
+	virtual void handle_failure(const server_id &si,
+	                            const virtual_server_id &vsi);
+	virtual bool handle_message(client *,
+	                            const server_id &si,
+	                            const virtual_server_id &vsi,
+	                            network_msgtype mt,
+	                            std::auto_ptr<e::buffer> msg,
+	                            e::unpacker up,
+	                            hyperdex_client_returncode *status,
+	                            e::error *error);
+
+public:
+	class item;
+
+	// noncopyable
+private:
+	pending_sorted_search(const pending_sorted_search &other);
+	pending_sorted_search &operator = (const pending_sorted_search &rhs);
+
+private:
+	client *m_cl;
+	bool m_yield;
+	region_id m_ri;
+	bool m_maximize;
+	const uint64_t m_limit;
+	const uint16_t m_sort_by_idx;
+	datatype_info *m_sort_by_di;
+	const hyperdex_client_attribute **m_attrs;
+	size_t *m_attrs_sz;
+	std::vector<item> m_results;
+	size_t m_results_idx;
 };
 
+class sorted_search_comparator
+{
+public:
+	sorted_search_comparator(bool maximize,
+	                         uint16_t sort_by_idx,
+	                         datatype_info *sort_by_di)
+		: m_maximize(maximize)
+		, m_sort_by_idx(sort_by_idx)
+		, m_sort_by_di(sort_by_di)
+	{
+	}
+
+public:
+	bool m_maximize;
+	uint16_t m_sort_by_idx;
+	datatype_info *m_sort_by_di;
+};
 class pending_sorted_search :: item
 {
-    public:
-        item();
-        item(const e::slice& key,
-             const std::vector<e::slice>& value,
-             e::compat::shared_ptr<e::buffer> backing);
-        item(const item&);
-        ~item() throw ();
-
-    public:
-        item& operator = (const item&);
-
-    public:
-        e::slice key;
-        std::vector<e::slice> value;
-        e::compat::shared_ptr<e::buffer> backing;
-
-    public:
-        friend class sorted_search_comparator;
+public:
+	item();
+	item(const sorted_search_comparator *sscobj,
+	     const e::slice &key,
+	     const std::vector<e::slice> &value,
+	     e::compat::shared_ptr<e::buffer> backing);
+	item(const item &);
+	~item() throw ();
+
+public:
+	item &operator = (const item &);
+
+public:
+	const sorted_search_comparator *ssc_ptr;
+	e::slice key;
+	std::vector<e::slice> value;
+	e::compat::shared_ptr<e::buffer> backing;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/client/pending_sum.cc b/client/pending_sum.cc
new file mode 100644
index 000000000..67f4fa40f
--- /dev/null
+++ b/client/pending_sum.cc
@@ -0,0 +1,111 @@
+// Copyright (c) 2012-2013, Cornell University
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+//     * Redistributions of source code must retain the above copyright notice,
+//       this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above copyright
+//       notice, this list of conditions and the following disclaimer in the
+//       documentation and/or other materials provided with the distribution.
+//     * Neither the name of HyperDex nor the names of its contributors may be
+//       used to endorse or promote products derived from this software without
+//       specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+// HyperDex
+#include "client/pending_sum.h"
+#include "common/datatype_info.h"
+
+using hyperdex::pending_sum;
+
+pending_sum :: pending_sum(uint64_t id,
+                           uint16_t sum_idx,
+                           datatype_info *sum_di,
+                           hyperdex_client_returncode *status,
+                           uint64_t *count)
+	: pending_aggregation(id, status)
+	, m_sum_idx(sum_idx)
+	, m_sum_di(sum_di)
+	, m_sum(count)
+	, m_done(false)
+{
+	set_status(HYPERDEX_CLIENT_SUCCESS);
+	set_error(e::error());
+}
+
+pending_sum :: ~pending_sum() throw ()
+{
+}
+
+bool
+pending_sum :: can_yield()
+{
+	return this->aggregation_done() && !m_done;
+}
+
+bool
+pending_sum :: yield(hyperdex_client_returncode *status, e::error *err)
+{
+	*status = HYPERDEX_CLIENT_SUCCESS;
+	*err = e::error();
+	assert(this->can_yield());
+	m_done = true;
+	return true;
+}
+
+void
+pending_sum :: handle_failure(const server_id &si,
+                              const virtual_server_id &vsi)
+{
+	PENDING_ERROR(RECONFIGURE) << "reconfiguration affecting "
+	                           << vsi << "/" << si;
+	return pending_aggregation::handle_failure(si, vsi);
+}
+
+bool
+pending_sum :: handle_message(client *cl,
+                              const server_id &si,
+                              const virtual_server_id &vsi,
+                              network_msgtype mt,
+                              std::auto_ptr<e::buffer> msg,
+                              e::unpacker up,
+                              hyperdex_client_returncode *status,
+                              e::error *err)
+{
+	bool handled = pending_aggregation::handle_message(cl, si, vsi, mt, std::auto_ptr<e::buffer>(), up, status, err);
+	assert(handled);
+	*status = HYPERDEX_CLIENT_SUCCESS;
+	*err = e::error();
+	if (mt != RESP_SUM)
+	{
+		PENDING_ERROR(SERVERERROR) << "server " << vsi << " responded to SUM with " << mt;
+		return true;
+	}
+	uint64_t local_sum;
+	up = up >> local_sum;
+	if (up.error())
+	{
+		PENDING_ERROR(SERVERERROR) << "communication error: server "
+		                           << vsi << " sent corrupt message="
+		                           << msg->as_slice().hex()
+		                           << " in response to a SUM";
+		return true;
+	}
+	*m_sum += local_sum;
+	// Don't set the status or error so that errors will carry through.  It was
+	// set to the success state in the constructor
+	return true;
+}
diff --git a/client/pending_sum.h b/client/pending_sum.h
new file mode 100644
index 000000000..cedd05c5b
--- /dev/null
+++ b/client/pending_sum.h
@@ -0,0 +1,80 @@
+// Copyright (c) 2012-2016, Cornell University
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+//     * Redistributions of source code must retain the above copyright notice,
+//       this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above copyright
+//       notice, this list of conditions and the following disclaimer in the
+//       documentation and/or other materials provided with the distribution.
+//     * Neither the name of HyperDex nor the names of its contributors may be
+//       used to endorse or promote products derived from this software without
+//       specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef hyperdex_client_pending_sum_h_
+#define hyperdex_client_pending_sum_h_
+
+// HyperDex
+#include "namespace.h"
+#include "client/pending_aggregation.h"
+
+BEGIN_HYPERDEX_NAMESPACE
+
+class datatype_info;
+class pending_sum : public pending_aggregation
+{
+public:
+	pending_sum(uint64_t client_visible_id,
+	            uint16_t sum_idx,
+	            datatype_info *sum_di,
+	            hyperdex_client_returncode *status,
+	            uint64_t *count);
+	virtual ~pending_sum() throw ();
+
+	// return to client
+public:
+	virtual bool can_yield();
+	virtual bool yield(hyperdex_client_returncode *status, e::error *error);
+
+	// events
+public:
+	virtual void handle_failure(const server_id &si,
+	                            const virtual_server_id &vsi);
+	virtual bool handle_message(client *,
+	                            const server_id &si,
+	                            const virtual_server_id &vsi,
+	                            network_msgtype mt,
+	                            std::auto_ptr<e::buffer> msg,
+	                            e::unpacker up,
+	                            hyperdex_client_returncode *status,
+	                            e::error *error);
+
+	// noncopyable
+private:
+	pending_sum(const pending_sum &other);
+	pending_sum &operator = (const pending_sum &rhs);
+
+private:
+	const uint16_t m_sum_idx;
+	datatype_info *m_sum_di;
+	uint64_t *m_sum;
+	bool m_done;
+};
+
+END_HYPERDEX_NAMESPACE
+
+#endif // hyperdex_client_pending_sum_h_
diff --git a/client/test/datastructures.cc b/client/test/datastructures.cc
index 77a617768..94e4ae531 100644
--- a/client/test/datastructures.cc
+++ b/client/test/datastructures.cc
@@ -34,796 +34,738 @@
 
 TEST(ClientDataStructures, ArenaCtorDtor)
 {
-    hyperdex_ds_arena* a = hyperdex_ds_arena_create();
-    hyperdex_ds_arena_destroy(a);
+	hyperdex_ds_arena *a = hyperdex_ds_arena_create();
+	hyperdex_ds_arena_destroy(a);
 }
 
 TEST(ClientDataStructures, AllocateAttribute)
 {
-    hyperdex_ds_arena* a = hyperdex_ds_arena_create();
-    hyperdex_client_attribute* attrs;
-    attrs = hyperdex_ds_allocate_attribute(a, 10);
-
-    for (size_t i = 0; i < 10; ++i)
-    {
-        // we don't care what it gets filled with, this just tests that we don't
-        // overrun the allocated space.
-        attrs[i].attr = "FOOBAR";
-        attrs[i].value = NULL;
-        attrs[i].value_sz = 0;
-        attrs[i].datatype = HYPERDATATYPE_GENERIC;
-    }
-
-    hyperdex_ds_arena_destroy(a);
+	hyperdex_ds_arena *a = hyperdex_ds_arena_create();
+	hyperdex_client_attribute *attrs;
+	attrs = hyperdex_ds_allocate_attribute(a, 10);
+	for (size_t i = 0; i < 10; ++i)
+	{
+		// we don't care what it gets filled with, this just tests that we don't
+		// overrun the allocated space.
+		attrs[i].attr = "FOOBAR";
+		attrs[i].value = NULL;
+		attrs[i].value_sz = 0;
+		attrs[i].datatype = HYPERDATATYPE_GENERIC;
+	}
+	hyperdex_ds_arena_destroy(a);
 }
 
 TEST(ClientDataStructures, AllocateAttributeCheck)
 {
-    hyperdex_ds_arena* a = hyperdex_ds_arena_create();
-    hyperdex_client_attribute_check* checks;
-    checks = hyperdex_ds_allocate_attribute_check(a, 10);
-
-    for (size_t i = 0; i < 10; ++i)
-    {
-        // we don't care what it gets filled with, this just tests that we don't
-        // overrun the allocated space.
-        checks[i].attr = "FOOBAR";
-        checks[i].value = NULL;
-        checks[i].value_sz = 0;
-        checks[i].datatype = HYPERDATATYPE_GENERIC;
-        checks[i].predicate = HYPERPREDICATE_FAIL;
-    }
-
-    hyperdex_ds_arena_destroy(a);
+	hyperdex_ds_arena *a = hyperdex_ds_arena_create();
+	hyperdex_client_attribute_check *checks;
+	checks = hyperdex_ds_allocate_attribute_check(a, 10);
+	for (size_t i = 0; i < 10; ++i)
+	{
+		// we don't care what it gets filled with, this just tests that we don't
+		// overrun the allocated space.
+		checks[i].attr = "FOOBAR";
+		checks[i].value = NULL;
+		checks[i].value_sz = 0;
+		checks[i].datatype = HYPERDATATYPE_GENERIC;
+		checks[i].predicate = HYPERPREDICATE_FAIL;
+	}
+	hyperdex_ds_arena_destroy(a);
 }
 
 TEST(ClientDataStructures, AllocateMapAttribute)
 {
-    hyperdex_ds_arena* a = hyperdex_ds_arena_create();
-    hyperdex_client_map_attribute* mapattrs;
-    mapattrs = hyperdex_ds_allocate_map_attribute(a, 10);
-
-    for (size_t i = 0; i < 10; ++i)
-    {
-        // we don't care what it gets filled with, this just tests that we don't
-        // overrun the allocated space.
-        mapattrs[i].attr = "FOOBAR";
-        mapattrs[i].map_key = NULL;
-        mapattrs[i].map_key_sz = 0;
-        mapattrs[i].map_key_datatype = HYPERDATATYPE_GENERIC;
-        mapattrs[i].value = NULL;
-        mapattrs[i].value_sz = 0;
-        mapattrs[i].value_datatype = HYPERDATATYPE_GENERIC;
-    }
-
-    hyperdex_ds_arena_destroy(a);
+	hyperdex_ds_arena *a = hyperdex_ds_arena_create();
+	hyperdex_client_map_attribute *mapattrs;
+	mapattrs = hyperdex_ds_allocate_map_attribute(a, 10);
+	for (size_t i = 0; i < 10; ++i)
+	{
+		// we don't care what it gets filled with, this just tests that we don't
+		// overrun the allocated space.
+		mapattrs[i].attr = "FOOBAR";
+		mapattrs[i].map_key = NULL;
+		mapattrs[i].map_key_sz = 0;
+		mapattrs[i].map_key_datatype = HYPERDATATYPE_GENERIC;
+		mapattrs[i].value = NULL;
+		mapattrs[i].value_sz = 0;
+		mapattrs[i].value_datatype = HYPERDATATYPE_GENERIC;
+	}
+	hyperdex_ds_arena_destroy(a);
 }
 
 TEST(ClientDataStructures, PackInt)
 {
-    char buf[sizeof(int64_t)];
-    hyperdex_ds_pack_int(0, buf);
-    ASSERT_TRUE(memcmp(buf, "\x00\x00\x00\x00\x00\x00\x00\x00", 8) == 0);
-    hyperdex_ds_pack_int(0xdeadbeef, buf);
-    ASSERT_TRUE(memcmp(buf, "\xef\xbe\xad\xde\x00\x00\x00\x00", 8) == 0);
+	char buf[sizeof(int64_t)];
+	hyperdex_ds_pack_int(0, buf);
+	ASSERT_TRUE(memcmp(buf, "\x00\x00\x00\x00\x00\x00\x00\x00", 8) == 0);
+	hyperdex_ds_pack_int(0xdeadbeef, buf);
+	ASSERT_TRUE(memcmp(buf, "\xef\xbe\xad\xde\x00\x00\x00\x00", 8) == 0);
 }
 
 TEST(ClientDataStructures, UnpackInt)
 {
-    int64_t num;
-    ASSERT_TRUE(hyperdex_ds_unpack_int("\x00\x00\x00\x00\x00\x00\x00\x00", 8, &num) == 0);
-    ASSERT_EQ(num, 0);
-    ASSERT_TRUE(hyperdex_ds_unpack_int("\xef\xbe\xad\xde\x00\x00\x00\x00", 8, &num) == 0);
-    ASSERT_EQ(num, 0xdeadbeef);
-    num = 0x8badf00d;
-    ASSERT_TRUE(hyperdex_ds_unpack_int("\xef\xbe\xad\xde\x00\x00\x00\x00", 7, &num) < 0);
-    ASSERT_EQ(num, 0x8badf00d);
+	int64_t num;
+	ASSERT_TRUE(hyperdex_ds_unpack_int("\x00\x00\x00\x00\x00\x00\x00\x00", 8, &num) == 0);
+	ASSERT_EQ(num, 0);
+	ASSERT_TRUE(hyperdex_ds_unpack_int("\xef\xbe\xad\xde\x00\x00\x00\x00", 8, &num) == 0);
+	ASSERT_EQ(num, 0xdeadbeef);
+	num = 0x8badf00d;
+	ASSERT_TRUE(hyperdex_ds_unpack_int("\xef\xbe\xad\xde\x00\x00\x00\x00", 7, &num) < 0);
+	ASSERT_EQ(num, 0x8badf00d);
 }
 
 TEST(ClientDataStructures, PackFloat)
 {
-    double num = 9006104071832581.0;
-    char buf[sizeof(double)];
-    hyperdex_ds_pack_float(num, buf);
-    ASSERT_TRUE(memcmp(buf, "\x05\x04\x03\x02\x01\xff\x3f\x43", 8) == 0);
+	double num = 9006104071832581.0;
+	char buf[sizeof(double)];
+	hyperdex_ds_pack_float(num, buf);
+	ASSERT_TRUE(memcmp(buf, "\x05\x04\x03\x02\x01\xff\x3f\x43", 8) == 0);
 }
 
 TEST(ClientDataStructures, UnpackFloat)
 {
-    double num;
-    ASSERT_TRUE(hyperdex_ds_unpack_float("\x05\x04\x03\x02\x01\xff\x3f\x43", 8, &num) == 0);
-    ASSERT_GE(num, 9006104071832580.9);
-    ASSERT_LE(num, 9006104071832581.1);
+	double num;
+	ASSERT_TRUE(hyperdex_ds_unpack_float("\x05\x04\x03\x02\x01\xff\x3f\x43", 8, &num) == 0);
+	ASSERT_GE(num, 9006104071832580.9);
+	ASSERT_LE(num, 9006104071832581.1);
 }
 
 TEST(ClientDataStructures, CopyString)
 {
-    char buf[6] = {'h', 'e', 'l', 'l', 'o', '\x00'};
-    hyperdex_ds_arena* a = hyperdex_ds_arena_create();
-    hyperdex_ds_returncode status;
-    const char* tmp = NULL;
-    size_t tmp_sz = 0;
-
-    ASSERT_TRUE(hyperdex_ds_copy_string(a, buf, 6,
-                                        &status,
-                                        &tmp, &tmp_sz) == 0);
-    ASSERT_EQ(status, HYPERDEX_DS_SUCCESS);
-    ASSERT_TRUE(tmp_sz == 6);
-    ASSERT_TRUE(strncmp(tmp, "hello", 6) == 0);
-    memmove(buf, "world\x00", 6);
-    ASSERT_TRUE(strncmp(tmp, "hello", 6) == 0);
-
-    hyperdex_ds_arena_destroy(a);
+	char buf[6] = {'h', 'e', 'l', 'l', 'o', '\x00'};
+	hyperdex_ds_arena *a = hyperdex_ds_arena_create();
+	hyperdex_ds_returncode status;
+	const char *tmp = NULL;
+	size_t tmp_sz = 0;
+	ASSERT_TRUE(hyperdex_ds_copy_string(a, buf, 6,
+	                                    &status,
+	                                    &tmp, &tmp_sz) == 0);
+	ASSERT_EQ(status, HYPERDEX_DS_SUCCESS);
+	ASSERT_TRUE(tmp_sz == 6);
+	ASSERT_TRUE(strncmp(tmp, "hello", 6) == 0);
+	memmove(buf, "world\x00", 6);
+	ASSERT_TRUE(strncmp(tmp, "hello", 6) == 0);
+	hyperdex_ds_arena_destroy(a);
 }
 
 TEST(ClientDataStructures, CopyInt)
 {
-    hyperdex_ds_arena* a = hyperdex_ds_arena_create();
-    hyperdex_ds_returncode status;
-    const char* tmp = NULL;
-    size_t tmp_sz = 0;
-
-    ASSERT_TRUE(hyperdex_ds_copy_int(a, 0xdeadbeef,
-                                     &status,
-                                     &tmp, &tmp_sz) == 0);
-    ASSERT_EQ(status, HYPERDEX_DS_SUCCESS);
-    ASSERT_TRUE(tmp_sz == 8);
-    ASSERT_TRUE(memcmp(tmp, "\xef\xbe\xad\xde\x00\x00\x00\x00", 8) == 0);
-
-    hyperdex_ds_arena_destroy(a);
+	hyperdex_ds_arena *a = hyperdex_ds_arena_create();
+	hyperdex_ds_returncode status;
+	const char *tmp = NULL;
+	size_t tmp_sz = 0;
+	ASSERT_TRUE(hyperdex_ds_copy_int(a, 0xdeadbeef,
+	                                 &status,
+	                                 &tmp, &tmp_sz) == 0);
+	ASSERT_EQ(status, HYPERDEX_DS_SUCCESS);
+	ASSERT_TRUE(tmp_sz == 8);
+	ASSERT_TRUE(memcmp(tmp, "\xef\xbe\xad\xde\x00\x00\x00\x00", 8) == 0);
+	hyperdex_ds_arena_destroy(a);
 }
 
 TEST(ClientDataStructures, AllocateList)
 {
-    hyperdex_ds_arena* a = hyperdex_ds_arena_create();
-    hyperdex_ds_list* list = hyperdex_ds_allocate_list(a);
-    list = list; // no more warnings
-    hyperdex_ds_arena_destroy(a);
+	hyperdex_ds_arena *a = hyperdex_ds_arena_create();
+	hyperdex_ds_list *list = hyperdex_ds_allocate_list(a);
+	list = list; // no more warnings
+	hyperdex_ds_arena_destroy(a);
 }
 
 TEST(ClientDataStructures, ListString)
 {
-    hyperdex_ds_returncode status;
-    const char* tmp = NULL;
-    size_t tmp_sz = 0;
-    hyperdatatype datatype;
-    hyperdex_ds_arena* a = hyperdex_ds_arena_create();
-    hyperdex_ds_list* list;
-
-    // example 1
-    list = hyperdex_ds_allocate_list(a);
-    ASSERT_TRUE(hyperdex_ds_list_finalize(list, &status,
-                                          &tmp, &tmp_sz,
-                                          &datatype) == 0);
-    ASSERT_EQ(tmp_sz, 0UL);
-    ASSERT_EQ(datatype, HYPERDATATYPE_LIST_GENERIC);
-    // example 2
-    list = hyperdex_ds_allocate_list(a);
-    ASSERT_TRUE(hyperdex_ds_list_append_string(list, "hello", 5, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_list_append_string(list, "world", 5, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_list_finalize(list, &status,
-                                          &tmp, &tmp_sz,
-                                          &datatype) == 0);
-    ASSERT_EQ(tmp_sz, 18UL);
-    ASSERT_TRUE(memcmp(tmp, "\x05\x00\x00\x00hello\x05\x00\x00\x00world", 18) == 0);
-    ASSERT_EQ(datatype, HYPERDATATYPE_LIST_STRING);
-    // error on cross-ds insert
-    list = hyperdex_ds_allocate_list(a);
-    ASSERT_TRUE(hyperdex_ds_list_append_string(list, "hello", 5, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_list_append_int(list, 0, &status) == -1);
-    ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
-    list = hyperdex_ds_allocate_list(a);
-    ASSERT_TRUE(hyperdex_ds_list_append_string(list, "hello", 5, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_list_append_float(list, 0., &status) == -1);
-    ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
-
-    hyperdex_ds_arena_destroy(a);
+	hyperdex_ds_returncode status;
+	const char *tmp = NULL;
+	size_t tmp_sz = 0;
+	hyperdatatype datatype;
+	hyperdex_ds_arena *a = hyperdex_ds_arena_create();
+	hyperdex_ds_list *list;
+	// example 1
+	list = hyperdex_ds_allocate_list(a);
+	ASSERT_TRUE(hyperdex_ds_list_finalize(list, &status,
+	                                      &tmp, &tmp_sz,
+	                                      &datatype) == 0);
+	ASSERT_EQ(tmp_sz, 0UL);
+	ASSERT_EQ(datatype, HYPERDATATYPE_LIST_GENERIC);
+	// example 2
+	list = hyperdex_ds_allocate_list(a);
+	ASSERT_TRUE(hyperdex_ds_list_append_string(list, "hello", 5, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_list_append_string(list, "world", 5, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_list_finalize(list, &status,
+	                                      &tmp, &tmp_sz,
+	                                      &datatype) == 0);
+	ASSERT_EQ(tmp_sz, 18UL);
+	ASSERT_TRUE(memcmp(tmp, "\x05\x00\x00\x00hello\x05\x00\x00\x00world", 18) == 0);
+	ASSERT_EQ(datatype, HYPERDATATYPE_LIST_STRING);
+	// error on cross-ds insert
+	list = hyperdex_ds_allocate_list(a);
+	ASSERT_TRUE(hyperdex_ds_list_append_string(list, "hello", 5, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_list_append_int(list, 0, &status) == -1);
+	ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
+	list = hyperdex_ds_allocate_list(a);
+	ASSERT_TRUE(hyperdex_ds_list_append_string(list, "hello", 5, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_list_append_float(list, 0., &status) == -1);
+	ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
+	hyperdex_ds_arena_destroy(a);
 }
 
 TEST(ClientDataStructures, ListInt)
 {
-    hyperdex_ds_returncode status;
-    const char* tmp = NULL;
-    size_t tmp_sz = 0;
-    hyperdatatype datatype;
-    hyperdex_ds_arena* a = hyperdex_ds_arena_create();
-    hyperdex_ds_list* list;
-
-    // example 1
-    list = hyperdex_ds_allocate_list(a);
-    ASSERT_TRUE(hyperdex_ds_list_finalize(list, &status,
-                                          &tmp, &tmp_sz,
-                                          &datatype) == 0);
-    ASSERT_EQ(tmp_sz, 0UL);
-    ASSERT_EQ(datatype, HYPERDATATYPE_LIST_GENERIC);
-    // example 2
-    list = hyperdex_ds_allocate_list(a);
-    ASSERT_TRUE(hyperdex_ds_list_append_int(list, 1, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_list_append_int(list, -1, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_list_append_int(list, 0xdeadbeef, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_list_finalize(list, &status,
-                                          &tmp, &tmp_sz,
-                                          &datatype) == 0);
-    ASSERT_EQ(tmp_sz, 24UL);
-    ASSERT_TRUE(memcmp(tmp, "\x01\x00\x00\x00\x00\x00\x00\x00"
-                            "\xff\xff\xff\xff\xff\xff\xff\xff"
-                            "\xef\xbe\xad\xde\x00\x00\x00\x00", 24) == 0);
-    ASSERT_EQ(datatype, HYPERDATATYPE_LIST_INT64);
-    // error on cross-ds insert
-    list = hyperdex_ds_allocate_list(a);
-    ASSERT_TRUE(hyperdex_ds_list_append_int(list, 0, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_list_append_string(list, "hello", 5, &status) == -1);
-    ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
-    list = hyperdex_ds_allocate_list(a);
-    ASSERT_TRUE(hyperdex_ds_list_append_int(list, 0, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_list_append_float(list, 0., &status) == -1);
-    ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
-
-    hyperdex_ds_arena_destroy(a);
+	hyperdex_ds_returncode status;
+	const char *tmp = NULL;
+	size_t tmp_sz = 0;
+	hyperdatatype datatype;
+	hyperdex_ds_arena *a = hyperdex_ds_arena_create();
+	hyperdex_ds_list *list;
+	// example 1
+	list = hyperdex_ds_allocate_list(a);
+	ASSERT_TRUE(hyperdex_ds_list_finalize(list, &status,
+	                                      &tmp, &tmp_sz,
+	                                      &datatype) == 0);
+	ASSERT_EQ(tmp_sz, 0UL);
+	ASSERT_EQ(datatype, HYPERDATATYPE_LIST_GENERIC);
+	// example 2
+	list = hyperdex_ds_allocate_list(a);
+	ASSERT_TRUE(hyperdex_ds_list_append_int(list, 1, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_list_append_int(list, -1, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_list_append_int(list, 0xdeadbeef, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_list_finalize(list, &status,
+	                                      &tmp, &tmp_sz,
+	                                      &datatype) == 0);
+	ASSERT_EQ(tmp_sz, 24UL);
+	ASSERT_TRUE(memcmp(tmp, "\x01\x00\x00\x00\x00\x00\x00\x00"
+	                   "\xff\xff\xff\xff\xff\xff\xff\xff"
+	                   "\xef\xbe\xad\xde\x00\x00\x00\x00", 24) == 0);
+	ASSERT_EQ(datatype, HYPERDATATYPE_LIST_INT64);
+	// error on cross-ds insert
+	list = hyperdex_ds_allocate_list(a);
+	ASSERT_TRUE(hyperdex_ds_list_append_int(list, 0, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_list_append_string(list, "hello", 5, &status) == -1);
+	ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
+	list = hyperdex_ds_allocate_list(a);
+	ASSERT_TRUE(hyperdex_ds_list_append_int(list, 0, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_list_append_float(list, 0., &status) == -1);
+	ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
+	hyperdex_ds_arena_destroy(a);
 }
 
 TEST(ClientDataStructures, ListFloat)
 {
-    hyperdex_ds_returncode status;
-    const char* tmp = NULL;
-    size_t tmp_sz = 0;
-    hyperdatatype datatype;
-    hyperdex_ds_arena* a = hyperdex_ds_arena_create();
-    hyperdex_ds_list* list;
-
-    // example 1
-    list = hyperdex_ds_allocate_list(a);
-    ASSERT_TRUE(hyperdex_ds_list_finalize(list, &status,
-                                          &tmp, &tmp_sz,
-                                          &datatype) == 0);
-    ASSERT_EQ(tmp_sz, 0UL);
-    ASSERT_EQ(datatype, HYPERDATATYPE_LIST_GENERIC);
-    // example 2
-    list = hyperdex_ds_allocate_list(a);
-    ASSERT_TRUE(hyperdex_ds_list_append_float(list, 0, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_list_append_float(list, 3.1415, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_list_finalize(list, &status,
-                                          &tmp, &tmp_sz,
-                                          &datatype) == 0);
-    ASSERT_EQ(tmp_sz, 16UL);
-    ASSERT_TRUE(memcmp(tmp, "\x00\x00\x00\x00\x00\x00\x00\x00"
-                            "o\x12\x83\xc0\xca!\t@", 16) == 0);
-    ASSERT_EQ(datatype, HYPERDATATYPE_LIST_FLOAT);
-    // error on cross-ds insert
-    list = hyperdex_ds_allocate_list(a);
-    ASSERT_TRUE(hyperdex_ds_list_append_float(list, 0, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_list_append_string(list, "hello", 5, &status) == -1);
-    ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
-    list = hyperdex_ds_allocate_list(a);
-    ASSERT_TRUE(hyperdex_ds_list_append_float(list, 0., &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_list_append_int(list, 0, &status) == -1);
-    ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
-
-    hyperdex_ds_arena_destroy(a);
+	hyperdex_ds_returncode status;
+	const char *tmp = NULL;
+	size_t tmp_sz = 0;
+	hyperdatatype datatype;
+	hyperdex_ds_arena *a = hyperdex_ds_arena_create();
+	hyperdex_ds_list *list;
+	// example 1
+	list = hyperdex_ds_allocate_list(a);
+	ASSERT_TRUE(hyperdex_ds_list_finalize(list, &status,
+	                                      &tmp, &tmp_sz,
+	                                      &datatype) == 0);
+	ASSERT_EQ(tmp_sz, 0UL);
+	ASSERT_EQ(datatype, HYPERDATATYPE_LIST_GENERIC);
+	// example 2
+	list = hyperdex_ds_allocate_list(a);
+	ASSERT_TRUE(hyperdex_ds_list_append_float(list, 0, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_list_append_float(list, 3.1415, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_list_finalize(list, &status,
+	                                      &tmp, &tmp_sz,
+	                                      &datatype) == 0);
+	ASSERT_EQ(tmp_sz, 16UL);
+	ASSERT_TRUE(memcmp(tmp, "\x00\x00\x00\x00\x00\x00\x00\x00"
+	                   "o\x12\x83\xc0\xca!\t@", 16) == 0);
+	ASSERT_EQ(datatype, HYPERDATATYPE_LIST_FLOAT);
+	// error on cross-ds insert
+	list = hyperdex_ds_allocate_list(a);
+	ASSERT_TRUE(hyperdex_ds_list_append_float(list, 0, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_list_append_string(list, "hello", 5, &status) == -1);
+	ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
+	list = hyperdex_ds_allocate_list(a);
+	ASSERT_TRUE(hyperdex_ds_list_append_float(list, 0., &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_list_append_int(list, 0, &status) == -1);
+	ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
+	hyperdex_ds_arena_destroy(a);
 }
 
 TEST(ClientDataStructures, SetString)
 {
-    hyperdex_ds_returncode status;
-    const char* tmp = NULL;
-    size_t tmp_sz = 0;
-    hyperdatatype datatype;
-    hyperdex_ds_arena* a = hyperdex_ds_arena_create();
-    hyperdex_ds_set* set;
-
-    // example 1
-    set = hyperdex_ds_allocate_set(a);
-    ASSERT_TRUE(hyperdex_ds_set_finalize(set, &status,
-                                         &tmp, &tmp_sz,
-                                         &datatype) == 0);
-    ASSERT_EQ(tmp_sz, 0UL);
-    ASSERT_EQ(datatype, HYPERDATATYPE_SET_GENERIC);
-    // example 2
-    set = hyperdex_ds_allocate_set(a);
-    ASSERT_TRUE(hyperdex_ds_set_insert_string(set, "world", 5, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_set_insert_string(set, "hello", 5, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_set_finalize(set, &status,
-                                         &tmp, &tmp_sz,
-                                         &datatype) == 0);
-    ASSERT_EQ(tmp_sz, 18UL);
-    ASSERT_TRUE(memcmp(tmp, "\x05\x00\x00\x00hello\x05\x00\x00\x00world", 16) == 0);
-    ASSERT_EQ(datatype, HYPERDATATYPE_SET_STRING);
-    // error on cross-ds insert
-    set = hyperdex_ds_allocate_set(a);
-    ASSERT_TRUE(hyperdex_ds_set_insert_string(set, "hello", 5, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_set_insert_int(set, 0, &status) == -1);
-    ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
-    set = hyperdex_ds_allocate_set(a);
-    ASSERT_TRUE(hyperdex_ds_set_insert_string(set, "hello", 5, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_set_insert_float(set, 0., &status) == -1);
-    ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
-
-    hyperdex_ds_arena_destroy(a);
+	hyperdex_ds_returncode status;
+	const char *tmp = NULL;
+	size_t tmp_sz = 0;
+	hyperdatatype datatype;
+	hyperdex_ds_arena *a = hyperdex_ds_arena_create();
+	hyperdex_ds_set *set;
+	// example 1
+	set = hyperdex_ds_allocate_set(a);
+	ASSERT_TRUE(hyperdex_ds_set_finalize(set, &status,
+	                                     &tmp, &tmp_sz,
+	                                     &datatype) == 0);
+	ASSERT_EQ(tmp_sz, 0UL);
+	ASSERT_EQ(datatype, HYPERDATATYPE_SET_GENERIC);
+	// example 2
+	set = hyperdex_ds_allocate_set(a);
+	ASSERT_TRUE(hyperdex_ds_set_insert_string(set, "world", 5, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_set_insert_string(set, "hello", 5, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_set_finalize(set, &status,
+	                                     &tmp, &tmp_sz,
+	                                     &datatype) == 0);
+	ASSERT_EQ(tmp_sz, 18UL);
+	ASSERT_TRUE(memcmp(tmp, "\x05\x00\x00\x00hello\x05\x00\x00\x00world", 16) == 0);
+	ASSERT_EQ(datatype, HYPERDATATYPE_SET_STRING);
+	// error on cross-ds insert
+	set = hyperdex_ds_allocate_set(a);
+	ASSERT_TRUE(hyperdex_ds_set_insert_string(set, "hello", 5, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_set_insert_int(set, 0, &status) == -1);
+	ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
+	set = hyperdex_ds_allocate_set(a);
+	ASSERT_TRUE(hyperdex_ds_set_insert_string(set, "hello", 5, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_set_insert_float(set, 0., &status) == -1);
+	ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
+	hyperdex_ds_arena_destroy(a);
 }
 
 TEST(ClientDataStructures, SetInt)
 {
-    hyperdex_ds_returncode status;
-    const char* tmp = NULL;
-    size_t tmp_sz = 0;
-    hyperdatatype datatype;
-    hyperdex_ds_arena* a = hyperdex_ds_arena_create();
-    hyperdex_ds_set* set;
-
-    // example 1
-    set = hyperdex_ds_allocate_set(a);
-    ASSERT_TRUE(hyperdex_ds_set_finalize(set, &status,
-                                         &tmp, &tmp_sz,
-                                         &datatype) == 0);
-    ASSERT_EQ(tmp_sz, 0UL);
-    ASSERT_EQ(datatype, HYPERDATATYPE_SET_GENERIC);
-    // example 2
-    set = hyperdex_ds_allocate_set(a);
-    ASSERT_TRUE(hyperdex_ds_set_insert_int(set, 1, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_set_insert_int(set, -1, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_set_insert_int(set, 0xdeadbeef, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_set_finalize(set, &status,
-                                         &tmp, &tmp_sz,
-                                         &datatype) == 0);
-    ASSERT_EQ(tmp_sz, 24UL);
-    ASSERT_TRUE(memcmp(tmp, "\xff\xff\xff\xff\xff\xff\xff\xff"
-                            "\x01\x00\x00\x00\x00\x00\x00\x00"
-                            "\xef\xbe\xad\xde\x00\x00\x00\x00", 24) == 0);
-    ASSERT_EQ(datatype, HYPERDATATYPE_SET_INT64);
-    // error on cross-ds insert
-    set = hyperdex_ds_allocate_set(a);
-    ASSERT_TRUE(hyperdex_ds_set_insert_int(set, 0, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_set_insert_string(set, "hello", 5, &status) == -1);
-    ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
-    set = hyperdex_ds_allocate_set(a);
-    ASSERT_TRUE(hyperdex_ds_set_insert_int(set, 0, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_set_insert_float(set, 0., &status) == -1);
-    ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
-
-    hyperdex_ds_arena_destroy(a);
+	hyperdex_ds_returncode status;
+	const char *tmp = NULL;
+	size_t tmp_sz = 0;
+	hyperdatatype datatype;
+	hyperdex_ds_arena *a = hyperdex_ds_arena_create();
+	hyperdex_ds_set *set;
+	// example 1
+	set = hyperdex_ds_allocate_set(a);
+	ASSERT_TRUE(hyperdex_ds_set_finalize(set, &status,
+	                                     &tmp, &tmp_sz,
+	                                     &datatype) == 0);
+	ASSERT_EQ(tmp_sz, 0UL);
+	ASSERT_EQ(datatype, HYPERDATATYPE_SET_GENERIC);
+	// example 2
+	set = hyperdex_ds_allocate_set(a);
+	ASSERT_TRUE(hyperdex_ds_set_insert_int(set, 1, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_set_insert_int(set, -1, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_set_insert_int(set, 0xdeadbeef, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_set_finalize(set, &status,
+	                                     &tmp, &tmp_sz,
+	                                     &datatype) == 0);
+	ASSERT_EQ(tmp_sz, 24UL);
+	ASSERT_TRUE(memcmp(tmp, "\xff\xff\xff\xff\xff\xff\xff\xff"
+	                   "\x01\x00\x00\x00\x00\x00\x00\x00"
+	                   "\xef\xbe\xad\xde\x00\x00\x00\x00", 24) == 0);
+	ASSERT_EQ(datatype, HYPERDATATYPE_SET_INT64);
+	// error on cross-ds insert
+	set = hyperdex_ds_allocate_set(a);
+	ASSERT_TRUE(hyperdex_ds_set_insert_int(set, 0, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_set_insert_string(set, "hello", 5, &status) == -1);
+	ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
+	set = hyperdex_ds_allocate_set(a);
+	ASSERT_TRUE(hyperdex_ds_set_insert_int(set, 0, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_set_insert_float(set, 0., &status) == -1);
+	ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
+	hyperdex_ds_arena_destroy(a);
 }
 
 TEST(ClientDataStructures, SetFloat)
 {
-    hyperdex_ds_returncode status;
-    const char* tmp = NULL;
-    size_t tmp_sz = 0;
-    hyperdatatype datatype;
-    hyperdex_ds_arena* a = hyperdex_ds_arena_create();
-    hyperdex_ds_set* set;
-
-    // example 1
-    set = hyperdex_ds_allocate_set(a);
-    ASSERT_TRUE(hyperdex_ds_set_finalize(set, &status,
-                                         &tmp, &tmp_sz,
-                                         &datatype) == 0);
-    ASSERT_EQ(tmp_sz, 0UL);
-    ASSERT_EQ(datatype, HYPERDATATYPE_SET_GENERIC);
-    // example 2
-    set = hyperdex_ds_allocate_set(a);
-    ASSERT_TRUE(hyperdex_ds_set_insert_float(set, 3.1415, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_set_insert_float(set, 0, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_set_finalize(set, &status,
-                                         &tmp, &tmp_sz,
-                                         &datatype) == 0);
-    ASSERT_EQ(tmp_sz, 16UL);
-    ASSERT_TRUE(memcmp(tmp, "\x00\x00\x00\x00\x00\x00\x00\x00"
-                            "o\x12\x83\xc0\xca!\t@", 16) == 0);
-    ASSERT_EQ(datatype, HYPERDATATYPE_SET_FLOAT);
-    // error on cross-ds insert
-    set = hyperdex_ds_allocate_set(a);
-    ASSERT_TRUE(hyperdex_ds_set_insert_float(set, 0, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_set_insert_string(set, "hello", 5, &status) == -1);
-    ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
-    set = hyperdex_ds_allocate_set(a);
-    ASSERT_TRUE(hyperdex_ds_set_insert_float(set, 0, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_set_insert_int(set, 0, &status) == -1);
-    ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
-
-    hyperdex_ds_arena_destroy(a);
+	hyperdex_ds_returncode status;
+	const char *tmp = NULL;
+	size_t tmp_sz = 0;
+	hyperdatatype datatype;
+	hyperdex_ds_arena *a = hyperdex_ds_arena_create();
+	hyperdex_ds_set *set;
+	// example 1
+	set = hyperdex_ds_allocate_set(a);
+	ASSERT_TRUE(hyperdex_ds_set_finalize(set, &status,
+	                                     &tmp, &tmp_sz,
+	                                     &datatype) == 0);
+	ASSERT_EQ(tmp_sz, 0UL);
+	ASSERT_EQ(datatype, HYPERDATATYPE_SET_GENERIC);
+	// example 2
+	set = hyperdex_ds_allocate_set(a);
+	ASSERT_TRUE(hyperdex_ds_set_insert_float(set, 3.1415, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_set_insert_float(set, 0, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_set_finalize(set, &status,
+	                                     &tmp, &tmp_sz,
+	                                     &datatype) == 0);
+	ASSERT_EQ(tmp_sz, 16UL);
+	ASSERT_TRUE(memcmp(tmp, "\x00\x00\x00\x00\x00\x00\x00\x00"
+	                   "o\x12\x83\xc0\xca!\t@", 16) == 0);
+	ASSERT_EQ(datatype, HYPERDATATYPE_SET_FLOAT);
+	// error on cross-ds insert
+	set = hyperdex_ds_allocate_set(a);
+	ASSERT_TRUE(hyperdex_ds_set_insert_float(set, 0, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_set_insert_string(set, "hello", 5, &status) == -1);
+	ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
+	set = hyperdex_ds_allocate_set(a);
+	ASSERT_TRUE(hyperdex_ds_set_insert_float(set, 0, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_set_insert_int(set, 0, &status) == -1);
+	ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
+	hyperdex_ds_arena_destroy(a);
 }
 
 TEST(ClientDataStructures, MapStringString)
 {
-    hyperdex_ds_returncode status;
-    const char* tmp = NULL;
-    size_t tmp_sz = 0;
-    hyperdatatype datatype;
-    hyperdex_ds_arena* a = hyperdex_ds_arena_create();
-    hyperdex_ds_map* map;
-
-    // example 1
-    map = hyperdex_ds_allocate_map(a);
-    ASSERT_TRUE(hyperdex_ds_map_finalize(map, &status,
-                                         &tmp, &tmp_sz,
-                                         &datatype) == 0);
-    ASSERT_EQ(tmp_sz, 0UL);
-    ASSERT_EQ(datatype, HYPERDATATYPE_MAP_GENERIC);
-    // example 2
-    map = hyperdex_ds_allocate_map(a);
-    ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_val_string(map, "world", 5, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "map key", 7, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_val_string(map, "map val", 7, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "map", 3, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_val_string(map, "encoding", 8, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_finalize(map, &status,
-                                         &tmp, &tmp_sz,
-                                         &datatype) == 0);
-    ASSERT_EQ(tmp_sz, 59UL);
-    ASSERT_TRUE(memcmp(tmp, "\x05\x00\x00\x00hello\x05\x00\x00\x00world"
-                            "\x03\x00\x00\x00map\x08\x00\x00\x00""encoding"
-                            "\x07\x00\x00\x00map key\x07\x00\x00\x00map val", 59) == 0);
-    ASSERT_EQ(datatype, HYPERDATATYPE_MAP_STRING_STRING);
-    // double key insert
-    map = hyperdex_ds_allocate_map(a);
-    ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == -1);
-    ASSERT_EQ(status, HYPERDEX_DS_WRONG_STATE);
-    // double value insert
-    map = hyperdex_ds_allocate_map(a);
-    ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_val_string(map, "hello", 5, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_val_string(map, "hello", 5, &status) == -1);
-    ASSERT_EQ(status, HYPERDEX_DS_WRONG_STATE);
-    // error on cross-ds insert
-    map = hyperdex_ds_allocate_map(a);
-    ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_val_string(map, "world", 5, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_key_int(map, 0, &status) == -1);
-    ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
-    map = hyperdex_ds_allocate_map(a);
-    ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_val_string(map, "world", 5, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "map key", 7, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_val_int(map, 0, &status) == -1);
-    ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
-    map = hyperdex_ds_allocate_map(a);
-    ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_val_string(map, "world", 5, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_key_float(map, 0., &status) == -1);
-    ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
-    map = hyperdex_ds_allocate_map(a);
-    ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_val_string(map, "world", 5, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "map key", 7, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_val_float(map, 0., &status) == -1);
-    ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
-
-    hyperdex_ds_arena_destroy(a);
+	hyperdex_ds_returncode status;
+	const char *tmp = NULL;
+	size_t tmp_sz = 0;
+	hyperdatatype datatype;
+	hyperdex_ds_arena *a = hyperdex_ds_arena_create();
+	hyperdex_ds_map *map;
+	// example 1
+	map = hyperdex_ds_allocate_map(a);
+	ASSERT_TRUE(hyperdex_ds_map_finalize(map, &status,
+	                                     &tmp, &tmp_sz,
+	                                     &datatype) == 0);
+	ASSERT_EQ(tmp_sz, 0UL);
+	ASSERT_EQ(datatype, HYPERDATATYPE_MAP_GENERIC);
+	// example 2
+	map = hyperdex_ds_allocate_map(a);
+	ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_val_string(map, "world", 5, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "map key", 7, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_val_string(map, "map val", 7, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "map", 3, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_val_string(map, "encoding", 8, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_finalize(map, &status,
+	                                     &tmp, &tmp_sz,
+	                                     &datatype) == 0);
+	ASSERT_EQ(tmp_sz, 59UL);
+	ASSERT_TRUE(memcmp(tmp, "\x05\x00\x00\x00hello\x05\x00\x00\x00world"
+	                   "\x03\x00\x00\x00map\x08\x00\x00\x00""encoding"
+	                   "\x07\x00\x00\x00map key\x07\x00\x00\x00map val", 59) == 0);
+	ASSERT_EQ(datatype, HYPERDATATYPE_MAP_STRING_STRING);
+	// double key insert
+	map = hyperdex_ds_allocate_map(a);
+	ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == -1);
+	ASSERT_EQ(status, HYPERDEX_DS_WRONG_STATE);
+	// double value insert
+	map = hyperdex_ds_allocate_map(a);
+	ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_val_string(map, "hello", 5, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_val_string(map, "hello", 5, &status) == -1);
+	ASSERT_EQ(status, HYPERDEX_DS_WRONG_STATE);
+	// error on cross-ds insert
+	map = hyperdex_ds_allocate_map(a);
+	ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_val_string(map, "world", 5, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_key_int(map, 0, &status) == -1);
+	ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
+	map = hyperdex_ds_allocate_map(a);
+	ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_val_string(map, "world", 5, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "map key", 7, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_val_int(map, 0, &status) == -1);
+	ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
+	map = hyperdex_ds_allocate_map(a);
+	ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_val_string(map, "world", 5, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_key_float(map, 0., &status) == -1);
+	ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
+	map = hyperdex_ds_allocate_map(a);
+	ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_val_string(map, "world", 5, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "map key", 7, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_val_float(map, 0., &status) == -1);
+	ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
+	hyperdex_ds_arena_destroy(a);
 }
 
 TEST(ClientDataStructures, MapStringInt)
 {
-    hyperdex_ds_returncode status;
-    const char* tmp = NULL;
-    size_t tmp_sz = 0;
-    hyperdatatype datatype;
-    hyperdex_ds_arena* a = hyperdex_ds_arena_create();
-    hyperdex_ds_map* map;
-
-    // example 1
-    map = hyperdex_ds_allocate_map(a);
-    ASSERT_TRUE(hyperdex_ds_map_finalize(map, &status,
-                                         &tmp, &tmp_sz,
-                                         &datatype) == 0);
-    ASSERT_EQ(tmp_sz, 0UL);
-    ASSERT_EQ(datatype, HYPERDATATYPE_MAP_GENERIC);
-    // example 2
-    map = hyperdex_ds_allocate_map(a);
-    ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "world", 5, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_val_int(map, -1, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_val_int(map, 1, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_finalize(map, &status,
-                                         &tmp, &tmp_sz,
-                                         &datatype) == 0);
-    ASSERT_EQ(tmp_sz, 34UL);
-    ASSERT_TRUE(memcmp(tmp, "\x05\x00\x00\x00hello\x01\x00\x00\x00\x00\x00\x00\x00"
-                            "\x05\x00\x00\x00world\xff\xff\xff\xff\xff\xff\xff\xff", 34) == 0);
-    ASSERT_EQ(datatype, HYPERDATATYPE_MAP_STRING_INT64);
-    // double key insert
-    map = hyperdex_ds_allocate_map(a);
-    ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == -1);
-    ASSERT_EQ(status, HYPERDEX_DS_WRONG_STATE);
-    // double value insert
-    map = hyperdex_ds_allocate_map(a);
-    ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_val_int(map, 0, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_val_int(map, 0, &status) == -1);
-    ASSERT_EQ(status, HYPERDEX_DS_WRONG_STATE);
-    // error on cross-ds insert
-    map = hyperdex_ds_allocate_map(a);
-    ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_val_int(map, 0, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_key_int(map, 0, &status) == -1);
-    ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
-    map = hyperdex_ds_allocate_map(a);
-    ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_val_int(map, 0, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "map key", 7, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_val_string(map, "hello", 5, &status) == -1);
-    ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
-    map = hyperdex_ds_allocate_map(a);
-    ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_val_int(map, 0, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_key_float(map, 0., &status) == -1);
-    ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
-    map = hyperdex_ds_allocate_map(a);
-    ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_val_int(map, 0, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "map key", 7, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_val_float(map, 0., &status) == -1);
-    ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
-
-    hyperdex_ds_arena_destroy(a);
+	hyperdex_ds_returncode status;
+	const char *tmp = NULL;
+	size_t tmp_sz = 0;
+	hyperdatatype datatype;
+	hyperdex_ds_arena *a = hyperdex_ds_arena_create();
+	hyperdex_ds_map *map;
+	// example 1
+	map = hyperdex_ds_allocate_map(a);
+	ASSERT_TRUE(hyperdex_ds_map_finalize(map, &status,
+	                                     &tmp, &tmp_sz,
+	                                     &datatype) == 0);
+	ASSERT_EQ(tmp_sz, 0UL);
+	ASSERT_EQ(datatype, HYPERDATATYPE_MAP_GENERIC);
+	// example 2
+	map = hyperdex_ds_allocate_map(a);
+	ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "world", 5, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_val_int(map, -1, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_val_int(map, 1, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_finalize(map, &status,
+	                                     &tmp, &tmp_sz,
+	                                     &datatype) == 0);
+	ASSERT_EQ(tmp_sz, 34UL);
+	ASSERT_TRUE(memcmp(tmp, "\x05\x00\x00\x00hello\x01\x00\x00\x00\x00\x00\x00\x00"
+	                   "\x05\x00\x00\x00world\xff\xff\xff\xff\xff\xff\xff\xff", 34) == 0);
+	ASSERT_EQ(datatype, HYPERDATATYPE_MAP_STRING_INT64);
+	// double key insert
+	map = hyperdex_ds_allocate_map(a);
+	ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == -1);
+	ASSERT_EQ(status, HYPERDEX_DS_WRONG_STATE);
+	// double value insert
+	map = hyperdex_ds_allocate_map(a);
+	ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_val_int(map, 0, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_val_int(map, 0, &status) == -1);
+	ASSERT_EQ(status, HYPERDEX_DS_WRONG_STATE);
+	// error on cross-ds insert
+	map = hyperdex_ds_allocate_map(a);
+	ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_val_int(map, 0, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_key_int(map, 0, &status) == -1);
+	ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
+	map = hyperdex_ds_allocate_map(a);
+	ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_val_int(map, 0, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "map key", 7, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_val_string(map, "hello", 5, &status) == -1);
+	ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
+	map = hyperdex_ds_allocate_map(a);
+	ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_val_int(map, 0, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_key_float(map, 0., &status) == -1);
+	ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
+	map = hyperdex_ds_allocate_map(a);
+	ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_val_int(map, 0, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "map key", 7, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_val_float(map, 0., &status) == -1);
+	ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
+	hyperdex_ds_arena_destroy(a);
 }
 
 TEST(ClientDataStructures, MapStringFloat)
 {
-    hyperdex_ds_returncode status;
-    const char* tmp = NULL;
-    size_t tmp_sz = 0;
-    hyperdatatype datatype;
-    hyperdex_ds_arena* a = hyperdex_ds_arena_create();
-    hyperdex_ds_map* map;
-
-    // example 1
-    map = hyperdex_ds_allocate_map(a);
-    ASSERT_TRUE(hyperdex_ds_map_finalize(map, &status,
-                                         &tmp, &tmp_sz,
-                                         &datatype) == 0);
-    ASSERT_EQ(tmp_sz, 0UL);
-    ASSERT_EQ(datatype, HYPERDATATYPE_MAP_GENERIC);
-    // example 2
-    map = hyperdex_ds_allocate_map(a);
-    ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "zero", 4, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_val_float(map, 0, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "pi", 2, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_val_float(map, 3.1415, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_finalize(map, &status,
-                                         &tmp, &tmp_sz,
-                                         &datatype) == 0);
-    ASSERT_EQ(tmp_sz, 30UL);
-    ASSERT_TRUE(memcmp(tmp, "\x02\x00\x00\x00pio\x12\x83\xc0\xca!\t@"
-                            "\x04\x00\x00\x00zero\x00\x00\x00\x00\x00\x00\x00\x00", 30) == 0);
-    ASSERT_EQ(datatype, HYPERDATATYPE_MAP_STRING_FLOAT);
-    // double key insert
-    map = hyperdex_ds_allocate_map(a);
-    ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == -1);
-    ASSERT_EQ(status, HYPERDEX_DS_WRONG_STATE);
-    // double value insert
-    map = hyperdex_ds_allocate_map(a);
-    ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_val_float(map, 3.1415, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_val_float(map, 3.1415, &status) == -1);
-    ASSERT_EQ(status, HYPERDEX_DS_WRONG_STATE);
-    // error on cross-ds insert
-    map = hyperdex_ds_allocate_map(a);
-    ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_val_float(map, 3.1415, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_key_float(map, 3.1415, &status) == -1);
-    ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
-    map = hyperdex_ds_allocate_map(a);
-    ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_val_float(map, 3.1415, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "map key", 7, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_val_string(map, "hello", 5, &status) == -1);
-    ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
-    map = hyperdex_ds_allocate_map(a);
-    ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_val_float(map, 3.1415, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_key_float(map, 3.1415, &status) == -1);
-    ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
-    map = hyperdex_ds_allocate_map(a);
-    ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_val_float(map, 3.1415, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "map key", 7, &status) == 0);
-    ASSERT_TRUE(hyperdex_ds_map_insert_val_int(map, 0, &status) == -1);
-    ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
-
-    hyperdex_ds_arena_destroy(a);
+	hyperdex_ds_returncode status;
+	const char *tmp = NULL;
+	size_t tmp_sz = 0;
+	hyperdatatype datatype;
+	hyperdex_ds_arena *a = hyperdex_ds_arena_create();
+	hyperdex_ds_map *map;
+	// example 1
+	map = hyperdex_ds_allocate_map(a);
+	ASSERT_TRUE(hyperdex_ds_map_finalize(map, &status,
+	                                     &tmp, &tmp_sz,
+	                                     &datatype) == 0);
+	ASSERT_EQ(tmp_sz, 0UL);
+	ASSERT_EQ(datatype, HYPERDATATYPE_MAP_GENERIC);
+	// example 2
+	map = hyperdex_ds_allocate_map(a);
+	ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "zero", 4, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_val_float(map, 0, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "pi", 2, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_val_float(map, 3.1415, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_finalize(map, &status,
+	                                     &tmp, &tmp_sz,
+	                                     &datatype) == 0);
+	ASSERT_EQ(tmp_sz, 30UL);
+	ASSERT_TRUE(memcmp(tmp, "\x02\x00\x00\x00pio\x12\x83\xc0\xca!\t@"
+	                   "\x04\x00\x00\x00zero\x00\x00\x00\x00\x00\x00\x00\x00", 30) == 0);
+	ASSERT_EQ(datatype, HYPERDATATYPE_MAP_STRING_FLOAT);
+	// double key insert
+	map = hyperdex_ds_allocate_map(a);
+	ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == -1);
+	ASSERT_EQ(status, HYPERDEX_DS_WRONG_STATE);
+	// double value insert
+	map = hyperdex_ds_allocate_map(a);
+	ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_val_float(map, 3.1415, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_val_float(map, 3.1415, &status) == -1);
+	ASSERT_EQ(status, HYPERDEX_DS_WRONG_STATE);
+	// error on cross-ds insert
+	map = hyperdex_ds_allocate_map(a);
+	ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_val_float(map, 3.1415, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_key_float(map, 3.1415, &status) == -1);
+	ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
+	map = hyperdex_ds_allocate_map(a);
+	ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_val_float(map, 3.1415, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "map key", 7, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_val_string(map, "hello", 5, &status) == -1);
+	ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
+	map = hyperdex_ds_allocate_map(a);
+	ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_val_float(map, 3.1415, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_key_float(map, 3.1415, &status) == -1);
+	ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
+	map = hyperdex_ds_allocate_map(a);
+	ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "hello", 5, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_val_float(map, 3.1415, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_key_string(map, "map key", 7, &status) == 0);
+	ASSERT_TRUE(hyperdex_ds_map_insert_val_int(map, 0, &status) == -1);
+	ASSERT_EQ(status, HYPERDEX_DS_MIXED_TYPES);
+	hyperdex_ds_arena_destroy(a);
 }
 
 // XXX test cases for the rest of the map types
 
 TEST(ClientDataStructures, IterateListString)
 {
-    hyperdex_ds_iterator iter;
-    const char* ptr = "\x05\x00\x00\x00hello\x05\x00\x00\x00world";
-    hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_LIST_STRING, ptr, 18);
-    const char* str = NULL;
-    size_t str_sz = 0;
-
-    ASSERT_TRUE(hyperdex_ds_iterate_list_string_next(&iter, &str, &str_sz) == 1);
-    ASSERT_EQ(str_sz, 5UL);
-    ASSERT_TRUE(memcmp(str, "hello", 5) == 0);
-
-    ASSERT_TRUE(hyperdex_ds_iterate_list_string_next(&iter, &str, &str_sz) == 1);
-    ASSERT_EQ(str_sz, 5UL);
-    ASSERT_TRUE(memcmp(str, "world", 5) == 0);
-
-    ASSERT_TRUE(hyperdex_ds_iterate_list_string_next(&iter, &str, &str_sz) == 0);
+	hyperdex_ds_iterator iter;
+	const char *ptr = "\x05\x00\x00\x00hello\x05\x00\x00\x00world";
+	hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_LIST_STRING, ptr, 18);
+	const char *str = NULL;
+	size_t str_sz = 0;
+	ASSERT_TRUE(hyperdex_ds_iterate_list_string_next(&iter, &str, &str_sz) == 1);
+	ASSERT_EQ(str_sz, 5UL);
+	ASSERT_TRUE(memcmp(str, "hello", 5) == 0);
+	ASSERT_TRUE(hyperdex_ds_iterate_list_string_next(&iter, &str, &str_sz) == 1);
+	ASSERT_EQ(str_sz, 5UL);
+	ASSERT_TRUE(memcmp(str, "world", 5) == 0);
+	ASSERT_TRUE(hyperdex_ds_iterate_list_string_next(&iter, &str, &str_sz) == 0);
 }
 
 TEST(ClientDataStructures, IterateListInt)
 {
-    hyperdex_ds_iterator iter;
-    const char* ptr = "\x01\x00\x00\x00\x00\x00\x00\x00"
-                      "\xff\xff\xff\xff\xff\xff\xff\xff"
-                      "\xef\xbe\xad\xde\x00\x00\x00\x00";
-    hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_LIST_INT64, ptr, 24);
-    int64_t num = 0;
-
-    ASSERT_TRUE(hyperdex_ds_iterate_list_int_next(&iter, &num) == 1);
-    ASSERT_EQ(num, 1L);
-
-    ASSERT_TRUE(hyperdex_ds_iterate_list_int_next(&iter, &num) == 1);
-    ASSERT_EQ(num, -1L);
-
-    ASSERT_TRUE(hyperdex_ds_iterate_list_int_next(&iter, &num) == 1);
-    ASSERT_EQ(num, 0xdeadbeef);
-
-    ASSERT_TRUE(hyperdex_ds_iterate_list_int_next(&iter, &num) == 0);
+	hyperdex_ds_iterator iter;
+	const char *ptr = "\x01\x00\x00\x00\x00\x00\x00\x00"
+	                  "\xff\xff\xff\xff\xff\xff\xff\xff"
+	                  "\xef\xbe\xad\xde\x00\x00\x00\x00";
+	hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_LIST_INT64, ptr, 24);
+	int64_t num = 0;
+	ASSERT_TRUE(hyperdex_ds_iterate_list_int_next(&iter, &num) == 1);
+	ASSERT_EQ(num, 1L);
+	ASSERT_TRUE(hyperdex_ds_iterate_list_int_next(&iter, &num) == 1);
+	ASSERT_EQ(num, -1L);
+	ASSERT_TRUE(hyperdex_ds_iterate_list_int_next(&iter, &num) == 1);
+	ASSERT_EQ(num, 0xdeadbeef);
+	ASSERT_TRUE(hyperdex_ds_iterate_list_int_next(&iter, &num) == 0);
 }
 
 TEST(ClientDataStructures, IterateListFloat)
 {
-    hyperdex_ds_iterator iter;
-    const char* ptr = "\x00\x00\x00\x00\x00\x00\x00\x00"
-                      "o\x12\x83\xc0\xca!\t@";
-    hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_LIST_FLOAT, ptr, 16);
-    double num = 1;
-
-    ASSERT_TRUE(hyperdex_ds_iterate_list_float_next(&iter, &num) == 1);
-    ASSERT_GE(num, -0.001);
-    ASSERT_LE(num, 0.001);
-
-    ASSERT_TRUE(hyperdex_ds_iterate_list_float_next(&iter, &num) == 1);
-    ASSERT_GE(num, 3.14149999);
-    ASSERT_LE(num, 3.14150001);
-
-    ASSERT_TRUE(hyperdex_ds_iterate_list_float_next(&iter, &num) == 0);
+	hyperdex_ds_iterator iter;
+	const char *ptr = "\x00\x00\x00\x00\x00\x00\x00\x00"
+	                  "o\x12\x83\xc0\xca!\t@";
+	hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_LIST_FLOAT, ptr, 16);
+	double num = 1;
+	ASSERT_TRUE(hyperdex_ds_iterate_list_float_next(&iter, &num) == 1);
+	ASSERT_GE(num, -0.001);
+	ASSERT_LE(num, 0.001);
+	ASSERT_TRUE(hyperdex_ds_iterate_list_float_next(&iter, &num) == 1);
+	ASSERT_GE(num, 3.14149999);
+	ASSERT_LE(num, 3.14150001);
+	ASSERT_TRUE(hyperdex_ds_iterate_list_float_next(&iter, &num) == 0);
 }
 
 TEST(ClientDataStructures, IterateSetString)
 {
-    hyperdex_ds_iterator iter;
-    const char* ptr = "\x05\x00\x00\x00hello\x05\x00\x00\x00world";
-    hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_SET_STRING, ptr, 18);
-    const char* str = NULL;
-    size_t str_sz = 0;
-
-    ASSERT_TRUE(hyperdex_ds_iterate_set_string_next(&iter, &str, &str_sz) == 1);
-    ASSERT_EQ(str_sz, 5UL);
-    ASSERT_TRUE(memcmp(str, "hello", 5) == 0);
-
-    ASSERT_TRUE(hyperdex_ds_iterate_set_string_next(&iter, &str, &str_sz) == 1);
-    ASSERT_EQ(str_sz, 5UL);
-    ASSERT_TRUE(memcmp(str, "world", 5) == 0);
-
-    ASSERT_TRUE(hyperdex_ds_iterate_set_string_next(&iter, &str, &str_sz) == 0);
+	hyperdex_ds_iterator iter;
+	const char *ptr = "\x05\x00\x00\x00hello\x05\x00\x00\x00world";
+	hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_SET_STRING, ptr, 18);
+	const char *str = NULL;
+	size_t str_sz = 0;
+	ASSERT_TRUE(hyperdex_ds_iterate_set_string_next(&iter, &str, &str_sz) == 1);
+	ASSERT_EQ(str_sz, 5UL);
+	ASSERT_TRUE(memcmp(str, "hello", 5) == 0);
+	ASSERT_TRUE(hyperdex_ds_iterate_set_string_next(&iter, &str, &str_sz) == 1);
+	ASSERT_EQ(str_sz, 5UL);
+	ASSERT_TRUE(memcmp(str, "world", 5) == 0);
+	ASSERT_TRUE(hyperdex_ds_iterate_set_string_next(&iter, &str, &str_sz) == 0);
 }
 
 TEST(ClientDataStructures, IterateSetInt)
 {
-    hyperdex_ds_iterator iter;
-    const char* ptr = "\xff\xff\xff\xff\xff\xff\xff\xff"
-                      "\x01\x00\x00\x00\x00\x00\x00\x00"
-                      "\xef\xbe\xad\xde\x00\x00\x00\x00";
-    hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_SET_INT64, ptr, 24);
-    int64_t num = 0;
-
-    ASSERT_TRUE(hyperdex_ds_iterate_set_int_next(&iter, &num) == 1);
-    ASSERT_EQ(num, -1L);
-
-    ASSERT_TRUE(hyperdex_ds_iterate_set_int_next(&iter, &num) == 1);
-    ASSERT_EQ(num, 1L);
-
-    ASSERT_TRUE(hyperdex_ds_iterate_set_int_next(&iter, &num) == 1);
-    ASSERT_EQ(num, 0xdeadbeef);
-
-    ASSERT_TRUE(hyperdex_ds_iterate_set_int_next(&iter, &num) == 0);
+	hyperdex_ds_iterator iter;
+	const char *ptr = "\xff\xff\xff\xff\xff\xff\xff\xff"
+	                  "\x01\x00\x00\x00\x00\x00\x00\x00"
+	                  "\xef\xbe\xad\xde\x00\x00\x00\x00";
+	hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_SET_INT64, ptr, 24);
+	int64_t num = 0;
+	ASSERT_TRUE(hyperdex_ds_iterate_set_int_next(&iter, &num) == 1);
+	ASSERT_EQ(num, -1L);
+	ASSERT_TRUE(hyperdex_ds_iterate_set_int_next(&iter, &num) == 1);
+	ASSERT_EQ(num, 1L);
+	ASSERT_TRUE(hyperdex_ds_iterate_set_int_next(&iter, &num) == 1);
+	ASSERT_EQ(num, 0xdeadbeef);
+	ASSERT_TRUE(hyperdex_ds_iterate_set_int_next(&iter, &num) == 0);
 }
 
 TEST(ClientDataStructures, IterateSetFloat)
 {
-    hyperdex_ds_iterator iter;
-    const char* ptr = "\x00\x00\x00\x00\x00\x00\x00\x00"
-                      "o\x12\x83\xc0\xca!\t@";
-    hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_SET_FLOAT, ptr, 16);
-    double num = 1;
-
-    ASSERT_TRUE(hyperdex_ds_iterate_set_float_next(&iter, &num) == 1);
-    ASSERT_GE(num, -0.001);
-    ASSERT_LE(num, 0.001);
-
-    ASSERT_TRUE(hyperdex_ds_iterate_set_float_next(&iter, &num) == 1);
-    ASSERT_GE(num, 3.14149999);
-    ASSERT_LE(num, 3.14150001);
-
-    ASSERT_TRUE(hyperdex_ds_iterate_set_float_next(&iter, &num) == 0);
+	hyperdex_ds_iterator iter;
+	const char *ptr = "\x00\x00\x00\x00\x00\x00\x00\x00"
+	                  "o\x12\x83\xc0\xca!\t@";
+	hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_SET_FLOAT, ptr, 16);
+	double num = 1;
+	ASSERT_TRUE(hyperdex_ds_iterate_set_float_next(&iter, &num) == 1);
+	ASSERT_GE(num, -0.001);
+	ASSERT_LE(num, 0.001);
+	ASSERT_TRUE(hyperdex_ds_iterate_set_float_next(&iter, &num) == 1);
+	ASSERT_GE(num, 3.14149999);
+	ASSERT_LE(num, 3.14150001);
+	ASSERT_TRUE(hyperdex_ds_iterate_set_float_next(&iter, &num) == 0);
 }
 
 TEST(ClientDataStructures, IterateMapStringString)
 {
-    hyperdex_ds_iterator iter;
-    const char* ptr = "\x05\x00\x00\x00hello\x05\x00\x00\x00world"
-                      "\x03\x00\x00\x00map\x08\x00\x00\x00""encoding"
-                      "\x07\x00\x00\x00map key\x07\x00\x00\x00map val";
-    hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_MAP_STRING_STRING, ptr, 59);
-    const char* key = NULL;
-    size_t key_sz = 0;
-    const char* val = NULL;
-    size_t val_sz = 0;
-
-    ASSERT_TRUE(hyperdex_ds_iterate_map_string_string_next(&iter, &key, &key_sz, &val, &val_sz) == 1);
-    ASSERT_EQ(key_sz, 5UL);
-    ASSERT_TRUE(memcmp(key, "hello", 5) == 0);
-    ASSERT_EQ(val_sz, 5UL);
-    ASSERT_TRUE(memcmp(val, "world", 5) == 0);
-
-    ASSERT_TRUE(hyperdex_ds_iterate_map_string_string_next(&iter, &key, &key_sz, &val, &val_sz) == 1);
-    ASSERT_EQ(key_sz, 3UL);
-    ASSERT_TRUE(memcmp(key, "map", 3) == 0);
-    ASSERT_EQ(val_sz, 8UL);
-    ASSERT_TRUE(memcmp(val, "encoding", 8) == 0);
-
-    ASSERT_TRUE(hyperdex_ds_iterate_map_string_string_next(&iter, &key, &key_sz, &val, &val_sz) == 1);
-    ASSERT_EQ(key_sz, 7UL);
-    ASSERT_TRUE(memcmp(key, "map key", 7) == 0);
-    ASSERT_EQ(val_sz, 7UL);
-    ASSERT_TRUE(memcmp(val, "map val", 7) == 0);
-
-    ASSERT_TRUE(hyperdex_ds_iterate_map_string_string_next(&iter, &key, &key_sz, &val, &val_sz) == 0);
+	hyperdex_ds_iterator iter;
+	const char *ptr = "\x05\x00\x00\x00hello\x05\x00\x00\x00world"
+	                  "\x03\x00\x00\x00map\x08\x00\x00\x00""encoding"
+	                  "\x07\x00\x00\x00map key\x07\x00\x00\x00map val";
+	hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_MAP_STRING_STRING, ptr, 59);
+	const char *key = NULL;
+	size_t key_sz = 0;
+	const char *val = NULL;
+	size_t val_sz = 0;
+	ASSERT_TRUE(hyperdex_ds_iterate_map_string_string_next(&iter, &key, &key_sz, &val, &val_sz) == 1);
+	ASSERT_EQ(key_sz, 5UL);
+	ASSERT_TRUE(memcmp(key, "hello", 5) == 0);
+	ASSERT_EQ(val_sz, 5UL);
+	ASSERT_TRUE(memcmp(val, "world", 5) == 0);
+	ASSERT_TRUE(hyperdex_ds_iterate_map_string_string_next(&iter, &key, &key_sz, &val, &val_sz) == 1);
+	ASSERT_EQ(key_sz, 3UL);
+	ASSERT_TRUE(memcmp(key, "map", 3) == 0);
+	ASSERT_EQ(val_sz, 8UL);
+	ASSERT_TRUE(memcmp(val, "encoding", 8) == 0);
+	ASSERT_TRUE(hyperdex_ds_iterate_map_string_string_next(&iter, &key, &key_sz, &val, &val_sz) == 1);
+	ASSERT_EQ(key_sz, 7UL);
+	ASSERT_TRUE(memcmp(key, "map key", 7) == 0);
+	ASSERT_EQ(val_sz, 7UL);
+	ASSERT_TRUE(memcmp(val, "map val", 7) == 0);
+	ASSERT_TRUE(hyperdex_ds_iterate_map_string_string_next(&iter, &key, &key_sz, &val, &val_sz) == 0);
 }
 
 TEST(ClientDataStructures, IterateMapStringInt)
 {
-    hyperdex_ds_iterator iter;
-    const char* ptr = "\x05\x00\x00\x00hello\x01\x00\x00\x00\x00\x00\x00\x00"
-                      "\x05\x00\x00\x00world\xff\xff\xff\xff\xff\xff\xff\xff";
-    hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_MAP_STRING_INT64, ptr, 34);
-    const char* key = NULL;
-    size_t key_sz = 0;
-    int64_t val = 0;
-
-    ASSERT_TRUE(hyperdex_ds_iterate_map_string_int_next(&iter, &key, &key_sz, &val) == 1);
-    ASSERT_EQ(key_sz, 5UL);
-    ASSERT_TRUE(memcmp(key, "hello", 5) == 0);
-    ASSERT_EQ(val, 1L);
-
-    ASSERT_TRUE(hyperdex_ds_iterate_map_string_int_next(&iter, &key, &key_sz, &val) == 1);
-    ASSERT_EQ(key_sz, 5UL);
-    ASSERT_TRUE(memcmp(key, "world", 5) == 0);
-    ASSERT_EQ(val, -1L);
-
-    ASSERT_TRUE(hyperdex_ds_iterate_map_string_int_next(&iter, &key, &key_sz, &val) == 0);
+	hyperdex_ds_iterator iter;
+	const char *ptr = "\x05\x00\x00\x00hello\x01\x00\x00\x00\x00\x00\x00\x00"
+	                  "\x05\x00\x00\x00world\xff\xff\xff\xff\xff\xff\xff\xff";
+	hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_MAP_STRING_INT64, ptr, 34);
+	const char *key = NULL;
+	size_t key_sz = 0;
+	int64_t val = 0;
+	ASSERT_TRUE(hyperdex_ds_iterate_map_string_int_next(&iter, &key, &key_sz, &val) == 1);
+	ASSERT_EQ(key_sz, 5UL);
+	ASSERT_TRUE(memcmp(key, "hello", 5) == 0);
+	ASSERT_EQ(val, 1L);
+	ASSERT_TRUE(hyperdex_ds_iterate_map_string_int_next(&iter, &key, &key_sz, &val) == 1);
+	ASSERT_EQ(key_sz, 5UL);
+	ASSERT_TRUE(memcmp(key, "world", 5) == 0);
+	ASSERT_EQ(val, -1L);
+	ASSERT_TRUE(hyperdex_ds_iterate_map_string_int_next(&iter, &key, &key_sz, &val) == 0);
 }
 
 TEST(ClientDataStructures, IterateMapStringFloat)
 {
-    hyperdex_ds_iterator iter;
-    const char* ptr = "\x02\x00\x00\x00pio\x12\x83\xc0\xca!\t@"
-                      "\x04\x00\x00\x00zero\x00\x00\x00\x00\x00\x00\x00\x00";
-    hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_MAP_STRING_FLOAT, ptr, 30);
-    const char* key = NULL;
-    size_t key_sz = 0;
-    double val = 0;
-
-    ASSERT_TRUE(hyperdex_ds_iterate_map_string_float_next(&iter, &key, &key_sz, &val) == 1);
-    ASSERT_EQ(key_sz, 2UL);
-    ASSERT_TRUE(memcmp(key, "pi", 2) == 0);
-    ASSERT_GE(val, 3.14149999);
-    ASSERT_LE(val, 3.14150001);
-
-    ASSERT_TRUE(hyperdex_ds_iterate_map_string_float_next(&iter, &key, &key_sz, &val) == 1);
-    ASSERT_EQ(key_sz, 4UL);
-    ASSERT_TRUE(memcmp(key, "zero", 4) == 0);
-    ASSERT_GE(val, -0.0001);
-    ASSERT_LE(val, 0.0001);
-
-    ASSERT_EQ(hyperdex_ds_iterate_map_string_float_next(&iter, &key, &key_sz, &val), 0);
+	hyperdex_ds_iterator iter;
+	const char *ptr = "\x02\x00\x00\x00pio\x12\x83\xc0\xca!\t@"
+	                  "\x04\x00\x00\x00zero\x00\x00\x00\x00\x00\x00\x00\x00";
+	hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_MAP_STRING_FLOAT, ptr, 30);
+	const char *key = NULL;
+	size_t key_sz = 0;
+	double val = 0;
+	ASSERT_TRUE(hyperdex_ds_iterate_map_string_float_next(&iter, &key, &key_sz, &val) == 1);
+	ASSERT_EQ(key_sz, 2UL);
+	ASSERT_TRUE(memcmp(key, "pi", 2) == 0);
+	ASSERT_GE(val, 3.14149999);
+	ASSERT_LE(val, 3.14150001);
+	ASSERT_TRUE(hyperdex_ds_iterate_map_string_float_next(&iter, &key, &key_sz, &val) == 1);
+	ASSERT_EQ(key_sz, 4UL);
+	ASSERT_TRUE(memcmp(key, "zero", 4) == 0);
+	ASSERT_GE(val, -0.0001);
+	ASSERT_LE(val, 0.0001);
+	ASSERT_EQ(hyperdex_ds_iterate_map_string_float_next(&iter, &key, &key_sz, &val), 0);
 }
diff --git a/client/util.cc b/client/util.cc
index 4fddda946..439d52932 100644
--- a/client/util.cc
+++ b/client/util.cc
@@ -36,191 +36,180 @@
 #include "client/util.h"
 
 #define UTIL_ERROR(CODE) \
-    *op_status = HYPERDEX_CLIENT_ ## CODE; \
-    op_error->set_loc(__FILE__, __LINE__); \
-    op_error->set_msg()
+	*op_status = HYPERDEX_CLIENT_ ## CODE; \
+	op_error->set_loc(__FILE__, __LINE__); \
+	op_error->set_msg()
 
 bool
-hyperdex :: value_to_attributes(const configuration& config,
-                                const region_id& rid,
-                                const uint8_t* key,
+hyperdex :: value_to_attributes(const configuration &config,
+                                const region_id &rid,
+                                const uint8_t *key,
                                 size_t key_sz,
-                                const std::vector<e::slice>& _value,
-                                hyperdex_client_returncode* op_status,
-                                e::error* op_error,
-                                const hyperdex_client_attribute** attrs,
-                                size_t* attrs_sz,
+                                const std::vector<e::slice> &_value,
+                                hyperdex_client_returncode *op_status,
+                                e::error *op_error,
+                                const hyperdex_client_attribute **attrs,
+                                size_t *attrs_sz,
                                 bool convert_types)
 {
-    std::vector<e::slice> value(_value);
-    const schema* sc = config.get_schema(rid);
-    e::arena memory;
-
-    if (value.size() + 1 != sc->attrs_sz)
-    {
-        UTIL_ERROR(SERVERERROR) << "received object with " << value.size()
-                                << " attributes instead of "
-                                << sc->attrs_sz - 1 << " attributes";
-        return false;
-    }
-
-    if (convert_types)
-    {
-        for (size_t i = 0; i < value.size(); ++i)
-        {
-            datatype_info* di = datatype_info::lookup(sc->attrs[i + 1].type);
-
-            if (!di->server_to_client(value[i], &memory, &value[i]))
-            {
-                UTIL_ERROR(SERVERERROR) << "cannot convert from server-side form";
-                return false;
-            }
-        }
-    }
-
-    size_t sz = sizeof(hyperdex_client_attribute) * sc->attrs_sz + key_sz
-              + strlen(sc->attrs[0].name) + 1;
-
-    for (size_t i = 0; i < value.size(); ++i)
-    {
-        sz += strlen(sc->attrs[i + 1].name) + 1 + value[i].size();
-    }
-
-    std::vector<hyperdex_client_attribute> ha;
-    ha.reserve(sc->attrs_sz);
-    char* ret = static_cast<char*>(malloc(sz));
-
-    if (!ret)
-    {
-        UTIL_ERROR(NOMEM) << "out of memory";
-        return false;
-    }
-
-    e::guard g = e::makeguard(free, ret);
-    char* data = ret + sizeof(hyperdex_client_attribute) * value.size();
-
-    if (key)
-    {
-        data += sizeof(hyperdex_client_attribute);
-        ha.push_back(hyperdex_client_attribute());
-        size_t attr_sz = strlen(sc->attrs[0].name) + 1;
-        ha.back().attr = data;
-        memmove(data, sc->attrs[0].name, attr_sz);
-        data += attr_sz;
-        ha.back().value = data;
-        memmove(data, key, key_sz);
-        data += key_sz;
-        ha.back().value_sz = key_sz;
-        ha.back().datatype = sc->attrs[0].type;
-    }
-
-    for (size_t i = 0; i < value.size(); ++i)
-    {
-        if (sc->attrs[i + 1].type == HYPERDATATYPE_MACAROON_SECRET)
-        {
-            continue;
-        }
-
-        ha.push_back(hyperdex_client_attribute());
-        size_t attr_sz = strlen(sc->attrs[i + 1].name) + 1;
-        ha.back().attr = data;
-        memmove(data, sc->attrs[i + 1].name, attr_sz);
-        data += attr_sz;
-        ha.back().value = data;
-        memmove(data, value[i].data(), value[i].size());
-        data += value[i].size();
-        ha.back().value_sz = value[i].size();
-        ha.back().datatype = sc->attrs[i + 1].type;
-    }
-
-    memmove(ret, &ha.front(), sizeof(hyperdex_client_attribute) * ha.size());
-    *op_status = HYPERDEX_CLIENT_SUCCESS;
-    *op_error = e::error();
-    *attrs = reinterpret_cast<hyperdex_client_attribute*>(ret);
-    *attrs_sz = ha.size();
-    g.dismiss();
-    return true;
+	std::vector<e::slice> value(_value);
+	const schema *sc = config.get_schema(rid);
+	e::arena memory;
+	if (value.size() + 1 != sc->attrs_sz)
+	{
+		UTIL_ERROR(SERVERERROR) << "received object with " << value.size()
+		                        << " attributes instead of "
+		                        << sc->attrs_sz - 1 << " attributes";
+		return false;
+	}
+	if (convert_types)
+	{
+		for (size_t i = 0; i < value.size(); ++i)
+		{
+			datatype_info *di = datatype_info::lookup(sc->attrs[i + 1].type);
+			if (!di->server_to_client(value[i], &memory, &value[i]))
+			{
+				UTIL_ERROR(SERVERERROR) << "cannot convert from server-side form";
+				return false;
+			}
+		}
+	}
+	size_t sz = sizeof(hyperdex_client_attribute) * sc->attrs_sz + key_sz
+	            + strlen(sc->attrs[0].name) + 1;
+	for (size_t i = 0; i < value.size(); ++i)
+	{
+		sz += strlen(sc->attrs[i + 1].name) + 1 + value[i].size();
+	}
+	std::vector<hyperdex_client_attribute> ha;
+	ha.reserve(sc->attrs_sz);
+	char *ret = NULL;
+	if (attrs)
+	{
+		if (*attrs == NULL)
+		{
+			ret = static_cast<char *>(malloc(sz));
+		}
+		else
+		{
+			ret = static_cast<char *>(realloc((void *)*attrs, sz));
+		}
+	}
+	if (ret == NULL)
+	{
+		UTIL_ERROR(NOMEM) << "out of memory";
+		return false;
+	}
+	e::guard g = e::makeguard(free, ret);
+	char *data = ret + sizeof(hyperdex_client_attribute) * value.size();
+	if (key)
+	{
+		data += sizeof(hyperdex_client_attribute);
+		ha.push_back(hyperdex_client_attribute());
+		size_t attr_sz = strlen(sc->attrs[0].name) + 1;
+		ha.back().attr = data;
+		memmove(data, sc->attrs[0].name, attr_sz);
+		data += attr_sz;
+		ha.back().value = data;
+		memmove(data, key, key_sz);
+		data += key_sz;
+		ha.back().value_sz = key_sz;
+		ha.back().datatype = sc->attrs[0].type;
+	}
+	for (size_t i = 0; i < value.size(); ++i)
+	{
+		if (sc->attrs[i + 1].type == HYPERDATATYPE_MACAROON_SECRET)
+		{
+			continue;
+		}
+		ha.push_back(hyperdex_client_attribute());
+		size_t attr_sz = strlen(sc->attrs[i + 1].name) + 1;
+		ha.back().attr = data;
+		memmove(data, sc->attrs[i + 1].name, attr_sz);
+		data += attr_sz;
+		ha.back().value = data;
+		memmove(data, value[i].data(), value[i].size());
+		data += value[i].size();
+		ha.back().value_sz = value[i].size();
+		ha.back().datatype = sc->attrs[i + 1].type;
+	}
+	memmove(ret, &ha.front(), sizeof(hyperdex_client_attribute) * ha.size());
+	*op_status = HYPERDEX_CLIENT_SUCCESS;
+	*op_error = e::error();
+	*attrs = reinterpret_cast<hyperdex_client_attribute *>(ret);
+	*attrs_sz = ha.size();
+	g.dismiss();
+	return true;
 }
 
 bool
-hyperdex :: value_to_attributes(const configuration& config,
-                                const region_id& rid,
-                                const std::vector<std::pair<uint16_t, e::slice> >& _value,
-                                hyperdex_client_returncode* op_status,
-                                e::error* op_error,
-                                const hyperdex_client_attribute** attrs,
-                                size_t* attrs_sz,
+hyperdex :: value_to_attributes(const configuration &config,
+                                const region_id &rid,
+                                const std::vector<std::pair<uint16_t, e::slice> > &_value,
+                                hyperdex_client_returncode *op_status,
+                                e::error *op_error,
+                                const hyperdex_client_attribute **attrs,
+                                size_t *attrs_sz,
                                 bool convert_types)
 {
-    std::vector<std::pair<uint16_t, e::slice> > value(_value);
-    const schema* sc = config.get_schema(rid);
-    e::arena memory;
-    size_t sz = sizeof(hyperdex_client_attribute) * value.size()
-              + strlen(sc->attrs[0].name) + 1;
-
-    for (size_t i = 0; i < value.size(); ++i)
-    {
-        uint16_t attr = value[i].first;
-
-        if (attr >= sc->attrs_sz)
-        {
-            UTIL_ERROR(SERVERERROR) << "received object with attribute " << value[i].first
-                                    << " which exceeds the number of attributes in the schema ("
-                                    << sc->attrs_sz << ")";
-            return false;
-        }
-
-        sz += strlen(sc->attrs[attr].name) + 1 + value[i].second.size();
-        datatype_info* di = datatype_info::lookup(sc->attrs[attr].type);
-
-        if (convert_types)
-        {
-            if (!di->server_to_client(value[i].second, &memory, &value[i].second))
-            {
-                UTIL_ERROR(SERVERERROR) << "cannot convert from server-side form";
-                return false;
-            }
-        }
-    }
-
-    std::vector<hyperdex_client_attribute> ha;
-    ha.reserve(sc->attrs_sz);
-    char* ret = static_cast<char*>(malloc(sz));
-
-    if (!ret)
-    {
-        UTIL_ERROR(NOMEM) << "out of memory";
-        return false;
-    }
-
-    e::guard g = e::makeguard(free, ret);
-    char* data = ret + sizeof(hyperdex_client_attribute) * value.size();
-
-    for (size_t i = 0; i < value.size(); ++i)
-    {
-        if (sc->attrs[i + 1].type == HYPERDATATYPE_MACAROON_SECRET)
-        {
-            continue;
-        }
-
-        uint16_t attr = value[i].first;
-        ha.push_back(hyperdex_client_attribute());
-        size_t attr_sz = strlen(sc->attrs[attr].name) + 1;
-        ha.back().attr = data;
-        memmove(data, sc->attrs[attr].name, attr_sz);
-        data += attr_sz;
-        ha.back().value = data;
-        memmove(data, value[i].second.data(), value[i].second.size());
-        data += value[i].second.size();
-        ha.back().value_sz = value[i].second.size();
-        ha.back().datatype = sc->attrs[attr].type;
-    }
-
-    memmove(ret, &ha.front(), sizeof(hyperdex_client_attribute) * ha.size());
-    *op_status = HYPERDEX_CLIENT_SUCCESS;
-    *op_error = e::error();
-    *attrs = reinterpret_cast<hyperdex_client_attribute*>(ret);
-    *attrs_sz = ha.size();
-    g.dismiss();
-    return true;
+	std::vector<std::pair<uint16_t, e::slice> > value(_value);
+	const schema *sc = config.get_schema(rid);
+	e::arena memory;
+	size_t sz = sizeof(hyperdex_client_attribute) * value.size()
+	            + strlen(sc->attrs[0].name) + 1;
+	for (size_t i = 0; i < value.size(); ++i)
+	{
+		uint16_t attr = value[i].first;
+		if (attr >= sc->attrs_sz)
+		{
+			UTIL_ERROR(SERVERERROR) << "received object with attribute " << value[i].first
+			                        << " which exceeds the number of attributes in the schema ("
+			                        << sc->attrs_sz << ")";
+			return false;
+		}
+		sz += strlen(sc->attrs[attr].name) + 1 + value[i].second.size();
+		datatype_info *di = datatype_info::lookup(sc->attrs[attr].type);
+		if (convert_types)
+		{
+			if (!di->server_to_client(value[i].second, &memory, &value[i].second))
+			{
+				UTIL_ERROR(SERVERERROR) << "cannot convert from server-side form";
+				return false;
+			}
+		}
+	}
+	std::vector<hyperdex_client_attribute> ha;
+	ha.reserve(sc->attrs_sz);
+	char *ret = static_cast<char *>(malloc(sz));
+	if (!ret)
+	{
+		UTIL_ERROR(NOMEM) << "out of memory";
+		return false;
+	}
+	e::guard g = e::makeguard(free, ret);
+	char *data = ret + sizeof(hyperdex_client_attribute) * value.size();
+	for (size_t i = 0; i < value.size(); ++i)
+	{
+		if (sc->attrs[i + 1].type == HYPERDATATYPE_MACAROON_SECRET)
+		{
+			continue;
+		}
+		uint16_t attr = value[i].first;
+		ha.push_back(hyperdex_client_attribute());
+		size_t attr_sz = strlen(sc->attrs[attr].name) + 1;
+		ha.back().attr = data;
+		memmove(data, sc->attrs[attr].name, attr_sz);
+		data += attr_sz;
+		ha.back().value = data;
+		memmove(data, value[i].second.data(), value[i].second.size());
+		data += value[i].second.size();
+		ha.back().value_sz = value[i].second.size();
+		ha.back().datatype = sc->attrs[attr].type;
+	}
+	memmove(ret, &ha.front(), sizeof(hyperdex_client_attribute) * ha.size());
+	*op_status = HYPERDEX_CLIENT_SUCCESS;
+	*op_error = e::error();
+	*attrs = reinterpret_cast<hyperdex_client_attribute *>(ret);
+	*attrs_sz = ha.size();
+	g.dismiss();
+	return true;
 }
diff --git a/client/util.h b/client/util.h
index 0c8eecd74..c426d9c2f 100644
--- a/client/util.h
+++ b/client/util.h
@@ -42,25 +42,25 @@ BEGIN_HYPERDEX_NAMESPACE
 // Convert the key and value vector returned by entity to an array of
 // hyperdex_attribute using the given configuration.
 bool
-value_to_attributes(const configuration& config,
-                    const region_id& rid,
-                    const uint8_t* key,
+value_to_attributes(const configuration &config,
+                    const region_id &rid,
+                    const uint8_t *key,
                     size_t key_sz,
-                    const std::vector<e::slice>& value,
-                    hyperdex_client_returncode* op_status,
-                    e::error* op_error,
-                    const hyperdex_client_attribute** attrs,
-                    size_t* attrs_sz,
+                    const std::vector<e::slice> &value,
+                    hyperdex_client_returncode *op_status,
+                    e::error *op_error,
+                    const hyperdex_client_attribute **attrs,
+                    size_t *attrs_sz,
                     bool convert_types);
 
 bool
-value_to_attributes(const configuration& config,
-                    const region_id& rid,
-                    const std::vector<std::pair<uint16_t, e::slice> >& value,
-                    hyperdex_client_returncode* op_status,
-                    e::error* op_error,
-                    const hyperdex_client_attribute** attrs,
-                    size_t* attrs_sz,
+value_to_attributes(const configuration &config,
+                    const region_id &rid,
+                    const std::vector<std::pair<uint16_t, e::slice> > &value,
+                    hyperdex_client_returncode *op_status,
+                    e::error *op_error,
+                    const hyperdex_client_attribute **attrs,
+                    size_t *attrs_sz,
                     bool convert_types);
 
 END_HYPERDEX_NAMESPACE
diff --git a/common/attribute.cc b/common/attribute.cc
index 5d8bd1a76..ef26682de 100644
--- a/common/attribute.cc
+++ b/common/attribute.cc
@@ -31,27 +31,27 @@
 using hyperdex::attribute;
 
 attribute :: attribute()
-    : name("")
-    , type(HYPERDATATYPE_GARBAGE)
+	: name("")
+	, type(HYPERDATATYPE_GARBAGE)
 {
 }
 
-attribute :: attribute(const char* _name, hyperdatatype _type)
-    : name(_name)
-    , type(_type)
+attribute :: attribute(const char *_name, hyperdatatype _type)
+	: name(_name)
+	, type(_type)
 {
 }
 
-attribute :: attribute(const attribute& other)
-    : name(other.name)
-    , type(other.type)
+attribute :: attribute(const attribute &other)
+	: name(other.name)
+	, type(other.type)
 {
 }
 
-attribute&
-attribute :: operator = (const attribute& rhs)
+attribute &
+attribute :: operator = (const attribute &rhs)
 {
-    name = rhs.name;
-    type = rhs.type;
-    return *this;
+	name = rhs.name;
+	type = rhs.type;
+	return *this;
 }
diff --git a/common/attribute.h b/common/attribute.h
index 46cbd9cb8..e209eafb8 100644
--- a/common/attribute.h
+++ b/common/attribute.h
@@ -36,17 +36,17 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class attribute
 {
-    public:
-        attribute();
-        attribute(const char* name, hyperdatatype type);
-        attribute(const attribute& other);
+public:
+	attribute();
+	attribute(const char *name, hyperdatatype type);
+	attribute(const attribute &other);
 
-    public:
-        attribute& operator = (const attribute& rhs);
+public:
+	attribute &operator = (const attribute &rhs);
 
-    public:
-        const char* name;
-        hyperdatatype type;
+public:
+	const char *name;
+	hyperdatatype type;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/common/attribute_check.cc b/common/attribute_check.cc
index d5b60db7d..cb3fe2c4a 100644
--- a/common/attribute_check.cc
+++ b/common/attribute_check.cc
@@ -36,10 +36,10 @@
 using hyperdex::attribute_check;
 
 attribute_check :: attribute_check()
-    : attr()
-    , value()
-    , datatype(HYPERDATATYPE_GARBAGE)
-    , predicate(HYPERPREDICATE_FAIL)
+	: attr()
+	, value()
+	, datatype(HYPERDATATYPE_GARBAGE)
+	, predicate(HYPERPREDICATE_FAIL)
 {
 }
 
@@ -49,223 +49,208 @@ attribute_check :: ~attribute_check() throw ()
 
 bool
 hyperdex :: validate_attribute_check(hyperdatatype type,
-                                     const attribute_check& check)
+                                     const attribute_check &check)
 {
-    datatype_info* di_attr = datatype_info::lookup(type);
-    datatype_info* di_check = datatype_info::lookup(check.datatype);
-
-    if (!di_attr || !di_check)
-    {
-        return false;
-    }
-
-    if (di_attr->document())
-    {
-        return true;
-    }
-
-    if (!di_check->validate(check.value))
-    {
-        return false;
-    }
-
-    switch (check.predicate)
-    {
-        case HYPERPREDICATE_FAIL:
-            return true;
-        case HYPERPREDICATE_EQUALS:
-            return di_attr->datatype() == di_check->datatype();
-        case HYPERPREDICATE_LESS_THAN:
-        case HYPERPREDICATE_LESS_EQUAL:
-        case HYPERPREDICATE_GREATER_EQUAL:
-        case HYPERPREDICATE_GREATER_THAN:
-            return di_attr->datatype() == di_check->datatype() &&
-                   di_attr->comparable();
-        case HYPERPREDICATE_REGEX:
-            return di_check->datatype() == HYPERDATATYPE_STRING &&
-                   di_attr->has_regex();
-        case HYPERPREDICATE_CONTAINS_LESS_THAN:
-        case HYPERPREDICATE_LENGTH_EQUALS:
-        case HYPERPREDICATE_LENGTH_LESS_EQUAL:
-        case HYPERPREDICATE_LENGTH_GREATER_EQUAL:
-            return di_check->datatype() == HYPERDATATYPE_INT64 &&
-                   di_attr->has_length();
-        case HYPERPREDICATE_CONTAINS:
-            return di_attr->has_contains() &&
-                   di_attr->contains_datatype() == di_check->datatype();
-        default:
-            return false;
-    }
+	datatype_info *di_attr = datatype_info::lookup(type);
+	datatype_info *di_check = datatype_info::lookup(check.datatype);
+	if (!di_attr || !di_check)
+	{
+		return false;
+	}
+	if (di_attr->document())
+	{
+		return true;
+	}
+	if (!di_check->validate(check.value))
+	{
+		return false;
+	}
+	switch (check.predicate)
+	{
+	case HYPERPREDICATE_FAIL:
+		return true;
+	case HYPERPREDICATE_EQUALS:
+		return di_attr->datatype() == di_check->datatype();
+	case HYPERPREDICATE_LESS_THAN:
+	case HYPERPREDICATE_LESS_EQUAL:
+	case HYPERPREDICATE_GREATER_EQUAL:
+	case HYPERPREDICATE_GREATER_THAN:
+		return di_attr->datatype() == di_check->datatype() &&
+		       di_attr->comparable();
+	case HYPERPREDICATE_REGEX:
+		return di_check->datatype() == HYPERDATATYPE_STRING &&
+		       di_attr->has_regex();
+	case HYPERPREDICATE_CONTAINS_LESS_THAN:
+	case HYPERPREDICATE_LENGTH_EQUALS:
+	case HYPERPREDICATE_LENGTH_LESS_EQUAL:
+	case HYPERPREDICATE_LENGTH_GREATER_EQUAL:
+		return di_check->datatype() == HYPERDATATYPE_INT64 &&
+		       di_attr->has_length();
+	case HYPERPREDICATE_CONTAINS:
+		return di_attr->has_contains() &&
+		       di_attr->contains_datatype() == di_check->datatype();
+	default:
+		return false;
+	}
 }
 
 size_t
-hyperdex :: validate_attribute_checks(const schema& sc,
-                                      const std::vector<attribute_check>& checks)
+hyperdex :: validate_attribute_checks(const schema &sc,
+                                      const std::vector<attribute_check> &checks)
 {
-    for (size_t i = 0; i < checks.size(); ++i)
-    {
-        if (checks[i].attr >= sc.attrs_sz)
-        {
-            return i;
-        }
-
-        hyperdatatype type = sc.attrs[checks[i].attr].type;
-
-        if (!validate_attribute_check(type, checks[i]))
-        {
-            return i;
-        }
-    }
-
-    return checks.size();
+	for (size_t i = 0; i < checks.size(); ++i)
+	{
+		if (checks[i].attr >= sc.attrs_sz)
+		{
+			return i;
+		}
+		hyperdatatype type = sc.attrs[checks[i].attr].type;
+		if (!validate_attribute_check(type, checks[i]))
+		{
+			return i;
+		}
+	}
+	return checks.size();
 }
 
 bool
 hyperdex :: passes_attribute_check(hyperdatatype type,
-                                   const attribute_check& check,
-                                   const e::slice& value)
+                                   const attribute_check &check,
+                                   const e::slice &value)
 {
-    datatype_info* di_attr = datatype_info::lookup(type);
-    datatype_info* di_check = datatype_info::lookup(check.datatype);
-
-    if (!di_attr || !di_check)
-    {
-        return false;
-    }
-
-    if (di_attr->document())
-    {
-        return di_attr->document_check(check, value);
-    }
-
-    if (!di_attr->validate(value) ||
-        !di_check->validate(check.value))
-    {
-        return false;
-    }
-
-    char buf_i[sizeof(int64_t)];
-    int64_t tmp_i;
-
-    switch (check.predicate)
-    {
-        case HYPERPREDICATE_FAIL:
-            return false;
-        case HYPERPREDICATE_EQUALS:
-            return di_attr->datatype() == di_check->datatype() &&
-                   (check.value == value ||
-                    (di_attr->comparable() && di_attr->compare(check.value, value) == 0));
-        case HYPERPREDICATE_LESS_THAN:
-            return di_attr->datatype() == di_check->datatype() &&
-                   di_attr->comparable() &&
-                   di_attr->compare(check.value, value) > 0;
-        case HYPERPREDICATE_LESS_EQUAL:
-            return di_attr->datatype() == di_check->datatype() &&
-                   di_attr->comparable() &&
-                   di_attr->compare(check.value, value) >= 0;
-        case HYPERPREDICATE_GREATER_EQUAL:
-            return di_attr->datatype() == di_check->datatype() &&
-                   di_attr->comparable() &&
-                   di_attr->compare(check.value, value) <= 0;
-        case HYPERPREDICATE_GREATER_THAN:
-            return di_attr->datatype() == di_check->datatype() &&
-                   di_attr->comparable() &&
-                   di_attr->compare(check.value, value) < 0;
-        case HYPERPREDICATE_REGEX:
-            return di_check->datatype() == HYPERDATATYPE_STRING &&
-                   di_attr->has_regex() &&
-                   di_attr->regex(check.value, value);
-        case HYPERPREDICATE_LENGTH_EQUALS:
-            memset(buf_i, 0, sizeof(int64_t));
-            memmove(buf_i, check.value.data(), std::min(check.value.size(), sizeof(int64_t)));
-            e::unpack64le(buf_i, &tmp_i);
-            return di_check->datatype() == HYPERDATATYPE_INT64 &&
-                   di_attr->has_length() &&
-                   static_cast<int64_t>(di_attr->length(value)) == tmp_i;
-        case HYPERPREDICATE_CONTAINS_LESS_THAN:
-        case HYPERPREDICATE_LENGTH_LESS_EQUAL:
-            memset(buf_i, 0, sizeof(int64_t));
-            memmove(buf_i, check.value.data(), std::min(check.value.size(), sizeof(int64_t)));
-            e::unpack64le(buf_i, &tmp_i);
-            return di_check->datatype() == HYPERDATATYPE_INT64 &&
-                   di_attr->has_length() &&
-                   static_cast<int64_t>(di_attr->length(value)) <= tmp_i;
-        case HYPERPREDICATE_LENGTH_GREATER_EQUAL:
-            memset(buf_i, 0, sizeof(int64_t));
-            memmove(buf_i, check.value.data(), std::min(check.value.size(), sizeof(int64_t)));
-            e::unpack64le(buf_i, &tmp_i);
-            return di_check->datatype() == HYPERDATATYPE_INT64 &&
-                   di_attr->has_length() &&
-                   static_cast<int64_t>(di_attr->length(value)) >= tmp_i;
-        case HYPERPREDICATE_CONTAINS:
-            return di_attr->has_contains() &&
-                   di_attr->contains_datatype() == di_check->datatype() &&
-                   di_attr->contains(value, check.value);
-        default:
-            return false;
-    }
+	datatype_info *di_attr = datatype_info::lookup(type);
+	datatype_info *di_check = datatype_info::lookup(check.datatype);
+	if (!di_attr || !di_check)
+	{
+		return false;
+	}
+	if (di_attr->document())
+	{
+		return di_attr->document_check(check, value);
+	}
+	if (!di_attr->validate(value) ||
+	    !di_check->validate(check.value))
+	{
+		return false;
+	}
+	char buf_i[sizeof(int64_t)];
+	int64_t tmp_i;
+	switch (check.predicate)
+	{
+	case HYPERPREDICATE_FAIL:
+		return false;
+	case HYPERPREDICATE_EQUALS:
+		return di_attr->datatype() == di_check->datatype() &&
+		       (check.value == value ||
+		        (di_attr->comparable() && di_attr->compare(check.value, value) == 0));
+	case HYPERPREDICATE_LESS_THAN:
+		return di_attr->datatype() == di_check->datatype() &&
+		       di_attr->comparable() &&
+		       di_attr->compare(check.value, value) > 0;
+	case HYPERPREDICATE_LESS_EQUAL:
+		return di_attr->datatype() == di_check->datatype() &&
+		       di_attr->comparable() &&
+		       di_attr->compare(check.value, value) >= 0;
+	case HYPERPREDICATE_GREATER_EQUAL:
+		return di_attr->datatype() == di_check->datatype() &&
+		       di_attr->comparable() &&
+		       di_attr->compare(check.value, value) <= 0;
+	case HYPERPREDICATE_GREATER_THAN:
+		return di_attr->datatype() == di_check->datatype() &&
+		       di_attr->comparable() &&
+		       di_attr->compare(check.value, value) < 0;
+	case HYPERPREDICATE_REGEX:
+		return di_check->datatype() == HYPERDATATYPE_STRING &&
+		       di_attr->has_regex() &&
+		       di_attr->regex(check.value, value);
+	case HYPERPREDICATE_LENGTH_EQUALS:
+		memset(buf_i, 0, sizeof(int64_t));
+		memmove(buf_i, check.value.data(), std::min(check.value.size(), sizeof(int64_t)));
+		e::unpack64le(buf_i, &tmp_i);
+		return di_check->datatype() == HYPERDATATYPE_INT64 &&
+		       di_attr->has_length() &&
+		       static_cast<int64_t>(di_attr->length(value)) == tmp_i;
+	case HYPERPREDICATE_CONTAINS_LESS_THAN:
+	case HYPERPREDICATE_LENGTH_LESS_EQUAL:
+		memset(buf_i, 0, sizeof(int64_t));
+		memmove(buf_i, check.value.data(), std::min(check.value.size(), sizeof(int64_t)));
+		e::unpack64le(buf_i, &tmp_i);
+		return di_check->datatype() == HYPERDATATYPE_INT64 &&
+		       di_attr->has_length() &&
+		       static_cast<int64_t>(di_attr->length(value)) <= tmp_i;
+	case HYPERPREDICATE_LENGTH_GREATER_EQUAL:
+		memset(buf_i, 0, sizeof(int64_t));
+		memmove(buf_i, check.value.data(), std::min(check.value.size(), sizeof(int64_t)));
+		e::unpack64le(buf_i, &tmp_i);
+		return di_check->datatype() == HYPERDATATYPE_INT64 &&
+		       di_attr->has_length() &&
+		       static_cast<int64_t>(di_attr->length(value)) >= tmp_i;
+	case HYPERPREDICATE_CONTAINS:
+		return di_attr->has_contains() &&
+		       di_attr->contains_datatype() == di_check->datatype() &&
+		       di_attr->contains(value, check.value);
+	default:
+		return false;
+	}
 }
 
 size_t
-hyperdex :: passes_attribute_checks(const schema& sc,
-                                    const std::vector<hyperdex::attribute_check>& checks,
-                                    const e::slice& key,
-                                    const std::vector<e::slice>& value)
+hyperdex :: passes_attribute_checks(const schema &sc,
+                                    const std::vector<hyperdex::attribute_check> &checks,
+                                    const e::slice &key,
+                                    const std::vector<e::slice> &value)
 {
-    for (size_t i = 0; i < checks.size(); ++i)
-    {
-        if (checks[i].attr >= sc.attrs_sz)
-        {
-            return i;
-        }
-
-        hyperdatatype type = sc.attrs[checks[i].attr].type;
-
-        if (checks[i].attr > 0 &&
-            !passes_attribute_check(type, checks[i], value[checks[i].attr - 1]))
-        {
-            return i;
-        }
-        else if (checks[i].attr == 0 &&
-                 !passes_attribute_check(type, checks[i], key))
-        {
-            return i;
-        }
-    }
-
-    return checks.size();
+	for (size_t i = 0; i < checks.size(); ++i)
+	{
+		if (checks[i].attr >= sc.attrs_sz)
+		{
+			return i;
+		}
+		hyperdatatype type = sc.attrs[checks[i].attr].type;
+		if (checks[i].attr > 0 &&
+		    !passes_attribute_check(type, checks[i], value[checks[i].attr - 1]))
+		{
+			return i;
+		}
+		else if (checks[i].attr == 0 &&
+		         !passes_attribute_check(type, checks[i], key))
+		{
+			return i;
+		}
+	}
+	return checks.size();
 }
 
 bool
-hyperdex :: operator < (const attribute_check& lhs, const attribute_check& rhs)
+hyperdex :: operator < (const attribute_check &lhs, const attribute_check &rhs)
 {
-    return lhs.attr < rhs.attr;
+	return lhs.attr < rhs.attr;
 }
 
 e::packer
-hyperdex :: operator << (e::packer lhs, const attribute_check& rhs)
+hyperdex :: operator << (e::packer lhs, const attribute_check &rhs)
 {
-    return lhs << rhs.attr
-               << rhs.value
-               << rhs.datatype
-               << rhs.predicate;
+	return lhs << rhs.attr
+	       << rhs.value
+	       << rhs.datatype
+	       << rhs.predicate;
 }
 
 e::unpacker
-hyperdex :: operator >> (e::unpacker lhs, attribute_check& rhs)
+hyperdex :: operator >> (e::unpacker lhs, attribute_check &rhs)
 {
-    return lhs >> rhs.attr
-               >> rhs.value
-               >> rhs.datatype
-               >> rhs.predicate;
+	return lhs >> rhs.attr
+	       >> rhs.value
+	       >> rhs.datatype
+	       >> rhs.predicate;
 }
 
 size_t
-hyperdex :: pack_size(const attribute_check& rhs)
+hyperdex :: pack_size(const attribute_check &rhs)
 {
-    return sizeof(uint16_t)
-         + sizeof(uint32_t)
-         + rhs.value.size()
-         + pack_size(rhs.datatype)
-         + pack_size(rhs.predicate);
+	return sizeof(uint16_t)
+	       + sizeof(uint32_t)
+	       + rhs.value.size()
+	       + pack_size(rhs.datatype)
+	       + pack_size(rhs.predicate);
 }
diff --git a/common/attribute_check.h b/common/attribute_check.h
index 7c231d312..0005928c4 100644
--- a/common/attribute_check.h
+++ b/common/attribute_check.h
@@ -41,47 +41,47 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class attribute_check
 {
-    public:
-        attribute_check();
-        ~attribute_check() throw ();
+public:
+	attribute_check();
+	~attribute_check() throw ();
 
-    public:
-        uint16_t attr;
-        e::slice value;
-        hyperdatatype datatype;
-        hyperpredicate predicate;
+public:
+	uint16_t attr;
+	e::slice value;
+	hyperdatatype datatype;
+	hyperpredicate predicate;
 };
 
 bool
 validate_attribute_check(hyperdatatype type,
-                         const attribute_check& check);
+                         const attribute_check &check);
 
 size_t
-validate_attribute_checks(const schema& sc,
-                          const std::vector<hyperdex::attribute_check>& checks);
+validate_attribute_checks(const schema &sc,
+                          const std::vector<hyperdex::attribute_check> &checks);
 bool
 passes_attribute_check(hyperdatatype type,
-                       const attribute_check& chk,
-                       const e::slice& value);
+                       const attribute_check &chk,
+                       const e::slice &value);
 
 // Does several calls of passes_attribute_check at once
 // Returns point of failure in the vector or checks.size() on success
 size_t
-passes_attribute_checks(const schema& sc,
-                        const std::vector<hyperdex::attribute_check>& checks,
-                        const e::slice& key,
-                        const std::vector<e::slice>& values);
+passes_attribute_checks(const schema &sc,
+                        const std::vector<hyperdex::attribute_check> &checks,
+                        const e::slice &key,
+                        const std::vector<e::slice> &values);
 
 bool
-operator < (const attribute_check& lhs,
-            const attribute_check& rhs);
+operator < (const attribute_check &lhs,
+            const attribute_check &rhs);
 
 e::packer
-operator << (e::packer lhs, const attribute_check& rhs);
+operator << (e::packer lhs, const attribute_check &rhs);
 e::unpacker
-operator >> (e::unpacker lhs, attribute_check& rhs);
+operator >> (e::unpacker lhs, attribute_check &rhs);
 size_t
-pack_size(const attribute_check& rhs);
+pack_size(const attribute_check &rhs);
 
 END_HYPERDEX_NAMESPACE
 
diff --git a/common/auth_wallet.cc b/common/auth_wallet.cc
index 3b20a18c1..8de5a235d 100644
--- a/common/auth_wallet.cc
+++ b/common/auth_wallet.cc
@@ -35,85 +35,78 @@
 using hyperdex::auth_wallet;
 
 auth_wallet :: auth_wallet()
-    : m_macaroons()
+	: m_macaroons()
 {
 }
 
-auth_wallet :: auth_wallet(const char** macaroons, size_t macaroons_sz)
-    : m_macaroons()
+auth_wallet :: auth_wallet(const char **macaroons, size_t macaroons_sz)
+	: m_macaroons()
 {
-    m_macaroons.reserve(macaroons_sz);
-
-    for (size_t i = 0; i < macaroons_sz; ++i)
-    {
-        m_macaroons.push_back(std::string(macaroons[i], strlen(macaroons[i])));
-    }
+	m_macaroons.reserve(macaroons_sz);
+	for (size_t i = 0; i < macaroons_sz; ++i)
+	{
+		m_macaroons.push_back(std::string(macaroons[i], strlen(macaroons[i])));
+	}
 }
 
-auth_wallet :: auth_wallet(const auth_wallet& other)
-    : m_macaroons(other.m_macaroons)
+auth_wallet :: auth_wallet(const auth_wallet &other)
+	: m_macaroons(other.m_macaroons)
 {
 }
 
 bool
-auth_wallet :: get_macaroons(std::vector<macaroon*>* macaroons)
+auth_wallet :: get_macaroons(std::vector<macaroon *> *macaroons)
 {
-    for (size_t i = 0; i < m_macaroons.size(); ++i)
-    {
-        macaroon_returncode err;
-        macaroon* M = macaroon_deserialize(m_macaroons[i].c_str(), &err);
-
-        if (!M)
-        {
-            return false;
-        }
-
-        macaroons->push_back(M);
-    }
-
-    return true;
+	for (size_t i = 0; i < m_macaroons.size(); ++i)
+	{
+		macaroon_returncode err;
+		macaroon *M = macaroon_deserialize(m_macaroons[i].c_str(), &err);
+		if (!M)
+		{
+			return false;
+		}
+		macaroons->push_back(M);
+	}
+	return true;
 }
 
 static void
-build_macaroons(const std::vector<std::string>& in,
-                std::vector<e::slice>* out)
+build_macaroons(const std::vector<std::string> &in,
+                std::vector<e::slice> *out)
 {
-    out->clear();
-    out->reserve(in.size());
-
-    for (size_t i = 0; i < in.size(); ++i)
-    {
-        out->push_back(e::slice(in[i]));
-    }
+	out->clear();
+	out->reserve(in.size());
+	for (size_t i = 0; i < in.size(); ++i)
+	{
+		out->push_back(e::slice(in[i]));
+	}
 }
 
 e::packer
-hyperdex :: operator << (e::packer lhs, const auth_wallet& rhs)
+hyperdex :: operator << (e::packer lhs, const auth_wallet &rhs)
 {
-    std::vector<e::slice> macaroons;
-    build_macaroons(rhs.m_macaroons, &macaroons);
-    return lhs << macaroons;
+	std::vector<e::slice> macaroons;
+	build_macaroons(rhs.m_macaroons, &macaroons);
+	return lhs << macaroons;
 }
 
 e::unpacker
-hyperdex :: operator >> (e::unpacker lhs, auth_wallet& rhs)
+hyperdex :: operator >> (e::unpacker lhs, auth_wallet &rhs)
 {
-    std::vector<e::slice> macaroons;
-    lhs = lhs >> macaroons;
-    rhs.m_macaroons.resize(macaroons.size());
-
-    for (size_t i = 0; i < macaroons.size(); ++i)
-    {
-        rhs.m_macaroons[i].assign(macaroons[i].cdata(), macaroons[i].size());
-    }
-
-    return lhs;
+	std::vector<e::slice> macaroons;
+	lhs = lhs >> macaroons;
+	rhs.m_macaroons.resize(macaroons.size());
+	for (size_t i = 0; i < macaroons.size(); ++i)
+	{
+		rhs.m_macaroons[i].assign(macaroons[i].cdata(), macaroons[i].size());
+	}
+	return lhs;
 }
 
 size_t
-hyperdex :: pack_size(const auth_wallet& aw)
+hyperdex :: pack_size(const auth_wallet &aw)
 {
-    std::vector<e::slice> macaroons;
-    build_macaroons(aw.m_macaroons, &macaroons);
-    return pack_size(macaroons);
+	std::vector<e::slice> macaroons;
+	build_macaroons(aw.m_macaroons, &macaroons);
+	return pack_size(macaroons);
 }
diff --git a/common/auth_wallet.h b/common/auth_wallet.h
index 3621c695e..316dd1058 100644
--- a/common/auth_wallet.h
+++ b/common/auth_wallet.h
@@ -42,34 +42,34 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class auth_wallet
 {
-    public:
-        auth_wallet();
-        auth_wallet(const char** macaroons, size_t macaroons_sz);
-        auth_wallet(const auth_wallet&);
+public:
+	auth_wallet();
+	auth_wallet(const char **macaroons, size_t macaroons_sz);
+	auth_wallet(const auth_wallet &);
 
-    public:
-        bool get_macaroons(std::vector<macaroon*>* macaroons);
+public:
+	bool get_macaroons(std::vector<macaroon *> *macaroons);
 
-    private:
-        friend e::packer operator << (e::packer lhs, const auth_wallet& rhs);
-        friend e::unpacker operator >> (e::unpacker lhs, auth_wallet& rhs);
-        friend size_t pack_size(const auth_wallet& aw);
+private:
+	friend e::packer operator << (e::packer lhs, const auth_wallet &rhs);
+	friend e::unpacker operator >> (e::unpacker lhs, auth_wallet &rhs);
+	friend size_t pack_size(const auth_wallet &aw);
 
-        friend std::ostream& operator << (std::ostream& lhs, const auth_wallet& rhs); // XXX
+	friend std::ostream &operator << (std::ostream &lhs, const auth_wallet &rhs); // XXX
 
-    private:
-        auth_wallet& operator = (const auth_wallet&);
+private:
+	auth_wallet &operator = (const auth_wallet &);
 
-    private:
-        std::vector<std::string> m_macaroons;
+private:
+	std::vector<std::string> m_macaroons;
 };
 
 e::packer
-operator << (e::packer lhs, const auth_wallet& rhs);
+operator << (e::packer lhs, const auth_wallet &rhs);
 e::unpacker
-operator >> (e::unpacker lhs, auth_wallet& rhs);
+operator >> (e::unpacker lhs, auth_wallet &rhs);
 size_t
-pack_size(const auth_wallet& aw);
+pack_size(const auth_wallet &aw);
 
 END_HYPERDEX_NAMESPACE
 
diff --git a/common/configuration.cc b/common/configuration.cc
index 0120ff8f5..09f166704 100644
--- a/common/configuration.cc
+++ b/common/configuration.cc
@@ -50,47 +50,47 @@ using hyperdex::subspace_id;
 using hyperdex::virtual_server_id;
 
 configuration :: configuration()
-    : m_cluster(0)
-    , m_version(0)
-    , m_flags(0)
-    , m_servers()
-    , m_region_ids_by_virtual()
-    , m_server_ids_by_virtual()
-    , m_schemas_by_region()
-    , m_subspaces_by_region()
-    , m_subspace_ids_by_region()
-    , m_subspace_ids_for_prev()
-    , m_subspace_ids_for_next()
-    , m_heads_by_region()
-    , m_tails_by_region()
-    , m_next_by_virtual()
-    , m_point_leaders_by_virtual()
-    , m_spaces()
-    , m_transfers()
+	: m_cluster(0)
+	, m_version(0)
+	, m_flags(0)
+	, m_servers()
+	, m_region_ids_by_virtual()
+	, m_server_ids_by_virtual()
+	, m_schemas_by_region()
+	, m_subspaces_by_region()
+	, m_subspace_ids_by_region()
+	, m_subspace_ids_for_prev()
+	, m_subspace_ids_for_next()
+	, m_heads_by_region()
+	, m_tails_by_region()
+	, m_next_by_virtual()
+	, m_point_leaders_by_virtual()
+	, m_spaces()
+	, m_transfers()
 {
-    refill_cache();
+	refill_cache();
 }
 
-configuration :: configuration(const configuration& other)
-    : m_cluster(other.m_cluster)
-    , m_version(other.m_version)
-    , m_flags(other.m_flags)
-    , m_servers(other.m_servers)
-    , m_region_ids_by_virtual(other.m_region_ids_by_virtual)
-    , m_server_ids_by_virtual(other.m_server_ids_by_virtual)
-    , m_schemas_by_region(other.m_schemas_by_region)
-    , m_subspaces_by_region(other.m_subspaces_by_region)
-    , m_subspace_ids_by_region(other.m_subspace_ids_by_region)
-    , m_subspace_ids_for_prev(other.m_subspace_ids_for_prev)
-    , m_subspace_ids_for_next(other.m_subspace_ids_for_next)
-    , m_heads_by_region(other.m_heads_by_region)
-    , m_tails_by_region(other.m_tails_by_region)
-    , m_next_by_virtual(other.m_next_by_virtual)
-    , m_point_leaders_by_virtual(other.m_point_leaders_by_virtual)
-    , m_spaces(other.m_spaces)
-    , m_transfers(other.m_transfers)
+configuration :: configuration(const configuration &other)
+	: m_cluster(other.m_cluster)
+	, m_version(other.m_version)
+	, m_flags(other.m_flags)
+	, m_servers(other.m_servers)
+	, m_region_ids_by_virtual(other.m_region_ids_by_virtual)
+	, m_server_ids_by_virtual(other.m_server_ids_by_virtual)
+	, m_schemas_by_region(other.m_schemas_by_region)
+	, m_subspaces_by_region(other.m_subspaces_by_region)
+	, m_subspace_ids_by_region(other.m_subspace_ids_by_region)
+	, m_subspace_ids_for_prev(other.m_subspace_ids_for_prev)
+	, m_subspace_ids_for_next(other.m_subspace_ids_for_next)
+	, m_heads_by_region(other.m_heads_by_region)
+	, m_tails_by_region(other.m_tails_by_region)
+	, m_next_by_virtual(other.m_next_by_virtual)
+	, m_point_leaders_by_virtual(other.m_point_leaders_by_virtual)
+	, m_spaces(other.m_spaces)
+	, m_transfers(other.m_transfers)
 {
-    refill_cache();
+	refill_cache();
 }
 
 configuration :: ~configuration() throw ()
@@ -100,1122 +100,987 @@ configuration :: ~configuration() throw ()
 uint64_t
 configuration :: cluster() const
 {
-    return m_cluster;
+	return m_cluster;
 }
 
 uint64_t
 configuration :: version() const
 {
-    return m_version;
+	return m_version;
 }
 
 bool
 configuration :: read_only() const
 {
-    return m_flags & HYPERDEX_CONFIG_READ_ONLY;
+	return m_flags & HYPERDEX_CONFIG_READ_ONLY;
 }
 
 void
-configuration :: get_all_addresses(std::vector<std::pair<server_id, po6::net::location> >* addrs) const
+configuration :: get_all_addresses(std::vector<std::pair<server_id, po6::net::location> > *addrs) const
 {
-    addrs->resize(m_servers.size());
-
-    for (size_t i = 0; i < m_servers.size(); ++i)
-    {
-        (*addrs)[i].first = m_servers[i].id;
-        (*addrs)[i].second = m_servers[i].bind_to;
-    }
+	addrs->resize(m_servers.size());
+	for (size_t i = 0; i < m_servers.size(); ++i)
+	{
+		(*addrs)[i].first = m_servers[i].id;
+		(*addrs)[i].second = m_servers[i].bind_to;
+	}
 }
 
 bool
-configuration :: exists(const server_id& id) const
+configuration :: exists(const server_id &id) const
 {
-    for (size_t i = 0; i < m_servers.size(); ++i)
-    {
-        if (m_servers[i].id == id)
-        {
-            return true;
-        }
-    }
-
-    return false;
+	for (size_t i = 0; i < m_servers.size(); ++i)
+	{
+		if (m_servers[i].id == id)
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 po6::net::location
-configuration :: get_address(const server_id& id) const
+configuration :: get_address(const server_id &id) const
 {
-    for (size_t i = 0; i < m_servers.size(); ++i)
-    {
-        if (m_servers[i].id == id)
-        {
-            return m_servers[i].bind_to;
-        }
-    }
-
-    return po6::net::location();
+	for (size_t i = 0; i < m_servers.size(); ++i)
+	{
+		if (m_servers[i].id == id)
+		{
+			return m_servers[i].bind_to;
+		}
+	}
+	return po6::net::location();
 }
 
 server::state_t
-configuration :: get_state(const server_id& id) const
+configuration :: get_state(const server_id &id) const
 {
-    for (size_t i = 0; i < m_servers.size(); ++i)
-    {
-        if (m_servers[i].id == id)
-        {
-            return m_servers[i].state;
-        }
-    }
-
-    return server::KILLED;
+	for (size_t i = 0; i < m_servers.size(); ++i)
+	{
+		if (m_servers[i].id == id)
+		{
+			return m_servers[i].state;
+		}
+	}
+	return server::KILLED;
 }
 
 region_id
-configuration :: get_region_id(const virtual_server_id& id) const
+configuration :: get_region_id(const virtual_server_id &id) const
 {
-    std::vector<pair_uint64_t>::const_iterator it;
-    it = std::lower_bound(m_region_ids_by_virtual.begin(),
-                          m_region_ids_by_virtual.end(),
-                          pair_uint64_t(id.get(), 0));
-
-    if (it != m_region_ids_by_virtual.end() && it->first == id.get())
-    {
-        return region_id(it->second);
-    }
-
-    return region_id();
+	std::vector<pair_uint64_t>::const_iterator it;
+	it = std::lower_bound(m_region_ids_by_virtual.begin(),
+	                      m_region_ids_by_virtual.end(),
+	                      pair_uint64_t(id.get(), 0));
+	if (it != m_region_ids_by_virtual.end() && it->first == id.get())
+	{
+		return region_id(it->second);
+	}
+	return region_id();
 }
 
 server_id
-configuration :: get_server_id(const virtual_server_id& id) const
+configuration :: get_server_id(const virtual_server_id &id) const
 {
-    std::vector<pair_uint64_t>::const_iterator it;
-    it = std::lower_bound(m_server_ids_by_virtual.begin(),
-                          m_server_ids_by_virtual.end(),
-                          pair_uint64_t(id.get(), 0));
-
-    if (it != m_server_ids_by_virtual.end() && it->first == id.get())
-    {
-        return server_id(it->second);
-    }
-
-    return server_id();
+	std::vector<pair_uint64_t>::const_iterator it;
+	it = std::lower_bound(m_server_ids_by_virtual.begin(),
+	                      m_server_ids_by_virtual.end(),
+	                      pair_uint64_t(id.get(), 0));
+	if (it != m_server_ids_by_virtual.end() && it->first == id.get())
+	{
+		return server_id(it->second);
+	}
+	return server_id();
 }
 
-const schema*
-configuration :: get_schema(const char* sname) const
+const schema *
+configuration :: get_schema(const char *sname) const
 {
-    for (size_t s = 0; s < m_spaces.size(); ++s)
-    {
-        if (strcmp(sname, m_spaces[s].name) == 0)
-        {
-            return &m_spaces[s].sc;
-        }
-    }
-
-    return NULL;
+	for (size_t s = 0; s < m_spaces.size(); ++s)
+	{
+		if (strcmp(sname, m_spaces[s].name) == 0)
+		{
+			return &m_spaces[s].sc;
+		}
+	}
+	return NULL;
 }
 
-const schema*
-configuration :: get_schema(const region_id& ri) const
+const schema *
+configuration :: get_schema(const region_id &ri) const
 {
-    std::vector<uint64_schema_t>::const_iterator it;
-    it = std::lower_bound(m_schemas_by_region.begin(),
-                          m_schemas_by_region.end(),
-                          uint64_schema_t(ri.get(), NULL));
-
-    if (it != m_schemas_by_region.end() && it->first == ri.get())
-    {
-        return it->second;
-    }
-
-    return NULL;
+	std::vector<uint64_schema_t>::const_iterator it;
+	it = std::lower_bound(m_schemas_by_region.begin(),
+	                      m_schemas_by_region.end(),
+	                      uint64_schema_t(ri.get(), NULL));
+	if (it != m_schemas_by_region.end() && it->first == ri.get())
+	{
+		return it->second;
+	}
+	return NULL;
 }
 
-const subspace*
-configuration :: get_subspace(const region_id& ri) const
+const subspace *
+configuration :: get_subspace(const region_id &ri) const
 {
-    std::vector<uint64_subspace_t>::const_iterator it;
-    it = std::lower_bound(m_subspaces_by_region.begin(),
-                          m_subspaces_by_region.end(),
-                          uint64_subspace_t(ri.get(), NULL));
-
-    if (it != m_subspaces_by_region.end() && it->first == ri.get())
-    {
-        return it->second;
-    }
-
-    return NULL;
+	std::vector<uint64_subspace_t>::const_iterator it;
+	it = std::lower_bound(m_subspaces_by_region.begin(),
+	                      m_subspaces_by_region.end(),
+	                      uint64_subspace_t(ri.get(), NULL));
+	if (it != m_subspaces_by_region.end() && it->first == ri.get())
+	{
+		return it->second;
+	}
+	return NULL;
 }
 
 virtual_server_id
-configuration :: get_virtual(const region_id& ri, const server_id& si) const
+configuration :: get_virtual(const region_id &ri, const server_id &si) const
 {
-    for (size_t w = 0; w < m_spaces.size(); ++w)
-    {
-        const space& s(m_spaces[w]);
-
-        for (size_t x = 0; x < s.subspaces.size(); ++x)
-        {
-            const subspace& ss(s.subspaces[x]);
-
-            for (size_t y = 0; y < ss.regions.size(); ++y)
-            {
-                const region& r(ss.regions[y]);
-
-                if (r.id != ri)
-                {
-                    continue;
-                }
-
-                for (size_t z = 0; z < r.replicas.size(); ++z)
-                {
-                    if (r.replicas[z].si == si)
-                    {
-                        return r.replicas[z].vsi;
-                    }
-                }
-
-                return virtual_server_id();
-            }
-        }
-    }
-
-    return virtual_server_id();
+	for (size_t w = 0; w < m_spaces.size(); ++w)
+	{
+		const space &s(m_spaces[w]);
+		for (size_t x = 0; x < s.subspaces.size(); ++x)
+		{
+			const subspace &ss(s.subspaces[x]);
+			for (size_t y = 0; y < ss.regions.size(); ++y)
+			{
+				const region &r(ss.regions[y]);
+				if (r.id != ri)
+				{
+					continue;
+				}
+				for (size_t z = 0; z < r.replicas.size(); ++z)
+				{
+					if (r.replicas[z].si == si)
+					{
+						return r.replicas[z].vsi;
+					}
+				}
+				return virtual_server_id();
+			}
+		}
+	}
+	return virtual_server_id();
 }
 
 subspace_id
-configuration :: subspace_of(const region_id& ri) const
+configuration :: subspace_of(const region_id &ri) const
 {
-    std::vector<pair_uint64_t>::const_iterator it;
-    it = std::lower_bound(m_subspace_ids_by_region.begin(),
-                          m_subspace_ids_by_region.end(),
-                          pair_uint64_t(ri.get(), 0));
-
-    if (it != m_subspace_ids_by_region.end() && it->first == ri.get())
-    {
-        return subspace_id(it->second);
-    }
-
-    return subspace_id();
+	std::vector<pair_uint64_t>::const_iterator it;
+	it = std::lower_bound(m_subspace_ids_by_region.begin(),
+	                      m_subspace_ids_by_region.end(),
+	                      pair_uint64_t(ri.get(), 0));
+	if (it != m_subspace_ids_by_region.end() && it->first == ri.get())
+	{
+		return subspace_id(it->second);
+	}
+	return subspace_id();
 }
 
 subspace_id
-configuration :: subspace_prev(const subspace_id& ss) const
+configuration :: subspace_prev(const subspace_id &ss) const
 {
-    std::vector<pair_uint64_t>::const_iterator it;
-    it = std::lower_bound(m_subspace_ids_for_prev.begin(),
-                          m_subspace_ids_for_prev.end(),
-                          pair_uint64_t(ss.get(), 0));
-
-    if (it != m_subspace_ids_for_prev.end() && it->first == ss.get())
-    {
-        return subspace_id(it->second);
-    }
-
-    return subspace_id();
+	std::vector<pair_uint64_t>::const_iterator it;
+	it = std::lower_bound(m_subspace_ids_for_prev.begin(),
+	                      m_subspace_ids_for_prev.end(),
+	                      pair_uint64_t(ss.get(), 0));
+	if (it != m_subspace_ids_for_prev.end() && it->first == ss.get())
+	{
+		return subspace_id(it->second);
+	}
+	return subspace_id();
 }
 
 subspace_id
-configuration :: subspace_next(const subspace_id& ss) const
+configuration :: subspace_next(const subspace_id &ss) const
 {
-    std::vector<pair_uint64_t>::const_iterator it;
-    it = std::lower_bound(m_subspace_ids_for_next.begin(),
-                          m_subspace_ids_for_next.end(),
-                          pair_uint64_t(ss.get(), 0));
-
-    if (it != m_subspace_ids_for_next.end() && it->first == ss.get())
-    {
-        return subspace_id(it->second);
-    }
-
-    return subspace_id();
+	std::vector<pair_uint64_t>::const_iterator it;
+	it = std::lower_bound(m_subspace_ids_for_next.begin(),
+	                      m_subspace_ids_for_next.end(),
+	                      pair_uint64_t(ss.get(), 0));
+	if (it != m_subspace_ids_for_next.end() && it->first == ss.get())
+	{
+		return subspace_id(it->second);
+	}
+	return subspace_id();
 }
 
 virtual_server_id
-configuration :: head_of_region(const region_id& ri) const
+configuration :: head_of_region(const region_id &ri) const
 {
-    std::vector<pair_uint64_t>::const_iterator it;
-    it = std::lower_bound(m_heads_by_region.begin(),
-                          m_heads_by_region.end(),
-                          pair_uint64_t(ri.get(), 0));
-
-    if (it != m_heads_by_region.end() && it->first == ri.get())
-    {
-        return virtual_server_id(it->second);
-    }
-
-    return virtual_server_id();
+	std::vector<pair_uint64_t>::const_iterator it;
+	it = std::lower_bound(m_heads_by_region.begin(),
+	                      m_heads_by_region.end(),
+	                      pair_uint64_t(ri.get(), 0));
+	if (it != m_heads_by_region.end() && it->first == ri.get())
+	{
+		return virtual_server_id(it->second);
+	}
+	return virtual_server_id();
 }
 
 virtual_server_id
-configuration :: tail_of_region(const region_id& ri) const
+configuration :: tail_of_region(const region_id &ri) const
 {
-    std::vector<pair_uint64_t>::const_iterator it;
-    it = std::lower_bound(m_tails_by_region.begin(),
-                          m_tails_by_region.end(),
-                          pair_uint64_t(ri.get(), 0));
-
-    if (it != m_tails_by_region.end() && it->first == ri.get())
-    {
-        return virtual_server_id(it->second);
-    }
-
-    return virtual_server_id();
+	std::vector<pair_uint64_t>::const_iterator it;
+	it = std::lower_bound(m_tails_by_region.begin(),
+	                      m_tails_by_region.end(),
+	                      pair_uint64_t(ri.get(), 0));
+	if (it != m_tails_by_region.end() && it->first == ri.get())
+	{
+		return virtual_server_id(it->second);
+	}
+	return virtual_server_id();
 }
 
 virtual_server_id
-configuration :: next_in_region(const virtual_server_id& vsi) const
+configuration :: next_in_region(const virtual_server_id &vsi) const
 {
-    std::vector<pair_uint64_t>::const_iterator it;
-    it = std::lower_bound(m_next_by_virtual.begin(),
-                          m_next_by_virtual.end(),
-                          pair_uint64_t(vsi.get(), 0));
-
-    if (it != m_next_by_virtual.end() && it->first == vsi.get())
-    {
-        return virtual_server_id(it->second);
-    }
-
-    return virtual_server_id();
+	std::vector<pair_uint64_t>::const_iterator it;
+	it = std::lower_bound(m_next_by_virtual.begin(),
+	                      m_next_by_virtual.end(),
+	                      pair_uint64_t(vsi.get(), 0));
+	if (it != m_next_by_virtual.end() && it->first == vsi.get())
+	{
+		return virtual_server_id(it->second);
+	}
+	return virtual_server_id();
 }
 
 void
-configuration :: point_leaders(const server_id& si, std::vector<region_id>* servers) const
+configuration :: point_leaders(const server_id &si, std::vector<region_id> *servers) const
 {
-    for (size_t s = 0; s < m_spaces.size(); ++s)
-    {
-        for (size_t r = 0; r < m_spaces[s].subspaces[0].regions.size(); ++r)
-        {
-            if (!m_spaces[s].subspaces[0].regions[r].replicas.empty() &&
-                m_spaces[s].subspaces[0].regions[r].replicas[0].si == si)
-            {
-                servers->push_back(m_spaces[s].subspaces[0].regions[r].id);
-            }
-        }
-    }
+	for (size_t s = 0; s < m_spaces.size(); ++s)
+	{
+		for (size_t r = 0; r < m_spaces[s].subspaces[0].regions.size(); ++r)
+		{
+			if (!m_spaces[s].subspaces[0].regions[r].replicas.empty() &&
+			    m_spaces[s].subspaces[0].regions[r].replicas[0].si == si)
+			{
+				servers->push_back(m_spaces[s].subspaces[0].regions[r].id);
+			}
+		}
+	}
 }
 
 void
-configuration :: key_regions(const server_id& si, std::vector<region_id>* regions) const
+configuration :: key_regions(const server_id &si, std::vector<region_id> *regions) const
 {
-    for (size_t s = 0; s < m_spaces.size(); ++s)
-    {
-        for (size_t r = 0; r < m_spaces[s].subspaces[0].regions.size(); ++r)
-        {
-            for (size_t R = 0; R < m_spaces[s].subspaces[0].regions[r].replicas.size(); ++R)
-            {
-                if (m_spaces[s].subspaces[0].regions[r].replicas[R].si == si)
-                {
-                    regions->push_back(m_spaces[s].subspaces[0].regions[r].id);
-                    break;
-                }
-            }
-        }
-    }
-
-    std::sort(regions->begin(), regions->end());
+	for (size_t s = 0; s < m_spaces.size(); ++s)
+	{
+		for (size_t r = 0; r < m_spaces[s].subspaces[0].regions.size(); ++r)
+		{
+			for (size_t R = 0; R < m_spaces[s].subspaces[0].regions[r].replicas.size(); ++R)
+			{
+				if (m_spaces[s].subspaces[0].regions[r].replicas[R].si == si)
+				{
+					regions->push_back(m_spaces[s].subspaces[0].regions[r].id);
+					break;
+				}
+			}
+		}
+	}
+	std::sort(regions->begin(), regions->end());
 }
 
 bool
-configuration :: is_point_leader(const virtual_server_id& e) const
+configuration :: is_point_leader(const virtual_server_id &e) const
 {
-    return std::binary_search(m_point_leaders_by_virtual.begin(),
-                              m_point_leaders_by_virtual.end(),
-                              e.get());
+	return std::binary_search(m_point_leaders_by_virtual.begin(),
+	                          m_point_leaders_by_virtual.end(),
+	                          e.get());
 }
 
 virtual_server_id
-configuration :: point_leader(const char* sname, const e::slice& key) const
+configuration :: point_leader(const char *sname, const e::slice &key) const
 {
-    for (size_t s = 0; s < m_spaces.size(); ++s)
-    {
-        if (strcmp(sname, m_spaces[s].name) != 0)
-        {
-            continue;
-        }
-
-        uint64_t h;
-        hash(m_spaces[s].sc, key, &h);
-
-        for (size_t pl = 0; pl < m_spaces[s].subspaces[0].regions.size(); ++pl)
-        {
-            if (m_spaces[s].subspaces[0].regions[pl].lower_coord[0] <= h &&
-                h <= m_spaces[s].subspaces[0].regions[pl].upper_coord[0])
-            {
-                if (m_spaces[s].subspaces[0].regions[pl].replicas.empty())
-                {
-                    return virtual_server_id();
-                }
-
-                return m_spaces[s].subspaces[0].regions[pl].replicas[0].vsi;
-            }
-        }
-
-        abort();
-    }
-
-    return virtual_server_id();
+	for (size_t s = 0; s < m_spaces.size(); ++s)
+	{
+		if (strcmp(sname, m_spaces[s].name) != 0)
+		{
+			continue;
+		}
+		uint64_t h;
+		hash(m_spaces[s].sc, key, &h);
+		for (size_t pl = 0; pl < m_spaces[s].subspaces[0].regions.size(); ++pl)
+		{
+			if (m_spaces[s].subspaces[0].regions[pl].lower_coord[0] <= h &&
+			    h <= m_spaces[s].subspaces[0].regions[pl].upper_coord[0])
+			{
+				if (m_spaces[s].subspaces[0].regions[pl].replicas.empty())
+				{
+					return virtual_server_id();
+				}
+				return m_spaces[s].subspaces[0].regions[pl].replicas[0].vsi;
+			}
+		}
+		abort();
+	}
+	return virtual_server_id();
 }
 
 virtual_server_id
-configuration :: point_leader(const region_id& rid, const e::slice& key) const
+configuration :: point_leader(const region_id &rid, const e::slice &key) const
 {
-    for (size_t s = 0; s < m_spaces.size(); ++s)
-    {
-        for (size_t ss = 0; ss < m_spaces[s].subspaces.size(); ++ss)
-        {
-            for (size_t r = 0; r < m_spaces[s].subspaces[ss].regions.size(); ++r)
-            {
-                if (m_spaces[s].subspaces[ss].regions[r].id != rid)
-                {
-                    continue;
-                }
-
-                uint64_t h;
-                hash(m_spaces[s].sc, key, &h);
-
-                for (size_t pl = 0; pl < m_spaces[s].subspaces[0].regions.size(); ++pl)
-                {
-                    if (m_spaces[s].subspaces[0].regions[pl].lower_coord[0] <= h &&
-                        h <= m_spaces[s].subspaces[0].regions[pl].upper_coord[0])
-                    {
-                        if (m_spaces[s].subspaces[0].regions[pl].replicas.empty())
-                        {
-                            return virtual_server_id();
-                        }
-
-                        return m_spaces[s].subspaces[0].regions[pl].replicas[0].vsi;
-                    }
-                }
-
-                abort();
-            }
-        }
-    }
-
-    return virtual_server_id();
+	for (size_t s = 0; s < m_spaces.size(); ++s)
+	{
+		for (size_t ss = 0; ss < m_spaces[s].subspaces.size(); ++ss)
+		{
+			for (size_t r = 0; r < m_spaces[s].subspaces[ss].regions.size(); ++r)
+			{
+				if (m_spaces[s].subspaces[ss].regions[r].id != rid)
+				{
+					continue;
+				}
+				uint64_t h;
+				hash(m_spaces[s].sc, key, &h);
+				for (size_t pl = 0; pl < m_spaces[s].subspaces[0].regions.size(); ++pl)
+				{
+					if (m_spaces[s].subspaces[0].regions[pl].lower_coord[0] <= h &&
+					    h <= m_spaces[s].subspaces[0].regions[pl].upper_coord[0])
+					{
+						if (m_spaces[s].subspaces[0].regions[pl].replicas.empty())
+						{
+							return virtual_server_id();
+						}
+						return m_spaces[s].subspaces[0].regions[pl].replicas[0].vsi;
+					}
+				}
+				abort();
+			}
+		}
+	}
+	return virtual_server_id();
 }
 
 bool
-configuration :: subspace_adjacent(const virtual_server_id& lhs, const virtual_server_id& rhs) const
+configuration :: subspace_adjacent(const virtual_server_id &lhs, const virtual_server_id &rhs) const
 {
-    region_id rlhs = get_region_id(lhs);
-    region_id rrhs = get_region_id(rhs);
-    subspace_id slhs = subspace_of(rlhs);
-    subspace_id srhs = subspace_of(rrhs);
-    return subspace_next(slhs) == srhs &&
-           lhs == tail_of_region(rlhs) &&
-           rhs == head_of_region(rrhs);
+	region_id rlhs = get_region_id(lhs);
+	region_id rrhs = get_region_id(rhs);
+	subspace_id slhs = subspace_of(rlhs);
+	subspace_id srhs = subspace_of(rrhs);
+	return subspace_next(slhs) == srhs &&
+	       lhs == tail_of_region(rlhs) &&
+	       rhs == head_of_region(rrhs);
 }
 
 void
-configuration :: mapped_regions(const server_id& si, std::vector<region_id>* servers) const
+configuration :: mapped_regions(const server_id &si, std::vector<region_id> *servers) const
 {
-    for (size_t s = 0; s < m_spaces.size(); ++s)
-    {
-        for (size_t ss = 0; ss < m_spaces[s].subspaces.size(); ++ss)
-        {
-            for (size_t r = 0; r < m_spaces[s].subspaces[ss].regions.size(); ++r)
-            {
-                for (size_t R = 0; R < m_spaces[s].subspaces[ss].regions[r].replicas.size(); ++R)
-                {
-                    if (m_spaces[s].subspaces[ss].regions[r].replicas[R].si == si)
-                    {
-                        servers->push_back(m_spaces[s].subspaces[ss].regions[r].id);
-                        break;
-                    }
-                }
-            }
-        }
-    }
-
-    std::sort(servers->begin(), servers->end());
+	for (size_t s = 0; s < m_spaces.size(); ++s)
+	{
+		for (size_t ss = 0; ss < m_spaces[s].subspaces.size(); ++ss)
+		{
+			for (size_t r = 0; r < m_spaces[s].subspaces[ss].regions.size(); ++r)
+			{
+				for (size_t R = 0; R < m_spaces[s].subspaces[ss].regions[r].replicas.size(); ++R)
+				{
+					if (m_spaces[s].subspaces[ss].regions[r].replicas[R].si == si)
+					{
+						servers->push_back(m_spaces[s].subspaces[ss].regions[r].id);
+						break;
+					}
+				}
+			}
+		}
+	}
+	std::sort(servers->begin(), servers->end());
 }
 
-const hyperdex::index*
-configuration :: get_index(const index_id& ii) const
+const hyperdex::index *
+configuration :: get_index(const index_id &ii) const
 {
-    for (size_t s = 0; s < m_spaces.size(); ++s)
-    {
-        for (size_t i = 0; i < m_spaces[s].indices.size(); ++i)
-        {
-            if (m_spaces[s].indices[i].id == ii)
-            {
-                return &m_spaces[s].indices[i];
-            }
-        }
-    }
-
-    return NULL;
+	for (size_t s = 0; s < m_spaces.size(); ++s)
+	{
+		for (size_t i = 0; i < m_spaces[s].indices.size(); ++i)
+		{
+			if (m_spaces[s].indices[i].id == ii)
+			{
+				return &m_spaces[s].indices[i];
+			}
+		}
+	}
+	return NULL;
 }
 
 void
-configuration :: all_indices(const server_id& si, std::vector<std::pair<region_id, index_id> >* indices) const
+configuration :: all_indices(const server_id &si, std::vector<std::pair<region_id, index_id> > *indices) const
 {
-    for (size_t s = 0; s < m_spaces.size(); ++s)
-    {
-        for (size_t ss = 0; ss < m_spaces[s].subspaces.size(); ++ss)
-        {
-            for (size_t r = 0; r < m_spaces[s].subspaces[ss].regions.size(); ++r)
-            {
-                bool found = false;
-
-                for (size_t R = 0; !found && R < m_spaces[s].subspaces[ss].regions[r].replicas.size(); ++R)
-                {
-                    if (m_spaces[s].subspaces[ss].regions[r].replicas[R].si == si)
-                    {
-                        found = true;
-                        break;
-                    }
-                }
-
-                for (size_t i = 0; !found && i < m_transfers.size(); ++i)
-                {
-                    if (m_transfers[i].dst == si &&
-                        m_transfers[i].rid == m_spaces[s].subspaces[ss].regions[r].id)
-                    {
-                        found = true;
-                    }
-                }
-
-                if (found)
-                {
-                    for (size_t i = 0; i < m_spaces[s].indices.size(); ++i)
-                    {
-                        indices->push_back(std::make_pair(m_spaces[s].subspaces[ss].regions[r].id,
-                                                          m_spaces[s].indices[i].id));
-                    }
-                }
-            }
-        }
-    }
+	for (size_t s = 0; s < m_spaces.size(); ++s)
+	{
+		for (size_t ss = 0; ss < m_spaces[s].subspaces.size(); ++ss)
+		{
+			for (size_t r = 0; r < m_spaces[s].subspaces[ss].regions.size(); ++r)
+			{
+				bool found = false;
+				for (size_t R = 0; !found && R < m_spaces[s].subspaces[ss].regions[r].replicas.size(); ++R)
+				{
+					if (m_spaces[s].subspaces[ss].regions[r].replicas[R].si == si)
+					{
+						found = true;
+						break;
+					}
+				}
+				for (size_t i = 0; !found && i < m_transfers.size(); ++i)
+				{
+					if (m_transfers[i].dst == si &&
+					    m_transfers[i].rid == m_spaces[s].subspaces[ss].regions[r].id)
+					{
+						found = true;
+					}
+				}
+				if (found)
+				{
+					for (size_t i = 0; i < m_spaces[s].indices.size(); ++i)
+					{
+						indices->push_back(std::make_pair(m_spaces[s].subspaces[ss].regions[r].id,
+						                                  m_spaces[s].indices[i].id));
+					}
+				}
+			}
+		}
+	}
 }
 
 bool
-configuration :: is_server_involved_in_transfer(const server_id& si, const region_id& ri) const
+configuration :: is_server_involved_in_transfer(const server_id &si, const region_id &ri) const
 {
-    for (size_t i = 0; i < m_transfers.size(); ++i)
-    {
-        if (m_transfers[i].rid == ri &&
-            (m_transfers[i].src == si || m_transfers[i].dst == si))
-        {
-            return true;
-        }
-    }
-
-    return false;
+	for (size_t i = 0; i < m_transfers.size(); ++i)
+	{
+		if (m_transfers[i].rid == ri &&
+		    (m_transfers[i].src == si || m_transfers[i].dst == si))
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 bool
-configuration :: is_server_blocked_by_live_transfer(const server_id& si, const region_id& id) const
+configuration :: is_server_blocked_by_live_transfer(const server_id &si, const region_id &id) const
 {
-    for (size_t i = 0; i < m_transfers.size(); ++i)
-    {
-        if (m_transfers[i].src != si || m_transfers[i].rid != id)
-        {
-            continue;
-        }
-
-        virtual_server_id tail = tail_of_region(m_transfers[i].rid);
-
-        if (tail == m_transfers[i].vdst)
-        {
-            return true;
-        }
-
-        assert(tail == m_transfers[i].vsrc);
-    }
-
-    return false;
+	for (size_t i = 0; i < m_transfers.size(); ++i)
+	{
+		if (m_transfers[i].src != si || m_transfers[i].rid != id)
+		{
+			continue;
+		}
+		virtual_server_id tail = tail_of_region(m_transfers[i].rid);
+		if (tail == m_transfers[i].vdst)
+		{
+			return true;
+		}
+		assert(tail == m_transfers[i].vsrc);
+	}
+	return false;
 }
 
 bool
-configuration :: is_transfer_live(const transfer_id& id) const
+configuration :: is_transfer_live(const transfer_id &id) const
 {
-    for (size_t i = 0; i < m_transfers.size(); ++i)
-    {
-        if (m_transfers[i].id != id)
-        {
-            continue;
-        }
-
-        return m_transfers[i].vdst == tail_of_region(m_transfers[i].rid);
-    }
-
-    return false;
+	for (size_t i = 0; i < m_transfers.size(); ++i)
+	{
+		if (m_transfers[i].id != id)
+		{
+			continue;
+		}
+		return m_transfers[i].vdst == tail_of_region(m_transfers[i].rid);
+	}
+	return false;
 }
 
 void
-configuration :: transfers_in(const server_id& si, std::vector<transfer>* transfers) const
+configuration :: transfers_in(const server_id &si, std::vector<transfer> *transfers) const
 {
-    for (size_t i = 0; i < m_transfers.size(); ++i)
-    {
-        if (m_transfers[i].dst == si)
-        {
-            transfers->push_back(m_transfers[i]);
-        }
-    }
+	for (size_t i = 0; i < m_transfers.size(); ++i)
+	{
+		if (m_transfers[i].dst == si)
+		{
+			transfers->push_back(m_transfers[i]);
+		}
+	}
 }
 
 void
-configuration :: transfers_out(const server_id& si, std::vector<transfer>* transfers) const
+configuration :: transfers_out(const server_id &si, std::vector<transfer> *transfers) const
 {
-    for (size_t i = 0; i < m_transfers.size(); ++i)
-    {
-        if (m_transfers[i].src == si)
-        {
-            transfers->push_back(m_transfers[i]);
-        }
-    }
+	for (size_t i = 0; i < m_transfers.size(); ++i)
+	{
+		if (m_transfers[i].src == si)
+		{
+			transfers->push_back(m_transfers[i]);
+		}
+	}
 }
 
 void
-configuration :: transfers_in_regions(const server_id& si, std::vector<region_id>* transfers) const
+configuration :: transfers_in_regions(const server_id &si, std::vector<region_id> *transfers) const
 {
-    for (size_t i = 0; i < m_transfers.size(); ++i)
-    {
-        if (m_transfers[i].dst == si)
-        {
-            transfers->push_back(m_transfers[i].rid);
-        }
-    }
-
-    std::sort(transfers->begin(), transfers->end());
+	for (size_t i = 0; i < m_transfers.size(); ++i)
+	{
+		if (m_transfers[i].dst == si)
+		{
+			transfers->push_back(m_transfers[i].rid);
+		}
+	}
+	std::sort(transfers->begin(), transfers->end());
 }
 
 void
-configuration :: transfers_out_regions(const server_id& si, std::vector<region_id>* transfers) const
+configuration :: transfers_out_regions(const server_id &si, std::vector<region_id> *transfers) const
 {
-    for (size_t i = 0; i < m_transfers.size(); ++i)
-    {
-        if (m_transfers[i].src == si)
-        {
-            transfers->push_back(m_transfers[i].rid);
-        }
-    }
+	for (size_t i = 0; i < m_transfers.size(); ++i)
+	{
+		if (m_transfers[i].src == si)
+		{
+			transfers->push_back(m_transfers[i].rid);
+		}
+	}
 }
 
 void
-configuration :: lookup_region(const subspace_id& ssid,
-                               const std::vector<uint64_t>& hashes,
-                               region_id* rid) const
+configuration :: lookup_region(const subspace_id &ssid,
+                               const std::vector<uint64_t> &hashes,
+                               region_id *rid) const
 {
-    for (size_t s = 0; s < m_spaces.size(); ++s)
-    {
-        for (size_t ss = 0; ss < m_spaces[s].subspaces.size(); ++ss)
-        {
-            if (m_spaces[s].subspaces[ss].id != ssid)
-            {
-                continue;
-            }
-
-            assert(m_spaces[s].sc.attrs_sz == hashes.size());
-
-            for (size_t r = 0; r < m_spaces[s].subspaces[ss].regions.size(); ++r)
-            {
-                bool matches = true;
-
-                for (size_t a = 0; matches && a < m_spaces[s].subspaces[ss].attrs.size(); ++a)
-                {
-                    assert(a < m_spaces[s].sc.attrs_sz);
-                    matches &= m_spaces[s].subspaces[ss].regions[r].lower_coord[a] <= hashes[m_spaces[s].subspaces[ss].attrs[a]] &&
-                               hashes[m_spaces[s].subspaces[ss].attrs[a]] <= m_spaces[s].subspaces[ss].regions[r].upper_coord[a];
-                }
-
-                if (matches)
-                {
-                    *rid = m_spaces[s].subspaces[ss].regions[r].id;
-                    return;
-                }
-            }
-        }
-    }
-
-    *rid = region_id();
+	for (size_t s = 0; s < m_spaces.size(); ++s)
+	{
+		for (size_t ss = 0; ss < m_spaces[s].subspaces.size(); ++ss)
+		{
+			if (m_spaces[s].subspaces[ss].id != ssid)
+			{
+				continue;
+			}
+			assert(m_spaces[s].sc.attrs_sz == hashes.size());
+			for (size_t r = 0; r < m_spaces[s].subspaces[ss].regions.size(); ++r)
+			{
+				bool matches = true;
+				for (size_t a = 0; matches && a < m_spaces[s].subspaces[ss].attrs.size(); ++a)
+				{
+					assert(a < m_spaces[s].sc.attrs_sz);
+					matches &= m_spaces[s].subspaces[ss].regions[r].lower_coord[a] <= hashes[m_spaces[s].subspaces[ss].attrs[a]] &&
+					           hashes[m_spaces[s].subspaces[ss].attrs[a]] <= m_spaces[s].subspaces[ss].regions[r].upper_coord[a];
+				}
+				if (matches)
+				{
+					*rid = m_spaces[s].subspaces[ss].regions[r].id;
+					return;
+				}
+			}
+		}
+	}
+	*rid = region_id();
 }
 
 void
-configuration :: lookup_search(const char* space_name,
-                               const std::vector<attribute_check>& chks,
-                               std::vector<virtual_server_id>* servers) const
+configuration :: lookup_search(const char *space_name,
+                               const std::vector<attribute_check> &chks,
+                               std::vector<virtual_server_id> *servers) const
 {
-    const space* s = NULL;
-
-    for (size_t i = 0; i < m_spaces.size(); ++i)
-    {
-        if (strcmp(space_name, m_spaces[i].name) == 0)
-        {
-            s = &m_spaces[i];
-            break;
-        }
-    }
-
-    if (!s)
-    {
-        servers->clear();
-        return;
-    }
-
-    std::vector<range> ranges;
-    range_searches(s->sc, chks, &ranges);
-
-    for (size_t i = 0; i < ranges.size(); ++i)
-    {
-        if (ranges[i].invalid)
-        {
-            servers->clear();
-            return;
-        }
-    }
-
-    bool initialized = false;
-    std::vector<virtual_server_id> smallest_server_set;
-
-    for (size_t i = 0; i < s->subspaces.size(); ++i)
-    {
-        std::vector<virtual_server_id> this_server_set;
-
-        for (size_t j = 0; j < s->subspaces[i].regions.size(); ++j)
-        {
-            const region& reg(s->subspaces[i].regions[j]);
-
-            if (reg.replicas.empty())
-            {
-                continue;
-            }
-
-            bool exclude = false;
-
-            for (size_t k = 0; !exclude && k < ranges.size(); ++k)
-            {
-                assert(reg.lower_coord.size() == reg.upper_coord.size());
-                uint16_t attr = UINT16_MAX;
-
-                for (size_t l = 0; l < s->subspaces[i].attrs.size(); ++l)
-                {
-                    if (s->subspaces[i].attrs[l] == ranges[k].attr)
-                    {
-                        attr = l;
-                        break;
-                    }
-                }
-
-                if (attr == UINT16_MAX)
-                {
-                    continue;
-                }
-
-                if (attr >= reg.lower_coord.size() ||
-                    reg.lower_coord[attr] > reg.upper_coord[attr])
-                {
-                    servers->clear();
-                    return;
-                }
-
-                if (ranges[k].type == HYPERDATATYPE_STRING &&
-                    ranges[k].has_start && ranges[k].has_end &&
-                    ranges[k].start == ranges[k].end)
-                {
-                    uint64_t h = hash(ranges[k].type, ranges[k].start);
-
-                    if (reg.lower_coord[attr] > h ||
-                        reg.upper_coord[attr] < h)
-                    {
-                        exclude = true;
-                    }
-                }
-
-                if (ranges[k].type == HYPERDATATYPE_INT64 ||
-                    ranges[k].type == HYPERDATATYPE_FLOAT)
-                {
-                    if (ranges[k].has_start)
-                    {
-                        uint64_t h = hash(ranges[k].type, ranges[k].start);
-
-                        if (reg.upper_coord[attr] < h)
-                        {
-                            exclude = true;
-                        }
-                    }
-
-                    if (ranges[k].has_end)
-                    {
-                        uint64_t h = hash(ranges[k].type, ranges[k].end);
-
-                        if (reg.lower_coord[attr] > h)
-                        {
-                            exclude = true;
-                        }
-                    }
-                }
-            }
-
-            if (!exclude)
-            {
-                this_server_set.push_back(reg.replicas.back().vsi);
-            }
-        }
-
-        if (!initialized ||
-            (!this_server_set.empty() &&
-             this_server_set.size() <= smallest_server_set.size()))
-        {
-            smallest_server_set.swap(this_server_set);
-            initialized = true;
-        }
-    }
-
-    servers->swap(smallest_server_set);
+	const space *s = NULL;
+	for (size_t i = 0; i < m_spaces.size(); ++i)
+	{
+		if (strcmp(space_name, m_spaces[i].name) == 0)
+		{
+			s = &m_spaces[i];
+			break;
+		}
+	}
+	if (!s)
+	{
+		servers->clear();
+		return;
+	}
+	std::vector<range> ranges;
+	range_searches(s->sc, chks, &ranges);
+	for (size_t i = 0; i < ranges.size(); ++i)
+	{
+		if (ranges[i].invalid)
+		{
+			servers->clear();
+			return;
+		}
+	}
+	bool initialized = false;
+	std::vector<virtual_server_id> smallest_server_set;
+	for (size_t i = 0; i < s->subspaces.size(); ++i)
+	{
+		std::vector<virtual_server_id> this_server_set;
+		for (size_t j = 0; j < s->subspaces[i].regions.size(); ++j)
+		{
+			const region &reg(s->subspaces[i].regions[j]);
+			if (reg.replicas.empty())
+			{
+				continue;
+			}
+			bool exclude = false;
+			for (size_t k = 0; !exclude && k < ranges.size(); ++k)
+			{
+				assert(reg.lower_coord.size() == reg.upper_coord.size());
+				uint16_t attr = UINT16_MAX;
+				for (size_t l = 0; l < s->subspaces[i].attrs.size(); ++l)
+				{
+					if (s->subspaces[i].attrs[l] == ranges[k].attr)
+					{
+						attr = l;
+						break;
+					}
+				}
+				if (attr == UINT16_MAX)
+				{
+					continue;
+				}
+				if (attr >= reg.lower_coord.size() ||
+				    reg.lower_coord[attr] > reg.upper_coord[attr])
+				{
+					servers->clear();
+					return;
+				}
+				if (ranges[k].type == HYPERDATATYPE_STRING &&
+				    ranges[k].has_start && ranges[k].has_end &&
+				    ranges[k].start == ranges[k].end)
+				{
+					uint64_t h = hash(ranges[k].type, ranges[k].start);
+					if (reg.lower_coord[attr] > h ||
+					    reg.upper_coord[attr] < h)
+					{
+						exclude = true;
+					}
+				}
+				if (ranges[k].type == HYPERDATATYPE_INT64 ||
+				    ranges[k].type == HYPERDATATYPE_FLOAT)
+				{
+					if (ranges[k].has_start)
+					{
+						uint64_t h = hash(ranges[k].type, ranges[k].start);
+						if (reg.upper_coord[attr] < h)
+						{
+							exclude = true;
+						}
+					}
+					if (ranges[k].has_end)
+					{
+						uint64_t h = hash(ranges[k].type, ranges[k].end);
+						if (reg.lower_coord[attr] > h)
+						{
+							exclude = true;
+						}
+					}
+				}
+			}
+			if (!exclude)
+			{
+				this_server_set.push_back(reg.replicas.back().vsi);
+			}
+		}
+		if (!initialized ||
+		    (!this_server_set.empty() &&
+		     this_server_set.size() <= smallest_server_set.size()))
+		{
+			smallest_server_set.swap(this_server_set);
+			initialized = true;
+		}
+	}
+	servers->swap(smallest_server_set);
 }
 
 std::string
-configuration :: list_indices(const char* space_name) const
+configuration :: list_indices(const char *space_name) const
 {
-    std::ostringstream out;
-    ssize_t pos = -1;
-
-    for (size_t w = 0; w < m_spaces.size() && pos == -1; ++w)
-    {
-        if(strcmp(m_spaces[w].name, space_name) == 0)
-        {
-            pos = w;
-        }
-    }
-
-    if(pos < 0)
-    {
-        return "";
-    }
-
-    const space& s(m_spaces[pos]);
-
-    for(std::vector<index>::const_iterator it = s.indices.begin(); it != s.indices.end(); ++it)
-    {
-        out << it->id.get() << ":";
-        out << s.get_attribute(it->attr).name;
-        out << "\n";
-    }
-
-    return out.str();
+	std::ostringstream out;
+	ssize_t pos = -1;
+	for (size_t w = 0; w < m_spaces.size() && pos == -1; ++w)
+	{
+		if (strcmp(m_spaces[w].name, space_name) == 0)
+		{
+			pos = w;
+		}
+	}
+	if (pos < 0)
+	{
+		return "";
+	}
+	const space &s(m_spaces[pos]);
+	for (std::vector<index>::const_iterator it = s.indices.begin(); it != s.indices.end(); ++it)
+	{
+		out << it->id.get() << ":";
+		out << s.get_attribute(it->attr).name;
+		out << "\n";
+	}
+	return out.str();
 }
 
 std::string
-configuration :: list_subspaces(const char* space_name) const
+configuration :: list_subspaces(const char *space_name) const
 {
-    std::ostringstream out;
-    ssize_t pos = -1;
-
-    for (size_t w = 0; w < m_spaces.size() && pos == -1; ++w)
-    {
-        if(strcmp(m_spaces[w].name, space_name) == 0)
-        {
-            pos = w;
-        }
-    }
-
-    if(pos < 0)
-    {
-        return "";
-    }
-
-    const space& s(m_spaces[pos]);
-
-    for(std::vector<subspace>::const_iterator it = s.subspaces.begin(); it != s.subspaces.end(); ++it)
-    {
-        out << it->id.get() << ":";
-
-        for(std::vector<uint16_t>::const_iterator it2 = it->attrs.begin(); it2 != it->attrs.end(); ++it2)
-        {
-            if(it2 != it->attrs.begin())
-                out << ",";
-
-            out << s.get_attribute(*it2).name;
-        }
-
-        out << "\n";
-    }
-
-    return out.str();
+	std::ostringstream out;
+	ssize_t pos = -1;
+	for (size_t w = 0; w < m_spaces.size() && pos == -1; ++w)
+	{
+		if (strcmp(m_spaces[w].name, space_name) == 0)
+		{
+			pos = w;
+		}
+	}
+	if (pos < 0)
+	{
+		return "";
+	}
+	const space &s(m_spaces[pos]);
+	for (std::vector<subspace>::const_iterator it = s.subspaces.begin(); it != s.subspaces.end(); ++it)
+	{
+		out << it->id.get() << ":";
+		for (std::vector<uint16_t>::const_iterator it2 = it->attrs.begin(); it2 != it->attrs.end(); ++it2)
+		{
+			if (it2 != it->attrs.begin())
+				out << ",";
+			out << s.get_attribute(*it2).name;
+		}
+		out << "\n";
+	}
+	return out.str();
 }
 
 std::string
 configuration :: dump() const
 {
-    std::ostringstream out;
-    out << "cluster " << m_cluster << "\n";
-    out << "version " << m_version << "\n";
-    out << "flags " << std::hex << m_flags << std::dec << "\n";
-
-    for (size_t i = 0; i < m_servers.size(); ++i)
-    {
-        out << "server "
-            << m_servers[i].id.get() << " "
-            << m_servers[i].bind_to << " "
-            << server::to_string(m_servers[i].state) << "\n";
-    }
-
-    for (size_t w = 0; w < m_spaces.size(); ++w)
-    {
-        const space& s(m_spaces[w]);
-        out << "space " << s.id.get() << " " << s.name << "\n";
-        out << "  fault_tolerance " << s.fault_tolerance << "\n";
-        out << "  predecessor_width " << s.predecessor_width << "\n";
-        out << "  schema" << "\n";
-
-        for (size_t i = 0; i < s.sc.attrs_sz; ++i)
-        {
-            out << "    attribute "
-                << s.sc.attrs[i].name << " "
-                << s.sc.attrs[i].type << "\n";
-        }
-
-        if (s.sc.authorization)
-        {
-            out << "    with authorization\n";
-        }
-
-        for (size_t x = 0; x < s.subspaces.size(); ++x)
-        {
-            const subspace& ss(s.subspaces[x]);
-            out << "  subspace " << ss.id.get() << "\n";
-            out << "    attributes";
-
-            for (size_t i = 0; i < ss.attrs.size(); ++i)
-            {
-                out << " " << s.sc.attrs[ss.attrs[i]].name;
-            }
-
-            out << "\n";
-
-            for (size_t y = 0; y < ss.regions.size(); ++y)
-            {
-                const region& r(ss.regions[y]);
-                out << "    region " << r.id.get() << " lower=(";
-
-                for (size_t i = 0; i < r.lower_coord.size(); ++i)
-                {
-                    out << r.lower_coord[i] << ",";
-                }
-
-                out << ") upper=(";
-
-                for (size_t i = 0; i < r.upper_coord.size(); ++i)
-                {
-                    out << r.upper_coord[i] << ",";
-                }
-
-                out << ") replicas=[";
-                bool first = true;
-
-                for (size_t z = 0; z < r.replicas.size(); ++z)
-                {
-                    const replica& rr(r.replicas[z]);
-                    out << (first ? "" : ", ") << rr.si << "/" << rr.vsi;
-                    first = false;
-                }
-
-                out << "]" << std::endl;
-            }
-        }
-
-        for (size_t x = 0; x < s.indices.size(); ++x)
-        {
-            const index& idx(s.indices[x]);
-            out << "  index " << idx.id.get() << " attribute " << idx.attr;
-
-            if (idx.type == index::DOCUMENT)
-            {
-                out << " " << idx.extra.str();
-            }
-
-            out << "\n";
-        }
-    }
-
-    for (size_t i = 0; i < m_transfers.size(); ++i)
-    {
-        out << m_transfers[i] << std::endl;
-    }
-
-    return out.str();
+	std::ostringstream out;
+	out << "cluster " << m_cluster << "\n";
+	out << "version " << m_version << "\n";
+	out << "flags " << std::hex << m_flags << std::dec << "\n";
+	for (size_t i = 0; i < m_servers.size(); ++i)
+	{
+		out << "server "
+		    << m_servers[i].id.get() << " "
+		    << m_servers[i].bind_to << " "
+		    << server::to_string(m_servers[i].state) << "\n";
+	}
+	for (size_t w = 0; w < m_spaces.size(); ++w)
+	{
+		const space &s(m_spaces[w]);
+		out << "space " << s.id.get() << " " << s.name << "\n";
+		out << "  fault_tolerance " << s.fault_tolerance << "\n";
+		out << "  predecessor_width " << s.predecessor_width << "\n";
+		out << "  schema" << "\n";
+		for (size_t i = 0; i < s.sc.attrs_sz; ++i)
+		{
+			out << "    attribute "
+			    << s.sc.attrs[i].name << " "
+			    << s.sc.attrs[i].type << "\n";
+		}
+		if (s.sc.authorization)
+		{
+			out << "    with authorization\n";
+		}
+		for (size_t x = 0; x < s.subspaces.size(); ++x)
+		{
+			const subspace &ss(s.subspaces[x]);
+			out << "  subspace " << ss.id.get() << "\n";
+			out << "    attributes";
+			for (size_t i = 0; i < ss.attrs.size(); ++i)
+			{
+				out << " " << s.sc.attrs[ss.attrs[i]].name;
+			}
+			out << "\n";
+			for (size_t y = 0; y < ss.regions.size(); ++y)
+			{
+				const region &r(ss.regions[y]);
+				out << "    region " << r.id.get() << " lower=(";
+				for (size_t i = 0; i < r.lower_coord.size(); ++i)
+				{
+					out << r.lower_coord[i] << ",";
+				}
+				out << ") upper=(";
+				for (size_t i = 0; i < r.upper_coord.size(); ++i)
+				{
+					out << r.upper_coord[i] << ",";
+				}
+				out << ") replicas=[";
+				bool first = true;
+				for (size_t z = 0; z < r.replicas.size(); ++z)
+				{
+					const replica &rr(r.replicas[z]);
+					out << (first ? "" : ", ") << rr.si << "/" << rr.vsi;
+					first = false;
+				}
+				out << "]" << std::endl;
+			}
+		}
+		for (size_t x = 0; x < s.indices.size(); ++x)
+		{
+			const index &idx(s.indices[x]);
+			out << "  index " << idx.id.get() << " attribute " << idx.attr;
+			if (idx.type == index::DOCUMENT)
+			{
+				out << " " << idx.extra.str();
+			}
+			out << "\n";
+		}
+	}
+	for (size_t i = 0; i < m_transfers.size(); ++i)
+	{
+		out << m_transfers[i] << std::endl;
+	}
+	return out.str();
 }
 
 std::string
 configuration :: list_spaces() const
 {
-    std::ostringstream out;
-
-    for (size_t i = 0; i < m_spaces.size(); ++i)
-    {
-        out << m_spaces[i].name << std::endl;
-    }
-
-    return out.str();
+	std::ostringstream out;
+	for (size_t i = 0; i < m_spaces.size(); ++i)
+	{
+		out << m_spaces[i].name << std::endl;
+	}
+	return out.str();
 }
 
-configuration&
-configuration :: operator = (const configuration& rhs)
+configuration &
+configuration :: operator = (const configuration &rhs)
 {
-    if (this == &rhs)
-    {
-        return *this;
-    }
-
-    m_cluster = rhs.m_cluster;
-    m_version = rhs.m_version;
-    m_flags = rhs.m_flags;
-    m_servers = rhs.m_servers;
-    m_region_ids_by_virtual = rhs.m_region_ids_by_virtual;
-    m_server_ids_by_virtual = rhs.m_server_ids_by_virtual;
-    m_schemas_by_region = rhs.m_schemas_by_region;
-    m_subspaces_by_region = rhs.m_subspaces_by_region;
-    m_subspace_ids_by_region = rhs.m_subspace_ids_by_region;
-    m_subspace_ids_for_prev = rhs.m_subspace_ids_for_prev;
-    m_subspace_ids_for_next = rhs.m_subspace_ids_for_next;
-    m_heads_by_region = rhs.m_heads_by_region;
-    m_tails_by_region = rhs.m_tails_by_region;
-    m_next_by_virtual = rhs.m_next_by_virtual;
-    m_point_leaders_by_virtual = rhs.m_point_leaders_by_virtual;
-    m_spaces = rhs.m_spaces;
-    m_transfers = rhs.m_transfers;
-    refill_cache();
-    return *this;
+	if (this == &rhs)
+	{
+		return *this;
+	}
+	m_cluster = rhs.m_cluster;
+	m_version = rhs.m_version;
+	m_flags = rhs.m_flags;
+	m_servers = rhs.m_servers;
+	m_region_ids_by_virtual = rhs.m_region_ids_by_virtual;
+	m_server_ids_by_virtual = rhs.m_server_ids_by_virtual;
+	m_schemas_by_region = rhs.m_schemas_by_region;
+	m_subspaces_by_region = rhs.m_subspaces_by_region;
+	m_subspace_ids_by_region = rhs.m_subspace_ids_by_region;
+	m_subspace_ids_for_prev = rhs.m_subspace_ids_for_prev;
+	m_subspace_ids_for_next = rhs.m_subspace_ids_for_next;
+	m_heads_by_region = rhs.m_heads_by_region;
+	m_tails_by_region = rhs.m_tails_by_region;
+	m_next_by_virtual = rhs.m_next_by_virtual;
+	m_point_leaders_by_virtual = rhs.m_point_leaders_by_virtual;
+	m_spaces = rhs.m_spaces;
+	m_transfers = rhs.m_transfers;
+	refill_cache();
+	return *this;
 }
 
 void
 configuration :: refill_cache()
 {
-    m_region_ids_by_virtual.clear();
-    m_server_ids_by_virtual.clear();
-    m_schemas_by_region.clear();
-    m_subspaces_by_region.clear();
-    m_subspace_ids_by_region.clear();
-    m_subspace_ids_for_prev.clear();
-    m_subspace_ids_for_next.clear();
-    m_heads_by_region.clear();
-    m_tails_by_region.clear();
-    m_next_by_virtual.clear();
-    m_point_leaders_by_virtual.clear();
-
-    for (size_t w = 0; w < m_spaces.size(); ++w)
-    {
-        space& s(m_spaces[w]);
-
-        for (size_t x = 0; x < s.subspaces.size(); ++x)
-        {
-            subspace& ss(s.subspaces[x]);
-
-            if (x > 0)
-            {
-                m_subspace_ids_for_prev.push_back(std::make_pair(ss.id.get(),
-                                                                 s.subspaces[x - 1].id.get()));
-            }
-
-            if (x + 1 < s.subspaces.size())
-            {
-                m_subspace_ids_for_next.push_back(std::make_pair(ss.id.get(),
-                                                                 s.subspaces[x + 1].id.get()));
-            }
-
-            for (size_t y = 0; y < ss.regions.size(); ++y)
-            {
-                region& r(ss.regions[y]);
-                m_schemas_by_region.push_back(std::make_pair(r.id.get(), &s.sc));
-                m_subspaces_by_region.push_back(std::make_pair(r.id.get(), &ss));
-                m_subspace_ids_by_region.push_back(std::make_pair(r.id.get(), ss.id.get()));
-
-                if (r.replicas.empty())
-                {
-                    continue;
-                }
-
-                if (x == 0)
-                {
-                    m_point_leaders_by_virtual.push_back(r.replicas[0].vsi.get());
-                }
-
-                m_heads_by_region.push_back(std::make_pair(r.id.get(),
-                                                           r.replicas[0].vsi.get()));
-                m_tails_by_region.push_back(std::make_pair(r.id.get(),
-                                                           r.replicas[r.replicas.size() - 1].vsi.get()));
-
-                for (size_t z = 0; z < r.replicas.size(); ++z)
-                {
-                    m_region_ids_by_virtual.push_back(std::make_pair(r.replicas[z].vsi.get(),
-                                                                     r.id.get()));
-                    m_server_ids_by_virtual.push_back(std::make_pair(r.replicas[z].vsi.get(),
-                                                                     r.replicas[z].si.get()));
-
-                    if (z + 1 < r.replicas.size())
-                    {
-                        m_next_by_virtual.push_back(std::make_pair(r.replicas[z].vsi.get(),
-                                                                   r.replicas[z + 1].vsi.get()));
-                    }
-                }
-            }
-        }
-    }
-
-    for (size_t i = 0; i < m_transfers.size(); ++i)
-    {
-        transfer& xfer(m_transfers[i]);
-        m_region_ids_by_virtual.push_back(std::make_pair(xfer.vsrc.get(), xfer.rid.get()));
-        m_server_ids_by_virtual.push_back(std::make_pair(xfer.vdst.get(), xfer.dst.get()));
-    }
-
-    std::sort(m_servers.begin(), m_servers.end());
-    std::sort(m_region_ids_by_virtual.begin(), m_region_ids_by_virtual.end());
-    std::sort(m_server_ids_by_virtual.begin(), m_server_ids_by_virtual.end());
-    std::sort(m_schemas_by_region.begin(), m_schemas_by_region.end());
-    std::sort(m_subspaces_by_region.begin(), m_subspaces_by_region.end());
-    std::sort(m_subspace_ids_by_region.begin(), m_subspace_ids_by_region.end());
-    std::sort(m_subspace_ids_for_prev.begin(), m_subspace_ids_for_prev.end());
-    std::sort(m_subspace_ids_for_next.begin(), m_subspace_ids_for_next.end());
-    std::sort(m_heads_by_region.begin(), m_heads_by_region.end());
-    std::sort(m_tails_by_region.begin(), m_tails_by_region.end());
-    std::sort(m_next_by_virtual.begin(), m_next_by_virtual.end());
-    std::sort(m_point_leaders_by_virtual.begin(), m_point_leaders_by_virtual.end());
+	m_region_ids_by_virtual.clear();
+	m_server_ids_by_virtual.clear();
+	m_schemas_by_region.clear();
+	m_subspaces_by_region.clear();
+	m_subspace_ids_by_region.clear();
+	m_subspace_ids_for_prev.clear();
+	m_subspace_ids_for_next.clear();
+	m_heads_by_region.clear();
+	m_tails_by_region.clear();
+	m_next_by_virtual.clear();
+	m_point_leaders_by_virtual.clear();
+	for (size_t w = 0; w < m_spaces.size(); ++w)
+	{
+		space &s(m_spaces[w]);
+		for (size_t x = 0; x < s.subspaces.size(); ++x)
+		{
+			subspace &ss(s.subspaces[x]);
+			if (x > 0)
+			{
+				m_subspace_ids_for_prev.push_back(std::make_pair(ss.id.get(),
+				                                                 s.subspaces[x - 1].id.get()));
+			}
+			if (x + 1 < s.subspaces.size())
+			{
+				m_subspace_ids_for_next.push_back(std::make_pair(ss.id.get(),
+				                                                 s.subspaces[x + 1].id.get()));
+			}
+			for (size_t y = 0; y < ss.regions.size(); ++y)
+			{
+				region &r(ss.regions[y]);
+				m_schemas_by_region.push_back(std::make_pair(r.id.get(), &s.sc));
+				m_subspaces_by_region.push_back(std::make_pair(r.id.get(), &ss));
+				m_subspace_ids_by_region.push_back(std::make_pair(r.id.get(), ss.id.get()));
+				if (r.replicas.empty())
+				{
+					continue;
+				}
+				if (x == 0)
+				{
+					m_point_leaders_by_virtual.push_back(r.replicas[0].vsi.get());
+				}
+				m_heads_by_region.push_back(std::make_pair(r.id.get(),
+				                                           r.replicas[0].vsi.get()));
+				m_tails_by_region.push_back(std::make_pair(r.id.get(),
+				                                           r.replicas[r.replicas.size() - 1].vsi.get()));
+				for (size_t z = 0; z < r.replicas.size(); ++z)
+				{
+					m_region_ids_by_virtual.push_back(std::make_pair(r.replicas[z].vsi.get(),
+					                                                 r.id.get()));
+					m_server_ids_by_virtual.push_back(std::make_pair(r.replicas[z].vsi.get(),
+					                                                 r.replicas[z].si.get()));
+					if (z + 1 < r.replicas.size())
+					{
+						m_next_by_virtual.push_back(std::make_pair(r.replicas[z].vsi.get(),
+						                                           r.replicas[z + 1].vsi.get()));
+					}
+				}
+			}
+		}
+	}
+	for (size_t i = 0; i < m_transfers.size(); ++i)
+	{
+		transfer &xfer(m_transfers[i]);
+		m_region_ids_by_virtual.push_back(std::make_pair(xfer.vsrc.get(), xfer.rid.get()));
+		m_server_ids_by_virtual.push_back(std::make_pair(xfer.vdst.get(), xfer.dst.get()));
+	}
+	std::sort(m_servers.begin(), m_servers.end());
+	std::sort(m_region_ids_by_virtual.begin(), m_region_ids_by_virtual.end());
+	std::sort(m_server_ids_by_virtual.begin(), m_server_ids_by_virtual.end());
+	std::sort(m_schemas_by_region.begin(), m_schemas_by_region.end());
+	std::sort(m_subspaces_by_region.begin(), m_subspaces_by_region.end());
+	std::sort(m_subspace_ids_by_region.begin(), m_subspace_ids_by_region.end());
+	std::sort(m_subspace_ids_for_prev.begin(), m_subspace_ids_for_prev.end());
+	std::sort(m_subspace_ids_for_next.begin(), m_subspace_ids_for_next.end());
+	std::sort(m_heads_by_region.begin(), m_heads_by_region.end());
+	std::sort(m_tails_by_region.begin(), m_tails_by_region.end());
+	std::sort(m_next_by_virtual.begin(), m_next_by_virtual.end());
+	std::sort(m_point_leaders_by_virtual.begin(), m_point_leaders_by_virtual.end());
 }
 
 e::unpacker
-hyperdex :: operator >> (e::unpacker up, configuration& c)
+hyperdex :: operator >> (e::unpacker up, configuration &c)
 {
-    uint64_t num_servers = 0;
-    uint64_t num_spaces = 0;
-    uint64_t num_transfers = 0;
-    up = up >> c.m_cluster >> c.m_version >> c.m_flags
-            >> num_servers >> num_spaces
-            >> num_transfers;
-    c.m_servers.clear();
-    c.m_servers.reserve(num_servers);
-
-    for (size_t i = 0; !up.error() && i < num_servers; ++i)
-    {
-        server s;
-        up = up >> s;
-        c.m_servers.push_back(s);
-    }
-
-    c.m_spaces.clear();
-    c.m_spaces.reserve(num_spaces);
-
-    for (size_t i = 0; !up.error() && i < num_spaces; ++i)
-    {
-        space s;
-        up = up >> s;
-        c.m_spaces.push_back(s);
-    }
-
-    c.m_transfers.clear();
-    c.m_transfers.reserve(num_transfers);
-
-    for (size_t i = 0; !up.error() && i < num_transfers; ++i)
-    {
-        transfer xfer;
-        up = up >> xfer;
-        c.m_transfers.push_back(xfer);
-    }
-
-    c.refill_cache();
-    return up;
+	uint64_t num_servers = 0;
+	uint64_t num_spaces = 0;
+	uint64_t num_transfers = 0;
+	up = up >> c.m_cluster >> c.m_version >> c.m_flags
+	     >> num_servers >> num_spaces
+	     >> num_transfers;
+	c.m_servers.clear();
+	c.m_servers.reserve(num_servers);
+	for (size_t i = 0; !up.error() && i < num_servers; ++i)
+	{
+		server s;
+		up = up >> s;
+		c.m_servers.push_back(s);
+	}
+	c.m_spaces.clear();
+	c.m_spaces.reserve(num_spaces);
+	for (size_t i = 0; !up.error() && i < num_spaces; ++i)
+	{
+		space s;
+		up = up >> s;
+		c.m_spaces.push_back(s);
+	}
+	c.m_transfers.clear();
+	c.m_transfers.reserve(num_transfers);
+	for (size_t i = 0; !up.error() && i < num_transfers; ++i)
+	{
+		transfer xfer;
+		up = up >> xfer;
+		c.m_transfers.push_back(xfer);
+	}
+	c.refill_cache();
+	return up;
 }
diff --git a/common/configuration.h b/common/configuration.h
index 13c3d467e..9da962712 100644
--- a/common/configuration.h
+++ b/common/configuration.h
@@ -52,132 +52,132 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class configuration
 {
-    public:
-        configuration();
-        configuration(const configuration& other);
-        ~configuration() throw ();
-
-    // configuration metadata
-    public:
-        uint64_t cluster() const;
-        uint64_t version() const;
-        bool read_only() const;
-
-    // membership metadata
-    public:
-        void get_all_addresses(std::vector<std::pair<server_id, po6::net::location> >* addrs) const;
-        bool exists(const server_id& id) const;
-        po6::net::location get_address(const server_id& id) const;
-        server::state_t get_state(const server_id& id) const;
-        region_id get_region_id(const virtual_server_id& id) const;
-        server_id get_server_id(const virtual_server_id& id) const;
-
-    // hyperspace metadata
-    public:
-        const schema* get_schema(const char* space) const;
-        const schema* get_schema(const region_id& ri) const;
-        const subspace* get_subspace(const region_id& ri) const;
-        virtual_server_id get_virtual(const region_id& ri, const server_id& si) const;
-        subspace_id subspace_of(const region_id& ri) const;
-        subspace_id subspace_prev(const subspace_id& ss) const;
-        subspace_id subspace_next(const subspace_id& ss) const;
-        virtual_server_id head_of_region(const region_id& ri) const;
-        virtual_server_id tail_of_region(const region_id& ri) const;
-        virtual_server_id next_in_region(const virtual_server_id& vsi) const;
-        void point_leaders(const server_id& s, std::vector<region_id>* servers) const;
-        void key_regions(const server_id& s, std::vector<region_id>* servers) const;
-        bool is_point_leader(const virtual_server_id& e) const;
-        virtual_server_id point_leader(const char* space, const e::slice& key) const;
-        // point leader for this key in the same space as ri
-        virtual_server_id point_leader(const region_id& ri, const e::slice& key) const;
-        // lhs and rhs are in adjacent subspaces such that lhs sends CHAIN_PUT
-        // to rhs and rhs sends CHAIN_ACK to lhs
-        bool subspace_adjacent(const virtual_server_id& lhs, const virtual_server_id& rhs) const;
-        // mapped regions -- regions mapped for server "us"
-        void mapped_regions(const server_id& s, std::vector<region_id>* servers) const;
-
-    // index metadata
-    public:
-        const index* get_index(const index_id& ii) const;
-        void all_indices(const server_id& s, std::vector<std::pair<region_id, index_id> >* indices) const;
-
-    // transfers
-    public:
-        bool is_server_involved_in_transfer(const server_id& si, const region_id& ri) const;
-        bool is_server_blocked_by_live_transfer(const server_id& si, const region_id& ri) const;
-        bool is_transfer_live(const transfer_id& tid) const;
-        void transfers_in(const server_id& s, std::vector<transfer>* transfers) const;
-        void transfers_out(const server_id& s, std::vector<transfer>* transfers) const;
-        void transfers_in_regions(const server_id& s, std::vector<region_id>* transfers) const;
-        void transfers_out_regions(const server_id& s, std::vector<region_id>* transfers) const;
-
-    // hashing functions
-    public:
-        void lookup_region(const subspace_id& subspace,
-                           const std::vector<uint64_t>& hashes,
-                           region_id* region) const;
-        void lookup_search(const char* space,
-                           const std::vector<attribute_check>& chks,
-                           std::vector<virtual_server_id>* servers) const;
-
-    public:
-        std::string dump() const;
-
-        // List all spaces separated by \n
-        std::string list_spaces() const;
-
-        // List all suspaces of a space
-        // Attributes will be separated by a comma
-        // Spaces will be separated by a new line
-        std::string list_subspaces(const char* space) const;
-
-        // List all indexes of a space
-        // Indices will be seperate by a new line
-        // The output for each index is:
-        // <id>:<attribute>
-        std::string list_indices(const char* space) const;
-
-    public:
-        configuration& operator = (const configuration& rhs);
-
-    private:
-        void refill_cache();
-        friend size_t pack_size(const configuration&);
-        friend e::packer operator << (e::packer, const configuration& s);
-        friend e::unpacker operator >> (e::unpacker, configuration& s);
-
-    private:
-        typedef std::pair<uint64_t, uint64_t> pair_uint64_t;
-        typedef std::pair<uint64_t, schema*> uint64_schema_t;
-        typedef std::pair<uint64_t, subspace*> uint64_subspace_t;
-        typedef std::pair<uint64_t, po6::net::location> uint64_location_t;
-
-    private:
-        uint64_t m_cluster;
-        uint64_t m_version;
-        uint64_t m_flags;
-        std::vector<server> m_servers;
-        std::vector<pair_uint64_t> m_region_ids_by_virtual;
-        std::vector<pair_uint64_t> m_server_ids_by_virtual;
-        std::vector<uint64_schema_t> m_schemas_by_region;
-        std::vector<uint64_subspace_t> m_subspaces_by_region;
-        std::vector<pair_uint64_t> m_subspace_ids_by_region;
-        std::vector<pair_uint64_t> m_subspace_ids_for_prev;
-        std::vector<pair_uint64_t> m_subspace_ids_for_next;
-        std::vector<pair_uint64_t> m_heads_by_region;
-        std::vector<pair_uint64_t> m_tails_by_region;
-        std::vector<pair_uint64_t> m_next_by_virtual;
-        std::vector<uint64_t> m_point_leaders_by_virtual;
-        std::vector<space> m_spaces;
-        std::vector<transfer> m_transfers;
+public:
+	configuration();
+	configuration(const configuration &other);
+	~configuration() throw ();
+
+	// configuration metadata
+public:
+	uint64_t cluster() const;
+	uint64_t version() const;
+	bool read_only() const;
+
+	// membership metadata
+public:
+	void get_all_addresses(std::vector<std::pair<server_id, po6::net::location> > *addrs) const;
+	bool exists(const server_id &id) const;
+	po6::net::location get_address(const server_id &id) const;
+	server::state_t get_state(const server_id &id) const;
+	region_id get_region_id(const virtual_server_id &id) const;
+	server_id get_server_id(const virtual_server_id &id) const;
+
+	// hyperspace metadata
+public:
+	const schema *get_schema(const char *space) const;
+	const schema *get_schema(const region_id &ri) const;
+	const subspace *get_subspace(const region_id &ri) const;
+	virtual_server_id get_virtual(const region_id &ri, const server_id &si) const;
+	subspace_id subspace_of(const region_id &ri) const;
+	subspace_id subspace_prev(const subspace_id &ss) const;
+	subspace_id subspace_next(const subspace_id &ss) const;
+	virtual_server_id head_of_region(const region_id &ri) const;
+	virtual_server_id tail_of_region(const region_id &ri) const;
+	virtual_server_id next_in_region(const virtual_server_id &vsi) const;
+	void point_leaders(const server_id &s, std::vector<region_id> *servers) const;
+	void key_regions(const server_id &s, std::vector<region_id> *servers) const;
+	bool is_point_leader(const virtual_server_id &e) const;
+	virtual_server_id point_leader(const char *space, const e::slice &key) const;
+	// point leader for this key in the same space as ri
+	virtual_server_id point_leader(const region_id &ri, const e::slice &key) const;
+	// lhs and rhs are in adjacent subspaces such that lhs sends CHAIN_PUT
+	// to rhs and rhs sends CHAIN_ACK to lhs
+	bool subspace_adjacent(const virtual_server_id &lhs, const virtual_server_id &rhs) const;
+	// mapped regions -- regions mapped for server "us"
+	void mapped_regions(const server_id &s, std::vector<region_id> *servers) const;
+
+	// index metadata
+public:
+	const index *get_index(const index_id &ii) const;
+	void all_indices(const server_id &s, std::vector<std::pair<region_id, index_id> > *indices) const;
+
+	// transfers
+public:
+	bool is_server_involved_in_transfer(const server_id &si, const region_id &ri) const;
+	bool is_server_blocked_by_live_transfer(const server_id &si, const region_id &ri) const;
+	bool is_transfer_live(const transfer_id &tid) const;
+	void transfers_in(const server_id &s, std::vector<transfer> *transfers) const;
+	void transfers_out(const server_id &s, std::vector<transfer> *transfers) const;
+	void transfers_in_regions(const server_id &s, std::vector<region_id> *transfers) const;
+	void transfers_out_regions(const server_id &s, std::vector<region_id> *transfers) const;
+
+	// hashing functions
+public:
+	void lookup_region(const subspace_id &subspace,
+	                   const std::vector<uint64_t> &hashes,
+	                   region_id *region) const;
+	void lookup_search(const char *space,
+	                   const std::vector<attribute_check> &chks,
+	                   std::vector<virtual_server_id> *servers) const;
+
+public:
+	std::string dump() const;
+
+	// List all spaces separated by \n
+	std::string list_spaces() const;
+
+	// List all suspaces of a space
+	// Attributes will be separated by a comma
+	// Spaces will be separated by a new line
+	std::string list_subspaces(const char *space) const;
+
+	// List all indexes of a space
+	// Indices will be seperate by a new line
+	// The output for each index is:
+	// <id>:<attribute>
+	std::string list_indices(const char *space) const;
+
+public:
+	configuration &operator = (const configuration &rhs);
+
+private:
+	void refill_cache();
+	friend size_t pack_size(const configuration &);
+	friend e::packer operator << (e::packer, const configuration &s);
+	friend e::unpacker operator >> (e::unpacker, configuration &s);
+
+private:
+	typedef std::pair<uint64_t, uint64_t> pair_uint64_t;
+	typedef std::pair<uint64_t, schema *> uint64_schema_t;
+	typedef std::pair<uint64_t, subspace *> uint64_subspace_t;
+	typedef std::pair<uint64_t, po6::net::location> uint64_location_t;
+
+private:
+	uint64_t m_cluster;
+	uint64_t m_version;
+	uint64_t m_flags;
+	std::vector<server> m_servers;
+	std::vector<pair_uint64_t> m_region_ids_by_virtual;
+	std::vector<pair_uint64_t> m_server_ids_by_virtual;
+	std::vector<uint64_schema_t> m_schemas_by_region;
+	std::vector<uint64_subspace_t> m_subspaces_by_region;
+	std::vector<pair_uint64_t> m_subspace_ids_by_region;
+	std::vector<pair_uint64_t> m_subspace_ids_for_prev;
+	std::vector<pair_uint64_t> m_subspace_ids_for_next;
+	std::vector<pair_uint64_t> m_heads_by_region;
+	std::vector<pair_uint64_t> m_tails_by_region;
+	std::vector<pair_uint64_t> m_next_by_virtual;
+	std::vector<uint64_t> m_point_leaders_by_virtual;
+	std::vector<space> m_spaces;
+	std::vector<transfer> m_transfers;
 };
 
 e::packer
-operator << (e::packer, const configuration& c);
+operator << (e::packer, const configuration &c);
 e::unpacker
-operator >> (e::unpacker, configuration& c);
+operator >> (e::unpacker, configuration &c);
 size_t
-pack_size(const configuration&);
+pack_size(const configuration &);
 
 END_HYPERDEX_NAMESPACE
 
diff --git a/common/coordinator_returncode.cc b/common/coordinator_returncode.cc
index 28a60923d..c2ea1406f 100644
--- a/common/coordinator_returncode.cc
+++ b/common/coordinator_returncode.cc
@@ -29,21 +29,20 @@
 #include "common/coordinator_returncode.h"
 #include "common/macros.h"
 
-std::ostream&
-hyperdex :: operator << (std::ostream& lhs, coordinator_returncode rhs)
+std::ostream &
+hyperdex :: operator << (std::ostream &lhs, coordinator_returncode rhs)
 {
-    switch (rhs)
-    {
-        STRINGIFY(COORD_SUCCESS);
-        STRINGIFY(COORD_MALFORMED);
-        STRINGIFY(COORD_DUPLICATE);
-        STRINGIFY(COORD_NOT_FOUND);
-        STRINGIFY(COORD_UNINITIALIZED);
-        STRINGIFY(COORD_NO_CAN_DO);
-        default:
-            lhs << "unknown coordinator_returncode";
-            break;
-    }
-
-    return lhs;
+	switch (rhs)
+	{
+		STRINGIFY(COORD_SUCCESS);
+		STRINGIFY(COORD_MALFORMED);
+		STRINGIFY(COORD_DUPLICATE);
+		STRINGIFY(COORD_NOT_FOUND);
+		STRINGIFY(COORD_UNINITIALIZED);
+		STRINGIFY(COORD_NO_CAN_DO);
+	default:
+		lhs << "unknown coordinator_returncode";
+		break;
+	}
+	return lhs;
 }
diff --git a/common/coordinator_returncode.h b/common/coordinator_returncode.h
old mode 100755
new mode 100644
index 08802c202..677d13395
--- a/common/coordinator_returncode.h
+++ b/common/coordinator_returncode.h
@@ -41,16 +41,16 @@ BEGIN_HYPERDEX_NAMESPACE
 // keep them in sync
 enum coordinator_returncode
 {
-    COORD_SUCCESS = 8832,
-    COORD_MALFORMED = 8833,
-    COORD_DUPLICATE = 8834,
-    COORD_NOT_FOUND = 8835,
-    COORD_UNINITIALIZED = 8837,
-    COORD_NO_CAN_DO = 8839
+	COORD_SUCCESS = 8832,
+	COORD_MALFORMED = 8833,
+	COORD_DUPLICATE = 8834,
+	COORD_NOT_FOUND = 8835,
+	COORD_UNINITIALIZED = 8837,
+	COORD_NO_CAN_DO = 8839
 };
 
-std::ostream&
-operator << (std::ostream& lhs, coordinator_returncode rhs);
+std::ostream &
+operator << (std::ostream &lhs, coordinator_returncode rhs);
 
 END_HYPERDEX_NAMESPACE
 
diff --git a/common/datatype_document.cc b/common/datatype_document.cc
index c3068c5d2..be252dd1e 100644
--- a/common/datatype_document.cc
+++ b/common/datatype_document.cc
@@ -37,14 +37,14 @@
 #include "common/datatype_int64.h"
 #include "common/datatype_float.h"
 
-inline bool is_numeral(const hyperdatatype& t)
+inline bool is_numeral(const hyperdatatype &t)
 {
-    return t == HYPERDATATYPE_FLOAT || t == HYPERDATATYPE_INT64;
+	return t == HYPERDATATYPE_FLOAT || t == HYPERDATATYPE_INT64;
 }
 
-inline bool is_document_primitive(const hyperdatatype& t)
+inline bool is_document_primitive(const hyperdatatype &t)
 {
-    return is_numeral(t) || t == HYPERDATATYPE_STRING || t == HYPERDATATYPE_DOCUMENT;
+	return is_numeral(t) || t == HYPERDATATYPE_STRING || t == HYPERDATATYPE_DOCUMENT;
 }
 
 using hyperdex::datatype_document;
@@ -60,465 +60,423 @@ datatype_document :: ~datatype_document() throw ()
 hyperdatatype
 datatype_document :: datatype() const
 {
-    return HYPERDATATYPE_DOCUMENT;
+	return HYPERDATATYPE_DOCUMENT;
 }
 
 bool
-datatype_document :: validate(const e::slice& value) const
+datatype_document :: validate(const e::slice &value) const
 {
-    if (value.size() == 0)
-    {
-        // empty == "object"
-        return true;
-    }
-
-    return treadstone_binary_validate(value.data(), value.size()) == 0;
+	if (value.size() == 0)
+	{
+		// empty == "object"
+		return true;
+	}
+	return treadstone_binary_validate(value.data(), value.size()) == 0;
 }
 
 bool
-datatype_document :: check_args(const funcall& func) const
+datatype_document :: check_args(const funcall &func) const
 {
-    // A transformation that either sets (all/part of) the document, or
-    // pushes/pops an array (that is/within) the document.
-    if (is_document_primitive(func.arg1_datatype) &&
-        (func.name == FUNC_SET ||
-         func.name == FUNC_LIST_LPUSH ||
-         func.name == FUNC_LIST_RPUSH))
-    {
-        datatype_info* di = datatype_info::lookup(func.arg1_datatype);
-        return (func.arg2.empty() ||
-                (func.arg2_datatype == HYPERDATATYPE_STRING &&
-                 is_document_path(func.arg2))) &&
-               di && di->validate(func.arg1);
-    }
-    // Remove a particular path (arg2)
-    else if (func.arg2_datatype == HYPERDATATYPE_STRING &&
-             func.name == FUNC_DOC_UNSET)
-    {
-        return is_document_path(func.arg2);
-    }
-    // Rename a particular path (arg1)->(arg2)
-    else if (func.arg1_datatype == HYPERDATATYPE_STRING &&
-             func.arg2_datatype == HYPERDATATYPE_STRING &&
-             func.name == FUNC_DOC_RENAME)
-    {
-        return is_document_path(func.arg1) &&
-               is_document_path(func.arg2);
-    }
-    // Perform a nested operation on primitives
-    else if (func.arg2_datatype == HYPERDATATYPE_STRING &&
-             is_document_primitive(func.arg1_datatype) &&
-             func.arg1_datatype != HYPERDATATYPE_DOCUMENT)
-    {
-        datatype_info* di = datatype_info::lookup(func.arg1_datatype);
-        return is_document_path(func.arg2) && di->check_args(func);
-    }
-    // No other cases
-    else
-    {
-        return false;
-    }
+	// A transformation that either sets (all/part of) the document, or
+	// pushes/pops an array (that is/within) the document.
+	if (is_document_primitive(func.arg1_datatype) &&
+	    (func.name == FUNC_SET ||
+	     func.name == FUNC_LIST_LPUSH ||
+	     func.name == FUNC_LIST_RPUSH))
+	{
+		datatype_info *di = datatype_info::lookup(func.arg1_datatype);
+		return (func.arg2.empty() ||
+		        (func.arg2_datatype == HYPERDATATYPE_STRING &&
+		         is_document_path(func.arg2))) &&
+		       di && di->validate(func.arg1);
+	}
+	// Remove a particular path (arg2)
+	else if (func.arg2_datatype == HYPERDATATYPE_STRING &&
+	         func.name == FUNC_DOC_UNSET)
+	{
+		return is_document_path(func.arg2);
+	}
+	// Rename a particular path (arg1)->(arg2)
+	else if (func.arg1_datatype == HYPERDATATYPE_STRING &&
+	         func.arg2_datatype == HYPERDATATYPE_STRING &&
+	         func.name == FUNC_DOC_RENAME)
+	{
+		return is_document_path(func.arg1) &&
+		       is_document_path(func.arg2);
+	}
+	// Perform a nested operation on primitives
+	else if (func.arg2_datatype == HYPERDATATYPE_STRING &&
+	         is_document_primitive(func.arg1_datatype) &&
+	         func.arg1_datatype != HYPERDATATYPE_DOCUMENT)
+	{
+		datatype_info *di = datatype_info::lookup(func.arg1_datatype);
+		return is_document_path(func.arg2) && di->check_args(func);
+	}
+	// No other cases
+	else
+	{
+		return false;
+	}
 }
 
 void
-free_if_allocated(unsigned char** x)
+free_if_allocated(unsigned char **x)
 {
-    if (*x)
-    {
-        free(*x);
-    }
+	if (*x)
+	{
+		free(*x);
+	}
 }
 
 bool
-datatype_document :: apply(const e::slice& old_value,
-                           const funcall* funcs, size_t funcs_sz,
-                           e::arena* new_memory,
-                           e::slice* new_value) const
+datatype_document :: apply(const e::slice &old_value,
+                           const funcall *funcs, size_t funcs_sz,
+                           e::arena *new_memory,
+                           e::slice *new_value) const
 {
-    struct treadstone_transformer* trans = NULL;
-
-    if (old_value.empty())
-    {
-        trans = treadstone_transformer_create(reinterpret_cast<const unsigned char*>("\x40\x00"), 2);
-    }
-    else
-    {
-        trans = treadstone_transformer_create(old_value.data(), old_value.size());
-    }
-
-    if (!trans)
-    {
-        return false;
-    }
-
-    e::guard transg = e::makeguard(treadstone_transformer_destroy, trans);
-
-    for (size_t idx = 0; idx < funcs_sz; ++idx)
-    {
-        const funcall& func = funcs[idx];
-
-        if (is_document_primitive(func.arg1_datatype) &&
-            (func.name == FUNC_SET ||
-             func.name == FUNC_LIST_LPUSH ||
-             func.name == FUNC_LIST_RPUSH))
-        {
-            std::vector<char> scratch;
-            e::slice v;
-            coerce_primitive_to_binary(func.arg1_datatype, func.arg1, &scratch, &v);
-            std::string path(func.arg2.cdata(), func.arg2.size());
-
-            if (func.name == FUNC_SET)
-            {
-                if (treadstone_transformer_set_value(trans, path.c_str(), v.data(), v.size()) < 0)
-                {
-                    return false;
-                }
-            }
-            else if (func.name == FUNC_LIST_LPUSH)
-            {
-                if (treadstone_transformer_array_prepend_value(trans, path.c_str(), v.data(), v.size()) < 0)
-                {
-                    return false;
-                }
-            }
-            else if (func.name == FUNC_LIST_RPUSH)
-            {
-                if (treadstone_transformer_array_append_value(trans, path.c_str(), v.data(), v.size()) < 0)
-                {
-                    return false;
-                }
-            }
-            else
-            {
-                return false;
-            }
-        }
-        else if (func.arg2_datatype == HYPERDATATYPE_STRING &&
-                 func.name == FUNC_DOC_UNSET)
-        {
-            std::string path(func.arg2.cdata(), func.arg2.size());
-
-            if (treadstone_transformer_unset_value(trans, path.c_str()) < 0)
-            {
-                return false;
-            }
-        }
-        else if (func.arg1_datatype == HYPERDATATYPE_STRING &&
-                 func.arg2_datatype == HYPERDATATYPE_STRING &&
-                 func.name == FUNC_DOC_RENAME)
-        {
-            std::string src(func.arg2.cdata(), func.arg2.size());
-            std::string dst(func.arg1.cdata(), func.arg1.size());
-
-            unsigned char* value = NULL;
-            size_t value_sz = 0;
-            e::guard g = e::makeguard(free_if_allocated, &value);
-
-            if (treadstone_transformer_extract_value(trans, src.c_str(), &value, &value_sz) < 0)
-            {
-                return false;
-            }
-
-            if (treadstone_transformer_unset_value(trans, src.c_str()) < 0)
-            {
-                return false;
-            }
-
-            if (treadstone_transformer_set_value(trans, dst.c_str(), value, value_sz) < 0)
-            {
-                return false;
-            }
-        }
-        else if (func.arg2_datatype == HYPERDATATYPE_STRING &&
-                 is_document_primitive(func.arg1_datatype) &&
-                 func.arg1_datatype != HYPERDATATYPE_DOCUMENT)
-        {
-            unsigned char* value = NULL;
-            size_t value_sz = 0;
-            e::guard g = e::makeguard(free_if_allocated, &value);
-            std::string path(func.arg2.cdata(), func.arg2.size());
-            hyperdatatype type;
-            std::vector<char> scratch;
-            e::slice v;
-
-            if (treadstone_transformer_extract_value(trans, path.c_str(), &value, &value_sz) < 0)
-            {
-                // Value doesn't exist yet
-                type = func.arg1_datatype;
-                v = e::slice();
-            }
-            else
-            {
-                // Extract existing value from the document
-                if (!coerce_binary_to_primitive(e::slice(value, value_sz), &type, &scratch, &v))
-                {
-                    return false;
-                }
-
-
-                if (type == HYPERDATATYPE_INT64 &&
-                    func.arg1_datatype == HYPERDATATYPE_FLOAT)
-                {
-                    int64_t x = datatype_int64::unpack(v);
-                    double d = x;
-                    datatype_float::pack(d, &scratch, &v);
-                    type = HYPERDATATYPE_FLOAT;
-                }
-
-                // Both types are numerals (integer or float)
-                const bool numeral = is_numeral(type) && is_numeral(func.arg1_datatype);
-
-                if (func.name != FUNC_SET &&
-                    func.name != FUNC_DOC_UNSET &&
-                    func.name != FUNC_DOC_RENAME &&
-                    !numeral)
-                {
-                    // More complex modifications (string append etc)
-                    // only work with the same type
-                    if(type != func.arg1_datatype)
-                    {
-                        return false;
-                    }
-                }
-            }
-
-            datatype_info* di = datatype_info::lookup(type);
-            e::slice tmp_value;
-
-            if (!di->check_args(func))
-            {
-                return false;
-            }
-
-            // Pass funcall down to underlying datatype (string, integer etc...)
-            if (!di->apply(v, &func, 1, new_memory, &tmp_value))
-            {
-                return false;
-            }
-
-            std::vector<char> scratch_binary;
-            e::slice binary;
-            coerce_primitive_to_binary(type, tmp_value, &scratch_binary, &binary);
-
-            if (treadstone_transformer_set_value(trans, path.c_str(), binary.data(), binary.size()) < 0)
-            {
-                return false;
-            }
-        }
-        else
-        {
-            abort();
-        }
-    }
-
-    unsigned char* final_doc = NULL;
-    size_t final_doc_sz = 0;
-    e::guard g = e::makeguard(free_if_allocated, &final_doc);
-
-    if (treadstone_transformer_output(trans, &final_doc, &final_doc_sz) < 0)
-    {
-        return false;
-    }
-
-    new_memory->takeover(final_doc);
-    g.dismiss();
-    *new_value = e::slice(final_doc, final_doc_sz);
-    return true;
+	struct treadstone_transformer *trans = NULL;
+	if (old_value.empty())
+	{
+		trans = treadstone_transformer_create(reinterpret_cast<const unsigned char *>("\x40\x00"), 2);
+	}
+	else
+	{
+		trans = treadstone_transformer_create(old_value.data(), old_value.size());
+	}
+	if (!trans)
+	{
+		return false;
+	}
+	e::guard transg = e::makeguard(treadstone_transformer_destroy, trans);
+	for (size_t idx = 0; idx < funcs_sz; ++idx)
+	{
+		const funcall &func = funcs[idx];
+		if (is_document_primitive(func.arg1_datatype) &&
+		    (func.name == FUNC_SET ||
+		     func.name == FUNC_LIST_LPUSH ||
+		     func.name == FUNC_LIST_RPUSH))
+		{
+			std::vector<char> scratch;
+			e::slice v;
+			coerce_primitive_to_binary(func.arg1_datatype, func.arg1, &scratch, &v);
+			std::string path(func.arg2.cdata(), func.arg2.size());
+			if (func.name == FUNC_SET)
+			{
+				if (treadstone_transformer_set_value(trans, path.c_str(), v.data(), v.size()) < 0)
+				{
+					return false;
+				}
+			}
+			else if (func.name == FUNC_LIST_LPUSH)
+			{
+				if (treadstone_transformer_array_prepend_value(trans, path.c_str(), v.data(), v.size()) < 0)
+				{
+					return false;
+				}
+			}
+			else if (func.name == FUNC_LIST_RPUSH)
+			{
+				if (treadstone_transformer_array_append_value(trans, path.c_str(), v.data(), v.size()) < 0)
+				{
+					return false;
+				}
+			}
+			else
+			{
+				return false;
+			}
+		}
+		else if (func.arg2_datatype == HYPERDATATYPE_STRING &&
+		         func.name == FUNC_DOC_UNSET)
+		{
+			std::string path(func.arg2.cdata(), func.arg2.size());
+			if (treadstone_transformer_unset_value(trans, path.c_str()) < 0)
+			{
+				return false;
+			}
+		}
+		else if (func.arg1_datatype == HYPERDATATYPE_STRING &&
+		         func.arg2_datatype == HYPERDATATYPE_STRING &&
+		         func.name == FUNC_DOC_RENAME)
+		{
+			std::string src(func.arg2.cdata(), func.arg2.size());
+			std::string dst(func.arg1.cdata(), func.arg1.size());
+			unsigned char *value = NULL;
+			size_t value_sz = 0;
+			e::guard g = e::makeguard(free_if_allocated, &value);
+			if (treadstone_transformer_extract_value(trans, src.c_str(), &value, &value_sz) < 0)
+			{
+				return false;
+			}
+			if (treadstone_transformer_unset_value(trans, src.c_str()) < 0)
+			{
+				return false;
+			}
+			if (treadstone_transformer_set_value(trans, dst.c_str(), value, value_sz) < 0)
+			{
+				return false;
+			}
+		}
+		else if (func.arg2_datatype == HYPERDATATYPE_STRING &&
+		         is_document_primitive(func.arg1_datatype) &&
+		         func.arg1_datatype != HYPERDATATYPE_DOCUMENT)
+		{
+			unsigned char *value = NULL;
+			size_t value_sz = 0;
+			e::guard g = e::makeguard(free_if_allocated, &value);
+			std::string path(func.arg2.cdata(), func.arg2.size());
+			hyperdatatype type;
+			std::vector<char> scratch;
+			e::slice v;
+			if (treadstone_transformer_extract_value(trans, path.c_str(), &value, &value_sz) < 0)
+			{
+				// Value doesn't exist yet
+				type = func.arg1_datatype;
+				v = e::slice();
+			}
+			else
+			{
+				// Extract existing value from the document
+				if (!coerce_binary_to_primitive(e::slice(value, value_sz), &type, &scratch, &v))
+				{
+					return false;
+				}
+				if (type == HYPERDATATYPE_INT64 &&
+				    func.arg1_datatype == HYPERDATATYPE_FLOAT)
+				{
+					int64_t x = datatype_int64::unpack(v);
+					double d = x;
+					datatype_float::pack(d, &scratch, &v);
+					type = HYPERDATATYPE_FLOAT;
+				}
+				// Both types are numerals (integer or float)
+				const bool numeral = is_numeral(type) && is_numeral(func.arg1_datatype);
+				if (func.name != FUNC_SET &&
+				    func.name != FUNC_DOC_UNSET &&
+				    func.name != FUNC_DOC_RENAME &&
+				    !numeral)
+				{
+					// More complex modifications (string append etc)
+					// only work with the same type
+					if (type != func.arg1_datatype)
+					{
+						return false;
+					}
+				}
+			}
+			datatype_info *di = datatype_info::lookup(type);
+			e::slice tmp_value;
+			if (!di->check_args(func))
+			{
+				return false;
+			}
+			// Pass funcall down to underlying datatype (string, integer etc...)
+			if (!di->apply(v, &func, 1, new_memory, &tmp_value))
+			{
+				return false;
+			}
+			std::vector<char> scratch_binary;
+			e::slice binary;
+			coerce_primitive_to_binary(type, tmp_value, &scratch_binary, &binary);
+			if (treadstone_transformer_set_value(trans, path.c_str(), binary.data(), binary.size()) < 0)
+			{
+				return false;
+			}
+		}
+		else
+		{
+			abort();
+		}
+	}
+	unsigned char *final_doc = NULL;
+	size_t final_doc_sz = 0;
+	e::guard g = e::makeguard(free_if_allocated, &final_doc);
+	if (treadstone_transformer_output(trans, &final_doc, &final_doc_sz) < 0)
+	{
+		return false;
+	}
+	new_memory->takeover(final_doc);
+	g.dismiss();
+	*new_value = e::slice(final_doc, final_doc_sz);
+	return true;
 }
 
 bool
-datatype_document :: client_to_server(const e::slice& client,
-                                      e::arena* new_memory,
-                                      e::slice* server) const
+datatype_document :: client_to_server(const e::slice &client,
+                                      e::arena *new_memory,
+                                      e::slice *server) const
 {
-    unsigned char* binary;
-    size_t binary_sz;
-    std::string tmp(client.cdata(), client.size());
-
-    if (treadstone_json_to_binary(tmp.c_str(), &binary, &binary_sz) < 0)
-    {
-        return false;
-    }
-
-    new_memory->takeover(binary);
-    *server = e::slice(binary, binary_sz);
-    return true;
+	unsigned char *binary;
+	size_t binary_sz;
+	std::string tmp(client.cdata(), client.size());
+	if (treadstone_json_to_binary(tmp.c_str(), &binary, &binary_sz) < 0)
+	{
+		return false;
+	}
+	new_memory->takeover(binary);
+	*server = e::slice(binary, binary_sz);
+	return true;
 }
 
 bool
-datatype_document :: server_to_client(const e::slice& server,
-                                      e::arena* new_memory,
-                                      e::slice* client) const
+datatype_document :: server_to_client(const e::slice &server,
+                                      e::arena *new_memory,
+                                      e::slice *client) const
 {
-    char* json;
-
-    if (treadstone_binary_to_json(server.data(), server.size(), &json) < 0)
-    {
-        return false;
-    }
-
-    new_memory->takeover(json);
-    *client = e::slice(json, strlen(json) + 1);
-    return true;
+	char *json;
+	if (treadstone_binary_to_json(server.data(), server.size(), &json) < 0)
+	{
+		return false;
+	}
+	new_memory->takeover(json);
+	*client = e::slice(json, strlen(json) + 1);
+	return true;
 }
 
 bool
 datatype_document :: document() const
 {
-    return true;
+	return true;
 }
 
 bool
-datatype_document :: document_check(const attribute_check& check,
-                                    const e::slice& doc) const
+datatype_document :: document_check(const attribute_check &check,
+                                    const e::slice &doc) const
 {
-    // We expected the follwing format:
-    // <path>\0\n<value>
-
-    const char* path = reinterpret_cast<const char*>(check.value.data());
-    size_t path_sz = strnlen(path, check.value.size());
-
-    if (path_sz >= check.value.size())
-    {
-        return false;
-    }
-
-    hyperdatatype type;
-    std::vector<char> scratch;
-    e::slice value;
-
-    if (!extract_value(path, doc, &type, &scratch, &value))
-    {
-        return false;
-    }
-
-    if(type == HYPERDATATYPE_DOCUMENT)
-    {
-        // Compare two subdocuments
-        e::slice chk_value = check.value;
-        chk_value.advance(path_sz + 1);
-        return (value == chk_value);
-    }
-    else
-    {
-        // Pass down to underlying datatype
-        attribute_check new_check;
-        new_check.attr      = check.attr;
-        new_check.value     = check.value;
-        new_check.datatype  = check.datatype;
-        new_check.predicate = check.predicate;
-        new_check.value.advance(path_sz + 1);
-        return passes_attribute_check(type, new_check, value);
-    }
+	// We expected the follwing format:
+	// <path>\0\n<value>
+	const char *path = reinterpret_cast<const char *>(check.value.data());
+	size_t path_sz = strnlen(path, check.value.size());
+	if (path_sz >= check.value.size())
+	{
+		return false;
+	}
+	hyperdatatype type;
+	std::vector<char> scratch;
+	e::slice value;
+	if (!extract_value(path, doc, &type, &scratch, &value))
+	{
+		return false;
+	}
+	if (type == HYPERDATATYPE_DOCUMENT)
+	{
+		// Compare two subdocuments
+		e::slice chk_value = check.value;
+		chk_value.advance(path_sz + 1);
+		return (value == chk_value);
+	}
+	else
+	{
+		// Pass down to underlying datatype
+		attribute_check new_check;
+		new_check.attr      = check.attr;
+		new_check.value     = check.value;
+		new_check.datatype  = check.datatype;
+		new_check.predicate = check.predicate;
+		new_check.value.advance(path_sz + 1);
+		return passes_attribute_check(type, new_check, value);
+	}
 }
 
 bool
-datatype_document :: extract_value(const char* path,
-                                   const e::slice& data,
-                                   hyperdatatype* type,
-                                   std::vector<char>* scratch,
-                                   e::slice* value) const
+datatype_document :: extract_value(const char *path,
+                                   const e::slice &data,
+                                   hyperdatatype *type,
+                                   std::vector<char> *scratch,
+                                   e::slice *value) const
 {
-    struct treadstone_transformer* trans = NULL;
-    trans = treadstone_transformer_create(data.data(), data.size());
-
-    if (!trans)
-    {
-        return false;
-    }
-
-    e::guard transg = e::makeguard(treadstone_transformer_destroy, trans);
-    unsigned char* v = NULL;
-    size_t v_sz = 0;
-    e::guard g = e::makeguard(free_if_allocated, &v);
-
-    if (treadstone_transformer_extract_value(trans, path, &v, &v_sz) < 0)
-    {
-        return false;
-    }
-
-    return coerce_binary_to_primitive(e::slice(v, v_sz), type, scratch, value);
+	struct treadstone_transformer *trans = NULL;
+	trans = treadstone_transformer_create(data.data(), data.size());
+	if (!trans)
+	{
+		return false;
+	}
+	e::guard transg = e::makeguard(treadstone_transformer_destroy, trans);
+	unsigned char *v = NULL;
+	size_t v_sz = 0;
+	e::guard g = e::makeguard(free_if_allocated, &v);
+	if (treadstone_transformer_extract_value(trans, path, &v, &v_sz) < 0)
+	{
+		return false;
+	}
+	return coerce_binary_to_primitive(e::slice(v, v_sz), type, scratch, value);
 }
 
 void
 datatype_document :: coerce_primitive_to_binary(hyperdatatype type,
-                                                const e::slice& in,
-                                                std::vector<char>* scratch,
-                                                e::slice* value) const
+                                                const e::slice &in,
+                                                std::vector<char> *scratch,
+                                                e::slice *value) const
 {
-    assert(is_document_primitive(type));
-    unsigned char* v = NULL;
-    size_t v_sz = 0;
-    e::guard g = e::makeguard(free_if_allocated, &v);
-
-    if (type == HYPERDATATYPE_STRING)
-    {
-        int rc = treadstone_string_to_binary(in.cdata(), in.size(), &v, &v_sz);
-        assert(rc == 0);
-    }
-    else if (type == HYPERDATATYPE_INT64)
-    {
-        int rc = treadstone_integer_to_binary(datatype_int64::unpack(in), &v, &v_sz);
-        assert(rc == 0);
-    }
-    else if (type == HYPERDATATYPE_FLOAT)
-    {
-        int rc = treadstone_double_to_binary(datatype_float::unpack(in), &v, &v_sz);
-        assert(rc == 0);
-    }
-    else if (type == HYPERDATATYPE_DOCUMENT)
-    {
-        *value = in;
-        return;
-    }
-    else
-    {
-        abort();
-    }
-
-    scratch->resize(v_sz);
-    memmove(&(*scratch)[0], v, v_sz);
-    *value = e::slice(&(*scratch)[0], v_sz);
+	assert(is_document_primitive(type));
+	unsigned char *v = NULL;
+	size_t v_sz = 0;
+	e::guard g = e::makeguard(free_if_allocated, &v);
+	if (type == HYPERDATATYPE_STRING)
+	{
+		int rc = treadstone_string_to_binary(in.cdata(), in.size(), &v, &v_sz);
+		assert(rc == 0);
+	}
+	else if (type == HYPERDATATYPE_INT64)
+	{
+		int rc = treadstone_integer_to_binary(datatype_int64::unpack(in), &v, &v_sz);
+		assert(rc == 0);
+	}
+	else if (type == HYPERDATATYPE_FLOAT)
+	{
+		int rc = treadstone_double_to_binary(datatype_float::unpack(in), &v, &v_sz);
+		assert(rc == 0);
+	}
+	else if (type == HYPERDATATYPE_DOCUMENT)
+	{
+		*value = in;
+		return;
+	}
+	else
+	{
+		abort();
+	}
+	scratch->resize(v_sz);
+	memmove(&(*scratch)[0], v, v_sz);
+	*value = e::slice(&(*scratch)[0], v_sz);
 }
 
 bool
-datatype_document :: coerce_binary_to_primitive(const e::slice& in,
-                                                hyperdatatype* type,
-                                                std::vector<char>* scratch,
-                                                e::slice* value) const
+datatype_document :: coerce_binary_to_primitive(const e::slice &in,
+                                                hyperdatatype *type,
+                                                std::vector<char> *scratch,
+                                                e::slice *value) const
 {
-    if (treadstone_binary_validate(in.data(), in.size()) < 0)
-    {
-        return false;
-    }
-
-    if (treadstone_binary_is_string(in.data(), in.size()) == 0)
-    {
-        *type = HYPERDATATYPE_STRING;
-        size_t sz = treadstone_binary_string_bytes(in.data(), in.size());
-        scratch->resize(sz);
-        treadstone_binary_to_string(in.data(), in.size(), &(*scratch)[0]);
-        *value = e::slice(&(*scratch)[0], sz);
-    }
-    else if (treadstone_binary_is_integer(in.data(), in.size()) == 0)
-    {
-        *type = HYPERDATATYPE_INT64;
-        int64_t num = treadstone_binary_to_integer(in.data(), in.size());
-        datatype_int64::pack(num, scratch, value);
-    }
-    else if (treadstone_binary_is_double(in.data(), in.size()) == 0)
-    {
-        *type = HYPERDATATYPE_FLOAT;
-        double num = treadstone_binary_to_double(in.data(), in.size());
-        datatype_float::pack(num, scratch, value);
-    }
-    else
-    {
-        *type = HYPERDATATYPE_DOCUMENT;
-        scratch->resize(in.size());
-        memmove(scratch->data(), in.data(), in.size());
-        *value = e::slice(&(*scratch)[0], in.size());
-    }
-
-    return true;
+	if (treadstone_binary_validate(in.data(), in.size()) < 0)
+	{
+		return false;
+	}
+	if (treadstone_binary_is_string(in.data(), in.size()) == 0)
+	{
+		*type = HYPERDATATYPE_STRING;
+		size_t sz = treadstone_binary_string_bytes(in.data(), in.size());
+		scratch->resize(sz);
+		treadstone_binary_to_string(in.data(), in.size(), &(*scratch)[0]);
+		*value = e::slice(&(*scratch)[0], sz);
+	}
+	else if (treadstone_binary_is_integer(in.data(), in.size()) == 0)
+	{
+		*type = HYPERDATATYPE_INT64;
+		int64_t num = treadstone_binary_to_integer(in.data(), in.size());
+		datatype_int64::pack(num, scratch, value);
+	}
+	else if (treadstone_binary_is_double(in.data(), in.size()) == 0)
+	{
+		*type = HYPERDATATYPE_FLOAT;
+		double num = treadstone_binary_to_double(in.data(), in.size());
+		datatype_float::pack(num, scratch, value);
+	}
+	else
+	{
+		*type = HYPERDATATYPE_DOCUMENT;
+		scratch->resize(in.size());
+		memmove(scratch->data(), in.data(), in.size());
+		*value = e::slice(&(*scratch)[0], in.size());
+	}
+	return true;
 }
diff --git a/common/datatype_document.h b/common/datatype_document.h
index a34cf714e..b7c589941 100644
--- a/common/datatype_document.h
+++ b/common/datatype_document.h
@@ -36,48 +36,48 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class datatype_document : public datatype_info
 {
-    public:
-        datatype_document();
-        virtual ~datatype_document() throw ();
+public:
+	datatype_document();
+	virtual ~datatype_document() throw ();
 
-    public:
-        virtual hyperdatatype datatype() const;
-        virtual bool validate(const e::slice& value) const;
-        virtual bool check_args(const funcall& func) const;
-        virtual bool apply(const e::slice& old_value,
-                           const funcall* funcs, size_t funcs_sz,
-                           e::arena* new_memory,
-                           e::slice* new_value) const;
+public:
+	virtual hyperdatatype datatype() const;
+	virtual bool validate(const e::slice &value) const;
+	virtual bool check_args(const funcall &func) const;
+	virtual bool apply(const e::slice &old_value,
+	                   const funcall *funcs, size_t funcs_sz,
+	                   e::arena *new_memory,
+	                   e::slice *new_value) const;
 
-    public:
-        virtual bool client_to_server(const e::slice& client,
-                                      e::arena* new_memory,
-                                      e::slice* server) const;
-        virtual bool server_to_client(const e::slice& server,
-                                      e::arena* new_memory,
-                                      e::slice* client) const;
+public:
+	virtual bool client_to_server(const e::slice &client,
+	                              e::arena *new_memory,
+	                              e::slice *server) const;
+	virtual bool server_to_client(const e::slice &server,
+	                              e::arena *new_memory,
+	                              e::slice *client) const;
 
-    public:
-        virtual bool document() const;
-        virtual bool document_check(const attribute_check& check,
-                                    const e::slice& value) const;
+public:
+	virtual bool document() const;
+	virtual bool document_check(const attribute_check &check,
+	                            const e::slice &value) const;
 
-    public:
-        bool extract_value(const char* path,
-                           const e::slice& data,
-                           hyperdatatype* type,
-                           std::vector<char>* scratch,
-                           e::slice* value) const;
+public:
+	bool extract_value(const char *path,
+	                   const e::slice &data,
+	                   hyperdatatype *type,
+	                   std::vector<char> *scratch,
+	                   e::slice *value) const;
 
-    private:
-        void coerce_primitive_to_binary(hyperdatatype type,
-                                        const e::slice& in,
-                                        std::vector<char>* scratch,
-                                        e::slice* value) const;
-        bool coerce_binary_to_primitive(const e::slice& in,
-                                        hyperdatatype* type,
-                                        std::vector<char>* scratch,
-                                        e::slice* value) const;
+private:
+	void coerce_primitive_to_binary(hyperdatatype type,
+	                                const e::slice &in,
+	                                std::vector<char> *scratch,
+	                                e::slice *value) const;
+	bool coerce_binary_to_primitive(const e::slice &in,
+	                                hyperdatatype *type,
+	                                std::vector<char> *scratch,
+	                                e::slice *value) const;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/common/datatype_float.cc b/common/datatype_float.cc
index d451f4134..2b0414b03 100644
--- a/common/datatype_float.cc
+++ b/common/datatype_float.cc
@@ -42,53 +42,50 @@ using hyperdex::datatype_info;
 using hyperdex::datatype_float;
 
 double
-datatype_float :: unpack(const e::slice& value)
+datatype_float :: unpack(const e::slice &value)
 {
-    assert(value.size() == 0 || value.size() == sizeof(int64_t));
-
-    if (value.size() == 0)
-    {
-        return 0;
-    }
-
-    double number;
-    e::unpackdoublele(value.data(), &number);
-    return number;
+	assert(value.size() == 0 || value.size() == sizeof(int64_t));
+	if (value.size() == 0)
+	{
+		return 0;
+	}
+	double number;
+	e::unpackdoublele(value.data(), &number);
+	return number;
 }
 
 double
-datatype_float :: unpack(const funcall& value)
+datatype_float :: unpack(const funcall &value)
 {
-    if (value.arg1_datatype == HYPERDATATYPE_INT64)
-    {
-        return datatype_int64::unpack(value.arg1);
-    }
-    else if (value.arg1_datatype == HYPERDATATYPE_FLOAT)
-    {
-        return datatype_float::unpack(value.arg1);
-    }
-    else
-    {
-        return 0;
-    }
+	if (value.arg1_datatype == HYPERDATATYPE_INT64)
+	{
+		return datatype_int64::unpack(value.arg1);
+	}
+	else if (value.arg1_datatype == HYPERDATATYPE_FLOAT)
+	{
+		return datatype_float::unpack(value.arg1);
+	}
+	else
+	{
+		return 0;
+	}
 }
 
 void
-datatype_float :: pack(double num, std::vector<char>* scratch, e::slice* value)
+datatype_float :: pack(double num, std::vector<char> *scratch, e::slice *value)
 {
-    if (scratch->size() < sizeof(double))
-    {
-        scratch->resize(sizeof(double));
-    }
-
-    e::packdoublele(num, &(*scratch)[0]);
-    *value = e::slice(&(*scratch)[0], sizeof(double));
+	if (scratch->size() < sizeof(double))
+	{
+		scratch->resize(sizeof(double));
+	}
+	e::packdoublele(num, &(*scratch)[0]);
+	*value = e::slice(&(*scratch)[0], sizeof(double));
 }
 
 bool
-datatype_float :: static_validate(const e::slice& value)
+datatype_float :: static_validate(const e::slice &value)
 {
-    return value.size() == sizeof(double) || value.empty();
+	return value.size() == sizeof(double) || value.empty();
 }
 
 datatype_float :: datatype_float()
@@ -102,191 +99,185 @@ datatype_float :: ~datatype_float() throw ()
 hyperdatatype
 datatype_float :: datatype() const
 {
-    return HYPERDATATYPE_FLOAT;
+	return HYPERDATATYPE_FLOAT;
 }
 
 bool
-datatype_float :: validate(const e::slice& value) const
+datatype_float :: validate(const e::slice &value) const
 {
-    return static_validate(value);
+	return static_validate(value);
 }
 
 bool
-datatype_float :: check_args(const funcall& func) const
+datatype_float :: check_args(const funcall &func) const
 {
-    return ((func.arg1_datatype == HYPERDATATYPE_FLOAT && validate(func.arg1)) ||
-            (func.arg1_datatype == HYPERDATATYPE_INT64 && datatype_int64::static_validate(func.arg1))) &&
-           (func.name == FUNC_SET ||
-            func.name == FUNC_NUM_ADD ||
-            func.name == FUNC_NUM_SUB ||
-            func.name == FUNC_NUM_MUL ||
-            func.name == FUNC_NUM_DIV ||
-            func.name == FUNC_NUM_MAX ||
-            func.name == FUNC_NUM_MIN);
+	return ((func.arg1_datatype == HYPERDATATYPE_FLOAT && validate(func.arg1)) ||
+	        (func.arg1_datatype == HYPERDATATYPE_INT64 && datatype_int64::static_validate(func.arg1))) &&
+	       (func.name == FUNC_SET ||
+	        func.name == FUNC_NUM_ADD ||
+	        func.name == FUNC_NUM_SUB ||
+	        func.name == FUNC_NUM_MUL ||
+	        func.name == FUNC_NUM_DIV ||
+	        func.name == FUNC_NUM_MAX ||
+	        func.name == FUNC_NUM_MIN);
 }
 
 bool
-datatype_float :: apply(const e::slice& old_value,
-                        const funcall* funcs, size_t funcs_sz,
-                        e::arena* new_memory,
-                        e::slice* new_value) const
+datatype_float :: apply(const e::slice &old_value,
+                        const funcall *funcs, size_t funcs_sz,
+                        e::arena *new_memory,
+                        e::slice *new_value) const
 {
-    double number = unpack(old_value);
-
-    for (size_t i = 0; i < funcs_sz; ++i)
-    {
-        const funcall* func = funcs + i;
-        double arg = unpack(*func);
-
-        switch (func->name)
-        {
-            case FUNC_SET:
-                number = arg;
-                break;
-            case FUNC_NUM_ADD:
-                number += arg;
-                break;
-            case FUNC_NUM_SUB:
-                number -= arg;
-                break;
-            case FUNC_NUM_MUL:
-                number *= arg;
-                break;
-            case FUNC_NUM_DIV:
-                number /= arg;
-                break;
-            case FUNC_NUM_MAX:
-                number = std::max(number, arg);
-                break;
-            case FUNC_NUM_MIN:
-                number = std::min(number, arg);
-                break;
-            case FUNC_NUM_MOD:
-            case FUNC_NUM_AND:
-            case FUNC_NUM_OR:
-            case FUNC_NUM_XOR:
-            case FUNC_STRING_APPEND:
-            case FUNC_STRING_PREPEND:
-            case FUNC_STRING_LTRIM:
-            case FUNC_STRING_RTRIM:
-            case FUNC_LIST_LPUSH:
-            case FUNC_LIST_RPUSH:
-            case FUNC_SET_ADD:
-            case FUNC_SET_REMOVE:
-            case FUNC_SET_INTERSECT:
-            case FUNC_SET_UNION:
-            case FUNC_DOC_RENAME:
-            case FUNC_DOC_UNSET:
-            case FUNC_MAP_ADD:
-            case FUNC_MAP_REMOVE:
-            case FUNC_FAIL:
-            default:
-                abort();
-        }
-    }
-
-    uint8_t* ptr = NULL;
-    new_memory->allocate(sizeof(double), &ptr);
-    e::packdoublele(number, ptr);
-    *new_value = e::slice(ptr, sizeof(double));
-    return true;
+	double number = unpack(old_value);
+	for (size_t i = 0; i < funcs_sz; ++i)
+	{
+		const funcall *func = funcs + i;
+		double arg = unpack(*func);
+		switch (func->name)
+		{
+		case FUNC_SET:
+			number = arg;
+			break;
+		case FUNC_NUM_ADD:
+			number += arg;
+			break;
+		case FUNC_NUM_SUB:
+			number -= arg;
+			break;
+		case FUNC_NUM_MUL:
+			number *= arg;
+			break;
+		case FUNC_NUM_DIV:
+			number /= arg;
+			break;
+		case FUNC_NUM_MAX:
+			number = std::max(number, arg);
+			break;
+		case FUNC_NUM_MIN:
+			number = std::min(number, arg);
+			break;
+		case FUNC_NUM_MOD:
+		case FUNC_NUM_AND:
+		case FUNC_NUM_OR:
+		case FUNC_NUM_XOR:
+		case FUNC_STRING_APPEND:
+		case FUNC_STRING_PREPEND:
+		case FUNC_STRING_LTRIM:
+		case FUNC_STRING_RTRIM:
+		case FUNC_LIST_LPUSH:
+		case FUNC_LIST_RPUSH:
+		case FUNC_SET_ADD:
+		case FUNC_SET_REMOVE:
+		case FUNC_SET_INTERSECT:
+		case FUNC_SET_UNION:
+		case FUNC_DOC_RENAME:
+		case FUNC_DOC_UNSET:
+		case FUNC_MAP_ADD:
+		case FUNC_MAP_REMOVE:
+		case FUNC_FAIL:
+		default:
+			abort();
+		}
+	}
+	uint8_t *ptr = NULL;
+	new_memory->allocate(sizeof(double), &ptr);
+	e::packdoublele(number, ptr);
+	*new_value = e::slice(ptr, sizeof(double));
+	return true;
 }
 
 bool
 datatype_float :: hashable() const
 {
-    return true;
+	return true;
 }
 
 uint64_t
-datatype_float :: hash(const e::slice& value) const
+datatype_float :: hash(const e::slice &value) const
 {
-    assert(validate(value));
-    double number = unpack(value);
-    return ordered_encode_double(number);
+	assert(validate(value));
+	double number = unpack(value);
+	return ordered_encode_double(number);
 }
 
 bool
 datatype_float :: indexable() const
 {
-    return true;
+	return true;
 }
 
 bool
 datatype_float :: containable() const
 {
-    return true;
+	return true;
 }
 
 bool
-datatype_float :: step(const uint8_t** ptr,
-                       const uint8_t* end,
-                       e::slice* elem) const
+datatype_float :: step(const uint8_t **ptr,
+                       const uint8_t *end,
+                       e::slice *elem) const
 {
-    if (static_cast<size_t>(end - *ptr) < sizeof(double))
-    {
-        return false;
-    }
-
-    *elem = e::slice(*ptr, sizeof(double));
-    *ptr += sizeof(double);
-    return true;
+	if (static_cast<size_t>(end - *ptr) < sizeof(double))
+	{
+		return false;
+	}
+	*elem = e::slice(*ptr, sizeof(double));
+	*ptr += sizeof(double);
+	return true;
 }
 
 uint64_t
-datatype_float :: write_sz(const e::slice& elem) const
+datatype_float :: write_sz(const e::slice &elem) const
 {
-    return elem.size();
+	return elem.size();
 }
 
-uint8_t*
-datatype_float :: write(const e::slice& elem,
-                        uint8_t* write_to) const
+uint8_t *
+datatype_float :: write(const e::slice &elem,
+                        uint8_t *write_to) const
 {
-    memmove(write_to, elem.data(), elem.size());
-    return write_to + elem.size();
+	memmove(write_to, elem.data(), elem.size());
+	return write_to + elem.size();
 }
 
 bool
 datatype_float :: comparable() const
 {
-    return true;
+	return true;
 }
 
 static int
-compare(const e::slice& lhs,
-        const e::slice& rhs)
+compare(const e::slice &lhs,
+        const e::slice &rhs)
 {
-    double lhsnum = datatype_float::unpack(lhs);
-    double rhsnum = datatype_float::unpack(rhs);
-
-    if (lhsnum < rhsnum)
-    {
-        return -1;
-    }
-    if (lhsnum > rhsnum)
-    {
-        return 1;
-    }
-
-    return 0;
+	double lhsnum = datatype_float::unpack(lhs);
+	double rhsnum = datatype_float::unpack(rhs);
+	if (lhsnum < rhsnum)
+	{
+		return -1;
+	}
+	if (lhsnum > rhsnum)
+	{
+		return 1;
+	}
+	return 0;
 }
 
 int
-datatype_float :: compare(const e::slice& lhs, const e::slice& rhs) const
+datatype_float :: compare(const e::slice &lhs, const e::slice &rhs) const
 {
-    return ::compare(lhs, rhs);
+	return ::compare(lhs, rhs);
 }
 
 static bool
-compare_less(const e::slice& lhs,
-             const e::slice& rhs)
+compare_less(const e::slice &lhs,
+             const e::slice &rhs)
 {
-    return compare(lhs, rhs) < 0;
+	return compare(lhs, rhs) < 0;
 }
 
 datatype_info::compares_less
 datatype_float :: compare_less() const
 {
-    return &::compare_less;
+	return &::compare_less;
 }
diff --git a/common/datatype_float.h b/common/datatype_float.h
index eef741ebb..972021845 100644
--- a/common/datatype_float.h
+++ b/common/datatype_float.h
@@ -36,43 +36,43 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class datatype_float : public datatype_info
 {
-    public:
-        static double unpack(const e::slice& value);
-        static double unpack(const funcall& value);
-        static void pack(double num, std::vector<char>* scratch, e::slice* value);
-        static bool static_validate(const e::slice& value);
+public:
+	static double unpack(const e::slice &value);
+	static double unpack(const funcall &value);
+	static void pack(double num, std::vector<char> *scratch, e::slice *value);
+	static bool static_validate(const e::slice &value);
 
-    public:
-        datatype_float();
-        virtual ~datatype_float() throw ();
+public:
+	datatype_float();
+	virtual ~datatype_float() throw ();
 
-    public:
-        virtual hyperdatatype datatype() const;
-        virtual bool validate(const e::slice& value) const;
-        virtual bool check_args(const funcall& func) const;
-        virtual bool apply(const e::slice& old_value,
-                           const funcall* funcs, size_t funcs_sz,
-                           e::arena* new_memory,
-                           e::slice* new_value) const;
+public:
+	virtual hyperdatatype datatype() const;
+	virtual bool validate(const e::slice &value) const;
+	virtual bool check_args(const funcall &func) const;
+	virtual bool apply(const e::slice &old_value,
+	                   const funcall *funcs, size_t funcs_sz,
+	                   e::arena *new_memory,
+	                   e::slice *new_value) const;
 
-    public:
-        virtual bool hashable() const;
-        virtual uint64_t hash(const e::slice& value) const;
-        virtual bool indexable() const;
+public:
+	virtual bool hashable() const;
+	virtual uint64_t hash(const e::slice &value) const;
+	virtual bool indexable() const;
 
-    public:
-        virtual bool containable() const;
-        virtual bool step(const uint8_t** ptr,
-                          const uint8_t* end,
-                          e::slice* elem) const;
-        virtual uint64_t write_sz(const e::slice& elem) const;
-        virtual uint8_t* write(const e::slice& elem,
-                               uint8_t* write_to) const;
+public:
+	virtual bool containable() const;
+	virtual bool step(const uint8_t **ptr,
+	                  const uint8_t *end,
+	                  e::slice *elem) const;
+	virtual uint64_t write_sz(const e::slice &elem) const;
+	virtual uint8_t *write(const e::slice &elem,
+	                       uint8_t *write_to) const;
 
-    public:
-        virtual bool comparable() const;
-        virtual int compare(const e::slice& lhs, const e::slice& rhs) const;
-        virtual compares_less compare_less() const;
+public:
+	virtual bool comparable() const;
+	virtual int compare(const e::slice &lhs, const e::slice &rhs) const;
+	virtual compares_less compare_less() const;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/common/datatype_info.cc b/common/datatype_info.cc
index 106b88130..3a503ae5e 100644
--- a/common/datatype_info.cc
+++ b/common/datatype_info.cc
@@ -69,75 +69,75 @@ static hyperdex::datatype_timestamp d_timestamp_week(HYPERDATATYPE_TIMESTAMP_WEE
 static hyperdex::datatype_timestamp d_timestamp_month(HYPERDATATYPE_TIMESTAMP_MONTH);
 static hyperdex::datatype_macaroon_secret d_macaroon_secret;
 
-datatype_info*
+datatype_info *
 datatype_info :: lookup(hyperdatatype datatype)
 {
-    switch (datatype)
-    {
-        case HYPERDATATYPE_STRING:
-            return &d_string;
-        case HYPERDATATYPE_INT64:
-            return &d_int64;
-        case HYPERDATATYPE_FLOAT:
-            return &d_float;
-        case HYPERDATATYPE_DOCUMENT:
-            return &d_document;
-        case HYPERDATATYPE_LIST_STRING:
-            return &d_list_string;
-        case HYPERDATATYPE_LIST_INT64:
-            return &d_list_int64;
-        case HYPERDATATYPE_LIST_FLOAT:
-            return &d_list_float;
-        case HYPERDATATYPE_SET_STRING:
-            return &d_set_string;
-        case HYPERDATATYPE_SET_INT64:
-            return &d_set_int64;
-        case HYPERDATATYPE_SET_FLOAT:
-            return &d_set_float;
-        case HYPERDATATYPE_MAP_STRING_STRING:
-            return &d_map_string_string;
-        case HYPERDATATYPE_MAP_STRING_INT64:
-            return &d_map_string_int64;
-        case HYPERDATATYPE_MAP_STRING_FLOAT:
-            return &d_map_string_float;
-        case HYPERDATATYPE_MAP_INT64_STRING:
-            return &d_map_int64_string;
-        case HYPERDATATYPE_MAP_INT64_INT64:
-            return &d_map_int64_int64;
-        case HYPERDATATYPE_MAP_INT64_FLOAT:
-            return &d_map_int64_float;
-        case HYPERDATATYPE_MAP_FLOAT_STRING:
-            return &d_map_float_string;
-        case HYPERDATATYPE_MAP_FLOAT_INT64:
-            return &d_map_float_int64;
-        case HYPERDATATYPE_MAP_FLOAT_FLOAT:
-            return &d_map_float_float;
-        case HYPERDATATYPE_TIMESTAMP_SECOND:
-          return &d_timestamp_second;
-        case HYPERDATATYPE_TIMESTAMP_MINUTE:
-          return &d_timestamp_minute;
-        case HYPERDATATYPE_TIMESTAMP_HOUR:
-          return &d_timestamp_hour;
-        case HYPERDATATYPE_TIMESTAMP_DAY:
-          return &d_timestamp_day;
-        case HYPERDATATYPE_TIMESTAMP_WEEK:
-          return &d_timestamp_week;
-        case HYPERDATATYPE_TIMESTAMP_MONTH:
-          return &d_timestamp_month;
-        case HYPERDATATYPE_MACAROON_SECRET:
-            return &d_macaroon_secret;
-        case HYPERDATATYPE_GENERIC:
-        case HYPERDATATYPE_TIMESTAMP_GENERIC:
-        case HYPERDATATYPE_LIST_GENERIC:
-        case HYPERDATATYPE_SET_GENERIC:
-        case HYPERDATATYPE_MAP_GENERIC:
-        case HYPERDATATYPE_MAP_STRING_KEYONLY:
-        case HYPERDATATYPE_MAP_INT64_KEYONLY:
-        case HYPERDATATYPE_MAP_FLOAT_KEYONLY:
-        case HYPERDATATYPE_GARBAGE:
-        default:
-            return NULL;
-    }
+	switch (datatype)
+	{
+	case HYPERDATATYPE_STRING:
+		return &d_string;
+	case HYPERDATATYPE_INT64:
+		return &d_int64;
+	case HYPERDATATYPE_FLOAT:
+		return &d_float;
+	case HYPERDATATYPE_DOCUMENT:
+		return &d_document;
+	case HYPERDATATYPE_LIST_STRING:
+		return &d_list_string;
+	case HYPERDATATYPE_LIST_INT64:
+		return &d_list_int64;
+	case HYPERDATATYPE_LIST_FLOAT:
+		return &d_list_float;
+	case HYPERDATATYPE_SET_STRING:
+		return &d_set_string;
+	case HYPERDATATYPE_SET_INT64:
+		return &d_set_int64;
+	case HYPERDATATYPE_SET_FLOAT:
+		return &d_set_float;
+	case HYPERDATATYPE_MAP_STRING_STRING:
+		return &d_map_string_string;
+	case HYPERDATATYPE_MAP_STRING_INT64:
+		return &d_map_string_int64;
+	case HYPERDATATYPE_MAP_STRING_FLOAT:
+		return &d_map_string_float;
+	case HYPERDATATYPE_MAP_INT64_STRING:
+		return &d_map_int64_string;
+	case HYPERDATATYPE_MAP_INT64_INT64:
+		return &d_map_int64_int64;
+	case HYPERDATATYPE_MAP_INT64_FLOAT:
+		return &d_map_int64_float;
+	case HYPERDATATYPE_MAP_FLOAT_STRING:
+		return &d_map_float_string;
+	case HYPERDATATYPE_MAP_FLOAT_INT64:
+		return &d_map_float_int64;
+	case HYPERDATATYPE_MAP_FLOAT_FLOAT:
+		return &d_map_float_float;
+	case HYPERDATATYPE_TIMESTAMP_SECOND:
+		return &d_timestamp_second;
+	case HYPERDATATYPE_TIMESTAMP_MINUTE:
+		return &d_timestamp_minute;
+	case HYPERDATATYPE_TIMESTAMP_HOUR:
+		return &d_timestamp_hour;
+	case HYPERDATATYPE_TIMESTAMP_DAY:
+		return &d_timestamp_day;
+	case HYPERDATATYPE_TIMESTAMP_WEEK:
+		return &d_timestamp_week;
+	case HYPERDATATYPE_TIMESTAMP_MONTH:
+		return &d_timestamp_month;
+	case HYPERDATATYPE_MACAROON_SECRET:
+		return &d_macaroon_secret;
+	case HYPERDATATYPE_GENERIC:
+	case HYPERDATATYPE_TIMESTAMP_GENERIC:
+	case HYPERDATATYPE_LIST_GENERIC:
+	case HYPERDATATYPE_SET_GENERIC:
+	case HYPERDATATYPE_MAP_GENERIC:
+	case HYPERDATATYPE_MAP_STRING_KEYONLY:
+	case HYPERDATATYPE_MAP_INT64_KEYONLY:
+	case HYPERDATATYPE_MAP_FLOAT_KEYONLY:
+	case HYPERDATATYPE_GARBAGE:
+	default:
+		return NULL;
+	}
 }
 
 datatype_info :: datatype_info()
@@ -149,154 +149,154 @@ datatype_info :: ~datatype_info() throw ()
 }
 
 bool
-datatype_info :: client_to_server(const e::slice& client,
-                                  e::arena*,
-                                  e::slice* server) const
+datatype_info :: client_to_server(const e::slice &client,
+                                  e::arena *,
+                                  e::slice *server) const
 {
-    *server = client;
-    return true;
+	*server = client;
+	return true;
 }
 
 bool
-datatype_info :: server_to_client(const e::slice& server,
-                                  e::arena*,
-                                  e::slice* client) const
+datatype_info :: server_to_client(const e::slice &server,
+                                  e::arena *,
+                                  e::slice *client) const
 {
-    *client = server;
-    return true;
+	*client = server;
+	return true;
 }
 
 bool
 datatype_info :: hashable() const
 {
-    return false;
+	return false;
 }
 
 uint64_t
-datatype_info :: hash(const e::slice&) const
+datatype_info :: hash(const e::slice &) const
 {
-    // if you see an abort here, you overrode "hashable", but not this method
-    abort();
+	// if you see an abort here, you overrode "hashable", but not this method
+	abort();
 }
 
 bool
 datatype_info :: indexable() const
 {
-    return false;
+	return false;
 }
 
 bool
 datatype_info :: has_length() const
 {
-    return false;
+	return false;
 }
 
 uint64_t
-datatype_info :: length(const e::slice&) const
+datatype_info :: length(const e::slice &) const
 {
-    // if you see an abort here, you overrode "has_length", but not this method
-    abort();
+	// if you see an abort here, you overrode "has_length", but not this method
+	abort();
 }
 
 bool
 datatype_info :: has_regex() const
 {
-    return false;
+	return false;
 }
 
 bool
-datatype_info :: regex(const e::slice&,
-                       const e::slice&) const
+datatype_info :: regex(const e::slice &,
+                       const e::slice &) const
 {
-    // if you see an abort here, you overrode "has_regex", but not this method
-    abort();
+	// if you see an abort here, you overrode "has_regex", but not this method
+	abort();
 }
 
 bool
 datatype_info :: has_contains() const
 {
-    return false;
+	return false;
 }
 
 hyperdatatype
 datatype_info :: contains_datatype() const
 {
-    // if you see an abort here, you overrode "has_contains", but not this method
-    abort();
+	// if you see an abort here, you overrode "has_contains", but not this method
+	abort();
 }
 
 bool
-datatype_info :: contains(const e::slice&, const e::slice&) const
+datatype_info :: contains(const e::slice &, const e::slice &) const
 {
-    // if you see an abort here, you overrode "has_contains", but not this method
-    abort();
+	// if you see an abort here, you overrode "has_contains", but not this method
+	abort();
 }
 
 bool
 datatype_info :: containable() const
 {
-    return false;
+	return false;
 }
 
 bool
-datatype_info :: step(const uint8_t**,
-                      const uint8_t*,
-                      e::slice*) const
+datatype_info :: step(const uint8_t **,
+                      const uint8_t *,
+                      e::slice *) const
 {
-    // if you see an abort here, you overrode "containable", but not this
-    // method
-    abort();
+	// if you see an abort here, you overrode "containable", but not this
+	// method
+	abort();
 }
 
 uint64_t
-datatype_info :: write_sz(const e::slice&) const
+datatype_info :: write_sz(const e::slice &) const
 {
-    // if you see an abort here, you overrode "containable", but not this
-    // method
-    abort();
+	// if you see an abort here, you overrode "containable", but not this
+	// method
+	abort();
 }
 
-uint8_t*
-datatype_info :: write(const e::slice&, uint8_t*) const
+uint8_t *
+datatype_info :: write(const e::slice &, uint8_t *) const
 {
-    // if you see an abort here, you overrode "containable", but not this
-    // method
-    abort();
+	// if you see an abort here, you overrode "containable", but not this
+	// method
+	abort();
 }
 
 bool
 datatype_info :: comparable() const
 {
-    return false;
+	return false;
 }
 
 int
-datatype_info :: compare(const e::slice&, const e::slice&) const
+datatype_info :: compare(const e::slice &, const e::slice &) const
 {
-    // if you see an abort here, you overrode "comparable", but not this
-    // method
-    abort();
+	// if you see an abort here, you overrode "comparable", but not this
+	// method
+	abort();
 }
 
 datatype_info::compares_less
 datatype_info :: compare_less() const
 {
-    // if you see an abort here, you overrode "comparable", but not this
-    // method
-    abort();
+	// if you see an abort here, you overrode "comparable", but not this
+	// method
+	abort();
 }
 
 bool
 datatype_info :: document() const
 {
-    return false;
+	return false;
 }
 
 bool
-datatype_info :: document_check(const attribute_check&,
-                                const e::slice&) const
+datatype_info :: document_check(const attribute_check &,
+                                const e::slice &) const
 {
-    // if you see an abort here, you overrode "document", but not this
-    // method
-    abort();
+	// if you see an abort here, you overrode "document", but not this
+	// method
+	abort();
 }
diff --git a/common/datatype_info.h b/common/datatype_info.h
index f5be572e4..febaf843b 100644
--- a/common/datatype_info.h
+++ b/common/datatype_info.h
@@ -43,92 +43,92 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class datatype_info
 {
-    public:
-        // Return a pointer to the datatype_info representing the specific datatyp
-        // Must not be deleted
-        static datatype_info* lookup(hyperdatatype datatype);
-
-    public:
-        datatype_info();
-        virtual ~datatype_info() throw ();
-
-    // all types must implement these
-    public:
-        virtual hyperdatatype datatype() const = 0;
-        virtual bool validate(const e::slice& value) const = 0;
-        virtual bool check_args(const funcall& func) const = 0;
-        virtual bool apply(const e::slice& old_value,
-                           const funcall* funcs, size_t funcs_sz,
-                           e::arena* new_memory,
-                           e::slice* new_value) const = 0;
-
-    // override these if the type's client-facing representation is not used as
-    // the server-side representation
-    public:
-        virtual bool client_to_server(const e::slice& client,
-                                      e::arena* new_memory,
-                                      e::slice* server) const;
-        virtual bool server_to_client(const e::slice& server,
-                                      e::arena* new_memory,
-                                      e::slice* client) const;
-
-    // override these if the type is hashable
-    public:
-        virtual bool hashable() const;
-        virtual uint64_t hash(const e::slice& value) const;
-
-    // override these if the type is indexable
-    public:
-        virtual bool indexable() const;
-
-    // override these if the type has a "length"
-    public:
-        virtual bool has_length() const;
-        virtual uint64_t length(const e::slice& value) const;
-
-    // override these if the type can be matched with regexes
-    public:
-        virtual bool has_regex() const;
-        virtual bool regex(const e::slice& regex,
-                           const e::slice& value) const;
-
-    // override these if the type can be matched with "contains"
-    public:
-        virtual bool has_contains() const;
-        virtual hyperdatatype contains_datatype() const;
-        virtual bool contains(const e::slice& value, const e::slice& needle) const;
-
-    // override these if the type will be used within containers
-    public:
-        virtual bool containable() const;
-        virtual bool step(const uint8_t** ptr,
-                          const uint8_t* end,
-                          e::slice* elem) const;
-        virtual uint64_t write_sz(const e::slice& elem) const;
-        // must handle the case where elem/writeto overlap
-        // may only touch [write_to,write_to+write_sz(elem))
-        virtual uint8_t* write(const e::slice& elem,
-                               uint8_t* write_to) const;
-
-    // override these if the type can be compared
-    public:
-        virtual bool comparable() const;
-        virtual int compare(const e::slice& lhs, const e::slice& rhs) const;
-        typedef bool (*compares_less)(const e::slice& lhs, const e::slice& rhs);
-        virtual compares_less compare_less() const;
-
-    // override these if the type can be variable/document-like
-    //
-    // Custom document-like types cannot use the above comparables because they
-    // don't fit our long-held assumptions about different datatypes.
-    // Rather than break those assumptions and chase bugs, introduce a
-    // document_check call that converts the document check into something sane,
-    // possibly a non-document type.  It's easy to create a sample value/check
-    // and pass that to the attribute checks instead.
-    public:
-        virtual bool document() const;
-        virtual bool document_check(const attribute_check& check,
-                                    const e::slice& value) const;
+public:
+	// Return a pointer to the datatype_info representing the specific datatyp
+	// Must not be deleted
+	static datatype_info *lookup(hyperdatatype datatype);
+
+public:
+	datatype_info();
+	virtual ~datatype_info() throw ();
+
+	// all types must implement these
+public:
+	virtual hyperdatatype datatype() const = 0;
+	virtual bool validate(const e::slice &value) const = 0;
+	virtual bool check_args(const funcall &func) const = 0;
+	virtual bool apply(const e::slice &old_value,
+	                   const funcall *funcs, size_t funcs_sz,
+	                   e::arena *new_memory,
+	                   e::slice *new_value) const = 0;
+
+	// override these if the type's client-facing representation is not used as
+	// the server-side representation
+public:
+	virtual bool client_to_server(const e::slice &client,
+	                              e::arena *new_memory,
+	                              e::slice *server) const;
+	virtual bool server_to_client(const e::slice &server,
+	                              e::arena *new_memory,
+	                              e::slice *client) const;
+
+	// override these if the type is hashable
+public:
+	virtual bool hashable() const;
+	virtual uint64_t hash(const e::slice &value) const;
+
+	// override these if the type is indexable
+public:
+	virtual bool indexable() const;
+
+	// override these if the type has a "length"
+public:
+	virtual bool has_length() const;
+	virtual uint64_t length(const e::slice &value) const;
+
+	// override these if the type can be matched with regexes
+public:
+	virtual bool has_regex() const;
+	virtual bool regex(const e::slice &regex,
+	                   const e::slice &value) const;
+
+	// override these if the type can be matched with "contains"
+public:
+	virtual bool has_contains() const;
+	virtual hyperdatatype contains_datatype() const;
+	virtual bool contains(const e::slice &value, const e::slice &needle) const;
+
+	// override these if the type will be used within containers
+public:
+	virtual bool containable() const;
+	virtual bool step(const uint8_t **ptr,
+	                  const uint8_t *end,
+	                  e::slice *elem) const;
+	virtual uint64_t write_sz(const e::slice &elem) const;
+	// must handle the case where elem/writeto overlap
+	// may only touch [write_to,write_to+write_sz(elem))
+	virtual uint8_t *write(const e::slice &elem,
+	                       uint8_t *write_to) const;
+
+	// override these if the type can be compared
+public:
+	virtual bool comparable() const;
+	virtual int compare(const e::slice &lhs, const e::slice &rhs) const;
+	typedef bool (*compares_less)(const e::slice &lhs, const e::slice &rhs);
+	virtual compares_less compare_less() const;
+
+	// override these if the type can be variable/document-like
+	//
+	// Custom document-like types cannot use the above comparables because they
+	// don't fit our long-held assumptions about different datatypes.
+	// Rather than break those assumptions and chase bugs, introduce a
+	// document_check call that converts the document check into something sane,
+	// possibly a non-document type.  It's easy to create a sample value/check
+	// and pass that to the attribute checks instead.
+public:
+	virtual bool document() const;
+	virtual bool document_check(const attribute_check &check,
+	                            const e::slice &value) const;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/common/datatype_int64.cc b/common/datatype_int64.cc
index d705cfe06..e5c018441 100644
--- a/common/datatype_int64.cc
+++ b/common/datatype_int64.cc
@@ -44,53 +44,50 @@ using hyperdex::datatype_info;
 using hyperdex::datatype_int64;
 
 int64_t
-datatype_int64 :: unpack(const e::slice& value)
+datatype_int64 :: unpack(const e::slice &value)
 {
-    assert(value.size() == 0 || value.size() == sizeof(int64_t));
-
-    if (value.size() == 0)
-    {
-        return 0;
-    }
-
-    int64_t number;
-    e::unpack64le(value.data(), &number);
-    return number;
+	assert(value.size() == 0 || value.size() == sizeof(int64_t));
+	if (value.size() == 0)
+	{
+		return 0;
+	}
+	int64_t number;
+	e::unpack64le(value.data(), &number);
+	return number;
 }
 
 int64_t
-datatype_int64 :: unpack(const funcall& value)
+datatype_int64 :: unpack(const funcall &value)
 {
-    if (value.arg1_datatype == HYPERDATATYPE_INT64)
-    {
-        return datatype_int64::unpack(value.arg1);
-    }
-    else if (value.arg1_datatype == HYPERDATATYPE_FLOAT)
-    {
-        return llrint(datatype_float::unpack(value.arg1));
-    }
-    else
-    {
-        return 0;
-    }
+	if (value.arg1_datatype == HYPERDATATYPE_INT64)
+	{
+		return datatype_int64::unpack(value.arg1);
+	}
+	else if (value.arg1_datatype == HYPERDATATYPE_FLOAT)
+	{
+		return llrint(datatype_float::unpack(value.arg1));
+	}
+	else
+	{
+		return 0;
+	}
 }
 
 void
-datatype_int64 :: pack(int64_t num, std::vector<char>* scratch, e::slice* value)
+datatype_int64 :: pack(int64_t num, std::vector<char> *scratch, e::slice *value)
 {
-    if (scratch->size() < sizeof(int64_t))
-    {
-        scratch->resize(sizeof(int64_t));
-    }
-
-    e::pack64le(num, &(*scratch)[0]);
-    *value = e::slice(&(*scratch)[0], sizeof(int64_t));
+	if (scratch->size() < sizeof(int64_t))
+	{
+		scratch->resize(sizeof(int64_t));
+	}
+	e::pack64le(num, &(*scratch)[0]);
+	*value = e::slice(&(*scratch)[0], sizeof(int64_t));
 }
 
 bool
-datatype_int64 :: static_validate(const e::slice& value)
+datatype_int64 :: static_validate(const e::slice &value)
 {
-    return value.size() == sizeof(int64_t) || value.empty();
+	return value.size() == sizeof(int64_t) || value.empty();
 }
 
 datatype_int64 :: datatype_int64()
@@ -104,217 +101,211 @@ datatype_int64 :: ~datatype_int64() throw ()
 hyperdatatype
 datatype_int64 :: datatype() const
 {
-    return HYPERDATATYPE_INT64;
+	return HYPERDATATYPE_INT64;
 }
 
 bool
-datatype_int64 :: validate(const e::slice& value) const
+datatype_int64 :: validate(const e::slice &value) const
 {
-    return static_validate(value);
+	return static_validate(value);
 }
 
 bool
-datatype_int64 :: check_args(const funcall& func) const
+datatype_int64 :: check_args(const funcall &func) const
 {
-    return ((func.arg1_datatype == HYPERDATATYPE_INT64 && validate(func.arg1)) ||
-            (func.arg1_datatype == HYPERDATATYPE_FLOAT && datatype_float::static_validate(func.arg1))) &&
-           (func.name == FUNC_SET ||
-            func.name == FUNC_NUM_MAX ||
-            func.name == FUNC_NUM_MIN ||
-            func.name == FUNC_NUM_ADD ||
-            func.name == FUNC_NUM_SUB ||
-            func.name == FUNC_NUM_MUL ||
-            func.name == FUNC_NUM_DIV ||
-            func.name == FUNC_NUM_MOD ||
-            func.name == FUNC_NUM_AND ||
-            func.name == FUNC_NUM_OR ||
-            func.name == FUNC_NUM_XOR);
+	return ((func.arg1_datatype == HYPERDATATYPE_INT64 && validate(func.arg1)) ||
+	        (func.arg1_datatype == HYPERDATATYPE_FLOAT && datatype_float::static_validate(func.arg1))) &&
+	       (func.name == FUNC_SET ||
+	        func.name == FUNC_NUM_MAX ||
+	        func.name == FUNC_NUM_MIN ||
+	        func.name == FUNC_NUM_ADD ||
+	        func.name == FUNC_NUM_SUB ||
+	        func.name == FUNC_NUM_MUL ||
+	        func.name == FUNC_NUM_DIV ||
+	        func.name == FUNC_NUM_MOD ||
+	        func.name == FUNC_NUM_AND ||
+	        func.name == FUNC_NUM_OR ||
+	        func.name == FUNC_NUM_XOR);
 }
 
 bool
-datatype_int64 :: apply(const e::slice& old_value,
-                        const funcall* funcs, size_t funcs_sz,
-                        e::arena* new_memory,
-                        e::slice* new_value) const
+datatype_int64 :: apply(const e::slice &old_value,
+                        const funcall *funcs, size_t funcs_sz,
+                        e::arena *new_memory,
+                        e::slice *new_value) const
 {
-    int64_t number = unpack(old_value);
-
-    for (size_t i = 0; i < funcs_sz; ++i)
-    {
-        const funcall* func = funcs + i;
-        int64_t arg = unpack(*func);
-
-        switch (func->name)
-        {
-            case FUNC_SET:
-                number = arg;
-                break;
-            case FUNC_NUM_MAX:
-                number = std::max(number, arg);
-                break;
-            case FUNC_NUM_MIN:
-                number = std::min(number, arg);
-                break;
-            case FUNC_NUM_ADD:
-                if (!e::safe_add(number, arg, &number))
-                {
-                    return false; // XXX signed overflow
-                }
-                break;
-            case FUNC_NUM_SUB:
-                if (!e::safe_sub(number, arg, &number))
-                {
-                    return false; // XXX signed overflow
-                }
-                break;
-            case FUNC_NUM_MUL:
-                if (!e::safe_mul(number, arg, &number))
-                {
-                    return false; // XXX signed overflow
-                }
-                break;
-            case FUNC_NUM_DIV:
-                if (!e::safe_div(number, arg, &number))
-                {
-                    return false; // XXX signed overflow
-                }
-                break;
-            case FUNC_NUM_MOD:
-                if (!e::safe_mod(number, arg, &number))
-                {
-                    return false; // XXX signed overflow
-                }
-                break;
-            case FUNC_NUM_AND:
-                number &= arg;
-                break;
-            case FUNC_NUM_OR:
-                number |= arg;
-                break;
-            case FUNC_NUM_XOR:
-                number ^= arg;
-                break;
-            case FUNC_STRING_APPEND:
-            case FUNC_STRING_PREPEND:
-            case FUNC_STRING_LTRIM:
-            case FUNC_STRING_RTRIM:
-            case FUNC_LIST_LPUSH:
-            case FUNC_LIST_RPUSH:
-            case FUNC_SET_ADD:
-            case FUNC_SET_REMOVE:
-            case FUNC_SET_INTERSECT:
-            case FUNC_SET_UNION:
-            case FUNC_MAP_ADD:
-            case FUNC_MAP_REMOVE:
-            case FUNC_FAIL:
-            case FUNC_DOC_RENAME:
-            case FUNC_DOC_UNSET:
-            default:
-                abort();
-        }
-    }
-
-    uint8_t* ptr = NULL;
-    new_memory->allocate(sizeof(int64_t), &ptr);
-    e::pack64le(number, ptr);
-    *new_value = e::slice(ptr, sizeof(int64_t));
-    return true;
+	int64_t number = unpack(old_value);
+	for (size_t i = 0; i < funcs_sz; ++i)
+	{
+		const funcall *func = funcs + i;
+		int64_t arg = unpack(*func);
+		switch (func->name)
+		{
+		case FUNC_SET:
+			number = arg;
+			break;
+		case FUNC_NUM_MAX:
+			number = std::max(number, arg);
+			break;
+		case FUNC_NUM_MIN:
+			number = std::min(number, arg);
+			break;
+		case FUNC_NUM_ADD:
+			if (!e::safe_add(number, arg, &number))
+			{
+				return false; // XXX signed overflow
+			}
+			break;
+		case FUNC_NUM_SUB:
+			if (!e::safe_sub(number, arg, &number))
+			{
+				return false; // XXX signed overflow
+			}
+			break;
+		case FUNC_NUM_MUL:
+			if (!e::safe_mul(number, arg, &number))
+			{
+				return false; // XXX signed overflow
+			}
+			break;
+		case FUNC_NUM_DIV:
+			if (!e::safe_div(number, arg, &number))
+			{
+				return false; // XXX signed overflow
+			}
+			break;
+		case FUNC_NUM_MOD:
+			if (!e::safe_mod(number, arg, &number))
+			{
+				return false; // XXX signed overflow
+			}
+			break;
+		case FUNC_NUM_AND:
+			number &= arg;
+			break;
+		case FUNC_NUM_OR:
+			number |= arg;
+			break;
+		case FUNC_NUM_XOR:
+			number ^= arg;
+			break;
+		case FUNC_STRING_APPEND:
+		case FUNC_STRING_PREPEND:
+		case FUNC_STRING_LTRIM:
+		case FUNC_STRING_RTRIM:
+		case FUNC_LIST_LPUSH:
+		case FUNC_LIST_RPUSH:
+		case FUNC_SET_ADD:
+		case FUNC_SET_REMOVE:
+		case FUNC_SET_INTERSECT:
+		case FUNC_SET_UNION:
+		case FUNC_MAP_ADD:
+		case FUNC_MAP_REMOVE:
+		case FUNC_FAIL:
+		case FUNC_DOC_RENAME:
+		case FUNC_DOC_UNSET:
+		default:
+			abort();
+		}
+	}
+	uint8_t *ptr = NULL;
+	new_memory->allocate(sizeof(int64_t), &ptr);
+	e::pack64le(number, ptr);
+	*new_value = e::slice(ptr, sizeof(int64_t));
+	return true;
 }
 
 bool
 datatype_int64 :: hashable() const
 {
-    return true;
+	return true;
 }
 
 uint64_t
-datatype_int64 :: hash(const e::slice& value) const
+datatype_int64 :: hash(const e::slice &value) const
 {
-    assert(validate(value));
-    return ordered_encode_int64(unpack(value));
+	assert(validate(value));
+	return ordered_encode_int64(unpack(value));
 }
 
 bool
 datatype_int64 :: indexable() const
 {
-    return true;
+	return true;
 }
 
 bool
 datatype_int64 :: containable() const
 {
-    return true;
+	return true;
 }
 
 bool
-datatype_int64 :: step(const uint8_t** ptr,
-                       const uint8_t* end,
-                       e::slice* elem) const
+datatype_int64 :: step(const uint8_t **ptr,
+                       const uint8_t *end,
+                       e::slice *elem) const
 {
-    if (static_cast<size_t>(end - *ptr) < sizeof(int64_t))
-    {
-        return false;
-    }
-
-    *elem = e::slice(*ptr, sizeof(int64_t));
-    *ptr += sizeof(int64_t);
-    return true;
+	if (static_cast<size_t>(end - *ptr) < sizeof(int64_t))
+	{
+		return false;
+	}
+	*elem = e::slice(*ptr, sizeof(int64_t));
+	*ptr += sizeof(int64_t);
+	return true;
 }
 
 uint64_t
-datatype_int64 :: write_sz(const e::slice& elem) const
+datatype_int64 :: write_sz(const e::slice &elem) const
 {
-    return elem.size();
+	return elem.size();
 }
 
-uint8_t*
-datatype_int64 :: write(const e::slice& elem,
-                        uint8_t* write_to) const
+uint8_t *
+datatype_int64 :: write(const e::slice &elem,
+                        uint8_t *write_to) const
 {
-    memmove(write_to, elem.data(), elem.size());
-    return write_to + elem.size();
+	memmove(write_to, elem.data(), elem.size());
+	return write_to + elem.size();
 }
 
 bool
 datatype_int64 :: comparable() const
 {
-    return true;
+	return true;
 }
 
 static int
-compare(const e::slice& lhs,
-        const e::slice& rhs)
+compare(const e::slice &lhs,
+        const e::slice &rhs)
 {
-    int64_t lhsnum = datatype_int64::unpack(lhs);
-    int64_t rhsnum = datatype_int64::unpack(rhs);
-
-    if (lhsnum < rhsnum)
-    {
-        return -1;
-    }
-    if (lhsnum > rhsnum)
-    {
-        return 1;
-    }
-
-    return 0;
+	int64_t lhsnum = datatype_int64::unpack(lhs);
+	int64_t rhsnum = datatype_int64::unpack(rhs);
+	if (lhsnum < rhsnum)
+	{
+		return -1;
+	}
+	if (lhsnum > rhsnum)
+	{
+		return 1;
+	}
+	return 0;
 }
 
 int
-datatype_int64 :: compare(const e::slice& lhs, const e::slice& rhs) const
+datatype_int64 :: compare(const e::slice &lhs, const e::slice &rhs) const
 {
-    return ::compare(lhs, rhs);
+	return ::compare(lhs, rhs);
 }
 
 static bool
-compare_less(const e::slice& lhs,
-             const e::slice& rhs)
+compare_less(const e::slice &lhs,
+             const e::slice &rhs)
 {
-    return compare(lhs, rhs) < 0;
+	return compare(lhs, rhs) < 0;
 }
 
 datatype_info::compares_less
 datatype_int64 :: compare_less() const
 {
-    return &::compare_less;
+	return &::compare_less;
 }
diff --git a/common/datatype_int64.h b/common/datatype_int64.h
index 49a4e6b2f..5c030769d 100644
--- a/common/datatype_int64.h
+++ b/common/datatype_int64.h
@@ -36,43 +36,43 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class datatype_int64 : public datatype_info
 {
-    public:
-        static int64_t unpack(const e::slice& value);
-        static int64_t unpack(const funcall& func);
-        static void pack(int64_t num, std::vector<char>* scratch, e::slice* value);
-        static bool static_validate(const e::slice& value);
+public:
+	static int64_t unpack(const e::slice &value);
+	static int64_t unpack(const funcall &func);
+	static void pack(int64_t num, std::vector<char> *scratch, e::slice *value);
+	static bool static_validate(const e::slice &value);
 
-    public:
-        datatype_int64();
-        virtual ~datatype_int64() throw ();
+public:
+	datatype_int64();
+	virtual ~datatype_int64() throw ();
 
-    public:
-        virtual hyperdatatype datatype() const;
-        virtual bool validate(const e::slice& value) const;
-        virtual bool check_args(const funcall& func) const;
-        virtual bool apply(const e::slice& old_value,
-                           const funcall* funcs, size_t funcs_sz,
-                           e::arena* new_memory,
-                           e::slice* new_value) const;
+public:
+	virtual hyperdatatype datatype() const;
+	virtual bool validate(const e::slice &value) const;
+	virtual bool check_args(const funcall &func) const;
+	virtual bool apply(const e::slice &old_value,
+	                   const funcall *funcs, size_t funcs_sz,
+	                   e::arena *new_memory,
+	                   e::slice *new_value) const;
 
-    public:
-        virtual bool hashable() const;
-        virtual uint64_t hash(const e::slice& value) const;
-        virtual bool indexable() const;
+public:
+	virtual bool hashable() const;
+	virtual uint64_t hash(const e::slice &value) const;
+	virtual bool indexable() const;
 
-    public:
-        virtual bool containable() const;
-        virtual bool step(const uint8_t** ptr,
-                          const uint8_t* end,
-                          e::slice* elem) const;
-        virtual uint64_t write_sz(const e::slice& elem) const;
-        virtual uint8_t* write(const e::slice& elem,
-                               uint8_t* write_to) const;
+public:
+	virtual bool containable() const;
+	virtual bool step(const uint8_t **ptr,
+	                  const uint8_t *end,
+	                  e::slice *elem) const;
+	virtual uint64_t write_sz(const e::slice &elem) const;
+	virtual uint8_t *write(const e::slice &elem,
+	                       uint8_t *write_to) const;
 
-    public:
-        virtual bool comparable() const;
-        virtual int compare(const e::slice& lhs, const e::slice& rhs) const;
-        virtual compares_less compare_less() const;
+public:
+	virtual bool comparable() const;
+	virtual int compare(const e::slice &lhs, const e::slice &rhs) const;
+	virtual compares_less compare_less() const;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/common/datatype_list.cc b/common/datatype_list.cc
index 519deffb0..5a6d8beda 100644
--- a/common/datatype_list.cc
+++ b/common/datatype_list.cc
@@ -42,10 +42,10 @@
 
 using hyperdex::datatype_list;
 
-datatype_list :: datatype_list(datatype_info* elem)
-    : m_elem(elem)
+datatype_list :: datatype_list(datatype_info *elem)
+	: m_elem(elem)
 {
-    assert(m_elem->containable());
+	assert(m_elem->containable());
 }
 
 datatype_list :: ~datatype_list() throw ()
@@ -55,188 +55,172 @@ datatype_list :: ~datatype_list() throw ()
 hyperdatatype
 datatype_list :: datatype() const
 {
-    return CREATE_CONTAINER(HYPERDATATYPE_LIST_GENERIC, m_elem->datatype());
+	return CREATE_CONTAINER(HYPERDATATYPE_LIST_GENERIC, m_elem->datatype());
 }
 
 bool
-datatype_list :: validate(const e::slice& list) const
+datatype_list :: validate(const e::slice &list) const
 {
-    const uint8_t* ptr = list.data();
-    const uint8_t* end = list.data() + list.size();
-    e::slice elem;
-
-    while (ptr < end)
-    {
-        if (!m_elem->step(&ptr, end, &elem))
-        {
-            return false;
-        }
-    }
-
-    return ptr == end;
+	const uint8_t *ptr = list.data();
+	const uint8_t *end = list.data() + list.size();
+	e::slice elem;
+	while (ptr < end)
+	{
+		if (!m_elem->step(&ptr, end, &elem))
+		{
+			return false;
+		}
+	}
+	return ptr == end;
 }
 
 bool
-datatype_list :: check_args(const funcall& func) const
+datatype_list :: check_args(const funcall &func) const
 {
-    return ((func.arg1_datatype == datatype() ||
-             func.arg1_datatype == HYPERDATATYPE_LIST_GENERIC) &&
-            validate(func.arg1) && func.name == FUNC_SET) ||
-           (func.arg1_datatype == m_elem->datatype() &&
-            m_elem->validate(func.arg1) &&
-            (func.name == FUNC_LIST_LPUSH ||
-             func.name == FUNC_LIST_RPUSH));
+	return ((func.arg1_datatype == datatype() ||
+	         func.arg1_datatype == HYPERDATATYPE_LIST_GENERIC) &&
+	        validate(func.arg1) && func.name == FUNC_SET) ||
+	       (func.arg1_datatype == m_elem->datatype() &&
+	        m_elem->validate(func.arg1) &&
+	        (func.name == FUNC_LIST_LPUSH ||
+	         func.name == FUNC_LIST_RPUSH));
 }
 
 bool
-datatype_list :: apply(const e::slice& old_value,
-                       const funcall* funcs, size_t funcs_sz,
-                       e::arena* new_memory,
-                       e::slice* new_value) const
+datatype_list :: apply(const e::slice &old_value,
+                       const funcall *funcs, size_t funcs_sz,
+                       e::arena *new_memory,
+                       e::slice *new_value) const
 {
-    std::list<e::slice> list;
-    const uint8_t* ptr = old_value.data();
-    const uint8_t* end = old_value.data() + old_value.size();
-    e::slice elem;
-
-    while (ptr < end)
-    {
-        bool stepped = m_elem->step(&ptr, end, &elem);
-        assert(stepped); // safe because of check_args
-        list.push_back(elem);
-    }
-
-    for (size_t i = 0; i < funcs_sz; ++i)
-    {
-        switch (funcs[i].name)
-        {
-            case FUNC_SET:
-                list.clear();
-                ptr = funcs[i].arg1.data();
-                end = funcs[i].arg1.data() + funcs[i].arg1.size();
-
-                while (ptr < end)
-                {
-                    bool stepped = m_elem->step(&ptr, end, &elem);
-                    assert(stepped); // safe because of check_args
-                    list.push_back(elem);
-                }
-
-                break;
-            case FUNC_LIST_LPUSH:
-                list.push_front(funcs[i].arg1);
-                break;
-            case FUNC_LIST_RPUSH:
-                list.push_back(funcs[i].arg1);
-                break;
-            case FUNC_FAIL:
-            case FUNC_STRING_APPEND:
-            case FUNC_STRING_PREPEND:
-            case FUNC_STRING_LTRIM:
-            case FUNC_STRING_RTRIM:
-            case FUNC_NUM_ADD:
-            case FUNC_NUM_SUB:
-            case FUNC_NUM_MUL:
-            case FUNC_NUM_DIV:
-            case FUNC_NUM_MOD:
-            case FUNC_NUM_AND:
-            case FUNC_NUM_OR:
-            case FUNC_NUM_XOR:
-            case FUNC_NUM_MAX:
-            case FUNC_NUM_MIN:
-            case FUNC_SET_ADD:
-            case FUNC_SET_REMOVE:
-            case FUNC_SET_INTERSECT:
-            case FUNC_SET_UNION:
-            case FUNC_MAP_ADD:
-            case FUNC_MAP_REMOVE:
-            case FUNC_DOC_RENAME:
-            case FUNC_DOC_UNSET:
-            default:
-                abort();
-        }
-    }
-
-    size_t sz = 0;
-
-    for (std::list<e::slice>::iterator i = list.begin(); i != list.end(); ++i)
-    {
-        sz += m_elem->write_sz(*i);
-    }
-
-    uint8_t* write_to = NULL;
-    new_memory->allocate(sz, &write_to);
-    *new_value = e::slice(write_to, sz);
-
-    for (std::list<e::slice>::iterator i = list.begin(); i != list.end(); ++i)
-    {
-        write_to = m_elem->write(*i, write_to);
-    }
-
-    return true;
+	std::list<e::slice> list;
+	const uint8_t *ptr = old_value.data();
+	const uint8_t *end = old_value.data() + old_value.size();
+	e::slice elem;
+	while (ptr < end)
+	{
+		bool stepped = m_elem->step(&ptr, end, &elem);
+		assert(stepped); // safe because of check_args
+		list.push_back(elem);
+	}
+	for (size_t i = 0; i < funcs_sz; ++i)
+	{
+		switch (funcs[i].name)
+		{
+		case FUNC_SET:
+			list.clear();
+			ptr = funcs[i].arg1.data();
+			end = funcs[i].arg1.data() + funcs[i].arg1.size();
+			while (ptr < end)
+			{
+				bool stepped = m_elem->step(&ptr, end, &elem);
+				assert(stepped); // safe because of check_args
+				list.push_back(elem);
+			}
+			break;
+		case FUNC_LIST_LPUSH:
+			list.push_front(funcs[i].arg1);
+			break;
+		case FUNC_LIST_RPUSH:
+			list.push_back(funcs[i].arg1);
+			break;
+		case FUNC_FAIL:
+		case FUNC_STRING_APPEND:
+		case FUNC_STRING_PREPEND:
+		case FUNC_STRING_LTRIM:
+		case FUNC_STRING_RTRIM:
+		case FUNC_NUM_ADD:
+		case FUNC_NUM_SUB:
+		case FUNC_NUM_MUL:
+		case FUNC_NUM_DIV:
+		case FUNC_NUM_MOD:
+		case FUNC_NUM_AND:
+		case FUNC_NUM_OR:
+		case FUNC_NUM_XOR:
+		case FUNC_NUM_MAX:
+		case FUNC_NUM_MIN:
+		case FUNC_SET_ADD:
+		case FUNC_SET_REMOVE:
+		case FUNC_SET_INTERSECT:
+		case FUNC_SET_UNION:
+		case FUNC_MAP_ADD:
+		case FUNC_MAP_REMOVE:
+		case FUNC_DOC_RENAME:
+		case FUNC_DOC_UNSET:
+		default:
+			abort();
+		}
+	}
+	size_t sz = 0;
+	for (std::list<e::slice>::iterator i = list.begin(); i != list.end(); ++i)
+	{
+		sz += m_elem->write_sz(*i);
+	}
+	uint8_t *write_to = NULL;
+	new_memory->allocate(sz, &write_to);
+	*new_value = e::slice(write_to, sz);
+	for (std::list<e::slice>::iterator i = list.begin(); i != list.end(); ++i)
+	{
+		write_to = m_elem->write(*i, write_to);
+	}
+	return true;
 }
 
 bool
 datatype_list :: indexable() const
 {
-    return m_elem->indexable();
+	return m_elem->indexable();
 }
 
 bool
 datatype_list :: has_length() const
 {
-    return true;
+	return true;
 }
 
 uint64_t
-datatype_list :: length(const e::slice& list) const
+datatype_list :: length(const e::slice &list) const
 {
-    const uint8_t* ptr = list.data();
-    const uint8_t* end = list.data() + list.size();
-    e::slice elem;
-    uint64_t count = 0;
-
-    while (ptr < end)
-    {
-        bool stepped = m_elem->step(&ptr, end, &elem);
-        assert(stepped);
-        ++count;
-    }
-
-    assert(ptr == end);
-    return count;
+	const uint8_t *ptr = list.data();
+	const uint8_t *end = list.data() + list.size();
+	e::slice elem;
+	uint64_t count = 0;
+	while (ptr < end)
+	{
+		bool stepped = m_elem->step(&ptr, end, &elem);
+		assert(stepped);
+		++count;
+	}
+	assert(ptr == end);
+	return count;
 }
 
 bool
 datatype_list :: has_contains() const
 {
-    return true;
+	return true;
 }
 
 hyperdatatype
 datatype_list :: contains_datatype() const
 {
-    return m_elem->datatype();
+	return m_elem->datatype();
 }
 
 bool
-datatype_list :: contains(const e::slice& list, const e::slice& needle) const
+datatype_list :: contains(const e::slice &list, const e::slice &needle) const
 {
-    const uint8_t* ptr = list.data();
-    const uint8_t* end = list.data() + list.size();
-    e::slice elem;
-
-    while (ptr < end)
-    {
-        bool stepped = m_elem->step(&ptr, end, &elem);
-        assert(stepped);
-
-        if (elem == needle)
-        {
-            return true;
-        }
-    }
-
-    assert(ptr == end);
-    return false;
+	const uint8_t *ptr = list.data();
+	const uint8_t *end = list.data() + list.size();
+	e::slice elem;
+	while (ptr < end)
+	{
+		bool stepped = m_elem->step(&ptr, end, &elem);
+		assert(stepped);
+		if (elem == needle)
+		{
+			return true;
+		}
+	}
+	assert(ptr == end);
+	return false;
 }
diff --git a/common/datatype_list.h b/common/datatype_list.h
index 4fdc7ed54..e36c7bbee 100644
--- a/common/datatype_list.h
+++ b/common/datatype_list.h
@@ -39,37 +39,37 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class datatype_list : public datatype_info
 {
-    public:
-        datatype_list(datatype_info* elem);
-        virtual ~datatype_list() throw ();
+public:
+	datatype_list(datatype_info *elem);
+	virtual ~datatype_list() throw ();
 
-    public:
-        virtual hyperdatatype datatype() const;
-        virtual bool validate(const e::slice& value) const;
-        virtual bool check_args(const funcall& func) const;
-        virtual bool apply(const e::slice& old_value,
-                           const funcall* funcs, size_t funcs_sz,
-                           e::arena* new_memory,
-                           e::slice* new_value) const;
+public:
+	virtual hyperdatatype datatype() const;
+	virtual bool validate(const e::slice &value) const;
+	virtual bool check_args(const funcall &func) const;
+	virtual bool apply(const e::slice &old_value,
+	                   const funcall *funcs, size_t funcs_sz,
+	                   e::arena *new_memory,
+	                   e::slice *new_value) const;
 
-    public:
-        virtual bool indexable() const;
+public:
+	virtual bool indexable() const;
 
-    public:
-        virtual bool has_length() const;
-        virtual uint64_t length(const e::slice& value) const;
+public:
+	virtual bool has_length() const;
+	virtual uint64_t length(const e::slice &value) const;
 
-    public:
-        virtual bool has_contains() const;
-        virtual hyperdatatype contains_datatype() const;
-        virtual bool contains(const e::slice& value, const e::slice& needle) const;
+public:
+	virtual bool has_contains() const;
+	virtual hyperdatatype contains_datatype() const;
+	virtual bool contains(const e::slice &value, const e::slice &needle) const;
 
-    private:
-        datatype_list(const datatype_list&);
-        datatype_list& operator = (const datatype_list&);
+private:
+	datatype_list(const datatype_list &);
+	datatype_list &operator = (const datatype_list &);
 
-    private:
-        datatype_info* m_elem;
+private:
+	datatype_info *m_elem;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/common/datatype_macaroon_secret.cc b/common/datatype_macaroon_secret.cc
index 4b505dd22..9e35f4070 100644
--- a/common/datatype_macaroon_secret.cc
+++ b/common/datatype_macaroon_secret.cc
@@ -43,39 +43,37 @@ datatype_macaroon_secret :: ~datatype_macaroon_secret() throw ()
 hyperdatatype
 datatype_macaroon_secret :: datatype() const
 {
-    return HYPERDATATYPE_STRING;
+	return HYPERDATATYPE_STRING;
 }
 
 bool
-datatype_macaroon_secret :: validate(const e::slice&) const
+datatype_macaroon_secret :: validate(const e::slice &) const
 {
-    return true;
+	return true;
 }
 
 bool
-datatype_macaroon_secret :: check_args(const funcall& func) const
+datatype_macaroon_secret :: check_args(const funcall &func) const
 {
-    return func.arg1_datatype == HYPERDATATYPE_MACAROON_SECRET &&
-           validate(func.arg1) && func.name == FUNC_SET;
+	return func.arg1_datatype == HYPERDATATYPE_MACAROON_SECRET &&
+	       validate(func.arg1) && func.name == FUNC_SET;
 }
 
 bool
-datatype_macaroon_secret :: apply(const e::slice& old_value,
-                                  const funcall* funcs, size_t funcs_sz,
-                                  e::arena* new_memory,
-                                  e::slice* new_value) const
+datatype_macaroon_secret :: apply(const e::slice &old_value,
+                                  const funcall *funcs, size_t funcs_sz,
+                                  e::arena *new_memory,
+                                  e::slice *new_value) const
 {
-    *new_value = old_value;
-
-    if (funcs_sz > 0)
-    {
-        assert(funcs[funcs_sz - 1].name == FUNC_SET);
-        *new_value = funcs[funcs_sz - 1].arg1;
-    }
-
-    uint8_t* ptr = NULL;
-    new_memory->allocate(new_value->size(), &ptr);
-    memmove(ptr, new_value->data(), new_value->size());
-    *new_value = e::slice(ptr, new_value->size());
-    return true;
+	*new_value = old_value;
+	if (funcs_sz > 0)
+	{
+		assert(funcs[funcs_sz - 1].name == FUNC_SET);
+		*new_value = funcs[funcs_sz - 1].arg1;
+	}
+	uint8_t *ptr = NULL;
+	new_memory->allocate(new_value->size(), &ptr);
+	memmove(ptr, new_value->data(), new_value->size());
+	*new_value = e::slice(ptr, new_value->size());
+	return true;
 }
diff --git a/common/datatype_macaroon_secret.h b/common/datatype_macaroon_secret.h
index 7c01aa979..76263dd16 100644
--- a/common/datatype_macaroon_secret.h
+++ b/common/datatype_macaroon_secret.h
@@ -36,18 +36,18 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class datatype_macaroon_secret : public datatype_info
 {
-    public:
-        datatype_macaroon_secret();
-        virtual ~datatype_macaroon_secret() throw ();
+public:
+	datatype_macaroon_secret();
+	virtual ~datatype_macaroon_secret() throw ();
 
-    public:
-        virtual hyperdatatype datatype() const;
-        virtual bool validate(const e::slice& value) const;
-        virtual bool check_args(const funcall& func) const;
-        virtual bool apply(const e::slice& old_value,
-                           const funcall* funcs, size_t funcs_sz,
-                           e::arena* new_memory,
-                           e::slice* new_value) const;
+public:
+	virtual hyperdatatype datatype() const;
+	virtual bool validate(const e::slice &value) const;
+	virtual bool check_args(const funcall &func) const;
+	virtual bool apply(const e::slice &old_value,
+	                   const funcall *funcs, size_t funcs_sz,
+	                   e::arena *new_memory,
+	                   e::slice *new_value) const;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/common/datatype_map.cc b/common/datatype_map.cc
index 61023116a..3c8c661c0 100644
--- a/common/datatype_map.cc
+++ b/common/datatype_map.cc
@@ -39,12 +39,12 @@
 
 using hyperdex::datatype_map;
 
-datatype_map :: datatype_map(datatype_info* k, datatype_info* v)
-    : m_k(k)
-    , m_v(v)
+datatype_map :: datatype_map(datatype_info *k, datatype_info *v)
+	: m_k(k)
+	, m_v(v)
 {
-    assert(m_k->containable() && m_k->comparable());
-    assert(m_v->containable() && m_v->comparable());
+	assert(m_k->containable() && m_k->comparable());
+	assert(m_v->containable() && m_v->comparable());
 }
 
 datatype_map :: ~datatype_map() throw ()
@@ -54,297 +54,271 @@ datatype_map :: ~datatype_map() throw ()
 hyperdatatype
 datatype_map :: datatype() const
 {
-    return CREATE_CONTAINER2(HYPERDATATYPE_MAP_GENERIC, m_k->datatype(), m_v->datatype());
+	return CREATE_CONTAINER2(HYPERDATATYPE_MAP_GENERIC, m_k->datatype(), m_v->datatype());
 }
 
 bool
-datatype_map :: validate(const e::slice& map) const
+datatype_map :: validate(const e::slice &map) const
 {
-    const uint8_t* ptr = map.data();
-    const uint8_t* end = map.data() + map.size();
-    e::slice key;
-    e::slice val;
-    e::slice old;
-    bool has_old = false;
-
-    while (ptr < end)
-    {
-        if (!m_k->step(&ptr, end, &key))
-        {
-            return false;
-        }
-
-        if (!m_v->step(&ptr, end, &val))
-        {
-            return false;
-        }
-
-        if (has_old)
-        {
-            if (m_k->compare(old, key) >= 0)
-            {
-                return false;
-            }
-        }
-
-        old = key;
-        has_old = true;
-    }
-
-    return ptr == end;
+	const uint8_t *ptr = map.data();
+	const uint8_t *end = map.data() + map.size();
+	e::slice key;
+	e::slice val;
+	e::slice old;
+	bool has_old = false;
+	while (ptr < end)
+	{
+		if (!m_k->step(&ptr, end, &key))
+		{
+			return false;
+		}
+		if (!m_v->step(&ptr, end, &val))
+		{
+			return false;
+		}
+		if (has_old)
+		{
+			if (m_k->compare(old, key) >= 0)
+			{
+				return false;
+			}
+		}
+		old = key;
+		has_old = true;
+	}
+	return ptr == end;
 }
 
 bool
-datatype_map :: check_args(const funcall& func) const
+datatype_map :: check_args(const funcall &func) const
 {
-    // depending on the operation the arguments may differ
-    // we must ensure that they match
-
-    // set needs a whole map as an argument
-    if(func.name == FUNC_SET)
-    {
-        return (func.arg1_datatype == datatype() ||
-             func.arg1_datatype == HYPERDATATYPE_MAP_GENERIC)
-             && validate(func.arg1);
-    }
-    // inserting a new element needs a key/value-pair
-    else if(func.name == FUNC_MAP_ADD)
-    {
-        return m_v->validate(func.arg1) &&
-            m_k->validate(func.arg2) &&
-            func.arg1_datatype == m_v->datatype() &&
-            func.arg2_datatype == m_k->datatype();
-    }
-    // Remove only needs a key
-    else if(func.name == FUNC_MAP_REMOVE)
-    {
-        return m_k->validate(func.arg1) && func.arg1_datatype == m_k->datatype();
-    }
-    // Other operations embed their arguments in the second datatype
-    else if(func.name == FUNC_STRING_APPEND ||
-            func.name == FUNC_STRING_PREPEND ||
-            func.name == FUNC_NUM_ADD ||
-            func.name == FUNC_NUM_SUB ||
-            func.name == FUNC_NUM_MUL ||
-            func.name == FUNC_NUM_DIV ||
-            func.name == FUNC_NUM_MOD ||
-            func.name == FUNC_NUM_AND ||
-            func.name == FUNC_NUM_OR  ||
-            func.name == FUNC_NUM_XOR ||
-            func.name == FUNC_NUM_MIN ||
-            func.name == FUNC_NUM_MAX)
-    {
-        return m_k->validate(func.arg2)
-             && func.arg2_datatype == m_k->datatype()
-             && m_v->check_args(func);
-    }
-    else
-    {
-        return false;
-    }
+	// depending on the operation the arguments may differ
+	// we must ensure that they match
+	// set needs a whole map as an argument
+	if (func.name == FUNC_SET)
+	{
+		return (func.arg1_datatype == datatype() ||
+		        func.arg1_datatype == HYPERDATATYPE_MAP_GENERIC)
+		       && validate(func.arg1);
+	}
+	// inserting a new element needs a key/value-pair
+	else if (func.name == FUNC_MAP_ADD)
+	{
+		return m_v->validate(func.arg1) &&
+		       m_k->validate(func.arg2) &&
+		       func.arg1_datatype == m_v->datatype() &&
+		       func.arg2_datatype == m_k->datatype();
+	}
+	// Remove only needs a key
+	else if (func.name == FUNC_MAP_REMOVE)
+	{
+		return m_k->validate(func.arg1) && func.arg1_datatype == m_k->datatype();
+	}
+	// Other operations embed their arguments in the second datatype
+	else if (func.name == FUNC_STRING_APPEND ||
+	         func.name == FUNC_STRING_PREPEND ||
+	         func.name == FUNC_NUM_ADD ||
+	         func.name == FUNC_NUM_SUB ||
+	         func.name == FUNC_NUM_MUL ||
+	         func.name == FUNC_NUM_DIV ||
+	         func.name == FUNC_NUM_MOD ||
+	         func.name == FUNC_NUM_AND ||
+	         func.name == FUNC_NUM_OR  ||
+	         func.name == FUNC_NUM_XOR ||
+	         func.name == FUNC_NUM_MIN ||
+	         func.name == FUNC_NUM_MAX)
+	{
+		return m_k->validate(func.arg2)
+		       && func.arg2_datatype == m_k->datatype()
+		       && m_v->check_args(func);
+	}
+	else
+	{
+		return false;
+	}
 }
 
 bool
-datatype_map :: apply(const e::slice& old_value,
-                      const funcall* funcs, size_t funcs_sz,
-                      e::arena* new_memory,
-                      e::slice* new_value) const
+datatype_map :: apply(const e::slice &old_value,
+                      const funcall *funcs, size_t funcs_sz,
+                      e::arena *new_memory,
+                      e::slice *new_value) const
 {
-    // Initialize map with the compare operator of the key's datatype
-    map_t map(m_k->compare_less());
-
-    const uint8_t* ptr = old_value.data();
-    const uint8_t* end = old_value.data() + old_value.size();
-    e::slice key;
-    e::slice val;
-
-    // Read previous data into the map
-    while (ptr < end)
-    {
-        bool stepped;
-        stepped = m_k->step(&ptr, end, &key);
-        assert(stepped);
-        stepped = m_v->step(&ptr, end, &val);
-        assert(stepped);
-        map.insert(std::make_pair(key, val));
-    }
-
-    for (size_t i = 0; i < funcs_sz; ++i)
-    {
-        switch (funcs[i].name)
-        {
-            case FUNC_SET:
-                // Discard current content and insert a new key-value-pair
-                map.clear();
-                ptr = funcs[i].arg1.data();
-                end = funcs[i].arg1.data() + funcs[i].arg1.size();
-
-                while (ptr < end)
-                {
-                    bool stepped;
-                    stepped = m_k->step(&ptr, end, &key);
-                    assert(stepped);
-                    stepped = m_v->step(&ptr, end, &val);
-                    assert(stepped);
-                    map.insert(std::make_pair(key, val));
-                }
-
-                break;
-            case FUNC_MAP_ADD:
-                map[funcs[i].arg2] = funcs[i].arg1;
-                break;
-            case FUNC_MAP_REMOVE:
-                map.erase(funcs[i].arg1);
-                break;
-            case FUNC_STRING_APPEND:
-            case FUNC_STRING_PREPEND:
-            case FUNC_STRING_LTRIM:
-            case FUNC_STRING_RTRIM:
-            case FUNC_NUM_ADD:
-            case FUNC_NUM_MIN:
-            case FUNC_NUM_MAX:
-            case FUNC_NUM_SUB:
-            case FUNC_NUM_MUL:
-            case FUNC_NUM_DIV:
-            case FUNC_NUM_MOD:
-            case FUNC_NUM_AND:
-            case FUNC_NUM_OR:
-            case FUNC_NUM_XOR:
-                // This function is a composite of several subfunctions
-                if (!apply_inner(&map, funcs + i, new_memory))
-                {
-                    return false;
-                }
-
-                break;
-            case FUNC_FAIL:
-            case FUNC_LIST_LPUSH:
-            case FUNC_LIST_RPUSH:
-            case FUNC_DOC_RENAME:
-            case FUNC_DOC_UNSET:
-            case FUNC_SET_ADD:
-            case FUNC_SET_REMOVE:
-            case FUNC_SET_INTERSECT:
-            case FUNC_SET_UNION:
-            default:
-                abort();
-        }
-    }
-
-    size_t sz = 0;
-
-    for (map_t::iterator i = map.begin(); i != map.end(); ++i)
-    {
-        sz += m_k->write_sz(i->first);
-        sz += m_v->write_sz(i->second);
-    }
-
-    uint8_t* write_to = NULL;
-    new_memory->allocate(sz, &write_to);
-    *new_value = e::slice(write_to, sz);
-
-    for (map_t::iterator i = map.begin(); i != map.end(); ++i)
-    {
-        write_to = m_k->write(i->first, write_to);
-        write_to = m_v->write(i->second, write_to);
-    }
-
-    return true;
+	// Initialize map with the compare operator of the key's datatype
+	map_t map(m_k->compare_less());
+	const uint8_t *ptr = old_value.data();
+	const uint8_t *end = old_value.data() + old_value.size();
+	e::slice key;
+	e::slice val;
+	// Read previous data into the map
+	while (ptr < end)
+	{
+		bool stepped;
+		stepped = m_k->step(&ptr, end, &key);
+		assert(stepped);
+		stepped = m_v->step(&ptr, end, &val);
+		assert(stepped);
+		map.insert(std::make_pair(key, val));
+	}
+	for (size_t i = 0; i < funcs_sz; ++i)
+	{
+		switch (funcs[i].name)
+		{
+		case FUNC_SET:
+			// Discard current content and insert a new key-value-pair
+			map.clear();
+			ptr = funcs[i].arg1.data();
+			end = funcs[i].arg1.data() + funcs[i].arg1.size();
+			while (ptr < end)
+			{
+				bool stepped;
+				stepped = m_k->step(&ptr, end, &key);
+				assert(stepped);
+				stepped = m_v->step(&ptr, end, &val);
+				assert(stepped);
+				map.insert(std::make_pair(key, val));
+			}
+			break;
+		case FUNC_MAP_ADD:
+			map[funcs[i].arg2] = funcs[i].arg1;
+			break;
+		case FUNC_MAP_REMOVE:
+			map.erase(funcs[i].arg1);
+			break;
+		case FUNC_STRING_APPEND:
+		case FUNC_STRING_PREPEND:
+		case FUNC_STRING_LTRIM:
+		case FUNC_STRING_RTRIM:
+		case FUNC_NUM_ADD:
+		case FUNC_NUM_MIN:
+		case FUNC_NUM_MAX:
+		case FUNC_NUM_SUB:
+		case FUNC_NUM_MUL:
+		case FUNC_NUM_DIV:
+		case FUNC_NUM_MOD:
+		case FUNC_NUM_AND:
+		case FUNC_NUM_OR:
+		case FUNC_NUM_XOR:
+			// This function is a composite of several subfunctions
+			if (!apply_inner(&map, funcs + i, new_memory))
+			{
+				return false;
+			}
+			break;
+		case FUNC_FAIL:
+		case FUNC_LIST_LPUSH:
+		case FUNC_LIST_RPUSH:
+		case FUNC_DOC_RENAME:
+		case FUNC_DOC_UNSET:
+		case FUNC_SET_ADD:
+		case FUNC_SET_REMOVE:
+		case FUNC_SET_INTERSECT:
+		case FUNC_SET_UNION:
+		default:
+			abort();
+		}
+	}
+	size_t sz = 0;
+	for (map_t::iterator i = map.begin(); i != map.end(); ++i)
+	{
+		sz += m_k->write_sz(i->first);
+		sz += m_v->write_sz(i->second);
+	}
+	uint8_t *write_to = NULL;
+	new_memory->allocate(sz, &write_to);
+	*new_value = e::slice(write_to, sz);
+	for (map_t::iterator i = map.begin(); i != map.end(); ++i)
+	{
+		write_to = m_k->write(i->first, write_to);
+		write_to = m_v->write(i->second, write_to);
+	}
+	return true;
 }
 
 bool
-datatype_map :: apply_inner(map_t* m,
-                            const funcall* func,
-                            e::arena* new_memory) const
+datatype_map :: apply_inner(map_t *m,
+                            const funcall *func,
+                            e::arena *new_memory) const
 {
-    map_t::iterator it = m->find(func->arg2);
-    e::slice old_value("", 0);
-
-    if (it != m->end())
-    {
-        old_value = it->second;
-    }
-
-    e::slice new_value;
-
-    if (!m_v->apply(old_value, func, 1, new_memory, &new_value))
-    {
-        return false;
-    }
-
-    (*m)[func->arg2] = new_value;
-    return true;
+	map_t::iterator it = m->find(func->arg2);
+	e::slice old_value("", 0);
+	if (it != m->end())
+	{
+		old_value = it->second;
+	}
+	e::slice new_value;
+	if (!m_v->apply(old_value, func, 1, new_memory, &new_value))
+	{
+		return false;
+	}
+	(*m)[func->arg2] = new_value;
+	return true;
 }
 
 bool
 datatype_map :: indexable() const
 {
-    return m_k->indexable();
+	return m_k->indexable();
 }
 
 bool
 datatype_map :: has_length() const
 {
-    return true;
+	return true;
 }
 
 uint64_t
-datatype_map :: length(const e::slice& map) const
+datatype_map :: length(const e::slice &map) const
 {
-    const uint8_t* ptr = map.data();
-    const uint8_t* end = map.data() + map.size();
-    e::slice key;
-    e::slice val;
-    uint64_t count = 0;
-
-    while (ptr < end)
-    {
-        bool stepped;
-        stepped = m_k->step(&ptr, end, &key);
-        assert(stepped);
-        stepped = m_v->step(&ptr, end, &val);
-        assert(stepped);
-        ++count;
-    }
-
-    assert(ptr == end);
-    return count;
+	const uint8_t *ptr = map.data();
+	const uint8_t *end = map.data() + map.size();
+	e::slice key;
+	e::slice val;
+	uint64_t count = 0;
+	while (ptr < end)
+	{
+		bool stepped;
+		stepped = m_k->step(&ptr, end, &key);
+		assert(stepped);
+		stepped = m_v->step(&ptr, end, &val);
+		assert(stepped);
+		++count;
+	}
+	assert(ptr == end);
+	return count;
 }
 
 bool
 datatype_map :: has_contains() const
 {
-    return true;
+	return true;
 }
 
 hyperdatatype
 datatype_map :: contains_datatype() const
 {
-    return m_k->datatype();
+	return m_k->datatype();
 }
 
 bool
-datatype_map :: contains(const e::slice& map, const e::slice& needle) const
+datatype_map :: contains(const e::slice &map, const e::slice &needle) const
 {
-    const uint8_t* ptr = map.data();
-    const uint8_t* end = map.data() + map.size();
-    e::slice key;
-    e::slice val;
-
-    while (ptr < end)
-    {
-        bool stepped;
-        stepped = m_k->step(&ptr, end, &key);
-        assert(stepped);
-        stepped = m_v->step(&ptr, end, &val);
-        assert(stepped);
-
-        if (key == needle)
-        {
-            return true;
-        }
-    }
-
-    assert(ptr == end);
-    return false;
+	const uint8_t *ptr = map.data();
+	const uint8_t *end = map.data() + map.size();
+	e::slice key;
+	e::slice val;
+	while (ptr < end)
+	{
+		bool stepped;
+		stepped = m_k->step(&ptr, end, &key);
+		assert(stepped);
+		stepped = m_v->step(&ptr, end, &val);
+		assert(stepped);
+		if (key == needle)
+		{
+			return true;
+		}
+	}
+	assert(ptr == end);
+	return false;
 }
diff --git a/common/datatype_map.h b/common/datatype_map.h
index b1966476e..79aad8051 100644
--- a/common/datatype_map.h
+++ b/common/datatype_map.h
@@ -42,48 +42,48 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class datatype_map : public datatype_info
 {
-    public:
-        datatype_map(datatype_info* k, datatype_info* v);
-        virtual ~datatype_map() throw ();
-
-    public:
-        virtual hyperdatatype datatype() const;
-        virtual bool validate(const e::slice& value) const;
-        virtual bool check_args(const funcall& func) const;
-        virtual bool apply(const e::slice& old_value,
-                           const funcall* funcs, size_t funcs_sz,
-                           e::arena* new_memory,
-                           e::slice* new_value) const;
-
-    public:
-        virtual bool indexable() const;
-
-    public:
-        virtual bool has_length() const;
-        virtual uint64_t length(const e::slice& value) const;
-
-    public:
-        virtual bool has_contains() const;
-        virtual hyperdatatype contains_datatype() const;
-        virtual bool contains(const e::slice& value, const e::slice& needle) const;
-
-    private:
-        typedef std::map<e::slice, e::slice, datatype_info::compares_less> map_t;
-
-    private:
-        datatype_map(const datatype_map&);
-        datatype_map& operator = (const datatype_map&);
-
-    private:
-        bool apply_inner(map_t* m,
-                         const funcall* func,
-                         e::arena* new_memory) const;
-
-    private:
-        // Datatype of the keys
-        datatype_info* m_k;
-        // Datatype of the values
-        datatype_info* m_v;
+public:
+	datatype_map(datatype_info *k, datatype_info *v);
+	virtual ~datatype_map() throw ();
+
+public:
+	virtual hyperdatatype datatype() const;
+	virtual bool validate(const e::slice &value) const;
+	virtual bool check_args(const funcall &func) const;
+	virtual bool apply(const e::slice &old_value,
+	                   const funcall *funcs, size_t funcs_sz,
+	                   e::arena *new_memory,
+	                   e::slice *new_value) const;
+
+public:
+	virtual bool indexable() const;
+
+public:
+	virtual bool has_length() const;
+	virtual uint64_t length(const e::slice &value) const;
+
+public:
+	virtual bool has_contains() const;
+	virtual hyperdatatype contains_datatype() const;
+	virtual bool contains(const e::slice &value, const e::slice &needle) const;
+
+private:
+	typedef std::map<e::slice, e::slice, datatype_info::compares_less> map_t;
+
+private:
+	datatype_map(const datatype_map &);
+	datatype_map &operator = (const datatype_map &);
+
+private:
+	bool apply_inner(map_t *m,
+	                 const funcall *func,
+	                 e::arena *new_memory) const;
+
+private:
+	// Datatype of the keys
+	datatype_info *m_k;
+	// Datatype of the values
+	datatype_info *m_v;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/common/datatype_set.cc b/common/datatype_set.cc
index 811b1e91c..6f97282e9 100644
--- a/common/datatype_set.cc
+++ b/common/datatype_set.cc
@@ -43,10 +43,10 @@
 
 using hyperdex::datatype_set;
 
-datatype_set :: datatype_set(datatype_info* elem)
-    : m_elem(elem)
+datatype_set :: datatype_set(datatype_info *elem)
+	: m_elem(elem)
 {
-    assert(m_elem->containable() && m_elem->comparable());
+	assert(m_elem->containable() && m_elem->comparable());
 }
 
 datatype_set :: ~datatype_set() throw ()
@@ -56,224 +56,203 @@ datatype_set :: ~datatype_set() throw ()
 hyperdatatype
 datatype_set :: datatype() const
 {
-    return CREATE_CONTAINER(HYPERDATATYPE_SET_GENERIC, m_elem->datatype());
+	return CREATE_CONTAINER(HYPERDATATYPE_SET_GENERIC, m_elem->datatype());
 }
 
 bool
-datatype_set :: validate(const e::slice& set) const
+datatype_set :: validate(const e::slice &set) const
 {
-    const uint8_t* ptr = set.data();
-    const uint8_t* end = set.data() + set.size();
-    e::slice elem;
-    e::slice old;
-    bool has_old = false;
-
-    while (ptr < end)
-    {
-        if (!m_elem->step(&ptr, end, &elem))
-        {
-            return false;
-        }
-
-        if (has_old)
-        {
-            if (m_elem->compare(old, elem) >= 0)
-            {
-                return false;
-            }
-        }
-
-        old = elem;
-        has_old = true;
-    }
-
-    return ptr == end;
+	const uint8_t *ptr = set.data();
+	const uint8_t *end = set.data() + set.size();
+	e::slice elem;
+	e::slice old;
+	bool has_old = false;
+	while (ptr < end)
+	{
+		if (!m_elem->step(&ptr, end, &elem))
+		{
+			return false;
+		}
+		if (has_old)
+		{
+			if (m_elem->compare(old, elem) >= 0)
+			{
+				return false;
+			}
+		}
+		old = elem;
+		has_old = true;
+	}
+	return ptr == end;
 }
 
 bool
-datatype_set :: check_args(const funcall& func) const
+datatype_set :: check_args(const funcall &func) const
 {
-    return ((func.arg1_datatype == datatype() ||
-             func.arg1_datatype == HYPERDATATYPE_SET_GENERIC) &&
-            validate(func.arg1) &&
-            (func.name == FUNC_SET ||
-             func.name == FUNC_SET_UNION ||
-             func.name == FUNC_SET_INTERSECT)) ||
-           (func.arg1_datatype == m_elem->datatype() &&
-            m_elem->validate(func.arg1) &&
-            (func.name == FUNC_SET_ADD ||
-             func.name == FUNC_SET_REMOVE));
+	return ((func.arg1_datatype == datatype() ||
+	         func.arg1_datatype == HYPERDATATYPE_SET_GENERIC) &&
+	        validate(func.arg1) &&
+	        (func.name == FUNC_SET ||
+	         func.name == FUNC_SET_UNION ||
+	         func.name == FUNC_SET_INTERSECT)) ||
+	       (func.arg1_datatype == m_elem->datatype() &&
+	        m_elem->validate(func.arg1) &&
+	        (func.name == FUNC_SET_ADD ||
+	         func.name == FUNC_SET_REMOVE));
 }
 
 bool
-datatype_set :: apply(const e::slice& old_value,
-                      const funcall* funcs, size_t funcs_sz,
-                      e::arena* new_memory,
-                      e::slice* new_value) const
+datatype_set :: apply(const e::slice &old_value,
+                      const funcall *funcs, size_t funcs_sz,
+                      e::arena *new_memory,
+                      e::slice *new_value) const
 {
-    typedef std::set<e::slice, datatype_info::compares_less> set_t;
-    set_t set(m_elem->compare_less());
-    set_t tmp(m_elem->compare_less());
-    const uint8_t* ptr = old_value.data();
-    const uint8_t* end = old_value.data() + old_value.size();
-    e::slice elem;
-
-    while (ptr < end)
-    {
-        bool stepped = m_elem->step(&ptr, end, &elem);
-        assert(stepped); // safe because of check_args
-        set.insert(elem);
-    }
-
-    for (size_t i = 0; i < funcs_sz; ++i)
-    {
-        switch (funcs[i].name)
-        {
-            case FUNC_SET:
-                set.clear();
-                // intentional fall-through
-            case FUNC_SET_UNION:
-                ptr = funcs[i].arg1.data();
-                end = funcs[i].arg1.data() + funcs[i].arg1.size();
-
-                while (ptr < end)
-                {
-                    bool stepped = m_elem->step(&ptr, end, &elem);
-                    assert(stepped); // safe because of check_args
-                    set.insert(elem);
-                }
-
-                break;
-            case FUNC_SET_ADD:
-                set.insert(funcs[i].arg1);
-                break;
-            case FUNC_SET_REMOVE:
-                set.erase(funcs[i].arg1);
-                break;
-            case FUNC_SET_INTERSECT:
-                tmp.clear();
-                ptr = funcs[i].arg1.data();
-                end = funcs[i].arg1.data() + funcs[i].arg1.size();
-
-                while (ptr < end)
-                {
-                    bool stepped = m_elem->step(&ptr, end, &elem);
-                    assert(stepped); // safe because of check_args
-
-                    if (set.find(elem) != set.end())
-                    {
-                        tmp.insert(elem);
-                    }
-                }
-
-                set.swap(tmp);
-                break;
-            case FUNC_FAIL:
-            case FUNC_STRING_APPEND:
-            case FUNC_STRING_PREPEND:
-            case FUNC_STRING_LTRIM:
-            case FUNC_STRING_RTRIM:
-            case FUNC_NUM_ADD:
-            case FUNC_NUM_SUB:
-            case FUNC_NUM_MUL:
-            case FUNC_NUM_DIV:
-            case FUNC_NUM_MOD:
-            case FUNC_NUM_AND:
-            case FUNC_NUM_OR:
-            case FUNC_NUM_XOR:
-            case FUNC_NUM_MIN:
-            case FUNC_NUM_MAX:
-            case FUNC_DOC_RENAME:
-            case FUNC_DOC_UNSET:
-            case FUNC_LIST_LPUSH:
-            case FUNC_LIST_RPUSH:
-            case FUNC_MAP_ADD:
-            case FUNC_MAP_REMOVE:
-            default:
-                abort();
-        }
-    }
-
-    size_t sz = 0;
-
-    for (set_t::iterator i = set.begin(); i != set.end(); ++i)
-    {
-        sz += m_elem->write_sz(*i);
-    }
-
-    uint8_t* write_to = NULL;
-    new_memory->allocate(sz, &write_to);
-    *new_value = e::slice(write_to, sz);
-
-    for (set_t::iterator i = set.begin(); i != set.end(); ++i)
-    {
-        write_to = m_elem->write(*i, write_to);
-    }
-
-    return true;
+	typedef std::set<e::slice, datatype_info::compares_less> set_t;
+	set_t set(m_elem->compare_less());
+	set_t tmp(m_elem->compare_less());
+	const uint8_t *ptr = old_value.data();
+	const uint8_t *end = old_value.data() + old_value.size();
+	e::slice elem;
+	while (ptr < end)
+	{
+		bool stepped = m_elem->step(&ptr, end, &elem);
+		assert(stepped); // safe because of check_args
+		set.insert(elem);
+	}
+	for (size_t i = 0; i < funcs_sz; ++i)
+	{
+		switch (funcs[i].name)
+		{
+		case FUNC_SET:
+			set.clear();
+		// intentional fall-through
+		case FUNC_SET_UNION:
+			ptr = funcs[i].arg1.data();
+			end = funcs[i].arg1.data() + funcs[i].arg1.size();
+			while (ptr < end)
+			{
+				bool stepped = m_elem->step(&ptr, end, &elem);
+				assert(stepped); // safe because of check_args
+				set.insert(elem);
+			}
+			break;
+		case FUNC_SET_ADD:
+			set.insert(funcs[i].arg1);
+			break;
+		case FUNC_SET_REMOVE:
+			set.erase(funcs[i].arg1);
+			break;
+		case FUNC_SET_INTERSECT:
+			tmp.clear();
+			ptr = funcs[i].arg1.data();
+			end = funcs[i].arg1.data() + funcs[i].arg1.size();
+			while (ptr < end)
+			{
+				bool stepped = m_elem->step(&ptr, end, &elem);
+				assert(stepped); // safe because of check_args
+				if (set.find(elem) != set.end())
+				{
+					tmp.insert(elem);
+				}
+			}
+			set.swap(tmp);
+			break;
+		case FUNC_FAIL:
+		case FUNC_STRING_APPEND:
+		case FUNC_STRING_PREPEND:
+		case FUNC_STRING_LTRIM:
+		case FUNC_STRING_RTRIM:
+		case FUNC_NUM_ADD:
+		case FUNC_NUM_SUB:
+		case FUNC_NUM_MUL:
+		case FUNC_NUM_DIV:
+		case FUNC_NUM_MOD:
+		case FUNC_NUM_AND:
+		case FUNC_NUM_OR:
+		case FUNC_NUM_XOR:
+		case FUNC_NUM_MIN:
+		case FUNC_NUM_MAX:
+		case FUNC_DOC_RENAME:
+		case FUNC_DOC_UNSET:
+		case FUNC_LIST_LPUSH:
+		case FUNC_LIST_RPUSH:
+		case FUNC_MAP_ADD:
+		case FUNC_MAP_REMOVE:
+		default:
+			abort();
+		}
+	}
+	size_t sz = 0;
+	for (set_t::iterator i = set.begin(); i != set.end(); ++i)
+	{
+		sz += m_elem->write_sz(*i);
+	}
+	uint8_t *write_to = NULL;
+	new_memory->allocate(sz, &write_to);
+	*new_value = e::slice(write_to, sz);
+	for (set_t::iterator i = set.begin(); i != set.end(); ++i)
+	{
+		write_to = m_elem->write(*i, write_to);
+	}
+	return true;
 }
 
 bool
 datatype_set :: indexable() const
 {
-    return m_elem->indexable();
+	return m_elem->indexable();
 }
 
 bool
 datatype_set :: has_length() const
 {
-    return true;
+	return true;
 }
 
 uint64_t
-datatype_set :: length(const e::slice& set) const
+datatype_set :: length(const e::slice &set) const
 {
-    const uint8_t* ptr = set.data();
-    const uint8_t* end = set.data() + set.size();
-    e::slice elem;
-    uint64_t count = 0;
-
-    while (ptr < end)
-    {
-        bool stepped = m_elem->step(&ptr, end, &elem);
-        assert(stepped);
-        ++count;
-    }
-
-    assert(ptr == end);
-    return count;
+	const uint8_t *ptr = set.data();
+	const uint8_t *end = set.data() + set.size();
+	e::slice elem;
+	uint64_t count = 0;
+	while (ptr < end)
+	{
+		bool stepped = m_elem->step(&ptr, end, &elem);
+		assert(stepped);
+		++count;
+	}
+	assert(ptr == end);
+	return count;
 }
 
 bool
 datatype_set :: has_contains() const
 {
-    return true;
+	return true;
 }
 
 hyperdatatype
 datatype_set :: contains_datatype() const
 {
-    return m_elem->datatype();
+	return m_elem->datatype();
 }
 
 bool
-datatype_set :: contains(const e::slice& set, const e::slice& needle) const
+datatype_set :: contains(const e::slice &set, const e::slice &needle) const
 {
-    const uint8_t* ptr = set.data();
-    const uint8_t* end = set.data() + set.size();
-    e::slice elem;
-
-    while (ptr < end)
-    {
-        bool stepped = m_elem->step(&ptr, end, &elem);
-        assert(stepped);
-
-        if (elem == needle)
-        {
-            return true;
-        }
-    }
-
-    assert(ptr == end);
-    return false;
+	const uint8_t *ptr = set.data();
+	const uint8_t *end = set.data() + set.size();
+	e::slice elem;
+	while (ptr < end)
+	{
+		bool stepped = m_elem->step(&ptr, end, &elem);
+		assert(stepped);
+		if (elem == needle)
+		{
+			return true;
+		}
+	}
+	assert(ptr == end);
+	return false;
 }
diff --git a/common/datatype_set.h b/common/datatype_set.h
index 01b3a2ebf..608cca864 100644
--- a/common/datatype_set.h
+++ b/common/datatype_set.h
@@ -36,37 +36,37 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class datatype_set : public datatype_info
 {
-    public:
-        datatype_set(datatype_info* elem);
-        virtual ~datatype_set() throw ();
+public:
+	datatype_set(datatype_info *elem);
+	virtual ~datatype_set() throw ();
 
-    public:
-        virtual hyperdatatype datatype() const;
-        virtual bool validate(const e::slice& value) const;
-        virtual bool check_args(const funcall& func) const;
-        virtual bool apply(const e::slice& old_value,
-                           const funcall* funcs, size_t funcs_sz,
-                           e::arena* new_memory,
-                           e::slice* new_value) const;
+public:
+	virtual hyperdatatype datatype() const;
+	virtual bool validate(const e::slice &value) const;
+	virtual bool check_args(const funcall &func) const;
+	virtual bool apply(const e::slice &old_value,
+	                   const funcall *funcs, size_t funcs_sz,
+	                   e::arena *new_memory,
+	                   e::slice *new_value) const;
 
-    public:
-        virtual bool indexable() const;
+public:
+	virtual bool indexable() const;
 
-    public:
-        virtual bool has_length() const;
-        virtual uint64_t length(const e::slice& value) const;
+public:
+	virtual bool has_length() const;
+	virtual uint64_t length(const e::slice &value) const;
 
-    public:
-        virtual bool has_contains() const;
-        virtual hyperdatatype contains_datatype() const;
-        virtual bool contains(const e::slice& value, const e::slice& needle) const;
+public:
+	virtual bool has_contains() const;
+	virtual hyperdatatype contains_datatype() const;
+	virtual bool contains(const e::slice &value, const e::slice &needle) const;
 
-    private:
-        datatype_set(const datatype_set&);
-        datatype_set& operator = (const datatype_set&);
+private:
+	datatype_set(const datatype_set &);
+	datatype_set &operator = (const datatype_set &);
 
-    private:
-        datatype_info* m_elem;
+private:
+	datatype_info *m_elem;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/common/datatype_string.cc b/common/datatype_string.cc
index 4440c2ed2..f8ecf8c94 100644
--- a/common/datatype_string.cc
+++ b/common/datatype_string.cc
@@ -51,253 +51,242 @@ datatype_string :: ~datatype_string() throw ()
 hyperdatatype
 datatype_string :: datatype() const
 {
-    return HYPERDATATYPE_STRING;
+	return HYPERDATATYPE_STRING;
 }
 
 bool
-datatype_string :: validate(const e::slice&) const
+datatype_string :: validate(const e::slice &) const
 {
-    return true;
+	return true;
 }
 
 bool
-datatype_string :: check_args(const funcall& func) const
+datatype_string :: check_args(const funcall &func) const
 {
-    if (func.name == FUNC_SET ||
-        func.name == FUNC_STRING_PREPEND ||
-        func.name == FUNC_STRING_APPEND)
-    {
-        return func.arg1_datatype == HYPERDATATYPE_STRING &&
-               validate(func.arg1);
-    }
-    else if (func.name == FUNC_STRING_LTRIM ||
-             func.name == FUNC_STRING_RTRIM)
-    {
-        datatype_info* di = datatype_info::lookup(HYPERDATATYPE_INT64);
-
-        if (func.arg1_datatype != HYPERDATATYPE_INT64 ||
-            !di->validate(func.arg1))
-        {
-            return false;
-        }
-
-        return datatype_int64::unpack(func.arg1) >= 0;
-    }
-    else
-    {
-        return false;
-    }
+	if (func.name == FUNC_SET ||
+	    func.name == FUNC_STRING_PREPEND ||
+	    func.name == FUNC_STRING_APPEND)
+	{
+		return func.arg1_datatype == HYPERDATATYPE_STRING &&
+		       validate(func.arg1);
+	}
+	else if (func.name == FUNC_STRING_LTRIM ||
+	         func.name == FUNC_STRING_RTRIM)
+	{
+		datatype_info *di = datatype_info::lookup(HYPERDATATYPE_INT64);
+		if (func.arg1_datatype != HYPERDATATYPE_INT64 ||
+		    !di->validate(func.arg1))
+		{
+			return false;
+		}
+		return datatype_int64::unpack(func.arg1) >= 0;
+	}
+	else
+	{
+		return false;
+	}
 }
 
 bool
-datatype_string :: apply(const e::slice& old_value,
-                         const funcall* funcs, size_t funcs_sz,
-                         e::arena* new_memory,
-                         e::slice* new_value) const
+datatype_string :: apply(const e::slice &old_value,
+                         const funcall *funcs, size_t funcs_sz,
+                         e::arena *new_memory,
+                         e::slice *new_value) const
 {
-    size_t alloc_sz = old_value.size();
-
-    for (size_t i = 0; i < funcs_sz; ++i)
-    {
-        alloc_sz += funcs[i].arg1.size();
-    }
-
-    uint8_t* ptr = NULL;
-    new_memory->allocate(alloc_sz, &ptr);
-    size_t sz = old_value.size();
-    memmove(ptr, old_value.data(), sz);
-    int64_t x = 0;
-
-    for (size_t i = 0; i < funcs_sz; ++i)
-    {
-        switch (funcs[i].name)
-        {
-            case FUNC_SET:
-                // Overwrite
-                memmove(ptr, funcs[i].arg1.data(), funcs[i].arg1.size());
-                sz = funcs[i].arg1.size();
-                break;
-            case FUNC_STRING_PREPEND:
-                // Shift
-                memmove(ptr + funcs[i].arg1.size(), ptr, sz);
-                // Fill
-                memmove(ptr, funcs[i].arg1.data(), funcs[i].arg1.size());
-                // Resize
-                sz += funcs[i].arg1.size();
-                break;
-            case FUNC_STRING_APPEND:
-                // Fill
-                memmove(ptr + sz, funcs[i].arg1.data(), funcs[i].arg1.size());
-                // Resize
-                sz += funcs[i].arg1.size();
-                break;
-            case FUNC_STRING_LTRIM:
-                x = datatype_int64::unpack(funcs[i].arg1);
-                x = uint64_t(x) > sz ? sz : x;
-                sz -= x;
-                memmove(ptr, ptr + x, sz);
-                break;
-            case FUNC_STRING_RTRIM:
-                x = datatype_int64::unpack(funcs[i].arg1);
-                x = uint64_t(x) > sz ? sz : x;
-                sz -= x;
-                break;
-            case FUNC_FAIL:
-            case FUNC_NUM_ADD:
-            case FUNC_NUM_SUB:
-            case FUNC_NUM_MUL:
-            case FUNC_NUM_DIV:
-            case FUNC_NUM_MOD:
-            case FUNC_NUM_AND:
-            case FUNC_NUM_OR:
-            case FUNC_NUM_XOR:
-            case FUNC_NUM_MAX:
-            case FUNC_NUM_MIN:
-            case FUNC_LIST_LPUSH:
-            case FUNC_LIST_RPUSH:
-            case FUNC_SET_ADD:
-            case FUNC_SET_REMOVE:
-            case FUNC_SET_INTERSECT:
-            case FUNC_SET_UNION:
-            case FUNC_MAP_ADD:
-            case FUNC_MAP_REMOVE:
-            case FUNC_DOC_RENAME:
-            case FUNC_DOC_UNSET:
-            default:
-                abort();
-        }
-    }
-
-    *new_value = e::slice(ptr, sz);
-    return true;
+	size_t alloc_sz = old_value.size();
+	for (size_t i = 0; i < funcs_sz; ++i)
+	{
+		alloc_sz += funcs[i].arg1.size();
+	}
+	uint8_t *ptr = NULL;
+	new_memory->allocate(alloc_sz, &ptr);
+	size_t sz = old_value.size();
+	memmove(ptr, old_value.data(), sz);
+	int64_t x = 0;
+	for (size_t i = 0; i < funcs_sz; ++i)
+	{
+		switch (funcs[i].name)
+		{
+		case FUNC_SET:
+			// Overwrite
+			memmove(ptr, funcs[i].arg1.data(), funcs[i].arg1.size());
+			sz = funcs[i].arg1.size();
+			break;
+		case FUNC_STRING_PREPEND:
+			// Shift
+			memmove(ptr + funcs[i].arg1.size(), ptr, sz);
+			// Fill
+			memmove(ptr, funcs[i].arg1.data(), funcs[i].arg1.size());
+			// Resize
+			sz += funcs[i].arg1.size();
+			break;
+		case FUNC_STRING_APPEND:
+			// Fill
+			memmove(ptr + sz, funcs[i].arg1.data(), funcs[i].arg1.size());
+			// Resize
+			sz += funcs[i].arg1.size();
+			break;
+		case FUNC_STRING_LTRIM:
+			x = datatype_int64::unpack(funcs[i].arg1);
+			x = uint64_t(x) > sz ? sz : x;
+			sz -= x;
+			memmove(ptr, ptr + x, sz);
+			break;
+		case FUNC_STRING_RTRIM:
+			x = datatype_int64::unpack(funcs[i].arg1);
+			x = uint64_t(x) > sz ? sz : x;
+			sz -= x;
+			break;
+		case FUNC_FAIL:
+		case FUNC_NUM_ADD:
+		case FUNC_NUM_SUB:
+		case FUNC_NUM_MUL:
+		case FUNC_NUM_DIV:
+		case FUNC_NUM_MOD:
+		case FUNC_NUM_AND:
+		case FUNC_NUM_OR:
+		case FUNC_NUM_XOR:
+		case FUNC_NUM_MAX:
+		case FUNC_NUM_MIN:
+		case FUNC_LIST_LPUSH:
+		case FUNC_LIST_RPUSH:
+		case FUNC_SET_ADD:
+		case FUNC_SET_REMOVE:
+		case FUNC_SET_INTERSECT:
+		case FUNC_SET_UNION:
+		case FUNC_MAP_ADD:
+		case FUNC_MAP_REMOVE:
+		case FUNC_DOC_RENAME:
+		case FUNC_DOC_UNSET:
+		default:
+			abort();
+		}
+	}
+	*new_value = e::slice(ptr, sz);
+	return true;
 }
 
 bool
 datatype_string :: hashable() const
 {
-    return true;
+	return true;
 }
 
 uint64_t
-datatype_string :: hash(const e::slice& value) const
+datatype_string :: hash(const e::slice &value) const
 {
-    return CityHash64(reinterpret_cast<const char*>(value.data()), value.size());
+	return CityHash64(reinterpret_cast<const char *>(value.data()), value.size());
 }
 
 bool
 datatype_string :: indexable() const
 {
-    return true;
+	return true;
 }
 
 bool
 datatype_string :: has_length() const
 {
-    return true;
+	return true;
 }
 
 uint64_t
-datatype_string :: length(const e::slice& value) const
+datatype_string :: length(const e::slice &value) const
 {
-    return value.size();
+	return value.size();
 }
 
 bool
 datatype_string :: has_regex() const
 {
-    return true;
+	return true;
 }
 
 bool
-datatype_string :: regex(const e::slice& r,
-                         const e::slice& v) const
+datatype_string :: regex(const e::slice &r,
+                         const e::slice &v) const
 {
-    return regex_match(r.data(), r.size(), v.data(), v.size());
+	return regex_match(r.data(), r.size(), v.data(), v.size());
 }
 
 bool
 datatype_string :: containable() const
 {
-    return true;
+	return true;
 }
 
 bool
-datatype_string :: step(const uint8_t** ptr,
-                        const uint8_t* end,
-                        e::slice* elem) const
+datatype_string :: step(const uint8_t **ptr,
+                        const uint8_t *end,
+                        e::slice *elem) const
 {
-    if (static_cast<size_t>(end - *ptr) < sizeof(uint32_t))
-    {
-        return false;
-    }
-
-    uint32_t sz = 0;
-    *ptr = e::unpack32le(*ptr, &sz);
-    *elem = e::slice(*ptr, sz);
-    *ptr += sz;
-    return *ptr <= end;
+	if (static_cast<size_t>(end - *ptr) < sizeof(uint32_t))
+	{
+		return false;
+	}
+	uint32_t sz = 0;
+	*ptr = e::unpack32le(*ptr, &sz);
+	*elem = e::slice(*ptr, sz);
+	*ptr += sz;
+	return *ptr <= end;
 }
 
 uint64_t
-datatype_string :: write_sz(const e::slice& elem) const
+datatype_string :: write_sz(const e::slice &elem) const
 {
-    return sizeof(uint32_t) + elem.size();
+	return sizeof(uint32_t) + elem.size();
 }
 
-uint8_t*
-datatype_string :: write(const e::slice& elem,
-                         uint8_t* write_to) const
+uint8_t *
+datatype_string :: write(const e::slice &elem,
+                         uint8_t *write_to) const
 {
-    memmove(write_to + sizeof(uint32_t), elem.data(), elem.size());
-    e::pack32le(elem.size(), write_to);
-    return write_to + sizeof(uint32_t) + elem.size();
+	memmove(write_to + sizeof(uint32_t), elem.data(), elem.size());
+	e::pack32le(elem.size(), write_to);
+	return write_to + sizeof(uint32_t) + elem.size();
 }
 
 bool
 datatype_string :: comparable() const
 {
-    return true;
+	return true;
 }
 
 static int
-compare(const e::slice& lhs,
-        const e::slice& rhs)
+compare(const e::slice &lhs,
+        const e::slice &rhs)
 {
-    int cmp = memcmp(lhs.data(), rhs.data(), std::min(lhs.size(), rhs.size()));
-
-    if (cmp == 0)
-    {
-        if (lhs.size() < rhs.size())
-        {
-            return -1;
-        }
-
-        if (lhs.size() > rhs.size())
-        {
-            return 1;
-        }
-
-        return 0;
-    }
-
-    return cmp;
+	int cmp = memcmp(lhs.data(), rhs.data(), std::min(lhs.size(), rhs.size()));
+	if (cmp == 0)
+	{
+		if (lhs.size() < rhs.size())
+		{
+			return -1;
+		}
+		if (lhs.size() > rhs.size())
+		{
+			return 1;
+		}
+		return 0;
+	}
+	return cmp;
 }
 
 int
-datatype_string :: compare(const e::slice& lhs, const e::slice& rhs) const
+datatype_string :: compare(const e::slice &lhs, const e::slice &rhs) const
 {
-    return ::compare(lhs, rhs);
+	return ::compare(lhs, rhs);
 }
 
 static bool
-compare_less(const e::slice& lhs,
-             const e::slice& rhs)
+compare_less(const e::slice &lhs,
+             const e::slice &rhs)
 {
-    return compare(lhs, rhs) < 0;
+	return compare(lhs, rhs) < 0;
 }
 
 datatype_info::compares_less
 datatype_string :: compare_less() const
 {
-    return &::compare_less;
+	return &::compare_less;
 }
diff --git a/common/datatype_string.h b/common/datatype_string.h
index f7e84c50a..65127d81c 100644
--- a/common/datatype_string.h
+++ b/common/datatype_string.h
@@ -36,46 +36,46 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class datatype_string : public datatype_info
 {
-    public:
-        datatype_string();
-        virtual ~datatype_string() throw ();
+public:
+	datatype_string();
+	virtual ~datatype_string() throw ();
 
-    public:
-        virtual hyperdatatype datatype() const;
-        virtual bool validate(const e::slice& value) const;
-        virtual bool check_args(const funcall& func) const;
-        virtual bool apply(const e::slice& old_value,
-                           const funcall* funcs, size_t funcs_sz,
-                           e::arena* new_memory,
-                           e::slice* new_value) const;
+public:
+	virtual hyperdatatype datatype() const;
+	virtual bool validate(const e::slice &value) const;
+	virtual bool check_args(const funcall &func) const;
+	virtual bool apply(const e::slice &old_value,
+	                   const funcall *funcs, size_t funcs_sz,
+	                   e::arena *new_memory,
+	                   e::slice *new_value) const;
 
-    public:
-        virtual bool hashable() const;
-        virtual uint64_t hash(const e::slice& value) const;
-        virtual bool indexable() const;
+public:
+	virtual bool hashable() const;
+	virtual uint64_t hash(const e::slice &value) const;
+	virtual bool indexable() const;
 
-    public:
-        virtual bool has_length() const;
-        virtual uint64_t length(const e::slice& value) const;
+public:
+	virtual bool has_length() const;
+	virtual uint64_t length(const e::slice &value) const;
 
-    public:
-        virtual bool has_regex() const;
-        virtual bool regex(const e::slice& regex,
-                           const e::slice& value) const;
+public:
+	virtual bool has_regex() const;
+	virtual bool regex(const e::slice &regex,
+	                   const e::slice &value) const;
 
-    public:
-        virtual bool containable() const;
-        virtual bool step(const uint8_t** ptr,
-                          const uint8_t* end,
-                          e::slice* elem) const;
-        virtual uint64_t write_sz(const e::slice& elem) const;
-        virtual uint8_t* write(const e::slice& elem,
-                               uint8_t* write_to) const;
+public:
+	virtual bool containable() const;
+	virtual bool step(const uint8_t **ptr,
+	                  const uint8_t *end,
+	                  e::slice *elem) const;
+	virtual uint64_t write_sz(const e::slice &elem) const;
+	virtual uint8_t *write(const e::slice &elem,
+	                       uint8_t *write_to) const;
 
-    public:
-        virtual bool comparable() const;
-        virtual int compare(const e::slice& lhs, const e::slice& rhs) const;
-        virtual compares_less compare_less() const;
+public:
+	virtual bool comparable() const;
+	virtual int compare(const e::slice &lhs, const e::slice &rhs) const;
+	virtual compares_less compare_less() const;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/common/datatype_timestamp.cc b/common/datatype_timestamp.cc
index 9e3b9b6fe..97568de33 100644
--- a/common/datatype_timestamp.cc
+++ b/common/datatype_timestamp.cc
@@ -41,26 +41,24 @@ namespace
 {
 
 int64_t
-unpack(const e::slice& value)
+unpack(const e::slice &value)
 {
-    assert(value.size() == sizeof(int64_t) || value.empty());
-
-    if (value.empty())
-    {
-        return 0;
-    }
-
-    int64_t timestamp;
-    e::unpack64le(value.data(), &timestamp);
-    return timestamp;
+	assert(value.size() == sizeof(int64_t) || value.empty());
+	if (value.empty())
+	{
+		return 0;
+	}
+	int64_t timestamp;
+	e::unpack64le(value.data(), &timestamp);
+	return timestamp;
 }
 
 }
 
 datatype_timestamp :: datatype_timestamp(hyperdatatype t)
-    : m_type(t)
+	: m_type(t)
 {
-    assert(CONTAINER_TYPE(m_type) == HYPERDATATYPE_TIMESTAMP_GENERIC);
+	assert(CONTAINER_TYPE(m_type) == HYPERDATATYPE_TIMESTAMP_GENERIC);
 }
 
 datatype_timestamp :: ~datatype_timestamp() throw ()
@@ -70,48 +68,45 @@ datatype_timestamp :: ~datatype_timestamp() throw ()
 hyperdatatype
 datatype_timestamp :: datatype() const
 {
-    return m_type;
-
+	return m_type;
 }
 
 bool
-datatype_timestamp :: validate(const e::slice& value) const
+datatype_timestamp :: validate(const e::slice &value) const
 {
-    return value.size() == sizeof(int64_t) || value.empty();
+	return value.size() == sizeof(int64_t) || value.empty();
 }
 
 bool
-datatype_timestamp :: check_args(const funcall& func) const
+datatype_timestamp :: check_args(const funcall &func) const
 {
-    return func.name == FUNC_SET && func.arg1_datatype == this->datatype() && validate(func.arg1);
+	return func.name == FUNC_SET && func.arg1_datatype == this->datatype() && validate(func.arg1);
 }
 
 bool
-datatype_timestamp :: apply(const e::slice& old_value,
-                            const funcall* funcs, size_t funcs_sz,
-                            e::arena* new_memory,
-                            e::slice* new_value) const
+datatype_timestamp :: apply(const e::slice &old_value,
+                            const funcall *funcs, size_t funcs_sz,
+                            e::arena *new_memory,
+                            e::slice *new_value) const
 {
-    int64_t timestamp = unpack(old_value);
-
-    for(size_t i = 0; i < funcs_sz; i++ )
-    {
-        const funcall* func = funcs + i;
-        assert(func->name == FUNC_SET);
-        timestamp = unpack(func->arg1);
-    }
-
-    uint8_t* ptr = NULL;
-    new_memory->allocate(sizeof(int64_t), &ptr);
-    e::pack64le(timestamp, ptr);
-    *new_value = e::slice(ptr, sizeof(int64_t));
-    return true;
+	int64_t timestamp = unpack(old_value);
+	for (size_t i = 0; i < funcs_sz; i++ )
+	{
+		const funcall *func = funcs + i;
+		assert(func->name == FUNC_SET);
+		timestamp = unpack(func->arg1);
+	}
+	uint8_t *ptr = NULL;
+	new_memory->allocate(sizeof(int64_t), &ptr);
+	e::pack64le(timestamp, ptr);
+	*new_value = e::slice(ptr, sizeof(int64_t));
+	return true;
 }
 
 bool
 datatype_timestamp::hashable() const
 {
-    return true;
+	return true;
 }
 
 #define INT_SECONDS 60
@@ -126,7 +121,8 @@ const uint64_t INTERVALS[] = {INT_SECONDS,
                               INT_HOURS,
                               INT_DAYS,
                               INT_WEEKS,
-                              INT_MONTHS};
+                              INT_MONTHS
+                             };
 
 const unsigned TABLE_SECOND[] = {0, 1, 2, 3, 4, 5, 6};
 const unsigned TABLE_MINUTE[] = {1, 0, 2, 3, 4, 5, 6};
@@ -136,169 +132,160 @@ const unsigned TABLE_WEEK[]   = {4, 3, 2, 1, 0, 5, 6};
 const unsigned TABLE_MONTH[]  = {5, 4, 3, 2, 1, 0, 6};
 
 uint64_t
-datatype_timestamp :: hash(const e::slice& v) const
+datatype_timestamp :: hash(const e::slice &v) const
 {
-    uint64_t timestamp = unpack(v);
-    const unsigned* table = NULL;
-    uint64_t value[7];
-
-    switch (m_type)
-    {
-        case HYPERDATATYPE_TIMESTAMP_SECOND:
-            table = TABLE_SECOND;
-            break;
-        case HYPERDATATYPE_TIMESTAMP_MINUTE:
-            table = TABLE_MINUTE;
-            break;
-        case HYPERDATATYPE_TIMESTAMP_HOUR:
-            table = TABLE_HOUR;
-            break;
-        case HYPERDATATYPE_TIMESTAMP_DAY:
-            table = TABLE_DAY;
-            break;
-        case HYPERDATATYPE_TIMESTAMP_WEEK:
-            table = TABLE_WEEK;
-            break;
-        case HYPERDATATYPE_TIMESTAMP_MONTH:
-            table = TABLE_MONTH;
-            break;
-        case HYPERDATATYPE_GENERIC:
-        case HYPERDATATYPE_STRING:
-        case HYPERDATATYPE_INT64:
-        case HYPERDATATYPE_FLOAT:
-        case HYPERDATATYPE_DOCUMENT:
-        case HYPERDATATYPE_LIST_GENERIC:
-        case HYPERDATATYPE_LIST_STRING:
-        case HYPERDATATYPE_LIST_INT64:
-        case HYPERDATATYPE_LIST_FLOAT:
-        case HYPERDATATYPE_SET_GENERIC:
-        case HYPERDATATYPE_SET_STRING:
-        case HYPERDATATYPE_SET_INT64:
-        case HYPERDATATYPE_SET_FLOAT:
-        case HYPERDATATYPE_MAP_GENERIC:
-        case HYPERDATATYPE_MAP_STRING_KEYONLY:
-        case HYPERDATATYPE_MAP_STRING_STRING:
-        case HYPERDATATYPE_MAP_STRING_INT64:
-        case HYPERDATATYPE_MAP_STRING_FLOAT:
-        case HYPERDATATYPE_MAP_INT64_KEYONLY:
-        case HYPERDATATYPE_MAP_INT64_STRING:
-        case HYPERDATATYPE_MAP_INT64_INT64:
-        case HYPERDATATYPE_MAP_INT64_FLOAT:
-        case HYPERDATATYPE_MAP_FLOAT_KEYONLY:
-        case HYPERDATATYPE_MAP_FLOAT_STRING:
-        case HYPERDATATYPE_MAP_FLOAT_INT64:
-        case HYPERDATATYPE_MAP_FLOAT_FLOAT:
-        case HYPERDATATYPE_TIMESTAMP_GENERIC:
-        case HYPERDATATYPE_MACAROON_SECRET:
-        case HYPERDATATYPE_GARBAGE:
-        default:
-            return timestamp;
-    }
-
-    uint64_t x = timestamp / 1000000.;
-
-    for (unsigned i = 0; i < 6; ++i)
-    {
-        value[i] = x % INTERVALS[i];
-        x /= INTERVALS[i];
-    }
-
-    value[6] = x;
-    assert(table);
-    uint64_t y = UINT64_MAX;
-    uint64_t h = 0;
-
-    for (unsigned i = 0; i < 6; ++i)
-    {
-        y = y / INTERVALS[table[i]];
-        h += value[table[i]] * y;
-    }
-
-    h += value[table[6]];
-    return h;
+	uint64_t timestamp = unpack(v);
+	const unsigned *table = NULL;
+	uint64_t value[7];
+	switch (m_type)
+	{
+	case HYPERDATATYPE_TIMESTAMP_SECOND:
+		table = TABLE_SECOND;
+		break;
+	case HYPERDATATYPE_TIMESTAMP_MINUTE:
+		table = TABLE_MINUTE;
+		break;
+	case HYPERDATATYPE_TIMESTAMP_HOUR:
+		table = TABLE_HOUR;
+		break;
+	case HYPERDATATYPE_TIMESTAMP_DAY:
+		table = TABLE_DAY;
+		break;
+	case HYPERDATATYPE_TIMESTAMP_WEEK:
+		table = TABLE_WEEK;
+		break;
+	case HYPERDATATYPE_TIMESTAMP_MONTH:
+		table = TABLE_MONTH;
+		break;
+	case HYPERDATATYPE_GENERIC:
+	case HYPERDATATYPE_STRING:
+	case HYPERDATATYPE_INT64:
+	case HYPERDATATYPE_FLOAT:
+	case HYPERDATATYPE_DOCUMENT:
+	case HYPERDATATYPE_LIST_GENERIC:
+	case HYPERDATATYPE_LIST_STRING:
+	case HYPERDATATYPE_LIST_INT64:
+	case HYPERDATATYPE_LIST_FLOAT:
+	case HYPERDATATYPE_SET_GENERIC:
+	case HYPERDATATYPE_SET_STRING:
+	case HYPERDATATYPE_SET_INT64:
+	case HYPERDATATYPE_SET_FLOAT:
+	case HYPERDATATYPE_MAP_GENERIC:
+	case HYPERDATATYPE_MAP_STRING_KEYONLY:
+	case HYPERDATATYPE_MAP_STRING_STRING:
+	case HYPERDATATYPE_MAP_STRING_INT64:
+	case HYPERDATATYPE_MAP_STRING_FLOAT:
+	case HYPERDATATYPE_MAP_INT64_KEYONLY:
+	case HYPERDATATYPE_MAP_INT64_STRING:
+	case HYPERDATATYPE_MAP_INT64_INT64:
+	case HYPERDATATYPE_MAP_INT64_FLOAT:
+	case HYPERDATATYPE_MAP_FLOAT_KEYONLY:
+	case HYPERDATATYPE_MAP_FLOAT_STRING:
+	case HYPERDATATYPE_MAP_FLOAT_INT64:
+	case HYPERDATATYPE_MAP_FLOAT_FLOAT:
+	case HYPERDATATYPE_TIMESTAMP_GENERIC:
+	case HYPERDATATYPE_MACAROON_SECRET:
+	case HYPERDATATYPE_GARBAGE:
+	default:
+		return timestamp;
+	}
+	uint64_t x = timestamp / 1000000.;
+	for (unsigned i = 0; i < 6; ++i)
+	{
+		value[i] = x % INTERVALS[i];
+		x /= INTERVALS[i];
+	}
+	value[6] = x;
+	assert(table);
+	uint64_t y = UINT64_MAX;
+	uint64_t h = 0;
+	for (unsigned i = 0; i < 6; ++i)
+	{
+		y = y / INTERVALS[table[i]];
+		h += value[table[i]] * y;
+	}
+	h += value[table[6]];
+	return h;
 }
 
 bool
 datatype_timestamp :: indexable() const
 {
-    return true;
+	return true;
 }
 
 bool
 datatype_timestamp :: containable() const
 {
-    return true;
+	return true;
 }
 
 bool
-datatype_timestamp :: step(const uint8_t** ptr,
-                           const uint8_t* end,
-                           e::slice* elem) const
+datatype_timestamp :: step(const uint8_t **ptr,
+                           const uint8_t *end,
+                           e::slice *elem) const
 {
-    if (static_cast<size_t>(end - *ptr) < sizeof(int64_t))
-    {
-        return false;
-    }
-
-    *elem = e::slice(*ptr, sizeof(int64_t));
-    *ptr += sizeof(int64_t);
-    return true;
+	if (static_cast<size_t>(end - *ptr) < sizeof(int64_t))
+	{
+		return false;
+	}
+	*elem = e::slice(*ptr, sizeof(int64_t));
+	*ptr += sizeof(int64_t);
+	return true;
 }
 
 uint64_t
-datatype_timestamp :: write_sz(const e::slice& elem) const
+datatype_timestamp :: write_sz(const e::slice &elem) const
 {
-    return elem.size();
+	return elem.size();
 }
 
-uint8_t*
-datatype_timestamp :: write(const e::slice& elem,
-                            uint8_t* write_to) const
+uint8_t *
+datatype_timestamp :: write(const e::slice &elem,
+                            uint8_t *write_to) const
 {
-    memmove(write_to, elem.data(), elem.size());
-    return write_to + elem.size();
+	memmove(write_to, elem.data(), elem.size());
+	return write_to + elem.size();
 }
 
 bool
 datatype_timestamp :: comparable() const
 {
-    return true;
+	return true;
 }
 
 static int
-compare(const e::slice& lhs,
-        const e::slice& rhs)
+compare(const e::slice &lhs,
+        const e::slice &rhs)
 {
-    int64_t lhsnum = unpack(lhs);
-    int64_t rhsnum = unpack(rhs);
-
-    if (lhsnum < rhsnum)
-    {
-        return -1;
-    }
-    if (lhsnum > rhsnum)
-    {
-        return 1;
-    }
-
-    return 0;
+	int64_t lhsnum = unpack(lhs);
+	int64_t rhsnum = unpack(rhs);
+	if (lhsnum < rhsnum)
+	{
+		return -1;
+	}
+	if (lhsnum > rhsnum)
+	{
+		return 1;
+	}
+	return 0;
 }
 
 int
-datatype_timestamp :: compare(const e::slice& lhs, const e::slice& rhs) const
+datatype_timestamp :: compare(const e::slice &lhs, const e::slice &rhs) const
 {
-    return ::compare(lhs, rhs);
+	return ::compare(lhs, rhs);
 }
 
 static bool
-compare_less(const e::slice& lhs,
-             const e::slice& rhs)
+compare_less(const e::slice &lhs,
+             const e::slice &rhs)
 {
-    return compare(lhs, rhs) < 0;
+	return compare(lhs, rhs) < 0;
 }
 
 datatype_info::compares_less
 datatype_timestamp :: compare_less() const
 {
-    return &::compare_less;
+	return &::compare_less;
 }
diff --git a/common/datatype_timestamp.h b/common/datatype_timestamp.h
index 87cb8d9f7..caf84f28c 100644
--- a/common/datatype_timestamp.h
+++ b/common/datatype_timestamp.h
@@ -36,40 +36,40 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class datatype_timestamp : public datatype_info
 {
-    public:
-        datatype_timestamp(hyperdatatype t);
-        virtual ~datatype_timestamp() throw ();
+public:
+	datatype_timestamp(hyperdatatype t);
+	virtual ~datatype_timestamp() throw ();
 
-    public:
-        virtual hyperdatatype datatype() const;
-        virtual bool validate(const e::slice& value) const;
-        virtual bool check_args(const funcall& func) const;
-        virtual bool apply(const e::slice& old_value,
-                           const funcall* funcs, size_t funcs_sz,
-                           e::arena* new_memory,
-                           e::slice* new_value) const;
+public:
+	virtual hyperdatatype datatype() const;
+	virtual bool validate(const e::slice &value) const;
+	virtual bool check_args(const funcall &func) const;
+	virtual bool apply(const e::slice &old_value,
+	                   const funcall *funcs, size_t funcs_sz,
+	                   e::arena *new_memory,
+	                   e::slice *new_value) const;
 
-    public:
-        virtual bool hashable() const;
-        virtual uint64_t hash(const e::slice& value) const;
-        virtual bool indexable() const;
+public:
+	virtual bool hashable() const;
+	virtual uint64_t hash(const e::slice &value) const;
+	virtual bool indexable() const;
 
-    public:
-        virtual bool containable() const;
-        virtual bool step(const uint8_t** ptr,
-                          const uint8_t* end,
-                          e::slice* elem) const;
-        virtual uint64_t write_sz(const e::slice& elem) const;
-        virtual uint8_t* write(const e::slice& elem,
-                               uint8_t* write_to) const;
+public:
+	virtual bool containable() const;
+	virtual bool step(const uint8_t **ptr,
+	                  const uint8_t *end,
+	                  e::slice *elem) const;
+	virtual uint64_t write_sz(const e::slice &elem) const;
+	virtual uint8_t *write(const e::slice &elem,
+	                       uint8_t *write_to) const;
 
-    public:
-        virtual bool comparable() const;
-        virtual int compare(const e::slice& lhs, const e::slice& rhs) const;
-        virtual compares_less compare_less() const;
+public:
+	virtual bool comparable() const;
+	virtual int compare(const e::slice &lhs, const e::slice &rhs) const;
+	virtual compares_less compare_less() const;
 
-    private:
-        hyperdatatype m_type;
+private:
+	hyperdatatype m_type;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/common/documents.cc b/common/documents.cc
index 9fbc2f66a..0fd230727 100644
--- a/common/documents.cc
+++ b/common/documents.cc
@@ -32,30 +32,29 @@
 #include "common/documents.h"
 
 bool
-hyperdex :: is_document_path(const e::slice& p)
+hyperdex :: is_document_path(const e::slice &p)
 {
-    std::string path(p.cdata(), p.size());
-    return treadstone_validate_path(path.c_str()) == 0;
+	std::string path(p.cdata(), p.size());
+	return treadstone_validate_path(path.c_str()) == 0;
 }
 
 void
-hyperdex :: parse_document_path(const char* attr_path,
-                                const char** attr,
-                                const char** path,
-                                std::string* scratch)
+hyperdex :: parse_document_path(const char *attr_path,
+                                const char **attr,
+                                const char **path,
+                                std::string *scratch)
 {
-    *attr = attr_path;
-    *path = NULL;
-
-    for (size_t i = 0; attr_path[i] != '\0'; ++i)
-    {
-        if (attr_path[i] == '[' ||
-            attr_path[i] == '.')
-        {
-            scratch->assign(attr_path, attr_path + i);
-            *attr = scratch->c_str();
-            *path = attr_path + i + 1;
-            break;
-        }
-    }
+	*attr = attr_path;
+	*path = NULL;
+	for (size_t i = 0; attr_path[i] != '\0'; ++i)
+	{
+		if (attr_path[i] == '[' ||
+		    attr_path[i] == '.')
+		{
+			scratch->assign(attr_path, attr_path + i);
+			*attr = scratch->c_str();
+			*path = attr_path + i + 1;
+			break;
+		}
+	}
 }
diff --git a/common/documents.h b/common/documents.h
index 3eaf218d7..66c432a18 100644
--- a/common/documents.h
+++ b/common/documents.h
@@ -37,13 +37,13 @@
 BEGIN_HYPERDEX_NAMESPACE
 
 bool
-is_document_path(const e::slice& p);
+is_document_path(const e::slice &p);
 
 void
-parse_document_path(const char* attr_path,
-                    const char** attr,
-                    const char** path,
-                    std::string* scratch);
+parse_document_path(const char *attr_path,
+                    const char **attr,
+                    const char **path,
+                    std::string *scratch);
 
 END_HYPERDEX_NAMESPACE
 
diff --git a/common/funcall.cc b/common/funcall.cc
index d9378fd0b..1cbef0831 100644
--- a/common/funcall.cc
+++ b/common/funcall.cc
@@ -35,12 +35,12 @@
 using hyperdex::funcall;
 
 funcall :: funcall()
-    : attr(UINT16_MAX)
-    , name(FUNC_FAIL)
-    , arg1()
-    , arg1_datatype()
-    , arg2()
-    , arg2_datatype()
+	: attr(UINT16_MAX)
+	, name(FUNC_FAIL)
+	, arg1()
+	, arg1_datatype()
+	, arg2()
+	, arg2_datatype()
 {
 }
 
@@ -49,189 +49,170 @@ funcall :: ~funcall() throw ()
 }
 
 bool
-hyperdex :: validate_func(const schema& sc, const funcall& func)
+hyperdex :: validate_func(const schema &sc, const funcall &func)
 {
-    if (func.attr >= sc.attrs_sz)
-    {
-        return false;
-    }
-
-    datatype_info* di = datatype_info::lookup(sc.attrs[func.attr].type);
-
-    if (!di || !di->check_args(func))
-    {
-        return false;
-    }
-
-    return true;
+	if (func.attr >= sc.attrs_sz)
+	{
+		return false;
+	}
+	datatype_info *di = datatype_info::lookup(sc.attrs[func.attr].type);
+	if (!di || !di->check_args(func))
+	{
+		return false;
+	}
+	return true;
 }
 
 size_t
-hyperdex :: validate_funcs(const schema& sc,
-                           const std::vector<funcall>& funcs)
+hyperdex :: validate_funcs(const schema &sc,
+                           const std::vector<funcall> &funcs)
 {
-    for (size_t i = 0; i < funcs.size(); ++i)
-    {
-        if ((i > 0 && funcs[i - 1].attr > funcs[i].attr) ||
-            !validate_func(sc, funcs[i]))
-        {
-            return i;
-        }
-    }
-
-    return funcs.size();
+	for (size_t i = 0; i < funcs.size(); ++i)
+	{
+		if ((i > 0 && funcs[i - 1].attr > funcs[i].attr) ||
+		    !validate_func(sc, funcs[i]))
+		{
+			return i;
+		}
+	}
+	return funcs.size();
 }
 
 size_t
-hyperdex :: apply_funcs(const schema& sc,
-                        const std::vector<funcall>& funcs,
-                        const e::slice& key,
-                        const std::vector<e::slice>& old_value,
-                        e::arena* new_memory,
-                        std::vector<e::slice>* new_value)
+hyperdex :: apply_funcs(const schema &sc,
+                        const std::vector<funcall> &funcs,
+                        const e::slice &key,
+                        const std::vector<e::slice> &old_value,
+                        e::arena *new_memory,
+                        std::vector<e::slice> *new_value)
 {
-    // Figure out the size of the new buffer
-    size_t sz = key.size();
-
-    // size of the old value.
-    for (size_t i = 0; i < old_value.size(); ++i)
-    {
-        sz += old_value[i].size() + sizeof(uint64_t);
-    }
-
-    // size of the funcalls.
-    for (size_t i = 0; i < funcs.size(); ++i)
-    {
-        sz += 2 * sizeof(uint32_t)
-            + funcs[i].arg1.size()
-            + funcs[i].arg2.size() + sizeof(uint64_t);
-    }
-
-    new_memory->reserve(sz);
-
-    // Apply the funcalls to each value
-    const funcall* op = funcs.empty() ? NULL : &funcs.front();
-    const funcall* const stop = op + funcs.size();
-    // The next attribute to copy, indexed based on the total number of
-    // dimensions.  It starts at 1, because the key is 0, and 1 is the first
-    // secondary attribute.
-    uint16_t next_to_copy = 1;
-
-    while (op < stop)
-    {
-        const funcall* end = op;
-
-        // Advance until [op, end) is all a continuous range of funcs that all
-        // apply to the same attribute value.
-        while (end < stop && op->attr == end->attr)
-        {
-            if (end->attr == 0 ||
-                end->attr >= sc.attrs_sz ||
-                end->attr < next_to_copy)
-            {
-                return (op - &funcs.front());
-            }
-
-            ++end;
-        }
-
-        // Copy the attributes that are unaffected by funcs.
-        while (next_to_copy < op->attr)
-        {
-            assert(next_to_copy > 0);
-            size_t idx = next_to_copy - 1;
-            unsigned char* tmp = NULL;
-            new_memory->allocate(old_value[idx].size(), &tmp);
-            memmove(tmp, old_value[idx].data(), old_value[idx].size());
-            (*new_value)[idx] = e::slice(tmp, old_value[idx].size());
-            ++next_to_copy;
-        }
-
-        // - "op" now points to the first unapplied funcall
-        // - "end" points to one funcall past the last op we want to apply
-        // - we've copied all attributes so far, even those not mentioned by
-        //   funcs.
-
-        // This call may modify [op, end) funcs.
-        datatype_info* di = datatype_info::lookup(sc.attrs[op->attr].type);
-
-        if (!di->apply(old_value[op->attr - 1], op, end - op, new_memory, &(*new_value)[next_to_copy - 1]))
-        {
-            return (op - &funcs.front());
-        }
-
-        // Why ++ and assert rather than straight assign?  This will help us to
-        // catch any problems in the interaction between funcs and
-        // attributes which we just copy.
-        assert(next_to_copy == op->attr);
-        ++next_to_copy;
-
-        op = end;
-    }
-
-    // Copy the attributes that are unaffected by funcs.
-    while (next_to_copy < sc.attrs_sz)
-    {
-        assert(next_to_copy > 0);
-        size_t idx = next_to_copy - 1;
-        unsigned char* tmp = NULL;
-        new_memory->allocate(old_value[idx].size(), &tmp);
-        memmove(tmp, old_value[idx].data(), old_value[idx].size());
-        (*new_value)[idx] = e::slice(tmp, old_value[idx].size());
-        ++next_to_copy;
-    }
-
-    return funcs.size();
+	// Figure out the size of the new buffer
+	size_t sz = key.size();
+	// size of the old value.
+	for (size_t i = 0; i < old_value.size(); ++i)
+	{
+		sz += old_value[i].size() + sizeof(uint64_t);
+	}
+	// size of the funcalls.
+	for (size_t i = 0; i < funcs.size(); ++i)
+	{
+		sz += 2 * sizeof(uint32_t)
+		      + funcs[i].arg1.size()
+		      + funcs[i].arg2.size() + sizeof(uint64_t);
+	}
+	new_memory->reserve(sz);
+	// Apply the funcalls to each value
+	const funcall *op = funcs.empty() ? NULL : &funcs.front();
+	const funcall *const stop = op + funcs.size();
+	// The next attribute to copy, indexed based on the total number of
+	// dimensions.  It starts at 1, because the key is 0, and 1 is the first
+	// secondary attribute.
+	uint16_t next_to_copy = 1;
+	while (op < stop)
+	{
+		const funcall *end = op;
+		// Advance until [op, end) is all a continuous range of funcs that all
+		// apply to the same attribute value.
+		while (end < stop && op->attr == end->attr)
+		{
+			if (end->attr == 0 ||
+			    end->attr >= sc.attrs_sz ||
+			    end->attr < next_to_copy)
+			{
+				return (op - &funcs.front());
+			}
+			++end;
+		}
+		// Copy the attributes that are unaffected by funcs.
+		while (next_to_copy < op->attr)
+		{
+			assert(next_to_copy > 0);
+			size_t idx = next_to_copy - 1;
+			unsigned char *tmp = NULL;
+			new_memory->allocate(old_value[idx].size(), &tmp);
+			memmove(tmp, old_value[idx].data(), old_value[idx].size());
+			(*new_value)[idx] = e::slice(tmp, old_value[idx].size());
+			++next_to_copy;
+		}
+		// - "op" now points to the first unapplied funcall
+		// - "end" points to one funcall past the last op we want to apply
+		// - we've copied all attributes so far, even those not mentioned by
+		//   funcs.
+		// This call may modify [op, end) funcs.
+		datatype_info *di = datatype_info::lookup(sc.attrs[op->attr].type);
+		if (!di->apply(old_value[op->attr - 1], op, end - op, new_memory, &(*new_value)[next_to_copy - 1]))
+		{
+			return (op - &funcs.front());
+		}
+		// Why ++ and assert rather than straight assign?  This will help us to
+		// catch any problems in the interaction between funcs and
+		// attributes which we just copy.
+		assert(next_to_copy == op->attr);
+		++next_to_copy;
+		op = end;
+	}
+	// Copy the attributes that are unaffected by funcs.
+	while (next_to_copy < sc.attrs_sz)
+	{
+		assert(next_to_copy > 0);
+		size_t idx = next_to_copy - 1;
+		unsigned char *tmp = NULL;
+		new_memory->allocate(old_value[idx].size(), &tmp);
+		memmove(tmp, old_value[idx].data(), old_value[idx].size());
+		(*new_value)[idx] = e::slice(tmp, old_value[idx].size());
+		++next_to_copy;
+	}
+	return funcs.size();
 }
 
 bool
-hyperdex :: operator < (const funcall& lhs, const funcall& rhs)
+hyperdex :: operator < (const funcall &lhs, const funcall &rhs)
 {
-    return lhs.attr < rhs.attr;
+	return lhs.attr < rhs.attr;
 }
 
 e::packer
-hyperdex :: operator << (e::packer lhs, const funcall_t& rhs)
+hyperdex :: operator << (e::packer lhs, const funcall_t &rhs)
 {
-    uint8_t name = static_cast<uint8_t>(rhs);
-    return lhs << name;
+	uint8_t name = static_cast<uint8_t>(rhs);
+	return lhs << name;
 }
 
 e::unpacker
-hyperdex :: operator >> (e::unpacker lhs, funcall_t& rhs)
+hyperdex :: operator >> (e::unpacker lhs, funcall_t &rhs)
 {
-    uint8_t name;
-    lhs = lhs >> name;
-    rhs = static_cast<funcall_t>(name);
-    return lhs;
+	uint8_t name;
+	lhs = lhs >> name;
+	rhs = static_cast<funcall_t>(name);
+	return lhs;
 }
 
 size_t
-hyperdex :: pack_size(const funcall_t&)
+hyperdex :: pack_size(const funcall_t &)
 {
-    return sizeof(uint8_t);
+	return sizeof(uint8_t);
 }
 
 e::packer
-hyperdex :: operator << (e::packer lhs, const funcall& rhs)
+hyperdex :: operator << (e::packer lhs, const funcall &rhs)
 {
-    return lhs << rhs.attr << rhs.name
-               << rhs.arg1 << rhs.arg1_datatype
-               << rhs.arg2 << rhs.arg2_datatype;
+	return lhs << rhs.attr << rhs.name
+	       << rhs.arg1 << rhs.arg1_datatype
+	       << rhs.arg2 << rhs.arg2_datatype;
 }
 
 e::unpacker
-hyperdex :: operator >> (e::unpacker lhs, funcall& rhs)
+hyperdex :: operator >> (e::unpacker lhs, funcall &rhs)
 {
-    return lhs >> rhs.attr >> rhs.name
-               >> rhs.arg1 >> rhs.arg1_datatype
-               >> rhs.arg2 >> rhs.arg2_datatype;
+	return lhs >> rhs.attr >> rhs.name
+	       >> rhs.arg1 >> rhs.arg1_datatype
+	       >> rhs.arg2 >> rhs.arg2_datatype;
 }
 
 size_t
-hyperdex :: pack_size(const funcall& m)
+hyperdex :: pack_size(const funcall &m)
 {
-    return sizeof(uint16_t) + pack_size(m.name)
-         + pack_size(m.arg1) + pack_size(m.arg1_datatype)
-         + pack_size(m.arg2) + pack_size(m.arg2_datatype);
+	return sizeof(uint16_t) + pack_size(m.name)
+	       + pack_size(m.arg1) + pack_size(m.arg1_datatype)
+	       + pack_size(m.arg2) + pack_size(m.arg2_datatype);
 }
diff --git a/common/funcall.h b/common/funcall.h
index a12355542..d46c6530c 100644
--- a/common/funcall.h
+++ b/common/funcall.h
@@ -48,87 +48,87 @@ BEGIN_HYPERDEX_NAMESPACE
 
 enum funcall_t
 {
-    FUNC_FAIL = 0,
-
-    FUNC_SET = 1,
-
-    FUNC_STRING_APPEND  = 2,
-    FUNC_STRING_PREPEND = 3,
-    FUNC_STRING_LTRIM   = 24,
-    FUNC_STRING_RTRIM   = 25,
-
-    FUNC_NUM_ADD = 4,
-    FUNC_NUM_SUB = 5,
-    FUNC_NUM_MUL = 6,
-    FUNC_NUM_DIV = 7,
-    FUNC_NUM_MOD = 8,
-    FUNC_NUM_AND = 9,
-    FUNC_NUM_OR  = 10,
-    FUNC_NUM_XOR = 11,
-    FUNC_NUM_MAX = 12,
-    FUNC_NUM_MIN = 13,
-
-    FUNC_LIST_LPUSH = 14,
-    FUNC_LIST_RPUSH = 15,
-
-    FUNC_SET_ADD       = 16,
-    FUNC_SET_REMOVE    = 17,
-    FUNC_SET_INTERSECT = 18,
-    FUNC_SET_UNION     = 19,
-
-    FUNC_MAP_ADD    = 20,
-    FUNC_MAP_REMOVE = 21,
-
-    FUNC_DOC_RENAME = 22,
-    FUNC_DOC_UNSET  = 23
+	FUNC_FAIL = 0,
+
+	FUNC_SET = 1,
+
+	FUNC_STRING_APPEND  = 2,
+	FUNC_STRING_PREPEND = 3,
+	FUNC_STRING_LTRIM   = 24,
+	FUNC_STRING_RTRIM   = 25,
+
+	FUNC_NUM_ADD = 4,
+	FUNC_NUM_SUB = 5,
+	FUNC_NUM_MUL = 6,
+	FUNC_NUM_DIV = 7,
+	FUNC_NUM_MOD = 8,
+	FUNC_NUM_AND = 9,
+	FUNC_NUM_OR  = 10,
+	FUNC_NUM_XOR = 11,
+	FUNC_NUM_MAX = 12,
+	FUNC_NUM_MIN = 13,
+
+	FUNC_LIST_LPUSH = 14,
+	FUNC_LIST_RPUSH = 15,
+
+	FUNC_SET_ADD       = 16,
+	FUNC_SET_REMOVE    = 17,
+	FUNC_SET_INTERSECT = 18,
+	FUNC_SET_UNION     = 19,
+
+	FUNC_MAP_ADD    = 20,
+	FUNC_MAP_REMOVE = 21,
+
+	FUNC_DOC_RENAME = 22,
+	FUNC_DOC_UNSET  = 23
 };
 
 class funcall
 {
-    public:
-        funcall();
-        ~funcall() throw ();
-
-    public:
-        uint16_t attr;
-        funcall_t name;
-        e::slice arg1;
-        hyperdatatype arg1_datatype;
-        e::slice arg2;
-        hyperdatatype arg2_datatype;
+public:
+	funcall();
+	~funcall() throw ();
+
+public:
+	uint16_t attr;
+	funcall_t name;
+	e::slice arg1;
+	hyperdatatype arg1_datatype;
+	e::slice arg2;
+	hyperdatatype arg2_datatype;
 };
 
 bool
-validate_func(const schema& sc, const funcall& func);
+validate_func(const schema &sc, const funcall &func);
 
 size_t
-validate_funcs(const schema& sc,
-               const std::vector<funcall>& funcs);
+validate_funcs(const schema &sc,
+               const std::vector<funcall> &funcs);
 
 size_t
-apply_funcs(const schema& sc,
-            const std::vector<funcall>& funcs,
-            const e::slice& key,
-            const std::vector<e::slice>& old_value,
-            e::arena* new_memory,
-            std::vector<e::slice>* new_value);
+apply_funcs(const schema &sc,
+            const std::vector<funcall> &funcs,
+            const e::slice &key,
+            const std::vector<e::slice> &old_value,
+            e::arena *new_memory,
+            std::vector<e::slice> *new_value);
 
 bool
-operator < (const funcall& lhs, const funcall& rhs);
+operator < (const funcall &lhs, const funcall &rhs);
 
 e::packer
-operator << (e::packer lhs, const funcall_t& rhs);
+operator << (e::packer lhs, const funcall_t &rhs);
 e::unpacker
-operator >> (e::unpacker lhs, funcall_t& rhs);
+operator >> (e::unpacker lhs, funcall_t &rhs);
 size_t
-pack_size(const funcall_t& f);
+pack_size(const funcall_t &f);
 
 e::packer
-operator << (e::packer lhs, const funcall& rhs);
+operator << (e::packer lhs, const funcall &rhs);
 e::unpacker
-operator >> (e::unpacker lhs, funcall& rhs);
+operator >> (e::unpacker lhs, funcall &rhs);
 size_t
-pack_size(const funcall& f);
+pack_size(const funcall &f);
 
 END_HYPERDEX_NAMESPACE
 
diff --git a/common/hash.cc b/common/hash.cc
index 36785c0f8..92edbe142 100644
--- a/common/hash.cc
+++ b/common/hash.cc
@@ -32,37 +32,34 @@
 #include "common/hash.h"
 
 uint64_t
-hyperdex :: hash(hyperdatatype t, const e::slice& v)
+hyperdex :: hash(hyperdatatype t, const e::slice &v)
 {
-    datatype_info* di = datatype_info::lookup(t);
-    assert(di);
-
-    if (!di->hashable())
-    {
-        return 0;
-    }
-
-    return di->hash(v);
+	datatype_info *di = datatype_info::lookup(t);
+	assert(di);
+	if (!di->hashable())
+	{
+		return 0;
+	}
+	return di->hash(v);
 }
 
 void
-hyperdex :: hash(const schema& sc,
-                 const e::slice& key,
-                 uint64_t* h)
+hyperdex :: hash(const schema &sc,
+                 const e::slice &key,
+                 uint64_t *h)
 {
-    *h = hash(sc.attrs[0].type, key);
+	*h = hash(sc.attrs[0].type, key);
 }
 
 void
-hyperdex :: hash(const hyperdex::schema& sc,
-                 const e::slice& key,
-                 const std::vector<e::slice>& value,
-                 uint64_t* hs)
+hyperdex :: hash(const hyperdex::schema &sc,
+                 const e::slice &key,
+                 const std::vector<e::slice> &value,
+                 uint64_t *hs)
 {
-    hs[0] = hash(sc.attrs[0].type, key);
-
-    for (size_t i = 1; i < sc.attrs_sz; ++i)
-    {
-        hs[i] = hash(sc.attrs[i].type, value[i - 1]);
-    }
+	hs[0] = hash(sc.attrs[0].type, key);
+	for (size_t i = 1; i < sc.attrs_sz; ++i)
+	{
+		hs[i] = hash(sc.attrs[i].type, value[i - 1]);
+	}
 }
diff --git a/common/hash.h b/common/hash.h
index 15f7411f1..b7924dff9 100644
--- a/common/hash.h
+++ b/common/hash.h
@@ -41,18 +41,18 @@
 BEGIN_HYPERDEX_NAMESPACE
 
 uint64_t
-hash(hyperdatatype t, const e::slice& v);
+hash(hyperdatatype t, const e::slice &v);
 
 void
-hash(const schema& sc,
-     const e::slice& key,
-     uint64_t* h);
+hash(const schema &sc,
+     const e::slice &key,
+     uint64_t *h);
 
 void
-hash(const schema& sc,
-     const e::slice& key,
-     const std::vector<e::slice>& value,
-     uint64_t* hs);
+hash(const schema &sc,
+     const e::slice &key,
+     const std::vector<e::slice> &value,
+     uint64_t *hs);
 
 END_HYPERDEX_NAMESPACE
 
diff --git a/common/hyperdex.cc b/common/hyperdex.cc
index 3f177c811..b539b98e4 100644
--- a/common/hyperdex.cc
+++ b/common/hyperdex.cc
@@ -30,75 +30,73 @@
 #include "visibility.h"
 #include "common/macros.h"
 
-HYPERDEX_API std::ostream&
-operator << (std::ostream& lhs, hyperdatatype rhs)
+HYPERDEX_API std::ostream &
+operator << (std::ostream &lhs, hyperdatatype rhs)
 {
-    switch (rhs)
-    {
-        STRINGIFY(HYPERDATATYPE_GENERIC);
-        STRINGIFY(HYPERDATATYPE_STRING);
-        STRINGIFY(HYPERDATATYPE_INT64);
-        STRINGIFY(HYPERDATATYPE_FLOAT);
-        STRINGIFY(HYPERDATATYPE_DOCUMENT);
-        STRINGIFY(HYPERDATATYPE_LIST_GENERIC);
-        STRINGIFY(HYPERDATATYPE_LIST_STRING);
-        STRINGIFY(HYPERDATATYPE_LIST_INT64);
-        STRINGIFY(HYPERDATATYPE_LIST_FLOAT);
-        STRINGIFY(HYPERDATATYPE_SET_GENERIC);
-        STRINGIFY(HYPERDATATYPE_SET_STRING);
-        STRINGIFY(HYPERDATATYPE_SET_INT64);
-        STRINGIFY(HYPERDATATYPE_SET_FLOAT);
-        STRINGIFY(HYPERDATATYPE_MAP_GENERIC);
-        STRINGIFY(HYPERDATATYPE_MAP_STRING_KEYONLY);
-        STRINGIFY(HYPERDATATYPE_MAP_STRING_STRING);
-        STRINGIFY(HYPERDATATYPE_MAP_STRING_INT64);
-        STRINGIFY(HYPERDATATYPE_MAP_STRING_FLOAT);
-        STRINGIFY(HYPERDATATYPE_MAP_INT64_KEYONLY);
-        STRINGIFY(HYPERDATATYPE_MAP_INT64_STRING);
-        STRINGIFY(HYPERDATATYPE_MAP_INT64_INT64);
-        STRINGIFY(HYPERDATATYPE_MAP_INT64_FLOAT);
-        STRINGIFY(HYPERDATATYPE_MAP_FLOAT_KEYONLY);
-        STRINGIFY(HYPERDATATYPE_MAP_FLOAT_STRING);
-        STRINGIFY(HYPERDATATYPE_MAP_FLOAT_INT64);
-        STRINGIFY(HYPERDATATYPE_MAP_FLOAT_FLOAT);
-        STRINGIFY(HYPERDATATYPE_TIMESTAMP_GENERIC);
-        STRINGIFY(HYPERDATATYPE_TIMESTAMP_SECOND);
-        STRINGIFY(HYPERDATATYPE_TIMESTAMP_MINUTE);
-        STRINGIFY(HYPERDATATYPE_TIMESTAMP_HOUR);
-        STRINGIFY(HYPERDATATYPE_TIMESTAMP_DAY);
-        STRINGIFY(HYPERDATATYPE_TIMESTAMP_WEEK);
-        STRINGIFY(HYPERDATATYPE_TIMESTAMP_MONTH);
-        STRINGIFY(HYPERDATATYPE_MACAROON_SECRET);
-        STRINGIFY(HYPERDATATYPE_GARBAGE);
-        default:
-            lhs << "unknown hyperdatatype";
-            break;
-    }
-
-    return lhs;
+	switch (rhs)
+	{
+		STRINGIFY(HYPERDATATYPE_GENERIC);
+		STRINGIFY(HYPERDATATYPE_STRING);
+		STRINGIFY(HYPERDATATYPE_INT64);
+		STRINGIFY(HYPERDATATYPE_FLOAT);
+		STRINGIFY(HYPERDATATYPE_DOCUMENT);
+		STRINGIFY(HYPERDATATYPE_LIST_GENERIC);
+		STRINGIFY(HYPERDATATYPE_LIST_STRING);
+		STRINGIFY(HYPERDATATYPE_LIST_INT64);
+		STRINGIFY(HYPERDATATYPE_LIST_FLOAT);
+		STRINGIFY(HYPERDATATYPE_SET_GENERIC);
+		STRINGIFY(HYPERDATATYPE_SET_STRING);
+		STRINGIFY(HYPERDATATYPE_SET_INT64);
+		STRINGIFY(HYPERDATATYPE_SET_FLOAT);
+		STRINGIFY(HYPERDATATYPE_MAP_GENERIC);
+		STRINGIFY(HYPERDATATYPE_MAP_STRING_KEYONLY);
+		STRINGIFY(HYPERDATATYPE_MAP_STRING_STRING);
+		STRINGIFY(HYPERDATATYPE_MAP_STRING_INT64);
+		STRINGIFY(HYPERDATATYPE_MAP_STRING_FLOAT);
+		STRINGIFY(HYPERDATATYPE_MAP_INT64_KEYONLY);
+		STRINGIFY(HYPERDATATYPE_MAP_INT64_STRING);
+		STRINGIFY(HYPERDATATYPE_MAP_INT64_INT64);
+		STRINGIFY(HYPERDATATYPE_MAP_INT64_FLOAT);
+		STRINGIFY(HYPERDATATYPE_MAP_FLOAT_KEYONLY);
+		STRINGIFY(HYPERDATATYPE_MAP_FLOAT_STRING);
+		STRINGIFY(HYPERDATATYPE_MAP_FLOAT_INT64);
+		STRINGIFY(HYPERDATATYPE_MAP_FLOAT_FLOAT);
+		STRINGIFY(HYPERDATATYPE_TIMESTAMP_GENERIC);
+		STRINGIFY(HYPERDATATYPE_TIMESTAMP_SECOND);
+		STRINGIFY(HYPERDATATYPE_TIMESTAMP_MINUTE);
+		STRINGIFY(HYPERDATATYPE_TIMESTAMP_HOUR);
+		STRINGIFY(HYPERDATATYPE_TIMESTAMP_DAY);
+		STRINGIFY(HYPERDATATYPE_TIMESTAMP_WEEK);
+		STRINGIFY(HYPERDATATYPE_TIMESTAMP_MONTH);
+		STRINGIFY(HYPERDATATYPE_MACAROON_SECRET);
+		STRINGIFY(HYPERDATATYPE_GARBAGE);
+	default:
+		lhs << "unknown hyperdatatype";
+		break;
+	}
+	return lhs;
 }
 
-HYPERDEX_API std::ostream&
-operator << (std::ostream& lhs, hyperpredicate rhs)
+HYPERDEX_API std::ostream &
+operator << (std::ostream &lhs, hyperpredicate rhs)
 {
-    switch (rhs)
-    {
-        STRINGIFY(HYPERPREDICATE_FAIL);
-        STRINGIFY(HYPERPREDICATE_EQUALS);
-        STRINGIFY(HYPERPREDICATE_LESS_THAN);
-        STRINGIFY(HYPERPREDICATE_LESS_EQUAL);
-        STRINGIFY(HYPERPREDICATE_GREATER_EQUAL);
-        STRINGIFY(HYPERPREDICATE_GREATER_THAN);
-        STRINGIFY(HYPERPREDICATE_CONTAINS_LESS_THAN);
-        STRINGIFY(HYPERPREDICATE_REGEX);
-        STRINGIFY(HYPERPREDICATE_LENGTH_EQUALS);
-        STRINGIFY(HYPERPREDICATE_LENGTH_LESS_EQUAL);
-        STRINGIFY(HYPERPREDICATE_LENGTH_GREATER_EQUAL);
-        STRINGIFY(HYPERPREDICATE_CONTAINS);
-        default:
-            lhs << "unknown hyperpredicate";
-            break;
-    }
-
-    return lhs;
+	switch (rhs)
+	{
+		STRINGIFY(HYPERPREDICATE_FAIL);
+		STRINGIFY(HYPERPREDICATE_EQUALS);
+		STRINGIFY(HYPERPREDICATE_LESS_THAN);
+		STRINGIFY(HYPERPREDICATE_LESS_EQUAL);
+		STRINGIFY(HYPERPREDICATE_GREATER_EQUAL);
+		STRINGIFY(HYPERPREDICATE_GREATER_THAN);
+		STRINGIFY(HYPERPREDICATE_CONTAINS_LESS_THAN);
+		STRINGIFY(HYPERPREDICATE_REGEX);
+		STRINGIFY(HYPERPREDICATE_LENGTH_EQUALS);
+		STRINGIFY(HYPERPREDICATE_LENGTH_LESS_EQUAL);
+		STRINGIFY(HYPERPREDICATE_LENGTH_GREATER_EQUAL);
+		STRINGIFY(HYPERPREDICATE_CONTAINS);
+	default:
+		lhs << "unknown hyperpredicate";
+		break;
+	}
+	return lhs;
 }
diff --git a/common/hyperspace.cc b/common/hyperspace.cc
index 0c2e1a88e..18c72e44e 100644
--- a/common/hyperspace.cc
+++ b/common/hyperspace.cc
@@ -35,44 +35,44 @@ using hyperdex::region;
 using hyperdex::replica;
 
 space :: space()
-    : id()
-    , name("")
-    , fault_tolerance()
-    , predecessor_width(1)
-    , sc()
-    , subspaces()
-    , indices()
-    , m_c_strs()
-    , m_attrs()
-{
-}
-
-space :: space(const char* new_name, const hyperdex::schema& _sc)
-    : id()
-    , name(new_name)
-    , fault_tolerance()
-    , predecessor_width(1)
-    , sc(_sc)
-    , subspaces()
-    , indices()
-    , m_c_strs()
-    , m_attrs()
-{
-    reestablish_backing();
-}
-
-space :: space(const space& other)
-    : id(other.id)
-    , name(other.name)
-    , fault_tolerance(other.fault_tolerance)
-    , predecessor_width(other.predecessor_width)
-    , sc(other.sc)
-    , subspaces(other.subspaces)
-    , indices(other.indices)
-    , m_c_strs()
-    , m_attrs()
-{
-    reestablish_backing();
+	: id()
+	, name("")
+	, fault_tolerance()
+	, predecessor_width(1)
+	, sc()
+	, subspaces()
+	, indices()
+	, m_c_strs()
+	, m_attrs()
+{
+}
+
+space :: space(const char *new_name, const hyperdex::schema &_sc)
+	: id()
+	, name(new_name)
+	, fault_tolerance()
+	, predecessor_width(1)
+	, sc(_sc)
+	, subspaces()
+	, indices()
+	, m_c_strs()
+	, m_attrs()
+{
+	reestablish_backing();
+}
+
+space :: space(const space &other)
+	: id(other.id)
+	, name(other.name)
+	, fault_tolerance(other.fault_tolerance)
+	, predecessor_width(other.predecessor_width)
+	, sc(other.sc)
+	, subspaces(other.subspaces)
+	, indices(other.indices)
+	, m_c_strs()
+	, m_attrs()
+{
+	reestablish_backing();
 }
 
 space :: ~space() throw ()
@@ -82,237 +82,211 @@ space :: ~space() throw ()
 bool
 space :: validate() const
 {
-    for (size_t i = 0; i < sc.attrs_sz; ++i)
-    {
-        for (size_t j = i + 1; j < sc.attrs_sz; ++j)
-        {
-            if (strcmp(sc.attrs[i].name, sc.attrs[j].name) == 0)
-            {
-                return false;
-            }
-        }
-    }
-
-    for (size_t i = 0; i < subspaces.size(); ++i)
-    {
-        // XXX if subspaces[i].regions does not fill volume, then fail
-
-        for (size_t j = 0; j < subspaces[i].regions.size(); ++j)
-        {
-            if (subspaces[i].attrs.size() != subspaces[i].regions[j].lower_coord.size() ||
-                subspaces[i].attrs.size() != subspaces[i].regions[j].upper_coord.size())
-            {
-                return false;
-            }
-        }
-
-        for (size_t j = 0; j < subspaces[i].attrs.size(); ++j)
-        {
-            if (subspaces[i].attrs[j] >= sc.attrs_sz)
-            {
-                return false;
-            }
-
-            for (size_t k = j + 1; k < subspaces[i].attrs.size(); ++k)
-            {
-                if (subspaces[i].attrs[j] == subspaces[i].attrs[k])
-                {
-                    return false;
-                }
-            }
-        }
-    }
-
-    for (size_t i = 0; i < indices.size(); ++i)
-    {
-        if (indices[i].attr >= sc.attrs_sz)
-        {
-            return false;
-        }
-    }
-
-    return true;
-}
-
-space&
-space :: operator = (const space& rhs)
-{
-    id = rhs.id;
-    name = rhs.name;
-    fault_tolerance = rhs.fault_tolerance;
-    sc = rhs.sc;
-    subspaces = rhs.subspaces;
-    indices = rhs.indices;
-    reestablish_backing();
-    return *this;
+	for (size_t i = 0; i < sc.attrs_sz; ++i)
+	{
+		for (size_t j = i + 1; j < sc.attrs_sz; ++j)
+		{
+			if (strcmp(sc.attrs[i].name, sc.attrs[j].name) == 0)
+			{
+				return false;
+			}
+		}
+	}
+	for (size_t i = 0; i < subspaces.size(); ++i)
+	{
+		// XXX if subspaces[i].regions does not fill volume, then fail
+		for (size_t j = 0; j < subspaces[i].regions.size(); ++j)
+		{
+			if (subspaces[i].attrs.size() != subspaces[i].regions[j].lower_coord.size() ||
+			    subspaces[i].attrs.size() != subspaces[i].regions[j].upper_coord.size())
+			{
+				return false;
+			}
+		}
+		for (size_t j = 0; j < subspaces[i].attrs.size(); ++j)
+		{
+			if (subspaces[i].attrs[j] >= sc.attrs_sz)
+			{
+				return false;
+			}
+			for (size_t k = j + 1; k < subspaces[i].attrs.size(); ++k)
+			{
+				if (subspaces[i].attrs[j] == subspaces[i].attrs[k])
+				{
+					return false;
+				}
+			}
+		}
+	}
+	for (size_t i = 0; i < indices.size(); ++i)
+	{
+		if (indices[i].attr >= sc.attrs_sz)
+		{
+			return false;
+		}
+	}
+	return true;
+}
+
+space &
+space :: operator = (const space &rhs)
+{
+	id = rhs.id;
+	name = rhs.name;
+	fault_tolerance = rhs.fault_tolerance;
+	sc = rhs.sc;
+	subspaces = rhs.subspaces;
+	indices = rhs.indices;
+	reestablish_backing();
+	return *this;
 }
 
 void
 space :: reestablish_backing()
 {
-    // Compute the size of the c_strs backing
-    size_t sz = strlen(name) + 1;
-
-    for (size_t i = 0; i < sc.attrs_sz; ++i)
-    {
-        sz += strlen(sc.attrs[i].name) + 1;
-    }
-
-    for (size_t i = 0; i < indices.size(); ++i)
-    {
-        sz += indices[i].extra.size();
-    }
-
-    // Create the two new backings
-    e::array_ptr<char> old_c_strs = m_c_strs;
-    e::array_ptr<attribute> old_attrs = m_attrs;
-    m_c_strs = new char[sz];
-    m_attrs = new attribute[sc.attrs_sz];
-    char* ptr = m_c_strs.get();
-    sz = strlen(name) + 1;
-    memmove(ptr, name, sz);
-    name = ptr;
-    ptr += sz;
-
-    for (size_t i = 0; i < sc.attrs_sz; ++i)
-    {
-        m_attrs[i].type = sc.attrs[i].type;
-        sz = strlen(sc.attrs[i].name) + 1;
-        memmove(ptr, sc.attrs[i].name, sz);
-        m_attrs[i].name = ptr;
-        ptr += sz;
-    }
-
-    sc.attrs = m_attrs.get();
-
-    for (size_t i = 0; i < indices.size(); ++i)
-    {
-        memmove(ptr, indices[i].extra.data(), indices[i].extra.size());
-        indices[i].extra = e::slice(ptr, indices[i].extra.size());
-        ptr += indices[i].extra.size();
-    }
+	// Compute the size of the c_strs backing
+	size_t sz = strlen(name) + 1;
+	for (size_t i = 0; i < sc.attrs_sz; ++i)
+	{
+		sz += strlen(sc.attrs[i].name) + 1;
+	}
+	for (size_t i = 0; i < indices.size(); ++i)
+	{
+		sz += indices[i].extra.size();
+	}
+	// Create the two new backings
+	e::array_ptr<char> old_c_strs = m_c_strs;
+	e::array_ptr<attribute> old_attrs = m_attrs;
+	m_c_strs = new char[sz];
+	m_attrs = new attribute[sc.attrs_sz];
+	char *ptr = m_c_strs.get();
+	sz = strlen(name) + 1;
+	memmove(ptr, name, sz);
+	name = ptr;
+	ptr += sz;
+	for (size_t i = 0; i < sc.attrs_sz; ++i)
+	{
+		m_attrs[i].type = sc.attrs[i].type;
+		sz = strlen(sc.attrs[i].name) + 1;
+		memmove(ptr, sc.attrs[i].name, sz);
+		m_attrs[i].name = ptr;
+		ptr += sz;
+	}
+	sc.attrs = m_attrs.get();
+	for (size_t i = 0; i < indices.size(); ++i)
+	{
+		memmove(ptr, indices[i].extra.data(), indices[i].extra.size());
+		indices[i].extra = e::slice(ptr, indices[i].extra.size());
+		ptr += indices[i].extra.size();
+	}
 }
 
 e::packer
-hyperdex :: operator << (e::packer pa, const space& s)
-{
-    e::slice name;
-    uint16_t num_subspaces = s.subspaces.size();
-    uint16_t num_indices = s.indices.size();
-    name = e::slice(s.name, strlen(s.name));
-    pa = pa << s.id.get() << name << s.fault_tolerance << s.sc.attrs_sz
-            << num_subspaces << num_indices;
-
-    for (size_t i = 0; i < s.sc.attrs_sz; ++i)
-    {
-        name = e::slice(s.sc.attrs[i].name, strlen(s.sc.attrs[i].name));
-        pa = pa << name << static_cast<uint16_t>(s.sc.attrs[i].type);
-    }
-
-    for (size_t i = 0; i < num_subspaces; ++i)
-    {
-        pa = pa << s.subspaces[i];
-    }
-
-    for (size_t i = 0; i < num_indices; ++i)
-    {
-        pa = pa << s.indices[i];
-    }
-
-    return pa;
+hyperdex :: operator << (e::packer pa, const space &s)
+{
+	e::slice name;
+	uint16_t num_subspaces = s.subspaces.size();
+	uint16_t num_indices = s.indices.size();
+	name = e::slice(s.name, strlen(s.name));
+	pa = pa << s.id.get() << name << s.fault_tolerance << s.sc.attrs_sz
+	     << num_subspaces << num_indices;
+	for (size_t i = 0; i < s.sc.attrs_sz; ++i)
+	{
+		name = e::slice(s.sc.attrs[i].name, strlen(s.sc.attrs[i].name));
+		pa = pa << name << static_cast<uint16_t>(s.sc.attrs[i].type);
+	}
+	for (size_t i = 0; i < num_subspaces; ++i)
+	{
+		pa = pa << s.subspaces[i];
+	}
+	for (size_t i = 0; i < num_indices; ++i)
+	{
+		pa = pa << s.indices[i];
+	}
+	return pa;
 }
 
 e::unpacker
-hyperdex :: operator >> (e::unpacker up, space& s)
-{
-    e::slice name;
-    std::vector<std::string> strs;
-    std::vector<attribute> attrs;
-    uint16_t num_subspaces;
-    uint16_t num_indices;
-    up = up >> s.id >> name >> s.fault_tolerance >> s.sc.attrs_sz
-            >> num_subspaces >> num_indices;
-    strs.push_back(std::string(name.cdata(), name.size()));
-    s.name = strs.back().c_str();
-
-    // Unpack all attributes
-    for (size_t i = 0; !up.error() && i < s.sc.attrs_sz; ++i)
-    {
-        e::slice attr;
-        hyperdatatype type;
-        up = up >> attr >> type;
-        strs.push_back(std::string(attr.cdata(), attr.size()));
-        attrs.push_back(attribute(strs.back().c_str(), type));
-
-        if (type == HYPERDATATYPE_MACAROON_SECRET)
-        {
-            s.sc.authorization = true;
-        }
-    }
-
-    s.sc.attrs = &attrs.front();
-    s.sc.attrs_sz = attrs.size();
-
-    // Unpack subspaces
-    s.subspaces.resize(num_subspaces);
-
-    for (size_t i = 0; !up.error() && i < num_subspaces; ++i)
-    {
-        up = up >> s.subspaces[i];
-    }
-
-    // Unpack indices
-    s.indices.resize(num_indices);
-
-    for (size_t i = 0; !up.error() && i < num_indices; ++i)
-    {
-        up = up >> s.indices[i];
-    }
-
-    s.reestablish_backing();
-    return up;
+hyperdex :: operator >> (e::unpacker up, space &s)
+{
+	e::slice name;
+	std::vector<std::string> strs;
+	std::vector<attribute> attrs;
+	uint16_t num_subspaces;
+	uint16_t num_indices;
+	up = up >> s.id >> name >> s.fault_tolerance >> s.sc.attrs_sz
+	     >> num_subspaces >> num_indices;
+	strs.reserve(s.sc.attrs_sz + 1);
+	attrs.reserve(s.sc.attrs_sz);
+	strs.push_back(std::string(name.cdata(), name.size()));
+	s.name = strs.back().c_str();
+	// Unpack all attributes
+	for (size_t i = 0; !up.error() && i < s.sc.attrs_sz; ++i)
+	{
+		e::slice attr;
+		hyperdatatype type;
+		up = up >> attr >> type;
+		strs.push_back(std::string(attr.cdata(), attr.size()));
+		attrs.push_back(attribute(strs.back().c_str(), type));
+		if (type == HYPERDATATYPE_MACAROON_SECRET)
+		{
+			s.sc.authorization = true;
+		}
+	}
+	s.sc.attrs = &attrs.front();
+	s.sc.attrs_sz = attrs.size();
+	// Unpack subspaces
+	s.subspaces.resize(num_subspaces);
+	for (size_t i = 0; !up.error() && i < num_subspaces; ++i)
+	{
+		up = up >> s.subspaces[i];
+	}
+	// Unpack indices
+	s.indices.resize(num_indices);
+	for (size_t i = 0; !up.error() && i < num_indices; ++i)
+	{
+		up = up >> s.indices[i];
+	}
+	s.reestablish_backing();
+	return up;
 }
 
 size_t
-hyperdex :: pack_size(const space& s)
-{
-    size_t sz = sizeof(uint64_t) /* id */
-              + sizeof(uint32_t) + strlen(s.name) /* name */
-              + sizeof(uint64_t) /* fault_tolerance */
-              + sizeof(uint16_t) /* sc.attrs_sz */
-              + sizeof(uint16_t) /* num subspaces */
-              + sizeof(uint16_t); /* num indices */
-
-    for (size_t i = 0; i < s.sc.attrs_sz; ++i)
-    {
-        sz += sizeof(uint32_t) + strlen(s.sc.attrs[i].name)
-            + sizeof(uint16_t);
-    }
-
-    for (size_t i = 0; i < s.subspaces.size(); ++i)
-    {
-        sz += pack_size(s.subspaces[i]);
-    }
-
-    for (size_t i = 0; i < s.indices.size(); ++i)
-    {
-        sz += pack_size(s.indices[i]);
-    }
-
-    return sz;
+hyperdex :: pack_size(const space &s)
+{
+	size_t sz = sizeof(uint64_t) /* id */
+	            + sizeof(uint32_t) + strlen(s.name) /* name */
+	            + sizeof(uint64_t) /* fault_tolerance */
+	            + sizeof(uint16_t) /* sc.attrs_sz */
+	            + sizeof(uint16_t) /* num subspaces */
+	            + sizeof(uint16_t); /* num indices */
+	for (size_t i = 0; i < s.sc.attrs_sz; ++i)
+	{
+		sz += sizeof(uint32_t) + strlen(s.sc.attrs[i].name)
+		      + sizeof(uint16_t);
+	}
+	for (size_t i = 0; i < s.subspaces.size(); ++i)
+	{
+		sz += pack_size(s.subspaces[i]);
+	}
+	for (size_t i = 0; i < s.indices.size(); ++i)
+	{
+		sz += pack_size(s.indices[i]);
+	}
+	return sz;
 }
 
 subspace :: subspace()
-    : id()
-    , attrs()
-    , regions()
+	: id()
+	, attrs()
+	, regions()
 {
 }
 
-subspace :: subspace(const subspace& other)
-    : id(other.id)
-    , attrs(other.attrs)
-    , regions(other.regions)
+subspace :: subspace(const subspace &other)
+	: id(other.id)
+	, attrs(other.attrs)
+	, regions(other.regions)
 {
 }
 
@@ -320,90 +294,82 @@ subspace :: ~subspace() throw ()
 {
 }
 
-subspace&
-subspace :: operator = (const subspace& rhs)
+subspace &
+subspace :: operator = (const subspace &rhs)
 {
-    id = rhs.id;
-    attrs = rhs.attrs;
-    regions = rhs.regions;
-    return *this;
+	id = rhs.id;
+	attrs = rhs.attrs;
+	regions = rhs.regions;
+	return *this;
 }
 
 e::packer
-hyperdex :: operator << (e::packer pa, const subspace& s)
-{
-    uint16_t num_attrs = s.attrs.size();
-    uint32_t num_regions = s.regions.size();
-    pa = pa << s.id.get() << num_attrs << num_regions;
-
-    for (size_t i = 0; i < num_attrs; ++i)
-    {
-        pa = pa << s.attrs[i];
-    }
-
-    for (size_t i = 0; i < num_regions; ++i)
-    {
-        pa = pa << s.regions[i];
-    }
-
-    return pa;
+hyperdex :: operator << (e::packer pa, const subspace &s)
+{
+	uint16_t num_attrs = s.attrs.size();
+	uint32_t num_regions = s.regions.size();
+	pa = pa << s.id.get() << num_attrs << num_regions;
+	for (size_t i = 0; i < num_attrs; ++i)
+	{
+		pa = pa << s.attrs[i];
+	}
+	for (size_t i = 0; i < num_regions; ++i)
+	{
+		pa = pa << s.regions[i];
+	}
+	return pa;
 }
 
 e::unpacker
-hyperdex :: operator >> (e::unpacker up, subspace& s)
-{
-    uint64_t id;
-    uint16_t num_attrs;
-    uint32_t num_regions;
-    up = up >> id >> num_attrs >> num_regions;
-    s.id = subspace_id(id);
-    s.attrs.clear();
-    s.regions.resize(num_regions);
-
-    for (size_t i = 0; !up.error() && i < num_attrs; ++i)
-    {
-        uint16_t attr;
-        up = up >> attr;
-        s.attrs.push_back(attr);
-    }
-
-    for (size_t i = 0; !up.error() && i < num_regions; ++i)
-    {
-        up = up >> s.regions[i];
-    }
-
-    return up;
+hyperdex :: operator >> (e::unpacker up, subspace &s)
+{
+	uint64_t id;
+	uint16_t num_attrs;
+	uint32_t num_regions;
+	up = up >> id >> num_attrs >> num_regions;
+	s.id = subspace_id(id);
+	s.attrs.clear();
+	s.regions.resize(num_regions);
+	for (size_t i = 0; !up.error() && i < num_attrs; ++i)
+	{
+		uint16_t attr;
+		up = up >> attr;
+		s.attrs.push_back(attr);
+	}
+	for (size_t i = 0; !up.error() && i < num_regions; ++i)
+	{
+		up = up >> s.regions[i];
+	}
+	return up;
 }
 
 size_t
-hyperdex :: pack_size(const subspace& s)
+hyperdex :: pack_size(const subspace &s)
 {
-    size_t sz = sizeof(uint64_t) /* id */
-              + sizeof(uint16_t) /* num_attrs */
-              + sizeof(uint32_t) /* num_regions */
-              + sizeof(uint16_t) * s.attrs.size();
-
-    for (size_t i = 0; i < s.regions.size(); ++i)
-    {
-        sz += pack_size(s.regions[i]);
-    }
-
-    return sz;
+	size_t sz = sizeof(uint64_t) /* id */
+	            + sizeof(uint16_t) /* num_attrs */
+	            + sizeof(uint32_t) /* num_regions */
+	            + sizeof(uint16_t) * s.attrs.size();
+	for (size_t i = 0; i < s.regions.size(); ++i)
+	{
+		sz += pack_size(s.regions[i]);
+	}
+	return sz;
 }
 
 region :: region()
-    : id()
-    , lower_coord()
-    , upper_coord()
-    , replicas()
+	: id()
+	, lower_coord()
+	, upper_coord()
+	, replicas()
 {
 }
 
-region :: region(const region& other)
-    : id(other.id)
-    , lower_coord(other.lower_coord)
-    , upper_coord(other.upper_coord)
-    , replicas(other.replicas)
+region :: region(const region &other)
+	: id(other.id)
+	, lower_coord(other.lower_coord)
+	, upper_coord(other.upper_coord)
+	, replicas(other.replicas)
 {
 }
 
@@ -411,93 +377,85 @@ region :: ~region() throw ()
 {
 }
 
-region&
-region :: operator = (const region& rhs)
+region &
+region :: operator = (const region &rhs)
 {
-    id = rhs.id;
-    lower_coord = rhs.lower_coord;
-    upper_coord = rhs.upper_coord;
-    replicas = rhs.replicas;
-    return *this;
+	id = rhs.id;
+	lower_coord = rhs.lower_coord;
+	upper_coord = rhs.upper_coord;
+	replicas = rhs.replicas;
+	return *this;
 }
 
 e::packer
-hyperdex :: operator << (e::packer pa, const region& r)
-{
-    uint16_t num_hashes = r.lower_coord.size();
-    uint8_t num_replicas = r.replicas.size();
-    pa = pa << r.id.get() << num_hashes << num_replicas;
-
-    for (size_t i = 0; i < num_hashes; ++i)
-    {
-        pa = pa << r.lower_coord[i] << r.upper_coord[i];
-    }
-
-    for (size_t i = 0; i < num_replicas; ++i)
-    {
-        pa = pa << r.replicas[i];
-    }
-
-    return pa;
+hyperdex :: operator << (e::packer pa, const region &r)
+{
+	uint16_t num_hashes = r.lower_coord.size();
+	uint8_t num_replicas = r.replicas.size();
+	pa = pa << r.id.get() << num_hashes << num_replicas;
+	for (size_t i = 0; i < num_hashes; ++i)
+	{
+		pa = pa << r.lower_coord[i] << r.upper_coord[i];
+	}
+	for (size_t i = 0; i < num_replicas; ++i)
+	{
+		pa = pa << r.replicas[i];
+	}
+	return pa;
 }
 
 e::unpacker
-hyperdex :: operator >> (e::unpacker up, region& r)
-{
-    uint64_t id;
-    uint16_t num_hashes;
-    uint8_t num_replicas;
-    up = up >> id >> num_hashes >> num_replicas;
-    r.id = region_id(id);
-    r.lower_coord.resize(num_hashes);
-    r.upper_coord.resize(num_hashes);
-    r.replicas.resize(num_replicas);
-
-    for (size_t i = 0; !up.error() && i < num_hashes; ++i)
-    {
-        up = up >> r.lower_coord[i] >> r.upper_coord[i];
-    }
-
-    for (size_t i = 0; !up.error() && i < num_replicas; ++i)
-    {
-        up = up >> r.replicas[i];
-    }
-
-    return up;
+hyperdex :: operator >> (e::unpacker up, region &r)
+{
+	uint64_t id;
+	uint16_t num_hashes;
+	uint8_t num_replicas;
+	up = up >> id >> num_hashes >> num_replicas;
+	r.id = region_id(id);
+	r.lower_coord.resize(num_hashes);
+	r.upper_coord.resize(num_hashes);
+	r.replicas.resize(num_replicas);
+	for (size_t i = 0; !up.error() && i < num_hashes; ++i)
+	{
+		up = up >> r.lower_coord[i] >> r.upper_coord[i];
+	}
+	for (size_t i = 0; !up.error() && i < num_replicas; ++i)
+	{
+		up = up >> r.replicas[i];
+	}
+	return up;
 }
 
 size_t
-hyperdex :: pack_size(const region& r)
+hyperdex :: pack_size(const region &r)
 {
-    size_t sz = sizeof(uint64_t) /* id */
-              + sizeof(uint16_t) /* num_hashes */
-              + sizeof(uint8_t) /* num_replicas */
-              + 2 * sizeof(uint64_t) * r.lower_coord.size();
-
-    for (size_t i = 0; i < r.replicas.size(); ++i)
-    {
-        sz += pack_size(r.replicas[i]);
-    }
-
-    return sz;
+	size_t sz = sizeof(uint64_t) /* id */
+	            + sizeof(uint16_t) /* num_hashes */
+	            + sizeof(uint8_t) /* num_replicas */
+	            + 2 * sizeof(uint64_t) * r.lower_coord.size();
+	for (size_t i = 0; i < r.replicas.size(); ++i)
+	{
+		sz += pack_size(r.replicas[i]);
+	}
+	return sz;
 }
 
 replica :: replica()
-    : si()
-    , vsi()
+	: si()
+	, vsi()
 {
 }
 
-replica :: replica(const hyperdex::server_id& s,
-                   const hyperdex::virtual_server_id& v)
-    : si(s)
-    , vsi(v)
+replica :: replica(const hyperdex::server_id &s,
+                   const hyperdex::virtual_server_id &v)
+	: si(s)
+	, vsi(v)
 {
 }
 
-replica :: replica(const replica& other)
-    : si(other.si)
-    , vsi(other.vsi)
+replica :: replica(const replica &other)
+	: si(other.si)
+	, vsi(other.vsi)
 {
 }
 
@@ -505,33 +463,33 @@ replica :: ~replica() throw ()
 {
 }
 
-replica&
-replica :: operator = (const replica& rhs)
+replica &
+replica :: operator = (const replica &rhs)
 {
-    si = rhs.si;
-    vsi = rhs.vsi;
-    return *this;
+	si = rhs.si;
+	vsi = rhs.vsi;
+	return *this;
 }
 
 e::packer
-hyperdex :: operator << (e::packer pa, const replica& r)
+hyperdex :: operator << (e::packer pa, const replica &r)
 {
-    return pa << r.si.get() << r.vsi.get();
+	return pa << r.si.get() << r.vsi.get();
 }
 
 e::unpacker
-hyperdex :: operator >> (e::unpacker up, replica& r)
+hyperdex :: operator >> (e::unpacker up, replica &r)
 {
-    uint64_t si;
-    uint64_t vsi;
-    up = up >> si >> vsi;
-    r.si = server_id(si);
-    r.vsi = virtual_server_id(vsi);
-    return up;
+	uint64_t si;
+	uint64_t vsi;
+	up = up >> si >> vsi;
+	r.si = server_id(si);
+	r.vsi = virtual_server_id(vsi);
+	return up;
 }
 
 size_t
-hyperdex :: pack_size(const replica&)
+hyperdex :: pack_size(const replica &)
 {
-    return sizeof(uint64_t) + sizeof(uint64_t);
+	return sizeof(uint64_t) + sizeof(uint64_t);
 }
diff --git a/common/hyperspace.h b/common/hyperspace.h
index a785bc48b..35c8cad5b 100644
--- a/common/hyperspace.h
+++ b/common/hyperspace.h
@@ -49,123 +49,123 @@ class replica;
 
 class space
 {
-    public:
-        space();
-        space(const char* name, const schema& sc);
-        space(const space&);
-        ~space() throw ();
-
-    public:
-        bool validate() const;
-        void reestablish_backing();
-
-    public:
-        space& operator = (const space&);
-
-    public:
-        space_id id;
-        const char* name;
-        uint64_t fault_tolerance;
-        uint64_t predecessor_width;
-        hyperdex::schema sc;
-        std::vector<subspace> subspaces;
-        std::vector<index> indices;
-
-        const attribute& get_attribute(uint16_t index) const;
-
-    private:
-        friend e::packer operator << (e::packer, const space& s);
-        friend e::unpacker operator >> (e::unpacker, space& s);
-        friend size_t pack_size(const space&);
-
-    private:
-        e::array_ptr<char> m_c_strs;
-        e::array_ptr<attribute> m_attrs;
+public:
+	space();
+	space(const char *name, const schema &sc);
+	space(const space &);
+	~space() throw ();
+
+public:
+	bool validate() const;
+	void reestablish_backing();
+
+public:
+	space &operator = (const space &);
+
+public:
+	space_id id;
+	const char *name;
+	uint64_t fault_tolerance;
+	uint64_t predecessor_width;
+	hyperdex::schema sc;
+	std::vector<subspace> subspaces;
+	std::vector<index> indices;
+
+	const attribute &get_attribute(uint16_t index) const;
+
+private:
+	friend e::packer operator << (e::packer, const space &s);
+	friend e::unpacker operator >> (e::unpacker, space &s);
+	friend size_t pack_size(const space &);
+
+private:
+	e::array_ptr<char> m_c_strs;
+	e::array_ptr<attribute> m_attrs;
 
 };
 
-inline const attribute& space::get_attribute(uint16_t index) const
+inline const attribute &space::get_attribute(uint16_t index) const
 {
-    return m_attrs[index];
+	return m_attrs[index];
 }
 
 e::packer
-operator << (e::packer, const space& s);
+operator << (e::packer, const space &s);
 e::unpacker
-operator >> (e::unpacker, space& s);
+operator >> (e::unpacker, space &s);
 size_t
-pack_size(const space& s);
+pack_size(const space &s);
 
 class subspace
 {
-    public:
-        subspace();
-        subspace(const subspace&);
-        ~subspace() throw ();
-
-    public:
-        subspace& operator = (const subspace&);
-
-    public:
-        subspace_id id;
-        std::vector<uint16_t> attrs;
-        std::vector<region> regions;
+public:
+	subspace();
+	subspace(const subspace &);
+	~subspace() throw ();
+
+public:
+	subspace &operator = (const subspace &);
+
+public:
+	subspace_id id;
+	std::vector<uint16_t> attrs;
+	std::vector<region> regions;
 };
 
 e::packer
-operator << (e::packer, const subspace& s);
+operator << (e::packer, const subspace &s);
 e::unpacker
-operator >> (e::unpacker, subspace& s);
+operator >> (e::unpacker, subspace &s);
 size_t
-pack_size(const subspace& s);
+pack_size(const subspace &s);
 
 class region
 {
-    public:
-        region();
-        region(const region&);
-        ~region() throw ();
-
-    public:
-        region& operator = (const region&);
-
-    public:
-        region_id id;
-        std::vector<uint64_t> lower_coord;
-        std::vector<uint64_t> upper_coord;
-        std::vector<replica> replicas;
+public:
+	region();
+	region(const region &);
+	~region() throw ();
+
+public:
+	region &operator = (const region &);
+
+public:
+	region_id id;
+	std::vector<uint64_t> lower_coord;
+	std::vector<uint64_t> upper_coord;
+	std::vector<replica> replicas;
 };
 
 e::packer
-operator << (e::packer, const region& r);
+operator << (e::packer, const region &r);
 e::unpacker
-operator >> (e::unpacker, region& r);
+operator >> (e::unpacker, region &r);
 size_t
-pack_size(const region& r);
+pack_size(const region &r);
 
 class replica
 {
-    public:
-        replica();
-        replica(const server_id& si,
-                const virtual_server_id& vsi);
-        replica(const replica&);
-        ~replica() throw ();
-
-    public:
-        replica& operator = (const replica&);
-
-    public:
-        server_id si;
-        virtual_server_id vsi;
+public:
+	replica();
+	replica(const server_id &si,
+	        const virtual_server_id &vsi);
+	replica(const replica &);
+	~replica() throw ();
+
+public:
+	replica &operator = (const replica &);
+
+public:
+	server_id si;
+	virtual_server_id vsi;
 };
 
 e::packer
-operator << (e::packer, const replica& r);
+operator << (e::packer, const replica &r);
 e::unpacker
-operator >> (e::unpacker, replica& r);
+operator >> (e::unpacker, replica &r);
 size_t
-pack_size(const replica& r);
+pack_size(const replica &r);
 
 END_HYPERDEX_NAMESPACE
 
diff --git a/common/ids.cc b/common/ids.cc
index 39a1dab1c..350b3c02c 100644
--- a/common/ids.cc
+++ b/common/ids.cc
@@ -29,24 +29,24 @@
 #include "common/ids.h"
 
 #define CREATE_ID(TYPE) \
-    std::ostream& \
-    operator << (std::ostream& lhs, const TYPE ## _id& rhs) \
-    { \
-        return lhs << #TYPE "(" << rhs.get() << ")"; \
-    } \
-    e::packer \
-    operator << (e::packer pa, const TYPE ## _id& rhs) \
-    { \
-        return pa << rhs.get(); \
-    } \
-    e::unpacker \
-    operator >> (e::unpacker up, TYPE ## _id& rhs) \
-    { \
-        uint64_t id; \
-        up = up >> id; \
-        rhs = TYPE ## _id(id); \
-        return up; \
-    }
+	std::ostream& \
+	operator << (std::ostream& lhs, const TYPE ## _id& rhs) \
+	{ \
+		return lhs << #TYPE "(" << rhs.get() << ")"; \
+	} \
+	e::packer \
+	operator << (e::packer pa, const TYPE ## _id& rhs) \
+	{ \
+		return pa << rhs.get(); \
+	} \
+	e::unpacker \
+	operator >> (e::unpacker up, TYPE ## _id& rhs) \
+	{ \
+		uint64_t id; \
+		up = up >> id; \
+		rhs = TYPE ## _id(id); \
+		return up; \
+	}
 
 BEGIN_HYPERDEX_NAMESPACE
 
diff --git a/common/ids.h b/common/ids.h
index 13720c121..01ce8021c 100644
--- a/common/ids.h
+++ b/common/ids.h
@@ -45,40 +45,40 @@
 // accidently using one type of ID as another.
 
 #define OPERATOR(TYPE, OP) \
-    inline bool \
-    operator OP (const TYPE ## _id& lhs, const TYPE ## _id& rhs) \
-    { \
-        return lhs.get() OP rhs.get(); \
-    }
+	inline bool \
+	operator OP (const TYPE ## _id& lhs, const TYPE ## _id& rhs) \
+	{ \
+		return lhs.get() OP rhs.get(); \
+	}
 #define CREATE_ID(TYPE) \
-    class TYPE ## _id \
-    { \
-        public: \
-            static uint64_t hash(const TYPE ## _id& x) { return x.get(); } \
-            TYPE ## _id() : m_id(0) {} \
-            explicit TYPE ## _id(uint64_t id) : m_id(id) {} \
-        public: \
-            uint64_t get() const { return m_id; } \
-        private: \
-            uint64_t m_id; \
-    }; \
-    std::ostream& \
-    operator << (std::ostream& lhs, const TYPE ## _id& rhs); \
-    inline size_t \
-    pack_size(const TYPE ## _id&) \
-    { \
-        return sizeof(uint64_t); \
-    } \
-    e::packer \
-    operator << (e::packer pa, const TYPE ## _id& rhs); \
-    e::unpacker \
-    operator >> (e::unpacker up, TYPE ## _id& rhs); \
-    OPERATOR(TYPE, <) \
-    OPERATOR(TYPE, <=) \
-    OPERATOR(TYPE, ==) \
-    OPERATOR(TYPE, !=) \
-    OPERATOR(TYPE, >=) \
-    OPERATOR(TYPE, >)
+	class TYPE ## _id \
+	{ \
+	public: \
+		static uint64_t hash(const TYPE ## _id& x) { return x.get(); } \
+		TYPE ## _id() : m_id(0) {} \
+		explicit TYPE ## _id(uint64_t id) : m_id(id) {} \
+	public: \
+		uint64_t get() const { return m_id; } \
+	private: \
+		uint64_t m_id; \
+	}; \
+	std::ostream& \
+	operator << (std::ostream& lhs, const TYPE ## _id& rhs); \
+	inline size_t \
+	pack_size(const TYPE ## _id&) \
+	{ \
+		return sizeof(uint64_t); \
+	} \
+	e::packer \
+	operator << (e::packer pa, const TYPE ## _id& rhs); \
+	e::unpacker \
+	operator >> (e::unpacker up, TYPE ## _id& rhs); \
+	OPERATOR(TYPE, <) \
+	OPERATOR(TYPE, <=) \
+	OPERATOR(TYPE, ==) \
+	OPERATOR(TYPE, !=) \
+	OPERATOR(TYPE, >=) \
+	OPERATOR(TYPE, >)
 
 BEGIN_HYPERDEX_NAMESPACE
 
diff --git a/common/ieee.h b/common/ieee.h
index 2b34ab08f..4a8620619 100644
--- a/common/ieee.h
+++ b/common/ieee.h
@@ -94,29 +94,32 @@
 #define	EXT_FRACBITS	64
 
 #define	EXT_TO_ARRAY32(p, a) do {		\
-	(a)[0] = (uint32_t)(p)->ext_fracl;	\
-	(a)[1] = (uint32_t)(p)->ext_frach;	\
-} while(0)
+		(a)[0] = (uint32_t)(p)->ext_fracl;	\
+		(a)[1] = (uint32_t)(p)->ext_frach;	\
+	} while(0)
 
-struct ieee_single {
-	unsigned int	sng_frac:23;
-	unsigned int	sng_exp:8;
-	unsigned int	sng_sign:1;
+struct ieee_single
+{
+	unsigned int	sng_frac: 23;
+	unsigned int	sng_exp: 8;
+	unsigned int	sng_sign: 1;
 };
 
-struct ieee_double {
+struct ieee_double
+{
 	unsigned int	dbl_fracl;
-	unsigned int	dbl_frach:20;
-	unsigned int	dbl_exp:11;
-	unsigned int	dbl_sign:1;
+	unsigned int	dbl_frach: 20;
+	unsigned int	dbl_exp: 11;
+	unsigned int	dbl_sign: 1;
 };
 
-struct ieee_ext {
+struct ieee_ext
+{
 	unsigned int	ext_fracl;
 	unsigned int	ext_frach;
-	unsigned int	ext_exp:15;
-	unsigned int	ext_sign:1;
-	unsigned int	ext_padl:16;
+	unsigned int	ext_exp: 15;
+	unsigned int	ext_sign: 1;
+	unsigned int	ext_padl: 16;
 	unsigned int	ext_padh;
 };
 
diff --git a/common/index.cc b/common/index.cc
index c51b7c559..987861a60 100644
--- a/common/index.cc
+++ b/common/index.cc
@@ -33,18 +33,18 @@
 using hyperdex::index;
 
 index :: index()
-    : type(NORMAL)
-    , id()
-    , attr(UINT16_MAX)
-    , extra()
+	: type(NORMAL)
+	, id()
+	, attr(UINT16_MAX)
+	, extra()
 {
 }
 
-index :: index(index_t t, index_id i, uint16_t a, const e::slice& e)
-    : type(t)
-    , id(i)
-    , attr(a)
-    , extra(e)
+index :: index(index_t t, index_id i, uint16_t a, const e::slice &e)
+	: type(t)
+	, id(i)
+	, attr(a)
+	, extra(e)
 {
 }
 
@@ -52,76 +52,74 @@ index :: ~index() throw ()
 {
 }
 
-hyperdex::index&
-index :: operator = (const index& rhs)
+hyperdex::index &
+index :: operator = (const index &rhs)
 {
-    if (this != &rhs)
-    {
-        id = rhs.id;
-        attr = rhs.attr;
-    }
-
-    return *this;
+	if (this != &rhs)
+	{
+		id = rhs.id;
+		attr = rhs.attr;
+	}
+	return *this;
 }
 
-std::ostream&
-hyperdex :: operator << (std::ostream& lhs, const index& rhs)
+std::ostream &
+hyperdex :: operator << (std::ostream &lhs, const index &rhs)
 {
-    switch (rhs.type)
-    {
-        case index::NORMAL:
-            lhs << "index(" << rhs.id.get() << ", " << rhs.attr << ")";
-            break;
-        case index::DOCUMENT:
-            lhs << "index(" << rhs.id.get()
-                << ", " << rhs.extra.str()
-                << ", " << rhs.attr <<  ")";
-            break;
-        default:
-            abort();
-    }
-
-    return lhs;
+	switch (rhs.type)
+	{
+	case index::NORMAL:
+		lhs << "index(" << rhs.id.get() << ", " << rhs.attr << ")";
+		break;
+	case index::DOCUMENT:
+		lhs << "index(" << rhs.id.get()
+		    << ", " << rhs.extra.str()
+		    << ", " << rhs.attr <<  ")";
+		break;
+	default:
+		abort();
+	}
+	return lhs;
 }
 
 e::packer
-hyperdex :: operator << (e::packer pa, const index& t)
+hyperdex :: operator << (e::packer pa, const index &t)
 {
-    return pa << t.type << t.id << t.attr << t.extra;
+	return pa << t.type << t.id << t.attr << t.extra;
 }
 
 e::unpacker
-hyperdex :: operator >> (e::unpacker up, index& t)
+hyperdex :: operator >> (e::unpacker up, index &t)
 {
-    up = up >> t.type >> t.id >> t.attr >> t.extra;
-    return up;
+	up = up >> t.type >> t.id >> t.attr >> t.extra;
+	return up;
 }
 
 size_t
-hyperdex :: pack_size(const index& t)
+hyperdex :: pack_size(const index &t)
 {
-    return pack_size(t.type) + pack_size(t.id) + sizeof(t.attr)
-         + sizeof(uint32_t) + t.extra.size();
+	return pack_size(t.type) + pack_size(t.id) + sizeof(t.attr)
+	       + sizeof(uint32_t) + t.extra.size();
 }
 
 e::packer
-hyperdex :: operator << (e::packer pa, const index::index_t& t)
+hyperdex :: operator << (e::packer pa, const index::index_t &t)
 {
-    uint8_t x = t;
-    return pa << x;
+	uint8_t x = t;
+	return pa << x;
 }
 
 e::unpacker
-hyperdex :: operator >> (e::unpacker up, index::index_t& t)
+hyperdex :: operator >> (e::unpacker up, index::index_t &t)
 {
-    uint8_t x;
-    up = up >> x;
-    t = static_cast<index::index_t>(x);
-    return up;
+	uint8_t x;
+	up = up >> x;
+	t = static_cast<index::index_t>(x);
+	return up;
 }
 
 size_t
-hyperdex :: pack_size(const index::index_t&)
+hyperdex :: pack_size(const index::index_t &)
 {
-    return sizeof(uint8_t);
+	return sizeof(uint8_t);
 }
diff --git a/common/index.h b/common/index.h
index f4458b3f9..e965c3152 100644
--- a/common/index.h
+++ b/common/index.h
@@ -40,40 +40,40 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class index
 {
-    public:
-        enum index_t { NORMAL, DOCUMENT };
+public:
+	enum index_t { NORMAL, DOCUMENT };
 
-    public:
-        index();
-        index(index_t t, index_id i, uint16_t a, const e::slice& e);
-        ~index() throw ();
+public:
+	index();
+	index(index_t t, index_id i, uint16_t a, const e::slice &e);
+	~index() throw ();
 
-    public:
-        index& operator = (const index&);
+public:
+	index &operator = (const index &);
 
-    public:
-        index_t type;
-        index_id id;
-        uint16_t attr;
-        e::slice extra;
+public:
+	index_t type;
+	index_id id;
+	uint16_t attr;
+	e::slice extra;
 };
 
-std::ostream&
-operator << (std::ostream& lhs, const index& rhs);
+std::ostream &
+operator << (std::ostream &lhs, const index &rhs);
 
 e::packer
-operator << (e::packer, const index& t);
+operator << (e::packer, const index &t);
 e::unpacker
-operator >> (e::unpacker, index& t);
+operator >> (e::unpacker, index &t);
 size_t
-pack_size(const index& t);
+pack_size(const index &t);
 
 e::packer
-operator << (e::packer, const index::index_t& t);
+operator << (e::packer, const index::index_t &t);
 e::unpacker
-operator >> (e::unpacker, index::index_t& t);
+operator >> (e::unpacker, index::index_t &t);
 size_t
-pack_size(const index::index_t& t);
+pack_size(const index::index_t &t);
 
 END_HYPERDEX_NAMESPACE
 
diff --git a/common/json_path.h b/common/json_path.h
index fe59b59ad..73aeed839 100644
--- a/common/json_path.h
+++ b/common/json_path.h
@@ -38,87 +38,82 @@ BEGIN_HYPERDEX_NAMESPACE
 class json_path
 {
 public:
-    json_path(const char* cstr)
-        : path(cstr)
-    {}
-
-    json_path(const std::string& path_ = "")
-        : path(path_)
-    {}
-
-    json_path(const e::slice& slice)
-        : path(slice.cdata(), slice.size())
-    {}
-
-    bool empty() const
-    {
-        return str().size() == 0;
-    }
-
-    size_t size() const
-    {
-        return str().size();
-    }
-
-    void append(const std::string elem)
-    {
-        if(empty())
-        {
-            path = elem;
-        }
-        else
-        {
-            path += "." + elem;
-        }
-    }
-
-    // Does this path have a subtree?
-    // If not is is just the name of a single element
-    bool has_subtree() const
-    {
-        return path.find(".") != std::string::npos;
-    }
-
-    // Split path at the first .
-    bool split(std::string& root_name, json_path& subtree) const
-    {
-        size_t pos = path.find('.');
-
-        if(pos == std::string::npos)
-        {
-            return false;
-        }
-
-        root_name = path.substr(0, pos);
-        subtree.path = path.substr(pos+1);
-
-        return true;
-    }
-
-    // Split path at the last '.'
-    // i.e. Retrieve last element in the path
-    bool split_reverse(json_path& parent_path, std::string& child_name) const
-    {
-        size_t pos = path.find_last_of('.');
-
-        if(pos == std::string::npos)
-        {
-            return false;
-        }
-
-        child_name = path.substr(pos+1);
-        parent_path.path = path.substr(0, pos);
-        return true;
-    }
-
-    // Get a string representation of the path
-    const std::string& str() const
-    {
-        return path;
-    }
+	json_path(const char *cstr)
+		: path(cstr)
+	{}
+
+	json_path(const std::string &path_ = "")
+		: path(path_)
+	{}
+
+	json_path(const e::slice &slice)
+		: path(slice.cdata(), slice.size())
+	{}
+
+	bool empty() const
+	{
+		return str().size() == 0;
+	}
+
+	size_t size() const
+	{
+		return str().size();
+	}
+
+	void append(const std::string elem)
+	{
+		if (empty())
+		{
+			path = elem;
+		}
+		else
+		{
+			path += "." + elem;
+		}
+	}
+
+	// Does this path have a subtree?
+	// If not is is just the name of a single element
+	bool has_subtree() const
+	{
+		return path.find(".") != std::string::npos;
+	}
+
+	// Split path at the first .
+	bool split(std::string &root_name, json_path &subtree) const
+	{
+		size_t pos = path.find('.');
+		if (pos == std::string::npos)
+		{
+			return false;
+		}
+		root_name = path.substr(0, pos);
+		subtree.path = path.substr(pos + 1);
+		return true;
+	}
+
+	// Split path at the last '.'
+	// i.e. Retrieve last element in the path
+	bool split_reverse(json_path &parent_path, std::string &child_name) const
+	{
+		size_t pos = path.find_last_of('.');
+		if (pos == std::string::npos)
+		{
+			return false;
+		}
+		child_name = path.substr(pos + 1);
+		parent_path.path = path.substr(0, pos);
+		return true;
+	}
+
+	// Get a string representation of the path
+	const std::string &str() const
+	{
+		return path;
+	}
 
 private:
-    std::string path;
+	std::string path;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/common/key_change.cc b/common/key_change.cc
index 1ec19b60e..07afff9a9 100644
--- a/common/key_change.cc
+++ b/common/key_change.cc
@@ -37,29 +37,29 @@
 using hyperdex::key_change;
 
 key_change :: key_change()
-    : key()
-    , erase(false)
-    , fail_if_not_found(false)
-    , fail_if_found(false)
-    , checks()
-    , funcs()
-    , auth()
+	: key()
+	, erase(false)
+	, fail_if_not_found(false)
+	, fail_if_found(false)
+	, checks()
+	, funcs()
+	, auth()
 {
 }
 
-key_change :: key_change(const key_change& other)
-    : key(other.key)
-    , erase(other.erase)
-    , fail_if_not_found(other.fail_if_not_found)
-    , fail_if_found(other.fail_if_found)
-    , checks(other.checks)
-    , funcs(other.funcs)
-    , auth()
+key_change :: key_change(const key_change &other)
+	: key(other.key)
+	, erase(other.erase)
+	, fail_if_not_found(other.fail_if_not_found)
+	, fail_if_found(other.fail_if_found)
+	, checks(other.checks)
+	, funcs(other.funcs)
+	, auth()
 {
-    if (other.auth.get())
-    {
-        auth.reset(new auth_wallet(*other.auth));
-    }
+	if (other.auth.get())
+	{
+		auth.reset(new auth_wallet(*other.auth));
+	}
 }
 
 key_change :: ~key_change() throw ()
@@ -67,60 +67,56 @@ key_change :: ~key_change() throw ()
 }
 
 bool
-key_change :: validate(const schema& sc) const
+key_change :: validate(const schema &sc) const
 {
-    return datatype_info::lookup(sc.attrs[0].type)->validate(key) &&
-           validate_attribute_checks(sc, checks) == checks.size() &&
-           validate_funcs(sc, funcs) == funcs.size() &&
-           (!erase || funcs.empty());
+	return datatype_info::lookup(sc.attrs[0].type)->validate(key) &&
+	       validate_attribute_checks(sc, checks) == checks.size() &&
+	       validate_funcs(sc, funcs) == funcs.size() &&
+	       (!erase || funcs.empty());
 }
 
 hyperdex::network_returncode
-key_change :: check(const schema& sc,
+key_change :: check(const schema &sc,
                     bool has_old_value,
-                    const std::vector<e::slice>* old_value) const
+                    const std::vector<e::slice> *old_value) const
 {
-    const key_change* kc = this;
-
-    if (!has_old_value && kc->erase)
-    {
-        return NET_NOTFOUND;
-    }
-    else if (!has_old_value && kc->fail_if_not_found)
-    {
-        return NET_NOTFOUND;
-    }
-    else if (has_old_value && kc->fail_if_found)
-    {
-        return NET_CMPFAIL;
-    }
-    else if (has_old_value && passes_attribute_checks(sc, kc->checks, key, *old_value) < kc->checks.size())
-    {
-        return NET_CMPFAIL;
-    }
-
-    return NET_SUCCESS;
+	const key_change *kc = this;
+	if (!has_old_value && kc->erase)
+	{
+		return NET_NOTFOUND;
+	}
+	else if (!has_old_value && kc->fail_if_not_found)
+	{
+		return NET_NOTFOUND;
+	}
+	else if (has_old_value && kc->fail_if_found)
+	{
+		return NET_CMPFAIL;
+	}
+	else if (has_old_value && passes_attribute_checks(sc, kc->checks, key, *old_value) < kc->checks.size())
+	{
+		return NET_CMPFAIL;
+	}
+	return NET_SUCCESS;
 }
 
-key_change&
-key_change :: operator = (const key_change& rhs)
+key_change &
+key_change :: operator = (const key_change &rhs)
 {
-    if (this != &rhs)
-    {
-        key               = rhs.key;
-        erase             = rhs.erase;
-        fail_if_not_found = rhs.fail_if_not_found;
-        fail_if_found     = rhs.fail_if_found;
-        checks            = rhs.checks;
-        funcs             = rhs.funcs;
-
-        if (rhs.auth.get())
-        {
-            auth.reset(new auth_wallet(*rhs.auth));
-        }
-    }
-
-    return *this;
+	if (this != &rhs)
+	{
+		key               = rhs.key;
+		erase             = rhs.erase;
+		fail_if_not_found = rhs.fail_if_not_found;
+		fail_if_found     = rhs.fail_if_found;
+		checks            = rhs.checks;
+		funcs             = rhs.funcs;
+		if (rhs.auth.get())
+		{
+			auth.reset(new auth_wallet(*rhs.auth));
+		}
+	}
+	return *this;
 }
 
 #define FLAG_WRITE 128
@@ -129,46 +125,42 @@ key_change :: operator = (const key_change& rhs)
 #define FLAG_FIF 2
 
 e::packer
-hyperdex :: operator << (e::packer pa, const key_change& td)
+hyperdex :: operator << (e::packer pa, const key_change &td)
 {
-    uint8_t flags = (td.erase ? 0 : FLAG_WRITE)
-                  | (td.fail_if_not_found ? FLAG_FINF : 0)
-                  | (td.fail_if_found ? FLAG_FIF : 0)
-                  | (td.auth.get() ? FLAG_AUTH : 0);
-    pa = pa << td.key << flags << td.checks << td.funcs;
-
-    if (td.auth.get())
-    {
-        pa = pa << *td.auth;
-    }
-
-    return pa;
+	uint8_t flags = (td.erase ? 0 : FLAG_WRITE)
+	                | (td.fail_if_not_found ? FLAG_FINF : 0)
+	                | (td.fail_if_found ? FLAG_FIF : 0)
+	                | (td.auth.get() ? FLAG_AUTH : 0);
+	pa = pa << td.key << flags << td.checks << td.funcs;
+	if (td.auth.get())
+	{
+		pa = pa << *td.auth;
+	}
+	return pa;
 }
 
 e::unpacker
-hyperdex :: operator >> (e::unpacker up, key_change& td)
+hyperdex :: operator >> (e::unpacker up, key_change &td)
 {
-    uint8_t flags;
-    up = up >> td.key >> flags >> td.checks >> td.funcs;
-    td.erase = !(flags & FLAG_WRITE);
-    td.fail_if_not_found = flags & FLAG_FINF;
-    td.fail_if_found = flags & FLAG_FIF;
-
-    if ((flags & FLAG_AUTH))
-    {
-        td.auth.reset(new auth_wallet());
-        up = up >> *td.auth;
-    }
-
-    return up;
+	uint8_t flags;
+	up = up >> td.key >> flags >> td.checks >> td.funcs;
+	td.erase = !(flags & FLAG_WRITE);
+	td.fail_if_not_found = flags & FLAG_FINF;
+	td.fail_if_found = flags & FLAG_FIF;
+	if ((flags & FLAG_AUTH))
+	{
+		td.auth.reset(new auth_wallet());
+		up = up >> *td.auth;
+	}
+	return up;
 }
 
 size_t
-hyperdex :: pack_size(const key_change& td)
+hyperdex :: pack_size(const key_change &td)
 {
-    return pack_size(td.key)
-         + sizeof(uint8_t)
-         + pack_size(td.checks)
-         + pack_size(td.funcs)
-         + (td.auth.get() ? pack_size(*td.auth) : 0);
+	return pack_size(td.key)
+	       + sizeof(uint8_t)
+	       + pack_size(td.checks)
+	       + pack_size(td.funcs)
+	       + (td.auth.get() ? pack_size(*td.auth) : 0);
 }
diff --git a/common/key_change.h b/common/key_change.h
index e81633ee7..dafb71187 100644
--- a/common/key_change.h
+++ b/common/key_change.h
@@ -40,50 +40,50 @@ BEGIN_HYPERDEX_NAMESPACE
 // A (pending) change to an entry in the database
 class key_change
 {
-    public:
-        key_change();
-        key_change(const key_change& other);
-        ~key_change() throw ();
+public:
+	key_change();
+	key_change(const key_change &other);
+	~key_change() throw ();
 
-    public:
-        bool validate(const schema& sc) const;
+public:
+	bool validate(const schema &sc) const;
 
-        // Check if a key change can be peformed
-        network_returncode check(const schema& sc,
-                                 bool has_old_value,
-                                 const std::vector<e::slice>* old_value) const;
+	// Check if a key change can be peformed
+	network_returncode check(const schema &sc,
+	                         bool has_old_value,
+	                         const std::vector<e::slice> *old_value) const;
 
-    public:
-        key_change& operator = (const key_change&);
+public:
+	key_change &operator = (const key_change &);
 
-    public:
-        e::slice key;
+public:
+	e::slice key;
 
-        // Will this entry be removed?
-        bool erase;
+	// Will this entry be removed?
+	bool erase;
 
-        // Keychange should fail if there is no previous value
-        bool fail_if_not_found;
+	// Keychange should fail if there is no previous value
+	bool fail_if_not_found;
 
-        // Keychange should fail if there is a previous value
-        bool fail_if_found;
+	// Keychange should fail if there is a previous value
+	bool fail_if_found;
 
-        // Checks to be performed before key change
-        std::vector<attribute_check> checks;
+	// Checks to be performed before key change
+	std::vector<attribute_check> checks;
 
-        // The actual keychange is stored here
-        std::vector<funcall> funcs;
+	// The actual keychange is stored here
+	std::vector<funcall> funcs;
 
-        // Authorization info is stored here
-        std::auto_ptr<auth_wallet> auth;
+	// Authorization info is stored here
+	std::auto_ptr<auth_wallet> auth;
 };
 
 e::packer
-operator << (e::packer, const key_change& td);
+operator << (e::packer, const key_change &td);
 e::unpacker
-operator >> (e::unpacker, key_change& td);
+operator >> (e::unpacker, key_change &td);
 size_t
-pack_size(const key_change& td);
+pack_size(const key_change &td);
 
 END_HYPERDEX_NAMESPACE
 
diff --git a/common/mapper.cc b/common/mapper.cc
index 315e16120..17b59b86f 100644
--- a/common/mapper.cc
+++ b/common/mapper.cc
@@ -30,8 +30,8 @@
 
 using hyperdex::mapper;
 
-mapper :: mapper(const hyperdex::configuration* config)
-    : m_config(config)
+mapper :: mapper(const hyperdex::configuration *config)
+	: m_config(config)
 {
 }
 
@@ -40,8 +40,8 @@ mapper :: ~mapper() throw ()
 }
 
 bool
-mapper :: lookup(uint64_t id, po6::net::location* addr)
+mapper :: lookup(uint64_t id, po6::net::location *addr)
 {
-    *addr = m_config->get_address(server_id(id));
-    return *addr != po6::net::location();
+	*addr = m_config->get_address(server_id(id));
+	return *addr != po6::net::location();
 }
diff --git a/common/mapper.h b/common/mapper.h
index b84577d92..ff92ac6a3 100644
--- a/common/mapper.h
+++ b/common/mapper.h
@@ -39,19 +39,19 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class mapper : public ::busybee_mapper
 {
-    public:
-        mapper(const configuration* config);
-        ~mapper() throw ();
+public:
+	mapper(const configuration *config);
+	~mapper() throw ();
 
-    public:
-        virtual bool lookup(uint64_t id, po6::net::location* addr);
+public:
+	virtual bool lookup(uint64_t id, po6::net::location *addr);
 
-    private:
-        mapper(const mapper&);
-        mapper& operator = (const mapper&);
+private:
+	mapper(const mapper &);
+	mapper &operator = (const mapper &);
 
-    private:
-        const configuration* m_config;
+private:
+	const configuration *m_config;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/common/network_msgtype.cc b/common/network_msgtype.cc
index 01259ada0..d94d03fcb 100644
--- a/common/network_msgtype.cc
+++ b/common/network_msgtype.cc
@@ -29,47 +29,48 @@
 #include "common/macros.h"
 #include "common/network_msgtype.h"
 
-std::ostream&
-hyperdex :: operator << (std::ostream& lhs, const network_msgtype& rhs)
+std::ostream &
+hyperdex :: operator << (std::ostream &lhs, const network_msgtype &rhs)
 {
-    switch(rhs)
-    {
-        STRINGIFY(REQ_GET);
-        STRINGIFY(RESP_GET);
-        STRINGIFY(REQ_GET_PARTIAL);
-        STRINGIFY(RESP_GET_PARTIAL);
-        STRINGIFY(REQ_ATOMIC);
-        STRINGIFY(RESP_ATOMIC);
-        STRINGIFY(REQ_SEARCH_START);
-        STRINGIFY(REQ_SEARCH_NEXT);
-        STRINGIFY(REQ_SEARCH_STOP);
-        STRINGIFY(RESP_SEARCH_ITEM);
-        STRINGIFY(RESP_SEARCH_DONE);
-        STRINGIFY(REQ_SORTED_SEARCH);
-        STRINGIFY(RESP_SORTED_SEARCH);
-        STRINGIFY(REQ_COUNT);
-        STRINGIFY(RESP_COUNT);
-        STRINGIFY(REQ_SEARCH_DESCRIBE);
-        STRINGIFY(RESP_SEARCH_DESCRIBE);
-        STRINGIFY(REQ_GROUP_ATOMIC);
-        STRINGIFY(RESP_GROUP_ATOMIC);
-        STRINGIFY(CHAIN_OP);
-        STRINGIFY(CHAIN_SUBSPACE);
-        STRINGIFY(CHAIN_ACK);
-        STRINGIFY(XFER_OP);
-        STRINGIFY(XFER_ACK);
-        STRINGIFY(XFER_HS);
-        STRINGIFY(XFER_HSA);
-        STRINGIFY(XFER_HA);
-        STRINGIFY(XFER_HW);
-        STRINGIFY(BACKUP);
-        STRINGIFY(PERF_COUNTERS);
-        STRINGIFY(CONFIGMISMATCH);
-        STRINGIFY(PACKET_NOP);
-        default:
-            lhs << "unknown network_msgtype";
-            break;
-    }
-
-    return lhs;
+	switch (rhs)
+	{
+		STRINGIFY(REQ_GET);
+		STRINGIFY(RESP_GET);
+		STRINGIFY(REQ_GET_PARTIAL);
+		STRINGIFY(RESP_GET_PARTIAL);
+		STRINGIFY(REQ_ATOMIC);
+		STRINGIFY(RESP_ATOMIC);
+		STRINGIFY(REQ_SEARCH_START);
+		STRINGIFY(REQ_SEARCH_NEXT);
+		STRINGIFY(REQ_SEARCH_STOP);
+		STRINGIFY(RESP_SEARCH_ITEM);
+		STRINGIFY(RESP_SEARCH_DONE);
+		STRINGIFY(REQ_SORTED_SEARCH);
+		STRINGIFY(RESP_SORTED_SEARCH);
+		STRINGIFY(REQ_COUNT);
+		STRINGIFY(RESP_COUNT);
+		STRINGIFY(REQ_SUM);
+		STRINGIFY(RESP_SUM);
+		STRINGIFY(REQ_SEARCH_DESCRIBE);
+		STRINGIFY(RESP_SEARCH_DESCRIBE);
+		STRINGIFY(REQ_GROUP_ATOMIC);
+		STRINGIFY(RESP_GROUP_ATOMIC);
+		STRINGIFY(CHAIN_OP);
+		STRINGIFY(CHAIN_SUBSPACE);
+		STRINGIFY(CHAIN_ACK);
+		STRINGIFY(XFER_OP);
+		STRINGIFY(XFER_ACK);
+		STRINGIFY(XFER_HS);
+		STRINGIFY(XFER_HSA);
+		STRINGIFY(XFER_HA);
+		STRINGIFY(XFER_HW);
+		STRINGIFY(BACKUP);
+		STRINGIFY(PERF_COUNTERS);
+		STRINGIFY(CONFIGMISMATCH);
+		STRINGIFY(PACKET_NOP);
+	default:
+		lhs << "unknown network_msgtype";
+		break;
+	}
+	return lhs;
 }
diff --git a/common/network_msgtype.h b/common/network_msgtype.h
index dbfbc6474..5a70e25e9 100644
--- a/common/network_msgtype.h
+++ b/common/network_msgtype.h
@@ -38,56 +38,59 @@ BEGIN_HYPERDEX_NAMESPACE
 
 enum network_msgtype
 {
-    REQ_GET         = 8,
-    RESP_GET        = 9,
+	REQ_GET         = 8,
+	RESP_GET        = 9,
 
-    REQ_GET_PARTIAL = 10,
-    RESP_GET_PARTIAL = 11,
+	REQ_GET_PARTIAL = 10,
+	RESP_GET_PARTIAL = 11,
 
-    REQ_ATOMIC      = 16,
-    RESP_ATOMIC     = 17,
+	REQ_ATOMIC      = 16,
+	RESP_ATOMIC     = 17,
 
-    REQ_SEARCH_START    = 32,
-    REQ_SEARCH_NEXT     = 33,
-    REQ_SEARCH_STOP     = 34,
-    RESP_SEARCH_ITEM    = 35,
-    RESP_SEARCH_DONE    = 36,
+	REQ_SEARCH_START    = 32,
+	REQ_SEARCH_NEXT     = 33,
+	REQ_SEARCH_STOP     = 34,
+	RESP_SEARCH_ITEM    = 35,
+	RESP_SEARCH_DONE    = 36,
 
-    REQ_SORTED_SEARCH   = 40,
-    RESP_SORTED_SEARCH  = 41,
+	REQ_SORTED_SEARCH   = 40,
+	RESP_SORTED_SEARCH  = 41,
 
-    /* 48, 49 retired */
+	/* 48, 49 retired */
 
-    REQ_COUNT       = 50,
-    RESP_COUNT      = 51,
+	REQ_COUNT       = 50,
+	RESP_COUNT      = 51,
 
-    REQ_SEARCH_DESCRIBE  = 52,
-    RESP_SEARCH_DESCRIBE = 53,
+	REQ_SEARCH_DESCRIBE  = 52,
+	RESP_SEARCH_DESCRIBE = 53,
 
-    REQ_GROUP_ATOMIC = 54,
-    RESP_GROUP_ATOMIC = 55,
+	REQ_GROUP_ATOMIC = 54,
+	RESP_GROUP_ATOMIC = 55,
 
-    CHAIN_OP        = 64,
-    CHAIN_SUBSPACE  = 65,
-    CHAIN_ACK       = 66,
-    /* 67 retired */
+	REQ_SUM         = 58,
+	RESP_SUM        = 59,
 
-    XFER_OP  = 80,
-    XFER_ACK = 81,
-    XFER_HS  = 82, // handshake syn
-    XFER_HSA = 83, // handshake syn-ack
-    XFER_HA  = 84, // handshake ack
-    XFER_HW  = 85, // wiped
+	CHAIN_OP        = 64,
+	CHAIN_SUBSPACE  = 65,
+	CHAIN_ACK       = 66,
+	/* 67 retired */
 
-    BACKUP = 126,
-    PERF_COUNTERS = 127,
+	XFER_OP  = 80,
+	XFER_ACK = 81,
+	XFER_HS  = 82, // handshake syn
+	XFER_HSA = 83, // handshake syn-ack
+	XFER_HA  = 84, // handshake ack
+	XFER_HW  = 85, // wiped
 
-    CONFIGMISMATCH  = 254,
-    PACKET_NOP      = 255
+	BACKUP = 126,
+	PERF_COUNTERS = 127,
+
+	CONFIGMISMATCH  = 254,
+	PACKET_NOP      = 255
 };
 
-std::ostream&
-operator << (std::ostream& lhs, const network_msgtype& rhs);
+std::ostream &
+operator << (std::ostream &lhs, const network_msgtype &rhs);
 
 END_HYPERDEX_NAMESPACE
 
diff --git a/common/network_returncode.h b/common/network_returncode.h
old mode 100755
new mode 100644
index d2ea6d6d7..0b004ae1a
--- a/common/network_returncode.h
+++ b/common/network_returncode.h
@@ -36,15 +36,15 @@ BEGIN_HYPERDEX_NAMESPACE
 // HyperDisk returncode occupies [8320, 8448)
 enum network_returncode
 {
-    NET_SUCCESS      = 8320,
-    NET_NOTFOUND     = 8321,
-    NET_BADDIMSPEC   = 8322,
-    NET_NOTUS        = 8323,
-    NET_SERVERERROR  = 8324,
-    NET_CMPFAIL      = 8325,
-    NET_READONLY     = 8327,
-    NET_OVERFLOW     = 8328,
-    NET_UNAUTHORIZED = 8329
+	NET_SUCCESS      = 8320,
+	NET_NOTFOUND     = 8321,
+	NET_BADDIMSPEC   = 8322,
+	NET_NOTUS        = 8323,
+	NET_SERVERERROR  = 8324,
+	NET_CMPFAIL      = 8325,
+	NET_READONLY     = 8327,
+	NET_OVERFLOW     = 8328,
+	NET_UNAUTHORIZED = 8329
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/common/ordered_encoding.cc b/common/ordered_encoding.cc
index c1dd8471e..63fbf101f 100644
--- a/common/ordered_encoding.cc
+++ b/common/ordered_encoding.cc
@@ -43,17 +43,17 @@
 uint64_t
 hyperdex :: ordered_encode_int64(int64_t x)
 {
-    uint64_t out = static_cast<uint64_t>(x);
-    out += x >= 0 ? 0x8000000000000000ULL : INT64_MIN;
-    return out;
+	uint64_t out = static_cast<uint64_t>(x);
+	out += x >= 0 ? 0x8000000000000000ULL : INT64_MIN;
+	return out;
 }
 
 int64_t
 hyperdex :: ordered_decode_int64(uint64_t x)
 {
-    uint64_t out = static_cast<uint64_t>(x);
-    out -= x >= 0x8000000000000000ULL ? 0x8000000000000000ULL : INT64_MIN;
-    return out;
+	uint64_t out = static_cast<uint64_t>(x);
+	out -= x >= 0x8000000000000000ULL ? 0x8000000000000000ULL : INT64_MIN;
+	return out;
 }
 
 // A little reminder about IEEE 754 doubles.  Source Patterson&Hennessy 3ed.
@@ -114,48 +114,44 @@ hyperdex :: ordered_decode_int64(uint64_t x)
 uint64_t
 hyperdex :: ordered_encode_double(double x)
 {
-    uint64_t out = 0xffffffffffffffffULL;
-
-    if (std::isinf(x))
-    {
-        if (x > 0)
-        {
-            out = 0xfff0000000000000ULL + 2;
-        }
-        else
-        {
-            out = 0;
-        }
-    }
-    else if (std::isnan(x))
-    {
-        out = 0xfff0000000000000ULL + 3;
-    }
-    else if (x == 0)
-    {
-        out = 0x8000000000000000ULL + 1;
-    }
-    else
-    {
-        union { double d; ieee_double ieee; } d;
-        d.d = x;
-        uint64_t sign = d.ieee.dbl_sign ^ 0x1;
-        uint64_t exp  = d.ieee.dbl_exp;
-        uint64_t frac = d.ieee.dbl_frach;
-        frac <<= 32;
-        frac |= d.ieee.dbl_fracl;
-        uint64_t shift = 2;
-
-        if (x < 0)
-        {
-            exp  ^= 0x7ffULL;
-            frac ^= 0xfffffffffffffULL;
-            shift = 1;
-        }
-
-        out = (sign << 63) | (exp << 52) | (frac);
-        out += shift;
-    }
-
-    return out;
+	uint64_t out = 0xffffffffffffffffULL;
+	if (std::isinf(x))
+	{
+		if (x > 0)
+		{
+			out = 0xfff0000000000000ULL + 2;
+		}
+		else
+		{
+			out = 0;
+		}
+	}
+	else if (std::isnan(x))
+	{
+		out = 0xfff0000000000000ULL + 3;
+	}
+	else if (x == 0)
+	{
+		out = 0x8000000000000000ULL + 1;
+	}
+	else
+	{
+		union { double d; ieee_double ieee; } d;
+		d.d = x;
+		uint64_t sign = d.ieee.dbl_sign ^ 0x1;
+		uint64_t exp  = d.ieee.dbl_exp;
+		uint64_t frac = d.ieee.dbl_frach;
+		frac <<= 32;
+		frac |= d.ieee.dbl_fracl;
+		uint64_t shift = 2;
+		if (x < 0)
+		{
+			exp  ^= 0x7ffULL;
+			frac ^= 0xfffffffffffffULL;
+			shift = 1;
+		}
+		out = (sign << 63) | (exp << 52) | (frac);
+		out += shift;
+	}
+	return out;
 }
diff --git a/common/range.cc b/common/range.cc
index 57e4d6008..857a5870f 100644
--- a/common/range.cc
+++ b/common/range.cc
@@ -33,24 +33,24 @@
 using hyperdex::range;
 
 range :: range()
-    : attr(UINT16_MAX)
-    , type(HYPERDATATYPE_GARBAGE)
-    , start()
-    , end()
-    , has_start(false)
-    , has_end(false)
-    , invalid(true)
+	: attr(UINT16_MAX)
+	, type(HYPERDATATYPE_GARBAGE)
+	, start()
+	, end()
+	, has_start(false)
+	, has_end(false)
+	, invalid(true)
 {
 }
 
-range :: range(const range& other)
-    : attr(other.attr)
-    , type(other.type)
-    , start(other.start)
-    , end(other.end)
-    , has_start(other.has_start)
-    , has_end(other.has_end)
-    , invalid(other.invalid)
+range :: range(const range &other)
+	: attr(other.attr)
+	, type(other.type)
+	, start(other.start)
+	, end(other.end)
+	, has_start(other.has_start)
+	, has_end(other.has_end)
+	, invalid(other.invalid)
 {
 }
 
@@ -58,22 +58,22 @@ range :: ~range() throw ()
 {
 }
 
-range&
-range :: operator = (const range& rhs)
+range &
+range :: operator = (const range &rhs)
 {
-    attr = rhs.attr;
-    type = rhs.type;
-    start = rhs.start;
-    end = rhs.end;
-    has_start = rhs.has_start;
-    has_end = rhs.has_end;
-    invalid = rhs.invalid;
-    return *this;
+	attr = rhs.attr;
+	type = rhs.type;
+	start = rhs.start;
+	end = rhs.end;
+	has_start = rhs.has_start;
+	has_end = rhs.has_end;
+	invalid = rhs.invalid;
+	return *this;
 }
 
 bool
-range :: operator < (const range& rhs) const
+range :: operator < (const range &rhs) const
 {
-    const range& lhs(*this);
-    return lhs.attr < rhs.attr;
+	const range &lhs(*this);
+	return lhs.attr < rhs.attr;
 }
diff --git a/common/range.h b/common/range.h
index 6fac1bbe3..d3a85d924 100644
--- a/common/range.h
+++ b/common/range.h
@@ -40,23 +40,23 @@ BEGIN_HYPERDEX_NAMESPACE
 // a range is inclusive
 class range
 {
-    public:
-        range();
-        range(const range& other);
-        ~range() throw ();
+public:
+	range();
+	range(const range &other);
+	~range() throw ();
 
-    public:
-        range& operator = (const range& rhs);
-        bool operator < (const range& rhs) const;
+public:
+	range &operator = (const range &rhs);
+	bool operator < (const range &rhs) const;
 
-    public:
-        uint16_t attr;
-        hyperdatatype type; // XXX remove
-        e::slice start;
-        e::slice end;
-        bool has_start;
-        bool has_end;
-        bool invalid;
+public:
+	uint16_t attr;
+	hyperdatatype type; // XXX remove
+	e::slice start;
+	e::slice end;
+	bool has_start;
+	bool has_end;
+	bool invalid;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/common/range_searches.cc b/common/range_searches.cc
index aac97fa1c..25e0544dd 100644
--- a/common/range_searches.cc
+++ b/common/range_searches.cc
@@ -48,155 +48,140 @@ using hyperdex::range;
 // you will need to look at the way indices are picked in the data layer and the
 // way ranges are picked for hyperspace hashing.
 static bool
-range_search(const attribute_check& check, range* r)
+range_search(const attribute_check &check, range *r)
 {
-    switch (check.predicate)
-    {
-        case HYPERPREDICATE_EQUALS:
-            r->attr = check.attr;
-            r->type = check.datatype;
-            r->start = check.value;
-            r->end = check.value;
-            r->has_start = true;
-            r->has_end = true;
-            r->invalid = false;
-            return true;
-        case HYPERPREDICATE_LESS_THAN:
-        case HYPERPREDICATE_LESS_EQUAL:
-            r->attr = check.attr;
-            r->type = check.datatype;
-            r->end = check.value;
-            r->has_start = false;
-            r->has_end = true;
-            r->invalid = false;
-            return true;
-        case HYPERPREDICATE_GREATER_EQUAL:
-        case HYPERPREDICATE_GREATER_THAN:
-            r->attr = check.attr;
-            r->type = check.datatype;
-            r->start = check.value;
-            r->has_start = true;
-            r->has_end = false;
-            r->invalid = false;
-            return true;
-        case HYPERPREDICATE_FAIL:
-        case HYPERPREDICATE_CONTAINS_LESS_THAN:
-        case HYPERPREDICATE_REGEX:
-        case HYPERPREDICATE_LENGTH_EQUALS:
-        case HYPERPREDICATE_LENGTH_LESS_EQUAL:
-        case HYPERPREDICATE_LENGTH_GREATER_EQUAL:
-        case HYPERPREDICATE_CONTAINS:
-        default:
-            return false;
-    }
+	switch (check.predicate)
+	{
+	case HYPERPREDICATE_EQUALS:
+		r->attr = check.attr;
+		r->type = check.datatype;
+		r->start = check.value;
+		r->end = check.value;
+		r->has_start = true;
+		r->has_end = true;
+		r->invalid = false;
+		return true;
+	case HYPERPREDICATE_LESS_THAN:
+	case HYPERPREDICATE_LESS_EQUAL:
+		r->attr = check.attr;
+		r->type = check.datatype;
+		r->end = check.value;
+		r->has_start = false;
+		r->has_end = true;
+		r->invalid = false;
+		return true;
+	case HYPERPREDICATE_GREATER_EQUAL:
+	case HYPERPREDICATE_GREATER_THAN:
+		r->attr = check.attr;
+		r->type = check.datatype;
+		r->start = check.value;
+		r->has_start = true;
+		r->has_end = false;
+		r->invalid = false;
+		return true;
+	case HYPERPREDICATE_FAIL:
+	case HYPERPREDICATE_CONTAINS_LESS_THAN:
+	case HYPERPREDICATE_REGEX:
+	case HYPERPREDICATE_LENGTH_EQUALS:
+	case HYPERPREDICATE_LENGTH_LESS_EQUAL:
+	case HYPERPREDICATE_LENGTH_GREATER_EQUAL:
+	case HYPERPREDICATE_CONTAINS:
+	default:
+		return false;
+	}
 }
 
 static bool
-compress_ranges(const range* range_ptr, const range* range_end, range* r)
+compress_ranges(const range *range_ptr, const range *range_end, range *r)
 {
-    r->attr = range_ptr->attr;
-    r->type = range_ptr->type;
-    r->start = e::slice();
-    r->end = e::slice();
-    r->has_start = false;
-    r->has_end = false;
-    r->invalid = false;
-    datatype_info* di = datatype_info::lookup(range_ptr->type);
-
-    if (!di)
-    {
-        return false;
-    }
-
-    for (; range_ptr < range_end; ++range_ptr)
-    {
-        // bump/set the start if necessary
-        if (range_ptr->has_start && r->has_start)
-        {
-            if (di->compare(range_ptr->start, r->start) > 0)
-            {
-                r->start = range_ptr->start;
-            }
-        }
-        else if (range_ptr->has_start)
-        {
-            r->start = range_ptr->start;
-            r->has_start = true;
-        }
-
-        // cut/set the end if necessary
-        if (range_ptr->has_end && r->has_end)
-        {
-            if (di->compare(range_ptr->end, r->end) < 0)
-            {
-                r->end = range_ptr->end;
-            }
-        }
-        else if (range_ptr->has_end)
-        {
-            r->end = range_ptr->end;
-            r->has_end = true;
-        }
-    }
-
-    if (r->has_start && r->has_end && di->compare(r->start, r->end) > 0)
-    {
-        r->invalid = true;
-    }
-
-    return true;
+	r->attr = range_ptr->attr;
+	r->type = range_ptr->type;
+	r->start = e::slice();
+	r->end = e::slice();
+	r->has_start = false;
+	r->has_end = false;
+	r->invalid = false;
+	datatype_info *di = datatype_info::lookup(range_ptr->type);
+	if (!di)
+	{
+		return false;
+	}
+	for (; range_ptr < range_end; ++range_ptr)
+	{
+		// bump/set the start if necessary
+		if (range_ptr->has_start && r->has_start)
+		{
+			if (di->compare(range_ptr->start, r->start) > 0)
+			{
+				r->start = range_ptr->start;
+			}
+		}
+		else if (range_ptr->has_start)
+		{
+			r->start = range_ptr->start;
+			r->has_start = true;
+		}
+		// cut/set the end if necessary
+		if (range_ptr->has_end && r->has_end)
+		{
+			if (di->compare(range_ptr->end, r->end) < 0)
+			{
+				r->end = range_ptr->end;
+			}
+		}
+		else if (range_ptr->has_end)
+		{
+			r->end = range_ptr->end;
+			r->has_end = true;
+		}
+	}
+	if (r->has_start && r->has_end && di->compare(r->start, r->end) > 0)
+	{
+		r->invalid = true;
+	}
+	return true;
 }
 
 void
-hyperdex :: range_searches(const schema& sc,
-                           const std::vector<attribute_check>& checks,
-                           std::vector<range>* ranges)
+hyperdex :: range_searches(const schema &sc,
+                           const std::vector<attribute_check> &checks,
+                           std::vector<range> *ranges)
 {
-    std::vector<range> raw_ranges;
-    raw_ranges.reserve(checks.size());
-
-    for (size_t i = 0; i < checks.size(); ++i)
-    {
-        if (checks[i].attr >= sc.attrs_sz ||
-            datatype_info::lookup(sc.attrs[checks[i].attr].type)->document())
-        {
-            continue;
-        }
-
-        range r;
-
-        if (range_search(checks[i], &r))
-        {
-            raw_ranges.push_back(r);
-        }
-    }
-
-    std::sort(raw_ranges.begin(), raw_ranges.end());
-    const range* range_ptr = &raw_ranges.front();
-    const range* range_end = range_ptr + raw_ranges.size();
-    ranges->clear();
-
-    while (range_ptr < range_end)
-    {
-        const range* tmp = range_ptr;
-
-        while (tmp < range_end && range_ptr->attr == tmp->attr)
-        {
-            assert(range_ptr->attr == tmp->attr);
-            assert(range_ptr->type == tmp->type);
-            ++tmp;
-        }
-
-        assert(tmp == range_end || range_ptr->attr < tmp->attr);
-        range r;
-
-        if (compress_ranges(range_ptr, tmp, &r))
-        {
-            ranges->push_back(r);
-        }
-
-        range_ptr = tmp;
-    }
-
-    assert(ranges->size() <= checks.size());
+	std::vector<range> raw_ranges;
+	raw_ranges.reserve(checks.size());
+	for (size_t i = 0; i < checks.size(); ++i)
+	{
+		if (checks[i].attr >= sc.attrs_sz ||
+		    datatype_info::lookup(sc.attrs[checks[i].attr].type)->document())
+		{
+			continue;
+		}
+		range r;
+		if (range_search(checks[i], &r))
+		{
+			raw_ranges.push_back(r);
+		}
+	}
+	std::sort(raw_ranges.begin(), raw_ranges.end());
+	const range *range_ptr = &raw_ranges.front();
+	const range *range_end = range_ptr + raw_ranges.size();
+	ranges->clear();
+	while (range_ptr < range_end)
+	{
+		const range *tmp = range_ptr;
+		while (tmp < range_end && range_ptr->attr == tmp->attr)
+		{
+			assert(range_ptr->attr == tmp->attr);
+			assert(range_ptr->type == tmp->type);
+			++tmp;
+		}
+		assert(tmp == range_end || range_ptr->attr < tmp->attr);
+		range r;
+		if (compress_ranges(range_ptr, tmp, &r))
+		{
+			ranges->push_back(r);
+		}
+		range_ptr = tmp;
+	}
+	assert(ranges->size() <= checks.size());
 }
diff --git a/common/range_searches.h b/common/range_searches.h
index ac4deeb42..5e664bdfd 100644
--- a/common/range_searches.h
+++ b/common/range_searches.h
@@ -39,9 +39,9 @@
 BEGIN_HYPERDEX_NAMESPACE
 
 void
-range_searches(const schema& sc,
-               const std::vector<attribute_check>& checks,
-               std::vector<range>* ranges);
+range_searches(const schema &sc,
+               const std::vector<attribute_check> &checks,
+               std::vector<range> *ranges);
 
 END_HYPERDEX_NAMESPACE
 
diff --git a/common/regex_match.cc b/common/regex_match.cc
index bd914bf8a..f8b12d41e 100644
--- a/common/regex_match.cc
+++ b/common/regex_match.cc
@@ -5,103 +5,90 @@
 #include "common/regex_match.h"
 
 static bool
-anchored(const char* regex, const char* regex_end,
-         const char* text,  const char* text_end);
+anchored(const char *regex, const char *regex_end,
+         const char *text,  const char *text_end);
 
 static bool
 starred(int c,
-        const char* regex, const char* regex_end,
-        const char* text,  const char* text_end);
+        const char *regex, const char *regex_end,
+        const char *text,  const char *text_end);
 
 bool
-anchored(const char* regex, const char* regex_end,
-         const char* text,  const char* text_end)
+anchored(const char *regex, const char *regex_end,
+         const char *text,  const char *text_end)
 {
-    assert(regex <= regex_end);
-    assert(text <= text_end);
-
-    if (regex == regex_end)
-    {
-        return true;
-    }
-
-    if (regex[0] == '\\')
-    {
-        if (regex + 1 < regex_end &&
-            text < text_end &&
-            regex[1] == text[0])
-        {
-            return anchored(regex + 2, regex_end, text + 1, text_end);
-        }
-
-        return false;
-    }
-
-    if (regex + 1 < regex_end && regex[1] == '*')
-    {
-        return starred(regex[0], regex + 2, regex_end, text, text_end);
-    }
-
-    if (regex[0] == '$' && regex + 1 == regex_end)
-    {
-        return text == text_end;
-    }
-
-    if (text < text_end && (regex[0] == '.' || regex[0] == text[0]))
-    {
-        return anchored(regex + 1, regex_end, text + 1, text_end);
-    }
-
-    return false;
+	assert(regex <= regex_end);
+	assert(text <= text_end);
+	if (regex == regex_end)
+	{
+		return true;
+	}
+	if (regex[0] == '\\')
+	{
+		if (regex + 1 < regex_end &&
+		    text < text_end &&
+		    regex[1] == text[0])
+		{
+			return anchored(regex + 2, regex_end, text + 1, text_end);
+		}
+		return false;
+	}
+	if (regex + 1 < regex_end && regex[1] == '*')
+	{
+		return starred(regex[0], regex + 2, regex_end, text, text_end);
+	}
+	if (regex[0] == '$' && regex + 1 == regex_end)
+	{
+		return text == text_end;
+	}
+	if (text < text_end && (regex[0] == '.' || regex[0] == text[0]))
+	{
+		return anchored(regex + 1, regex_end, text + 1, text_end);
+	}
+	return false;
 }
 
 bool
 starred(int c,
-        const char* regex, const char* regex_end,
-        const char* text,  const char* text_end)
+        const char *regex, const char *regex_end,
+        const char *text,  const char *text_end)
 {
-    for (; text <= text_end; ++text)
-    {
-        if (anchored(regex, regex_end, text, text_end))
-        {
-            return true;
-        }
-
-        if (text < text_end && *text != c && c != '.')
-        {
-            break;
-        }
-    }
-
-    return false;
+	for (; text <= text_end; ++text)
+	{
+		if (anchored(regex, regex_end, text, text_end))
+		{
+			return true;
+		}
+		if (text < text_end && *text != c && c != '.')
+		{
+			break;
+		}
+	}
+	return false;
 }
 
 bool
-hyperdex :: regex_match(const uint8_t* _regex, size_t regex_sz,
-                        const uint8_t* _text, size_t text_sz)
+hyperdex :: regex_match(const uint8_t *_regex, size_t regex_sz,
+                        const uint8_t *_text, size_t text_sz)
 {
-    const char* regex = reinterpret_cast<const char*>(_regex);
-    const char* text  = reinterpret_cast<const char*>(_text);
-    const char* regex_end = regex + regex_sz;
-    const char* text_end  = text + text_sz;
-
-    if (regex_sz == 0)
-    {
-        return true;
-    }
-
-    if (regex[0] == '^')
-    {
-        return anchored(regex + 1, regex_end, text, text_end);
-    }
-
-    for (; text <= text_end; ++text)
-    {
-        if (anchored(regex, regex_end, text, text_end))
-        {
-            return true;
-        }
-    }
-
-    return false;
+	const char *regex = reinterpret_cast<const char *>(_regex);
+	const char *text  = reinterpret_cast<const char *>(_text);
+	const char *regex_end = regex + regex_sz;
+	const char *text_end  = text + text_sz;
+	if (regex_sz == 0)
+	{
+		return true;
+	}
+	if (regex[0] == '^')
+	{
+		return anchored(regex + 1, regex_end, text, text_end);
+	}
+	for (; text <= text_end; ++text)
+	{
+		if (anchored(regex, regex_end, text, text_end))
+		{
+			return true;
+		}
+	}
+	return false;
 }
diff --git a/common/regex_match.h b/common/regex_match.h
index 3d97c01dc..e38602b9a 100644
--- a/common/regex_match.h
+++ b/common/regex_match.h
@@ -38,8 +38,8 @@
 BEGIN_HYPERDEX_NAMESPACE
 
 bool
-regex_match(const uint8_t* regex, size_t regex_sz,
-            const uint8_t* text, size_t text_sz);
+regex_match(const uint8_t *regex, size_t regex_sz,
+            const uint8_t *text, size_t text_sz);
 
 END_HYPERDEX_NAMESPACE
 
diff --git a/common/schema.cc b/common/schema.cc
index 74517e357..6c52d7aa1 100644
--- a/common/schema.cc
+++ b/common/schema.cc
@@ -34,22 +34,21 @@
 using hyperdex::schema;
 
 schema :: schema()
-    : attrs_sz(0)
-    , attrs(NULL)
-    , authorization(false)
+	: attrs_sz(0)
+	, attrs(NULL)
+	, authorization(false)
 {
 }
 
 uint16_t
-schema :: lookup_attr(const char* name) const
+schema :: lookup_attr(const char *name) const
 {
-    for (uint16_t i = 0; i < attrs_sz; ++i)
-    {
-        if (strcmp(name, attrs[i].name) == 0)
-        {
-            return i;
-        }
-    }
-
-    return attrs_sz;
+	for (uint16_t i = 0; i < attrs_sz; ++i)
+	{
+		if (strcmp(name, attrs[i].name) == 0)
+		{
+			return i;
+		}
+	}
+	return attrs_sz;
 }
diff --git a/common/schema.h b/common/schema.h
index ad613fd21..6fd4e54c4 100644
--- a/common/schema.h
+++ b/common/schema.h
@@ -39,16 +39,16 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class schema
 {
-    public:
-        schema();
+public:
+	schema();
 
-    public:
-        uint16_t lookup_attr(const char* name) const;
+public:
+	uint16_t lookup_attr(const char *name) const;
 
-    public:
-        uint16_t attrs_sz;
-        const attribute* attrs;
-        bool authorization;
+public:
+	uint16_t attrs_sz;
+	const attribute *attrs;
+	bool authorization;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/common/serialization.cc b/common/serialization.cc
index e075954d9..446e5b960 100644
--- a/common/serialization.cc
+++ b/common/serialization.cc
@@ -29,45 +29,45 @@
 #include "common/serialization.h"
 
 e::packer
-hyperdex :: operator << (e::packer lhs, const hyperdatatype& rhs)
+hyperdex :: operator << (e::packer lhs, const hyperdatatype &rhs)
 {
-    uint16_t r = static_cast<uint16_t>(rhs);
-    return lhs << r;
+	uint16_t r = static_cast<uint16_t>(rhs);
+	return lhs << r;
 }
 
 e::unpacker
-hyperdex :: operator >> (e::unpacker lhs, hyperdatatype& rhs)
+hyperdex :: operator >> (e::unpacker lhs, hyperdatatype &rhs)
 {
-    uint16_t r;
-    lhs = lhs >> r;
-    rhs = static_cast<hyperdatatype>(r);
-    return lhs;
+	uint16_t r;
+	lhs = lhs >> r;
+	rhs = static_cast<hyperdatatype>(r);
+	return lhs;
 }
 
 size_t
-hyperdex :: pack_size(const hyperdatatype&)
+hyperdex :: pack_size(const hyperdatatype &)
 {
-    return sizeof(uint16_t);
+	return sizeof(uint16_t);
 }
 
 e::packer
-hyperdex :: operator << (e::packer lhs, const hyperpredicate& rhs)
+hyperdex :: operator << (e::packer lhs, const hyperpredicate &rhs)
 {
-    uint16_t r = static_cast<uint16_t>(rhs);
-    return lhs << r;
+	uint16_t r = static_cast<uint16_t>(rhs);
+	return lhs << r;
 }
 
 e::unpacker
-hyperdex :: operator >> (e::unpacker lhs, hyperpredicate& rhs)
+hyperdex :: operator >> (e::unpacker lhs, hyperpredicate &rhs)
 {
-    uint16_t r;
-    lhs = lhs >> r;
-    rhs = static_cast<hyperpredicate>(r);
-    return lhs;
+	uint16_t r;
+	lhs = lhs >> r;
+	rhs = static_cast<hyperpredicate>(r);
+	return lhs;
 }
 
 size_t
-hyperdex :: pack_size(const hyperpredicate&)
+hyperdex :: pack_size(const hyperpredicate &)
 {
-    return sizeof(uint16_t);
+	return sizeof(uint16_t);
 }
diff --git a/common/serialization.h b/common/serialization.h
index af8883f39..baa9c45f0 100644
--- a/common/serialization.h
+++ b/common/serialization.h
@@ -42,18 +42,18 @@ using ::pack_size;
 using e::pack_size;
 
 e::packer
-operator << (e::packer lhs, const hyperdatatype& rhs);
+operator << (e::packer lhs, const hyperdatatype &rhs);
 e::unpacker
-operator >> (e::unpacker lhs, hyperdatatype& rhs);
+operator >> (e::unpacker lhs, hyperdatatype &rhs);
 size_t
-pack_size(const hyperdatatype& h);
+pack_size(const hyperdatatype &h);
 
 e::packer
-operator << (e::packer lhs, const hyperpredicate& rhs);
+operator << (e::packer lhs, const hyperpredicate &rhs);
 e::unpacker
-operator >> (e::unpacker lhs, hyperpredicate& rhs);
+operator >> (e::unpacker lhs, hyperpredicate &rhs);
 size_t
-pack_size(const hyperpredicate& p);
+pack_size(const hyperpredicate &p);
 
 END_HYPERDEX_NAMESPACE
 
diff --git a/common/server.cc b/common/server.cc
index b5dbfa756..4e6a00235 100644
--- a/common/server.cc
+++ b/common/server.cc
@@ -31,66 +31,66 @@
 
 using hyperdex::server;
 
-const char*
+const char *
 server :: to_string(state_t state)
 {
-    switch (state)
-    {
-        case ASSIGNED:
-            return "ASSIGNED";
-        case NOT_AVAILABLE:
-            return "NOT_AVAILABLE";
-        case AVAILABLE:
-            return "AVAILABLE";
-        case SHUTDOWN:
-            return "SHUTDOWN";
-        case KILLED:
-            return "KILLED";
-        default:
-            return "UNKNOWN";
-    }
+	switch (state)
+	{
+	case ASSIGNED:
+		return "ASSIGNED";
+	case NOT_AVAILABLE:
+		return "NOT_AVAILABLE";
+	case AVAILABLE:
+		return "AVAILABLE";
+	case SHUTDOWN:
+		return "SHUTDOWN";
+	case KILLED:
+		return "KILLED";
+	default:
+		return "UNKNOWN";
+	}
 }
 
 server :: server()
-    : state(KILLED)
-    , id()
-    , bind_to()
+	: state(KILLED)
+	, id()
+	, bind_to()
 {
 }
 
-server :: server(const server_id& sid)
-    : state(ASSIGNED)
-    , id(sid)
-    , bind_to()
+server :: server(const server_id &sid)
+	: state(ASSIGNED)
+	, id(sid)
+	, bind_to()
 {
 }
 
 bool
-hyperdex :: operator < (const server& lhs, const server& rhs)
+hyperdex :: operator < (const server &lhs, const server &rhs)
 {
-    return lhs.id < rhs.id;
+	return lhs.id < rhs.id;
 }
 
 e::packer
-hyperdex :: operator << (e::packer lhs, const server& rhs)
+hyperdex :: operator << (e::packer lhs, const server &rhs)
 {
-    uint8_t s = static_cast<uint8_t>(rhs.state);
-    return lhs << s << rhs.id << rhs.bind_to;
+	uint8_t s = static_cast<uint8_t>(rhs.state);
+	return lhs << s << rhs.id << rhs.bind_to;
 }
 
 e::unpacker
-hyperdex :: operator >> (e::unpacker lhs, server& rhs)
+hyperdex :: operator >> (e::unpacker lhs, server &rhs)
 {
-    uint8_t s;
-    lhs = lhs >> s >> rhs.id >> rhs.bind_to;
-    rhs.state = static_cast<server::state_t>(s);
-    return lhs;
+	uint8_t s;
+	lhs = lhs >> s >> rhs.id >> rhs.bind_to;
+	rhs.state = static_cast<server::state_t>(s);
+	return lhs;
 }
 
 size_t
-hyperdex :: pack_size(const server& p)
+hyperdex :: pack_size(const server &p)
 {
-    return sizeof(uint8_t)
-         + sizeof(uint64_t)
-         + pack_size(p.bind_to);
+	return sizeof(uint8_t)
+	       + sizeof(uint64_t)
+	       + pack_size(p.bind_to);
 }
diff --git a/common/server.h b/common/server.h
index f74dabf03..7c7e9e653 100644
--- a/common/server.h
+++ b/common/server.h
@@ -39,36 +39,36 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class server
 {
-    public:
-        enum state_t
-        {
-            ASSIGNED = 1,
-            NOT_AVAILABLE = 2,
-            AVAILABLE = 3,
-            SHUTDOWN = 4,
-            KILLED = 5
-        };
-        static const char* to_string(state_t state);
+public:
+	enum state_t
+	{
+		ASSIGNED = 1,
+		NOT_AVAILABLE = 2,
+		AVAILABLE = 3,
+		SHUTDOWN = 4,
+		KILLED = 5
+	};
+	static const char *to_string(state_t state);
 
-    public:
-        server();
-        explicit server(const server_id&);
+public:
+	server();
+	explicit server(const server_id &);
 
-    public:
-        state_t state;
-        server_id id;
-        po6::net::location bind_to;
+public:
+	state_t state;
+	server_id id;
+	po6::net::location bind_to;
 };
 
 bool
-operator < (const server& lhs, const server& rhs);
+operator < (const server &lhs, const server &rhs);
 
 e::packer
-operator << (e::packer lhs, const server& rhs);
+operator << (e::packer lhs, const server &rhs);
 e::unpacker
-operator >> (e::unpacker lhs, server& rhs);
+operator >> (e::unpacker lhs, server &rhs);
 size_t
-pack_size(const server& p);
+pack_size(const server &p);
 
 END_HYPERDEX_NAMESPACE
 
diff --git a/common/test/ordered_encoding.cc b/common/test/ordered_encoding.cc
index 0093c16c5..aa197d5f4 100644
--- a/common/test/ordered_encoding.cc
+++ b/common/test/ordered_encoding.cc
@@ -41,83 +41,77 @@ using hyperdex::ordered_encode_double;
 
 TEST(OrderedEncoding, EncodeInt64)
 {
-    ASSERT_EQ(0xffffffffffffffffULL, ordered_encode_int64(INT64_MAX));
-    ASSERT_EQ(0xfffffffffffffffeULL, ordered_encode_int64(INT64_MAX - 1));
-    ASSERT_EQ(0x8000000000000001ULL, ordered_encode_int64(1));
-    ASSERT_EQ(0x8000000000000000ULL, ordered_encode_int64(0));
-    ASSERT_EQ(0x7fffffffffffffffULL, ordered_encode_int64(-1));
-    ASSERT_EQ(0x0000000000000001ULL, ordered_encode_int64(INT64_MIN + 1));
-    ASSERT_EQ(0x0000000000000000ULL, ordered_encode_int64(INT64_MIN));
+	ASSERT_EQ(0xffffffffffffffffULL, ordered_encode_int64(INT64_MAX));
+	ASSERT_EQ(0xfffffffffffffffeULL, ordered_encode_int64(INT64_MAX - 1));
+	ASSERT_EQ(0x8000000000000001ULL, ordered_encode_int64(1));
+	ASSERT_EQ(0x8000000000000000ULL, ordered_encode_int64(0));
+	ASSERT_EQ(0x7fffffffffffffffULL, ordered_encode_int64(-1));
+	ASSERT_EQ(0x0000000000000001ULL, ordered_encode_int64(INT64_MIN + 1));
+	ASSERT_EQ(0x0000000000000000ULL, ordered_encode_int64(INT64_MIN));
 }
 
 TEST(OrderedEncoding, DecodeInt64)
 {
-    ASSERT_EQ(INT64_MAX,     ordered_decode_int64(0xffffffffffffffffULL));
-    ASSERT_EQ(INT64_MAX - 1, ordered_decode_int64(0xfffffffffffffffeULL));
-    ASSERT_EQ(1,             ordered_decode_int64(0x8000000000000001ULL));
-    ASSERT_EQ(0,             ordered_decode_int64(0x8000000000000000ULL));
-    ASSERT_EQ(-1,            ordered_decode_int64(0x7fffffffffffffffULL));
-    ASSERT_EQ(INT64_MIN + 1, ordered_decode_int64(0x0000000000000001ULL));
-    ASSERT_EQ(INT64_MIN,     ordered_decode_int64(0x0000000000000000ULL));
+	ASSERT_EQ(INT64_MAX,     ordered_decode_int64(0xffffffffffffffffULL));
+	ASSERT_EQ(INT64_MAX - 1, ordered_decode_int64(0xfffffffffffffffeULL));
+	ASSERT_EQ(1,             ordered_decode_int64(0x8000000000000001ULL));
+	ASSERT_EQ(0,             ordered_decode_int64(0x8000000000000000ULL));
+	ASSERT_EQ(-1,            ordered_decode_int64(0x7fffffffffffffffULL));
+	ASSERT_EQ(INT64_MIN + 1, ordered_decode_int64(0x0000000000000001ULL));
+	ASSERT_EQ(INT64_MIN,     ordered_decode_int64(0x0000000000000000ULL));
 }
 
 TEST(IndexEncode, Double)
 {
-    ASSERT_EQ(0x0000000000000000ULL, ordered_encode_double(-INFINITY));
-    ASSERT_EQ(0xfff0000000000002ULL, ordered_encode_double(INFINITY));
-    ASSERT_EQ(0xfff0000000000003ULL, ordered_encode_double(NAN));
-    ASSERT_EQ(0x8000000000000001ULL, ordered_encode_double(0.));
-
-    double old_d = -INFINITY;
-    uint64_t old_e = 0x0000000000000000ULL;
-
-    for (size_t i = 0; i < 1000000; ++i)
-    {
-        double d = drand48() * mrand48() * mrand48();
-        uint64_t e = ordered_encode_double(d);
-
-        if (isinf(d) && d < 0)
-        {
-            ASSERT_EQ(0x0000000000000000ULL, e);
-        }
-        else if (isinf(d) && d > 0)
-        {
-            ASSERT_EQ(0xfff0000000000002ULL, e);
-        }
-        else if (isnan(d))
-        {
-            ASSERT_EQ(0xfff0000000000003ULL, e);
-        }
-        else
-        {
-            ASSERT_TRUE(e > 0x0000000000000000ULL);
-            ASSERT_TRUE(e < 0xfff0000000000002ULL);
-            ASSERT_TRUE(e < 0xfff0000000000003ULL);
-
-            if (d < 0)
-            {
-                ASSERT_TRUE(e < 0x8000000000000001ULL);
-            }
-            if (d > 0)
-            {
-                ASSERT_TRUE(e > 0x8000000000000001ULL);
-            }
-
-            if (old_d < d)
-            {
-                ASSERT_TRUE(old_e < e);
-            }
-            else if (old_d > d)
-            {
-                ASSERT_TRUE(old_e > e);
-            }
-            else
-            {
-                ASSERT_TRUE(old_e == e);
-            }
-
-            old_d = d;
-            old_e = e;
-        }
-    }
+	ASSERT_EQ(0x0000000000000000ULL, ordered_encode_double(-INFINITY));
+	ASSERT_EQ(0xfff0000000000002ULL, ordered_encode_double(INFINITY));
+	ASSERT_EQ(0xfff0000000000003ULL, ordered_encode_double(NAN));
+	ASSERT_EQ(0x8000000000000001ULL, ordered_encode_double(0.));
+	double old_d = -INFINITY;
+	uint64_t old_e = 0x0000000000000000ULL;
+	for (size_t i = 0; i < 1000000; ++i)
+	{
+		double d = drand48() * mrand48() * mrand48();
+		uint64_t e = ordered_encode_double(d);
+		if (isinf(d) && d < 0)
+		{
+			ASSERT_EQ(0x0000000000000000ULL, e);
+		}
+		else if (isinf(d) && d > 0)
+		{
+			ASSERT_EQ(0xfff0000000000002ULL, e);
+		}
+		else if (isnan(d))
+		{
+			ASSERT_EQ(0xfff0000000000003ULL, e);
+		}
+		else
+		{
+			ASSERT_TRUE(e > 0x0000000000000000ULL);
+			ASSERT_TRUE(e < 0xfff0000000000002ULL);
+			ASSERT_TRUE(e < 0xfff0000000000003ULL);
+			if (d < 0)
+			{
+				ASSERT_TRUE(e < 0x8000000000000001ULL);
+			}
+			if (d > 0)
+			{
+				ASSERT_TRUE(e > 0x8000000000000001ULL);
+			}
+			if (old_d < d)
+			{
+				ASSERT_TRUE(old_e < e);
+			}
+			else if (old_d > d)
+			{
+				ASSERT_TRUE(old_e > e);
+			}
+			else
+			{
+				ASSERT_TRUE(old_e == e);
+			}
+			old_d = d;
+			old_e = e;
+		}
+	}
 }
diff --git a/common/transfer.cc b/common/transfer.cc
index efe11d8d0..89e9c856e 100644
--- a/common/transfer.cc
+++ b/common/transfer.cc
@@ -31,37 +31,37 @@
 using hyperdex::transfer;
 
 transfer :: transfer()
-    : id()
-    , rid()
-    , src()
-    , vsrc()
-    , dst()
-    , vdst()
+	: id()
+	, rid()
+	, src()
+	, vsrc()
+	, dst()
+	, vdst()
 {
 }
 
-transfer :: transfer(const hyperdex::transfer_id& _id,
-                     const hyperdex::region_id& _rid,
-                     const hyperdex::server_id& _src,
-                     const hyperdex::virtual_server_id& _vsrc,
-                     const hyperdex::server_id& _dst,
-                     const hyperdex::virtual_server_id& _vdst)
-    : id(_id)
-    , rid(_rid)
-    , src(_src)
-    , vsrc(_vsrc)
-    , dst(_dst)
-    , vdst(_vdst)
+transfer :: transfer(const hyperdex::transfer_id &_id,
+                     const hyperdex::region_id &_rid,
+                     const hyperdex::server_id &_src,
+                     const hyperdex::virtual_server_id &_vsrc,
+                     const hyperdex::server_id &_dst,
+                     const hyperdex::virtual_server_id &_vdst)
+	: id(_id)
+	, rid(_rid)
+	, src(_src)
+	, vsrc(_vsrc)
+	, dst(_dst)
+	, vdst(_vdst)
 {
 }
 
-transfer :: transfer(const transfer& other)
-    : id(other.id)
-    , rid(other.rid)
-    , src(other.src)
-    , vsrc(other.vsrc)
-    , dst(other.dst)
-    , vdst(other.vdst)
+transfer :: transfer(const transfer &other)
+	: id(other.id)
+	, rid(other.rid)
+	, src(other.src)
+	, vsrc(other.vsrc)
+	, dst(other.dst)
+	, vdst(other.vdst)
 {
 }
 
@@ -69,94 +69,89 @@ transfer :: ~transfer() throw ()
 {
 }
 
-transfer&
-transfer :: operator = (const transfer& rhs)
+transfer &
+transfer :: operator = (const transfer &rhs)
 {
-    id = rhs.id;
-    rid = rhs.rid;
-    src = rhs.src;
-    vsrc = rhs.vsrc;
-    dst = rhs.dst;
-    vdst = rhs.vdst;
-    return *this;
+	id = rhs.id;
+	rid = rhs.rid;
+	src = rhs.src;
+	vsrc = rhs.vsrc;
+	dst = rhs.dst;
+	vdst = rhs.vdst;
+	return *this;
 }
 
 bool
-transfer :: operator < (const transfer& rhs) const
+transfer :: operator < (const transfer &rhs) const
 {
-    if (id < rhs.id)
-    {
-        return true;
-    }
-    else if (id > rhs.id)
-    {
-        return false;
-    }
-
-    if (rid < rhs.rid)
-    {
-        return true;
-    }
-    else if (rid > rhs.rid)
-    {
-        return false;
-    }
-
-    if (src < rhs.src)
-    {
-        return true;
-    }
-    else if (src > rhs.src)
-    {
-        return false;
-    }
-
-    if (vsrc < rhs.vsrc)
-    {
-        return true;
-    }
-    else if (vsrc > rhs.vsrc)
-    {
-        return false;
-    }
-
-    if (dst < rhs.dst)
-    {
-        return true;
-    }
-    else if (dst > rhs.dst)
-    {
-        return false;
-    }
-
-    return vdst < rhs.vdst;
+	if (id < rhs.id)
+	{
+		return true;
+	}
+	else if (id > rhs.id)
+	{
+		return false;
+	}
+	if (rid < rhs.rid)
+	{
+		return true;
+	}
+	else if (rid > rhs.rid)
+	{
+		return false;
+	}
+	if (src < rhs.src)
+	{
+		return true;
+	}
+	else if (src > rhs.src)
+	{
+		return false;
+	}
+	if (vsrc < rhs.vsrc)
+	{
+		return true;
+	}
+	else if (vsrc > rhs.vsrc)
+	{
+		return false;
+	}
+	if (dst < rhs.dst)
+	{
+		return true;
+	}
+	else if (dst > rhs.dst)
+	{
+		return false;
+	}
+	return vdst < rhs.vdst;
 }
 
-std::ostream&
-hyperdex :: operator << (std::ostream& lhs, const transfer& rhs)
+std::ostream &
+hyperdex :: operator << (std::ostream &lhs, const transfer &rhs)
 {
-    return lhs << "transfer(id=" << rhs.id
-               << ", region=" << rhs.rid
-               << ", src=" << rhs.src
-               << ", vsrc=" << rhs.vsrc
-               << ", dst=" << rhs.dst
-               << ", vdst=" << rhs.vdst << ")";
+	return lhs << "transfer(id=" << rhs.id
+	       << ", region=" << rhs.rid
+	       << ", src=" << rhs.src
+	       << ", vsrc=" << rhs.vsrc
+	       << ", dst=" << rhs.dst
+	       << ", vdst=" << rhs.vdst << ")";
 }
 
 e::packer
-hyperdex :: operator << (e::packer pa, const transfer& t)
+hyperdex :: operator << (e::packer pa, const transfer &t)
 {
-    return pa << t.id << t.rid << t.src << t.vsrc << t.dst << t.vdst;
+	return pa << t.id << t.rid << t.src << t.vsrc << t.dst << t.vdst;
 }
 
 e::unpacker
-hyperdex :: operator >> (e::unpacker up, transfer& t)
+hyperdex :: operator >> (e::unpacker up, transfer &t)
 {
-    return up >> t.id >> t.rid >> t.src >> t.vsrc >> t.dst >> t.vdst;
+	return up >> t.id >> t.rid >> t.src >> t.vsrc >> t.dst >> t.vdst;
 }
 
 size_t
-hyperdex :: pack_size(const transfer&)
+hyperdex :: pack_size(const transfer &)
 {
-    return 6 * sizeof(uint64_t);
+	return 6 * sizeof(uint64_t);
 }
diff --git a/common/transfer.h b/common/transfer.h
index 88b852ad7..1fdd410c1 100644
--- a/common/transfer.h
+++ b/common/transfer.h
@@ -39,39 +39,39 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class transfer
 {
-    public:
-        transfer();
-        transfer(const transfer_id& id,
-                 const region_id& rid,
-                 const server_id& src,
-                 const virtual_server_id& vsrc,
-                 const server_id& dst,
-                 const virtual_server_id& vdst);
-        transfer(const transfer&);
-        ~transfer() throw ();
+public:
+	transfer();
+	transfer(const transfer_id &id,
+	         const region_id &rid,
+	         const server_id &src,
+	         const virtual_server_id &vsrc,
+	         const server_id &dst,
+	         const virtual_server_id &vdst);
+	transfer(const transfer &);
+	~transfer() throw ();
 
-    public:
-        transfer& operator = (const transfer&);
-        bool operator < (const transfer&) const;
+public:
+	transfer &operator = (const transfer &);
+	bool operator < (const transfer &) const;
 
-    public:
-        transfer_id id;
-        region_id rid;
-        server_id src;
-        virtual_server_id vsrc;
-        server_id dst;
-        virtual_server_id vdst;
+public:
+	transfer_id id;
+	region_id rid;
+	server_id src;
+	virtual_server_id vsrc;
+	server_id dst;
+	virtual_server_id vdst;
 };
 
-std::ostream&
-operator << (std::ostream& lhs, const transfer& rhs);
+std::ostream &
+operator << (std::ostream &lhs, const transfer &rhs);
 
 e::packer
-operator << (e::packer, const transfer& t);
+operator << (e::packer, const transfer &t);
 e::unpacker
-operator >> (e::unpacker, transfer& t);
+operator >> (e::unpacker, transfer &t);
 size_t
-pack_size(const transfer& t);
+pack_size(const transfer &t);
 
 END_HYPERDEX_NAMESPACE
 
diff --git a/configure.ac b/configure.ac
index 15f33845a..a06553f4b 100755
--- a/configure.ac
+++ b/configure.ac
@@ -1,8 +1,8 @@
 #                                               -*- Autoconf -*-
 # Process this file with autoconf to produce a configure script.
 
-AC_PREREQ([2.62])
-AC_INIT([HyperDex], [1.8.dev], [robert@hyperdex.org])
+AC_PREREQ([2.59])
+AC_INIT([HyperDex], [1.8.2], [robert@hyperdex.org])
 m4_define([serial_tests], [
     m4_esyscmd([case `automake --version | head -n 1` in
                 *1.11*);;
diff --git a/coordinator/coordinator.cc b/coordinator/coordinator.cc
index 9def766db..1a3fb356a 100644
--- a/coordinator/coordinator.cc
+++ b/coordinator/coordinator.cc
@@ -61,105 +61,103 @@ namespace
 {
 
 std::string
-to_string(const po6::net::location& loc)
+to_string(const po6::net::location &loc)
 {
-    std::ostringstream oss;
-    oss << loc;
-    return oss.str();
+	std::ostringstream oss;
+	oss << loc;
+	return oss.str();
 }
 
 template <typename T>
 void
-shift_and_pop(size_t idx, std::vector<T>* v)
+shift_and_pop(size_t idx, std::vector<T> *v)
 {
-    for (size_t i = idx + 1; i < v->size(); ++i)
-    {
-        (*v)[i - 1] = (*v)[i];
-    }
-
-    v->pop_back();
+	for (size_t i = idx + 1; i < v->size(); ++i)
+	{
+		(*v)[i - 1] = (*v)[i];
+	}
+	v->pop_back();
 }
 
 template <typename T>
 void
-remove(const T& t, std::vector<T>* v)
+remove(const T &t, std::vector<T> *v)
 {
-    for (size_t i = 0; i < v->size(); )
-    {
-        if ((*v)[i] == t)
-        {
-            shift_and_pop(i, v);
-        }
-        else
-        {
-            ++i;
-        }
-    }
+	for (size_t i = 0; i < v->size(); )
+	{
+		if ((*v)[i] == t)
+		{
+			shift_and_pop(i, v);
+		}
+		else
+		{
+			++i;
+		}
+	}
 }
 
 template <class T, class TID>
 bool
-find_id(const TID& id, std::vector<T>& v, T** found)
+find_id(const TID &id, std::vector<T> &v, T **found)
 {
-    for (size_t i = 0; i < v.size(); ++i)
-    {
-        if (v[i].id == id)
-        {
-            *found = &v[i];
-            return true;
-        }
-    }
-
-    return false;
+	for (size_t i = 0; i < v.size(); ++i)
+	{
+		if (v[i].id == id)
+		{
+			*found = &v[i];
+			return true;
+		}
+	}
+	return false;
 }
 
 template <class T, class TID>
 void
-remove_id(const TID& id, std::vector<T>* v)
+remove_id(const TID &id, std::vector<T> *v)
 {
-    for (size_t i = 0; i < v->size(); )
-    {
-        if ((*v)[i].id == id)
-        {
-            shift_and_pop(i, v);
-        }
-        else
-        {
-            ++i;
-        }
-    }
+	for (size_t i = 0; i < v->size(); )
+	{
+		if ((*v)[i].id == id)
+		{
+			shift_and_pop(i, v);
+		}
+		else
+		{
+			++i;
+		}
+	}
 }
 
 } // namespace
 
 coordinator :: coordinator()
-    : m_cluster(0)
-    , m_counter(1)
-    , m_version(0)
-    , m_flags(0)
-    , m_servers()
-    , m_permutation()
-    , m_spares()
-    , m_desired_spares(0)
-    , m_spaces()
-    , m_intents()
-    , m_deferred_init()
-    , m_offline()
-    , m_transfers()
-    , m_config_ack_through(0)
-    , m_config_ack_barrier()
-    , m_config_stable_through(0)
-    , m_config_stable_barrier()
-    , m_checkpoint(0)
-    , m_checkpoint_stable_through(0)
-    , m_checkpoint_gc_through(0)
-    , m_checkpoint_stable_barrier()
-    , m_latest_config()
-    , m_response()
-{
-    assert(m_config_ack_through == m_config_ack_barrier.min_version());
-    assert(m_config_stable_through == m_config_stable_barrier.min_version());
-    assert(m_checkpoint_stable_through == m_checkpoint_stable_barrier.min_version());
+	: m_cluster(0)
+	, m_counter(1)
+	, m_version(0)
+	, m_flags(0)
+	, m_servers()
+	, m_permutation()
+	, m_spares()
+	, m_desired_spares(0)
+	, m_spaces()
+	, m_intents()
+	, m_deferred_init()
+	, m_offline()
+	, m_transfers()
+	, m_config_ack_through(0)
+	, m_config_ack_barrier()
+	, m_config_stable_through(0)
+	, m_config_stable_barrier()
+	, m_checkpoint(0)
+	, m_checkpoint_stable_through(0)
+	, m_checkpoint_gc_through(0)
+	, m_checkpoint_stable_barrier()
+	, m_latest_config()
+	, m_response()
+{
+	assert(m_config_ack_through == m_config_ack_barrier.min_version());
+	assert(m_config_stable_through == m_config_stable_barrier.min_version());
+	assert(m_checkpoint_stable_through == m_checkpoint_stable_barrier.min_version());
 }
 
 coordinator :: ~coordinator() throw ()
@@ -167,1966 +165,1750 @@ coordinator :: ~coordinator() throw ()
 }
 
 void
-coordinator :: init(rsm_context* ctx, uint64_t token)
-{
-    if (m_cluster != 0)
-    {
-        rsm_log(ctx, "cannot initialize HyperDex cluster with id %" PRIu64 " "
-                     "because it is already initialized to %" PRIu64 "\n", token, m_cluster);
-        // we lie to the client and pretend all is well
-        return generate_response(ctx, COORD_SUCCESS);
-    }
-
-    rsm_tick_interval(ctx, "periodic", ALARM_INTERVAL);
-    rsm_log(ctx, "initializing HyperDex cluster with id %" PRIu64 "\n", token);
-    m_cluster = token;
-    generate_next_configuration(ctx);
-    return generate_response(ctx, COORD_SUCCESS);
+coordinator :: init(rsm_context *ctx, uint64_t token)
+{
+	if (m_cluster != 0)
+	{
+		rsm_log(ctx, "cannot initialize HyperDex cluster with id %" PRIu64 " "
+		        "because it is already initialized to %" PRIu64 "\n", token, m_cluster);
+		// we lie to the client and pretend all is well
+		return generate_response(ctx, COORD_SUCCESS);
+	}
+	rsm_tick_interval(ctx, "periodic", ALARM_INTERVAL);
+	rsm_log(ctx, "initializing HyperDex cluster with id %" PRIu64 "\n", token);
+	m_cluster = token;
+	generate_next_configuration(ctx);
+	return generate_response(ctx, COORD_SUCCESS);
 }
 
 void
-coordinator :: read_only(rsm_context* ctx, bool ro)
-{
-    uint64_t old_flags = m_flags;
-
-    if (ro)
-    {
-        if ((m_flags & HYPERDEX_CONFIG_READ_ONLY))
-        {
-            rsm_log(ctx, "cluster already in read-only mode\n");
-        }
-        else
-        {
-            rsm_log(ctx, "putting cluster into read-only mode\n");
-        }
-
-        m_flags |= HYPERDEX_CONFIG_READ_ONLY;
-    }
-    else
-    {
-        if ((m_flags & HYPERDEX_CONFIG_READ_ONLY))
-        {
-            rsm_log(ctx, "putting cluster into read-write mode\n");
-        }
-        else
-        {
-            rsm_log(ctx, "cluster already in read-write mode\n");
-        }
-
-        uint64_t mask = HYPERDEX_CONFIG_READ_ONLY;
-        mask = ~mask;
-        m_flags &= mask;
-    }
-
-    if (old_flags != m_flags)
-    {
-        generate_next_configuration(ctx);
-    }
-
-    return generate_response(ctx, COORD_SUCCESS);
+coordinator :: read_only(rsm_context *ctx, bool ro)
+{
+	uint64_t old_flags = m_flags;
+	if (ro)
+	{
+		if ((m_flags & HYPERDEX_CONFIG_READ_ONLY))
+		{
+			rsm_log(ctx, "cluster already in read-only mode\n");
+		}
+		else
+		{
+			rsm_log(ctx, "putting cluster into read-only mode\n");
+		}
+		m_flags |= HYPERDEX_CONFIG_READ_ONLY;
+	}
+	else
+	{
+		if ((m_flags & HYPERDEX_CONFIG_READ_ONLY))
+		{
+			rsm_log(ctx, "putting cluster into read-write mode\n");
+		}
+		else
+		{
+			rsm_log(ctx, "cluster already in read-write mode\n");
+		}
+		uint64_t mask = HYPERDEX_CONFIG_READ_ONLY;
+		mask = ~mask;
+		m_flags &= mask;
+	}
+	if (old_flags != m_flags)
+	{
+		generate_next_configuration(ctx);
+	}
+	return generate_response(ctx, COORD_SUCCESS);
 }
 
 void
-coordinator :: fault_tolerance(rsm_context* ctx,
-                               const char* space, uint64_t ft)
-{
-    uint64_t R = 0;
-    uint64_t P = 0;
-    std::vector<server_id> replica_storage;
-    std::vector<replica_set> replica_sets;
-    space_ptr s;
-
-    for (space_map_t::iterator it = m_spaces.begin();
-            it != m_spaces.end(); ++it)
-    {
-        if (it->first == space)
-        {
-            s = it->second;
-            break;
-        }
-    }
-
-    if (!s)
-    {
-        return;
-    }
-
-    s->fault_tolerance = ft;
-
-    R = ft + 1;
-    P = s->predecessor_width;
-    compute_replica_sets(R, P, m_permutation, m_servers,
-                         &replica_storage,
-                         &replica_sets);
-
-    setup_intents(ctx, replica_sets, s.get(), false);
-
-    generate_next_configuration(ctx);
-    return generate_response(ctx, COORD_SUCCESS);
+coordinator :: fault_tolerance(rsm_context *ctx,
+                               const char *space, uint64_t ft)
+{
+	uint64_t R = 0;
+	uint64_t P = 0;
+	std::vector<server_id> replica_storage;
+	std::vector<replica_set> replica_sets;
+	space_ptr s;
+	for (space_map_t::iterator it = m_spaces.begin();
+	     it != m_spaces.end(); ++it)
+	{
+		if (it->first == space)
+		{
+			s = it->second;
+			break;
+		}
+	}
+	if (!s)
+	{
+		return;
+	}
+	s->fault_tolerance = ft;
+	R = ft + 1;
+	P = s->predecessor_width;
+	compute_replica_sets(R, P, m_permutation, m_servers,
+	                     &replica_storage,
+	                     &replica_sets);
+	setup_intents(ctx, replica_sets, s.get(), false);
+	generate_next_configuration(ctx);
+	return generate_response(ctx, COORD_SUCCESS);
 }
 
 void
-coordinator :: server_register(rsm_context* ctx,
-                               const server_id& sid,
-                               const po6::net::location& bind_to)
-{
-    server* srv = get_server(sid);
-
-    if (srv)
-    {
-        std::string str(to_string(srv->bind_to));
-        rsm_log(ctx, "cannot register server(%" PRIu64 ") because the id belongs to "
-                     "server(%" PRIu64 ", %s)\n", sid.get(), srv->id.get(), str.c_str());
-        return generate_response(ctx, hyperdex::COORD_DUPLICATE);
-    }
-
-    srv = new_server(sid);
-    srv->state = server::ASSIGNED;
-    srv->bind_to = bind_to;
-    rsm_log(ctx, "registered server(%" PRIu64 ")\n", sid.get());
-    generate_next_configuration(ctx);
-    return generate_response(ctx, COORD_SUCCESS);
+coordinator :: server_register(rsm_context *ctx,
+                               const server_id &sid,
+                               const po6::net::location &bind_to)
+{
+	server *srv = get_server(sid);
+	if (srv)
+	{
+		std::string str(to_string(srv->bind_to));
+		rsm_log(ctx, "cannot register server(%" PRIu64 ") because the id belongs to "
+		        "server(%" PRIu64 ", %s)\n", sid.get(), srv->id.get(), str.c_str());
+		return generate_response(ctx, hyperdex::COORD_DUPLICATE);
+	}
+	srv = new_server(sid);
+	srv->state = server::ASSIGNED;
+	srv->bind_to = bind_to;
+	rsm_log(ctx, "registered server(%" PRIu64 ")\n", sid.get());
+	generate_next_configuration(ctx);
+	return generate_response(ctx, COORD_SUCCESS);
 }
 
 void
-coordinator :: server_online(rsm_context* ctx,
-                             const server_id& sid,
-                             const po6::net::location* bind_to)
-{
-    server* srv = get_server(sid);
-
-    if (!srv)
-    {
-        rsm_log(ctx, "cannot bring server(%" PRIu64 ") online because "
-                     "the server doesn't exist\n", sid.get());
-        return generate_response(ctx, hyperdex::COORD_NOT_FOUND);
-    }
-
-    if (srv->state != server::ASSIGNED &&
-        srv->state != server::NOT_AVAILABLE &&
-        srv->state != server::SHUTDOWN &&
-        srv->state != server::AVAILABLE)
-    {
-        rsm_log(ctx, "cannot bring server(%" PRIu64 ") online because the server is "
-                     "%s\n", sid.get(), server::to_string(srv->state));
-        return generate_response(ctx, hyperdex::COORD_NO_CAN_DO);
-    }
-
-    bool changed = false;
-
-    if (bind_to && srv->bind_to != *bind_to)
-    {
-        std::string from(to_string(srv->bind_to));
-        std::string to(to_string(*bind_to));
-
-        for (size_t i = 0; i < m_servers.size(); ++i)
-        {
-            if (m_servers[i].id != sid &&
-                m_servers[i].bind_to == *bind_to)
-            {
-                rsm_log(ctx, "cannot change server(%" PRIu64 ") to %s "
-                             "because that address is in use by "
-                             "server(%" PRIu64 ")\n", sid.get(), to.c_str(),
-                             m_servers[i].id.get());
-                return generate_response(ctx, hyperdex::COORD_DUPLICATE);
-            }
-        }
-
-        rsm_log(ctx, "changing server(%" PRIu64 ")'s address from %s to %s\n",
-                     sid.get(), from.c_str(), to.c_str());
-        srv->bind_to = *bind_to;
-        changed = true;
-    }
-
-    if (srv->state != server::AVAILABLE)
-    {
-        rsm_log(ctx, "changing server(%" PRIu64 ") from %s to %s\n",
-                     sid.get(), server::to_string(srv->state),
-                     server::to_string(server::AVAILABLE));
-        srv->state = server::AVAILABLE;
-
-        if (!in_permutation(sid))
-        {
-            add_permutation(sid);
-        }
-
-        rebalance_replica_sets(ctx);
-        changed = true;
-    }
-
-    if (changed)
-    {
-        generate_next_configuration(ctx);
-    }
-
-    return generate_response(ctx, COORD_SUCCESS);
+coordinator :: server_online(rsm_context *ctx,
+                             const server_id &sid,
+                             const po6::net::location *bind_to)
+{
+	server *srv = get_server(sid);
+	if (!srv)
+	{
+		rsm_log(ctx, "cannot bring server(%" PRIu64 ") online because "
+		        "the server doesn't exist\n", sid.get());
+		return generate_response(ctx, hyperdex::COORD_NOT_FOUND);
+	}
+	if (srv->state != server::ASSIGNED &&
+	    srv->state != server::NOT_AVAILABLE &&
+	    srv->state != server::SHUTDOWN &&
+	    srv->state != server::AVAILABLE)
+	{
+		rsm_log(ctx, "cannot bring server(%" PRIu64 ") online because the server is "
+		        "%s\n", sid.get(), server::to_string(srv->state));
+		return generate_response(ctx, hyperdex::COORD_NO_CAN_DO);
+	}
+	bool changed = false;
+	if (bind_to && srv->bind_to != *bind_to)
+	{
+		std::string from(to_string(srv->bind_to));
+		std::string to(to_string(*bind_to));
+		for (size_t i = 0; i < m_servers.size(); ++i)
+		{
+			if (m_servers[i].id != sid &&
+			    m_servers[i].bind_to == *bind_to)
+			{
+				rsm_log(ctx, "cannot change server(%" PRIu64 ") to %s "
+				        "because that address is in use by "
+				        "server(%" PRIu64 ")\n", sid.get(), to.c_str(),
+				        m_servers[i].id.get());
+				return generate_response(ctx, hyperdex::COORD_DUPLICATE);
+			}
+		}
+		rsm_log(ctx, "changing server(%" PRIu64 ")'s address from %s to %s\n",
+		        sid.get(), from.c_str(), to.c_str());
+		srv->bind_to = *bind_to;
+		changed = true;
+	}
+	if (srv->state != server::AVAILABLE)
+	{
+		rsm_log(ctx, "changing server(%" PRIu64 ") from %s to %s\n",
+		        sid.get(), server::to_string(srv->state),
+		        server::to_string(server::AVAILABLE));
+		srv->state = server::AVAILABLE;
+		if (!in_permutation(sid))
+		{
+			add_permutation(sid);
+		}
+		rebalance_replica_sets(ctx);
+		changed = true;
+	}
+	if (changed)
+	{
+		generate_next_configuration(ctx);
+	}
+	return generate_response(ctx, COORD_SUCCESS);
 }
 
 void
-coordinator :: server_offline(rsm_context* ctx,
-                              const server_id& sid)
-{
-    server* srv = get_server(sid);
-
-    if (!srv)
-    {
-        rsm_log(ctx, "cannot bring server(%" PRIu64 ") offline because "
-                     "the server doesn't exist\n", sid.get());
-        return generate_response(ctx, hyperdex::COORD_NOT_FOUND);
-    }
-
-    if (srv->state != server::ASSIGNED &&
-        srv->state != server::NOT_AVAILABLE &&
-        srv->state != server::AVAILABLE &&
-        srv->state != server::SHUTDOWN)
-    {
-        rsm_log(ctx, "cannot bring server(%" PRIu64 ") offline because the server is "
-                     "%s\n", sid.get(), server::to_string(srv->state));
-        return generate_response(ctx, hyperdex::COORD_NO_CAN_DO);
-    }
-
-    if (srv->state != server::NOT_AVAILABLE && srv->state != server::SHUTDOWN)
-    {
-        rsm_log(ctx, "changing server(%" PRIu64 ") from %s to %s\n",
-                     sid.get(), server::to_string(srv->state),
-                     server::to_string(server::NOT_AVAILABLE));
-        srv->state = server::NOT_AVAILABLE;
-        rebalance_replica_sets(ctx);
-        generate_next_configuration(ctx);
-    }
-
-    return generate_response(ctx, COORD_SUCCESS);
+coordinator :: server_offline(rsm_context *ctx,
+                              const server_id &sid)
+{
+	server *srv = get_server(sid);
+	if (!srv)
+	{
+		rsm_log(ctx, "cannot bring server(%" PRIu64 ") offline because "
+		        "the server doesn't exist\n", sid.get());
+		return generate_response(ctx, hyperdex::COORD_NOT_FOUND);
+	}
+	if (srv->state != server::ASSIGNED &&
+	    srv->state != server::NOT_AVAILABLE &&
+	    srv->state != server::AVAILABLE &&
+	    srv->state != server::SHUTDOWN)
+	{
+		rsm_log(ctx, "cannot bring server(%" PRIu64 ") offline because the server is "
+		        "%s\n", sid.get(), server::to_string(srv->state));
+		return generate_response(ctx, hyperdex::COORD_NO_CAN_DO);
+	}
+	if (srv->state != server::NOT_AVAILABLE && srv->state != server::SHUTDOWN)
+	{
+		rsm_log(ctx, "changing server(%" PRIu64 ") from %s to %s\n",
+		        sid.get(), server::to_string(srv->state),
+		        server::to_string(server::NOT_AVAILABLE));
+		srv->state = server::NOT_AVAILABLE;
+		rebalance_replica_sets(ctx);
+		generate_next_configuration(ctx);
+	}
+	return generate_response(ctx, COORD_SUCCESS);
 }
 
 void
-coordinator :: server_shutdown(rsm_context* ctx,
-                               const server_id& sid)
-{
-    server* srv = get_server(sid);
-
-    if (!srv)
-    {
-        rsm_log(ctx, "cannot shutdown server(%" PRIu64 ") because "
-                     "the server doesn't exist\n", sid.get());
-        return generate_response(ctx, hyperdex::COORD_NOT_FOUND);
-    }
-
-    if (srv->state != server::ASSIGNED &&
-        srv->state != server::NOT_AVAILABLE &&
-        srv->state != server::AVAILABLE &&
-        srv->state != server::SHUTDOWN)
-    {
-        rsm_log(ctx, "cannot shutdown server(%" PRIu64 ") because the server is "
-                     "%s\n", sid.get(), server::to_string(srv->state));
-        return generate_response(ctx, hyperdex::COORD_NO_CAN_DO);
-    }
-
-    if (srv->state != server::SHUTDOWN)
-    {
-        rsm_log(ctx, "changing server(%" PRIu64 ") from %s to %s\n",
-                     sid.get(), server::to_string(srv->state),
-                     server::to_string(server::SHUTDOWN));
-        srv->state = server::SHUTDOWN;
-        rebalance_replica_sets(ctx);
-        generate_next_configuration(ctx);
-    }
-
-    return generate_response(ctx, COORD_SUCCESS);
+coordinator :: server_shutdown(rsm_context *ctx,
+                               const server_id &sid)
+{
+	server *srv = get_server(sid);
+	if (!srv)
+	{
+		rsm_log(ctx, "cannot shutdown server(%" PRIu64 ") because "
+		        "the server doesn't exist\n", sid.get());
+		return generate_response(ctx, hyperdex::COORD_NOT_FOUND);
+	}
+	if (srv->state != server::ASSIGNED &&
+	    srv->state != server::NOT_AVAILABLE &&
+	    srv->state != server::AVAILABLE &&
+	    srv->state != server::SHUTDOWN)
+	{
+		rsm_log(ctx, "cannot shutdown server(%" PRIu64 ") because the server is "
+		        "%s\n", sid.get(), server::to_string(srv->state));
+		return generate_response(ctx, hyperdex::COORD_NO_CAN_DO);
+	}
+	if (srv->state != server::SHUTDOWN)
+	{
+		rsm_log(ctx, "changing server(%" PRIu64 ") from %s to %s\n",
+		        sid.get(), server::to_string(srv->state),
+		        server::to_string(server::SHUTDOWN));
+		srv->state = server::SHUTDOWN;
+		rebalance_replica_sets(ctx);
+		generate_next_configuration(ctx);
+	}
+	return generate_response(ctx, COORD_SUCCESS);
 }
 
 void
-coordinator :: server_kill(rsm_context* ctx,
-                           const server_id& sid)
-{
-    server* srv = get_server(sid);
-
-    if (!srv)
-    {
-        rsm_log(ctx, "cannot kill server(%" PRIu64 ") because "
-                     "the server doesn't exist\n", sid.get());
-        return generate_response(ctx, hyperdex::COORD_NOT_FOUND);
-    }
-
-    if (srv->state != server::KILLED)
-    {
-        rsm_log(ctx, "changing server(%" PRIu64 ") from %s to %s\n",
-                     sid.get(), server::to_string(srv->state),
-                     server::to_string(server::KILLED));
-        srv->state = server::KILLED;
-        remove_permutation(sid);
-        remove_offline(sid);
-        rebalance_replica_sets(ctx);
-        generate_next_configuration(ctx);
-    }
-
-    return generate_response(ctx, COORD_SUCCESS);
+coordinator :: server_kill(rsm_context *ctx,
+                           const server_id &sid)
+{
+	server *srv = get_server(sid);
+	if (!srv)
+	{
+		rsm_log(ctx, "cannot kill server(%" PRIu64 ") because "
+		        "the server doesn't exist\n", sid.get());
+		return generate_response(ctx, hyperdex::COORD_NOT_FOUND);
+	}
+	if (srv->state != server::KILLED)
+	{
+		rsm_log(ctx, "changing server(%" PRIu64 ") from %s to %s\n",
+		        sid.get(), server::to_string(srv->state),
+		        server::to_string(server::KILLED));
+		srv->state = server::KILLED;
+		remove_permutation(sid);
+		remove_offline(sid);
+		rebalance_replica_sets(ctx);
+		generate_next_configuration(ctx);
+	}
+	return generate_response(ctx, COORD_SUCCESS);
 }
 
 void
-coordinator :: server_forget(rsm_context* ctx,
-                             const server_id& sid)
-{
-    server* srv = get_server(sid);
-
-    if (!srv)
-    {
-        rsm_log(ctx, "cannot forget server(%" PRIu64 ") because "
-                     "the server doesn't exist\n", sid.get());
-        return generate_response(ctx, hyperdex::COORD_NOT_FOUND);
-    }
-
-    for (size_t i = 0; i < m_servers.size(); ++i)
-    {
-        if (m_servers[i].id == sid)
-        {
-            std::swap(m_servers[i], m_servers[m_servers.size() - 1]);
-            m_servers.pop_back();
-        }
-    }
-
-    std::stable_sort(m_servers.begin(), m_servers.end());
-    remove_permutation(sid);
-    remove_offline(sid);
-    rebalance_replica_sets(ctx);
-    generate_next_configuration(ctx);
-    return generate_response(ctx, COORD_SUCCESS);
+coordinator :: server_forget(rsm_context *ctx,
+                             const server_id &sid)
+{
+	server *srv = get_server(sid);
+	if (!srv)
+	{
+		rsm_log(ctx, "cannot forget server(%" PRIu64 ") because "
+		        "the server doesn't exist\n", sid.get());
+		return generate_response(ctx, hyperdex::COORD_NOT_FOUND);
+	}
+	for (size_t i = 0; i < m_servers.size(); ++i)
+	{
+		if (m_servers[i].id == sid)
+		{
+			std::swap(m_servers[i], m_servers[m_servers.size() - 1]);
+			m_servers.pop_back();
+		}
+	}
+	std::stable_sort(m_servers.begin(), m_servers.end());
+	remove_permutation(sid);
+	remove_offline(sid);
+	rebalance_replica_sets(ctx);
+	generate_next_configuration(ctx);
+	return generate_response(ctx, COORD_SUCCESS);
 }
 
 void
-coordinator :: server_suspect(rsm_context* ctx,
-                              const server_id& sid)
-{
-    server* srv = get_server(sid);
-
-    if (!srv)
-    {
-        rsm_log(ctx, "cannot suspect server(%" PRIu64 ") because "
-                     "the server doesn't exist\n", sid.get());
-        return generate_response(ctx, hyperdex::COORD_NOT_FOUND);
-    }
-
-    if (srv->state == server::SHUTDOWN)
-    {
-        return generate_response(ctx, COORD_SUCCESS);
-    }
-
-    if (srv->state != server::ASSIGNED &&
-        srv->state != server::NOT_AVAILABLE &&
-        srv->state != server::AVAILABLE)
-    {
-        rsm_log(ctx, "cannot suspect server(%" PRIu64 ") because the server is "
-                     "%s\n", sid.get(), server::to_string(srv->state));
-        return generate_response(ctx, hyperdex::COORD_NO_CAN_DO);
-    }
-
-    if (srv->state != server::NOT_AVAILABLE && srv->state != server::SHUTDOWN)
-    {
-        rsm_log(ctx, "changing server(%" PRIu64 ") from %s to %s because we suspect it failed\n",
-                     sid.get(), server::to_string(srv->state),
-                     server::to_string(server::NOT_AVAILABLE));
-        srv->state = server::NOT_AVAILABLE;
-        rebalance_replica_sets(ctx);
-        generate_next_configuration(ctx);
-    }
-
-    return generate_response(ctx, COORD_SUCCESS);
+coordinator :: server_suspect(rsm_context *ctx,
+                              const server_id &sid)
+{
+	server *srv = get_server(sid);
+	if (!srv)
+	{
+		rsm_log(ctx, "cannot suspect server(%" PRIu64 ") because "
+		        "the server doesn't exist\n", sid.get());
+		return generate_response(ctx, hyperdex::COORD_NOT_FOUND);
+	}
+	if (srv->state == server::SHUTDOWN)
+	{
+		return generate_response(ctx, COORD_SUCCESS);
+	}
+	if (srv->state != server::ASSIGNED &&
+	    srv->state != server::NOT_AVAILABLE &&
+	    srv->state != server::AVAILABLE)
+	{
+		rsm_log(ctx, "cannot suspect server(%" PRIu64 ") because the server is "
+		        "%s\n", sid.get(), server::to_string(srv->state));
+		return generate_response(ctx, hyperdex::COORD_NO_CAN_DO);
+	}
+	if (srv->state != server::NOT_AVAILABLE && srv->state != server::SHUTDOWN)
+	{
+		rsm_log(ctx, "changing server(%" PRIu64 ") from %s to %s because we suspect it failed\n",
+		        sid.get(), server::to_string(srv->state),
+		        server::to_string(server::NOT_AVAILABLE));
+		srv->state = server::NOT_AVAILABLE;
+		rebalance_replica_sets(ctx);
+		generate_next_configuration(ctx);
+	}
+	return generate_response(ctx, COORD_SUCCESS);
 }
 
 void
-coordinator :: report_disconnect(rsm_context* ctx,
-                                 const server_id& sid, uint64_t version)
+coordinator :: report_disconnect(rsm_context *ctx,
+                                 const server_id &sid, uint64_t version)
 {
-    if (m_version != version)
-    {
-        return;
-    }
-
-    return server_suspect(ctx, sid);
+	if (m_version != version)
+	{
+		return;
+	}
+	return server_suspect(ctx, sid);
 }
 
 static bool
-is_space_name(const char* str)
+is_space_name(const char *str)
 {
-    size_t i = 0;
-
-    for (i = 0; str[i]; ++i)
-    {
-        if (!(i > 0 && isdigit(str[i])) &&
-            !(isalpha(str[i])) &&
-            str[i] != '_')
-        {
-            return false;
-        }
-    }
-
-    return i > 0;
+	size_t i = 0;
+	for (i = 0; str[i]; ++i)
+	{
+		if (!(i > 0 && isdigit(str[i])) &&
+		    !(isalpha(str[i])) &&
+		    str[i] != '_')
+		{
+			return false;
+		}
+	}
+	return i > 0;
 }
 
 void
-coordinator :: space_add(rsm_context* ctx, const space& _s)
-{
-
-    if (!_s.validate())
-    {
-        rsm_log(ctx, "could not add space \"%s\" because the space does not validate\n", _s.name);
-        return generate_response(ctx, COORD_MALFORMED);
-    }
-
-    if (m_spaces.find(std::string(_s.name)) != m_spaces.end())
-    {
-        rsm_log(ctx, "could not add space \"%s\" because there is already a space with that name\n", _s.name);
-        return generate_response(ctx, COORD_DUPLICATE);
-    }
-
-    // Assign unique ids throughout the space
-    e::compat::shared_ptr<space> s(new space(_s));
-    s->id = space_id(m_counter);
-    ++m_counter;
-
-    for (size_t i = 0; i < s->subspaces.size(); ++i)
-    {
-        s->subspaces[i].id = subspace_id(m_counter);
-        ++m_counter;
-
-        for (size_t j = 0; j < s->subspaces[i].regions.size(); ++j)
-        {
-            s->subspaces[i].regions[j].id = region_id(m_counter);
-            ++m_counter;
-            s->subspaces[i].regions[j].replicas.clear();
-        }
-    }
-
-    for (size_t i = 0; i < s->indices.size(); ++i)
-    {
-        s->indices[i].id = index_id(m_counter);
-        ++m_counter;
-    }
-
-    std::pair<space_map_t::iterator, bool> x;
-    x = m_spaces.insert(std::make_pair(std::string(s->name), s));
-    assert(x.second);
-    s->name = x.first->first.c_str();
-    rsm_log(ctx, "successfully added space \"%s\" with space(%" PRIu64 ")\n", s->name, s->id.get());
-    initial_space_layout(ctx, s.get());
-    generate_next_configuration(ctx);
-    return generate_response(ctx, COORD_SUCCESS);
+coordinator :: space_add(rsm_context *ctx, const space &_s)
+{
+	if (!_s.validate())
+	{
+		rsm_log(ctx, "could not add space \"%s\" because the space does not validate\n", _s.name);
+		return generate_response(ctx, COORD_MALFORMED);
+	}
+	if (m_spaces.find(std::string(_s.name)) != m_spaces.end())
+	{
+		rsm_log(ctx, "could not add space \"%s\" because there is already a space with that name\n", _s.name);
+		return generate_response(ctx, COORD_DUPLICATE);
+	}
+	// Assign unique ids throughout the space
+	e::compat::shared_ptr<space> s(new space(_s));
+	s->id = space_id(m_counter);
+	++m_counter;
+	for (size_t i = 0; i < s->subspaces.size(); ++i)
+	{
+		s->subspaces[i].id = subspace_id(m_counter);
+		++m_counter;
+		for (size_t j = 0; j < s->subspaces[i].regions.size(); ++j)
+		{
+			s->subspaces[i].regions[j].id = region_id(m_counter);
+			++m_counter;
+			s->subspaces[i].regions[j].replicas.clear();
+		}
+	}
+	for (size_t i = 0; i < s->indices.size(); ++i)
+	{
+		s->indices[i].id = index_id(m_counter);
+		++m_counter;
+	}
+	std::pair<space_map_t::iterator, bool> x;
+	x = m_spaces.insert(std::make_pair(std::string(s->name), s));
+	assert(x.second);
+	s->name = x.first->first.c_str();
+	rsm_log(ctx, "successfully added space \"%s\" with space(%" PRIu64 ")\n", s->name, s->id.get());
+	initial_space_layout(ctx, s.get());
+	generate_next_configuration(ctx);
+	return generate_response(ctx, COORD_SUCCESS);
 }
 
 void
-coordinator :: space_rm(rsm_context* ctx, const char* name)
-{
-    space_map_t::iterator it;
-    it = m_spaces.find(std::string(name));
-
-    if (it == m_spaces.end())
-    {
-        rsm_log(ctx, "could not remove space \"%s\" because it doesn't exist\n", name);
-        return generate_response(ctx, COORD_NOT_FOUND);
-    }
-    else
-    {
-        space_id sid(it->second->id.get());
-        rsm_log(ctx, "successfully removed space \"%s\"/space(%" PRIu64 ")\n", name, sid.get());
-        std::vector<region_id> rids;
-        regions_in_space(it->second, &rids);
-        std::sort(rids.begin(), rids.end());
-        m_spaces.erase(it);
-
-        for (size_t i = 0; i < m_intents.size(); )
-        {
-            if (std::binary_search(rids.begin(), rids.end(), m_intents[i].id))
-            {
-                std::swap(m_intents[i], m_intents.back());
-                m_intents.pop_back();
-            }
-            else
-            {
-                ++i;
-            }
-        }
-
-        for (size_t i = 0; i < m_transfers.size(); )
-        {
-            if (std::binary_search(rids.begin(), rids.end(), m_transfers[i].rid))
-            {
-                std::swap(m_transfers[i], m_transfers.back());
-                m_transfers.pop_back();
-            }
-            else
-            {
-                ++i;
-            }
-        }
-
-        remove(sid, &m_deferred_init);
-        generate_next_configuration(ctx);
-        return generate_response(ctx, COORD_SUCCESS);
-    }
+coordinator :: space_rm(rsm_context *ctx, const char *name)
+{
+	space_map_t::iterator it;
+	it = m_spaces.find(std::string(name));
+	if (it == m_spaces.end())
+	{
+		rsm_log(ctx, "could not remove space \"%s\" because it doesn't exist\n", name);
+		return generate_response(ctx, COORD_NOT_FOUND);
+	}
+	else
+	{
+		space_id sid(it->second->id.get());
+		rsm_log(ctx, "successfully removed space \"%s\"/space(%" PRIu64 ")\n", name, sid.get());
+		std::vector<region_id> rids;
+		regions_in_space(it->second, &rids);
+		std::sort(rids.begin(), rids.end());
+		m_spaces.erase(it);
+		for (size_t i = 0; i < m_intents.size(); )
+		{
+			if (std::binary_search(rids.begin(), rids.end(), m_intents[i].id))
+			{
+				std::swap(m_intents[i], m_intents.back());
+				m_intents.pop_back();
+			}
+			else
+			{
+				++i;
+			}
+		}
+		for (size_t i = 0; i < m_transfers.size(); )
+		{
+			if (std::binary_search(rids.begin(), rids.end(), m_transfers[i].rid))
+			{
+				std::swap(m_transfers[i], m_transfers.back());
+				m_transfers.pop_back();
+			}
+			else
+			{
+				++i;
+			}
+		}
+		remove(sid, &m_deferred_init);
+		generate_next_configuration(ctx);
+		return generate_response(ctx, COORD_SUCCESS);
+	}
 }
 
 void
-coordinator :: space_mv(rsm_context* ctx, const char* src, const char* dst)
-{
-    space_map_t::iterator it;
-    it = m_spaces.find(std::string(src));
-
-    if (it == m_spaces.end())
-    {
-        rsm_log(ctx, "could not rename space \"%s\" because it doesn't exist\n", src);
-        return generate_response(ctx, COORD_NOT_FOUND);
-    }
-    else if (m_spaces.find(std::string(dst)) != m_spaces.end())
-    {
-        rsm_log(ctx, "could not rename space \"%s\" to \"%s\" because there is already a space \"%s\"\n", src, dst, dst);
-        return generate_response(ctx, COORD_DUPLICATE);
-    }
-    else if (!is_space_name(dst))
-    {
-        rsm_log(ctx, "could not rename space \"%s\" to \"%s\" because \"%s\" is an invalid space name\n", src, dst, dst);
-        return generate_response(ctx, COORD_NO_CAN_DO);
-    }
-    else
-    {
-        space_ptr sp(it->second);
-        space_id sid(sp->id.get());
-        rsm_log(ctx, "renaming space \"%s\" (%" PRIu64 ") to \"%s\"\n", src, sid.get(), dst);
-        m_spaces.erase(it);
-        std::pair<space_map_t::iterator, bool> x;
-        x = m_spaces.insert(std::make_pair(std::string(dst), sp));
-        assert(x.second);
-        sp->name = x.first->first.c_str();
-        generate_next_configuration(ctx);
-        return generate_response(ctx, COORD_SUCCESS);
-    }
+coordinator :: space_mv(rsm_context *ctx, const char *src, const char *dst)
+{
+	space_map_t::iterator it;
+	it = m_spaces.find(std::string(src));
+	if (it == m_spaces.end())
+	{
+		rsm_log(ctx, "could not rename space \"%s\" because it doesn't exist\n", src);
+		return generate_response(ctx, COORD_NOT_FOUND);
+	}
+	else if (m_spaces.find(std::string(dst)) != m_spaces.end())
+	{
+		rsm_log(ctx, "could not rename space \"%s\" to \"%s\" because there is already a space \"%s\"\n", src, dst, dst);
+		return generate_response(ctx, COORD_DUPLICATE);
+	}
+	else if (!is_space_name(dst))
+	{
+		rsm_log(ctx, "could not rename space \"%s\" to \"%s\" because \"%s\" is an invalid space name\n", src, dst, dst);
+		return generate_response(ctx, COORD_NO_CAN_DO);
+	}
+	else
+	{
+		space_ptr sp(it->second);
+		space_id sid(sp->id.get());
+		rsm_log(ctx, "renaming space \"%s\" (%" PRIu64 ") to \"%s\"\n", src, sid.get(), dst);
+		m_spaces.erase(it);
+		std::pair<space_map_t::iterator, bool> x;
+		x = m_spaces.insert(std::make_pair(std::string(dst), sp));
+		assert(x.second);
+		sp->name = x.first->first.c_str();
+		generate_next_configuration(ctx);
+		return generate_response(ctx, COORD_SUCCESS);
+	}
 }
 
 void
-coordinator :: index_add(rsm_context* ctx,
-                         const char* space, const char* what)
-{
-    space_map_t::iterator it;
-    it = m_spaces.find(std::string(space));
-
-    if (it == m_spaces.end())
-    {
-        rsm_log(ctx, "could not create index on \"%s\" on space \"%s\" because the space doesn't exist\n", what, space);
-        return generate_response(ctx, COORD_NOT_FOUND);
-    }
-
-    hyperdex::space* sp = it->second.get();
-
-    // split the attr into "attr" and "dotpath" components
-    const size_t what_sz = strlen(what);
-    std::string attr;
-    std::string dotpath;
-    index::index_t type;
-    const char* ptr = strchr(what, '.');
-
-    if (ptr)
-    {
-        type = index::DOCUMENT;
-        attr.assign(what, ptr - what);
-        dotpath.assign(ptr + 1, what_sz - (ptr - what) - 1);
-    }
-    else
-    {
-        type = index::NORMAL;
-        attr.assign(what, what_sz);
-        dotpath.assign("", 0);
-    }
-
-    uint16_t attr_num = sp->sc.lookup_attr(attr.c_str());
-
-    if (attr_num >= sp->sc.attrs_sz)
-    {
-        rsm_log(ctx, "could not create index on \"%s\" on space \"%s\" because the attribute doesn't exist\n", what, space);
-        return generate_response(ctx, COORD_NOT_FOUND);
-    }
-
-    if (type == index::NORMAL &&
-        sp->sc.attrs[attr_num].type == HYPERDATATYPE_DOCUMENT)
-    {
-        rsm_log(ctx, "could not create index on \"%s\" on space \"%s\" because "
-                     "it is a document and no dotted path was provided\n", what, space);
-        return generate_response(ctx, COORD_NO_CAN_DO);
-    }
-
-    if (type == index::DOCUMENT &&
-        sp->sc.attrs[attr_num].type != HYPERDATATYPE_DOCUMENT)
-    {
-        rsm_log(ctx, "could not create index on \"%s\" on space \"%s\" because "
-                     "it is a not document and a dotted path was provided\n", what, space);
-        return generate_response(ctx, COORD_NO_CAN_DO);
-    }
-
-    for (size_t i = 0; i < sp->indices.size(); ++i)
-    {
-        if (sp->indices[i].type == type &&
-            sp->indices[i].attr == attr_num &&
-            sp->indices[i].extra == e::slice(dotpath))
-        {
-            rsm_log(ctx, "did not create index on \"%s\" on space \"%s\" because it is already indexed\n", what, space);
-            return generate_response(ctx, COORD_DUPLICATE);
-        }
-    }
-
-    rsm_log(ctx, "creating index on \"%s\" on space \"%s\"\n", what, space);
-    index_id id(m_counter);
-    ++m_counter;
-    sp->indices.push_back(index(type, id, attr_num, e::slice(dotpath)));
-    sp->reestablish_backing();
-    generate_next_configuration(ctx);
-    return generate_response(ctx, COORD_SUCCESS);
+coordinator :: index_add(rsm_context *ctx,
+                         const char *space, const char *what)
+{
+	space_map_t::iterator it;
+	it = m_spaces.find(std::string(space));
+	if (it == m_spaces.end())
+	{
+		rsm_log(ctx, "could not create index on \"%s\" on space \"%s\" because the space doesn't exist\n", what, space);
+		return generate_response(ctx, COORD_NOT_FOUND);
+	}
+	hyperdex::space *sp = it->second.get();
+	// split the attr into "attr" and "dotpath" components
+	const size_t what_sz = strlen(what);
+	std::string attr;
+	std::string dotpath;
+	index::index_t type;
+	const char *ptr = strchr(what, '.');
+	if (ptr)
+	{
+		type = index::DOCUMENT;
+		attr.assign(what, ptr - what);
+		dotpath.assign(ptr + 1, what_sz - (ptr - what) - 1);
+	}
+	else
+	{
+		type = index::NORMAL;
+		attr.assign(what, what_sz);
+		dotpath.assign("", 0);
+	}
+	uint16_t attr_num = sp->sc.lookup_attr(attr.c_str());
+	if (attr_num >= sp->sc.attrs_sz)
+	{
+		rsm_log(ctx, "could not create index on \"%s\" on space \"%s\" because the attribute doesn't exist\n", what, space);
+		return generate_response(ctx, COORD_NOT_FOUND);
+	}
+	if (type == index::NORMAL &&
+	    sp->sc.attrs[attr_num].type == HYPERDATATYPE_DOCUMENT)
+	{
+		rsm_log(ctx, "could not create index on \"%s\" on space \"%s\" because "
+		        "it is a document and no dotted path was provided\n", what, space);
+		return generate_response(ctx, COORD_NO_CAN_DO);
+	}
+	if (type == index::DOCUMENT &&
+	    sp->sc.attrs[attr_num].type != HYPERDATATYPE_DOCUMENT)
+	{
+		rsm_log(ctx, "could not create index on \"%s\" on space \"%s\" because "
+		        "it is a not document and a dotted path was provided\n", what, space);
+		return generate_response(ctx, COORD_NO_CAN_DO);
+	}
+	for (size_t i = 0; i < sp->indices.size(); ++i)
+	{
+		if (sp->indices[i].type == type &&
+		    sp->indices[i].attr == attr_num &&
+		    sp->indices[i].extra == e::slice(dotpath))
+		{
+			rsm_log(ctx, "did not create index on \"%s\" on space \"%s\" because it is already indexed\n", what, space);
+			return generate_response(ctx, COORD_DUPLICATE);
+		}
+	}
+	rsm_log(ctx, "creating index on \"%s\" on space \"%s\"\n", what, space);
+	index_id id(m_counter);
+	++m_counter;
+	sp->indices.push_back(index(type, id, attr_num, e::slice(dotpath)));
+	sp->reestablish_backing();
+	generate_next_configuration(ctx);
+	return generate_response(ctx, COORD_SUCCESS);
 }
 
 void
-coordinator :: index_rm(rsm_context* ctx, index_id ii)
-{
-    e::compat::shared_ptr<space> s;
-    index* idx;
-
-    for (space_map_t::iterator it = m_spaces.begin();
-            it != m_spaces.end(); ++it)
-    {
-        if (find_id(ii, it->second->indices, &idx))
-        {
-            s = it->second;
-            break;
-        }
-    }
-
-    if (!s.get() || !idx)
-    {
-        rsm_log(ctx, "could not remove index %lu because it doesn't exist\n", ii.get());
-        return generate_response(ctx, COORD_NOT_FOUND);
-    }
-
-    for (std::vector<subspace>::iterator it = s->subspaces.begin();
-            it != s->subspaces.end(); ++it)
-    {
-        for (size_t a = 0; a < it->attrs.size(); ++a)
-        {
-            if (it->attrs[a] == idx->attr)
-            {
-                rsm_log(ctx, "could not remove index %lu because it's in use by subspace \"%lu\"\n",
-                             ii.get(), it->id.get());
-                return generate_response(ctx, COORD_NO_CAN_DO);
-            }
-        }
-    }
-
-    remove_id(ii, &s->indices);
-    rsm_log(ctx, "removed index %lu from space \"%s\"\n", ii.get(), s->name);
-    generate_next_configuration(ctx);
-    return generate_response(ctx, COORD_SUCCESS);
+coordinator :: index_rm(rsm_context *ctx, index_id ii)
+{
+	e::compat::shared_ptr<space> s;
+	index *idx;
+	for (space_map_t::iterator it = m_spaces.begin();
+	     it != m_spaces.end(); ++it)
+	{
+		if (find_id(ii, it->second->indices, &idx))
+		{
+			s = it->second;
+			break;
+		}
+	}
+	if (!s.get() || !idx)
+	{
+		rsm_log(ctx, "could not remove index %lu because it doesn't exist\n", ii.get());
+		return generate_response(ctx, COORD_NOT_FOUND);
+	}
+	for (std::vector<subspace>::iterator it = s->subspaces.begin();
+	     it != s->subspaces.end(); ++it)
+	{
+		for (size_t a = 0; a < it->attrs.size(); ++a)
+		{
+			if (it->attrs[a] == idx->attr)
+			{
+				rsm_log(ctx, "could not remove index %lu because it's in use by subspace \"%lu\"\n",
+				        ii.get(), it->id.get());
+				return generate_response(ctx, COORD_NO_CAN_DO);
+			}
+		}
+	}
+	remove_id(ii, &s->indices);
+	rsm_log(ctx, "removed index %lu from space \"%s\"\n", ii.get(), s->name);
+	generate_next_configuration(ctx);
+	return generate_response(ctx, COORD_SUCCESS);
 }
 
 void
-coordinator :: transfer_go_live(rsm_context* ctx,
-                                const transfer_id& xid)
-{
-    transfer* xfer = get_transfer(xid);
-
-    if (!xfer)
-    {
-        return;
-    }
-
-    region* reg = get_region(xfer->rid);
-
-    if (!reg)
-    {
-        rsm_log(ctx, "cannot make transfer(%" PRIu64 ") live because it doesn't exist\n", xid.get());
-        INVARIANT_BROKEN("transfer refers to nonexistent region");
-        return generate_response(ctx, COORD_SUCCESS);
-    }
-
-    // If the transfer is already live
-    if (reg->replicas.size() > 1 &&
-        reg->replicas[reg->replicas.size() - 2].si == xfer->src &&
-        reg->replicas[reg->replicas.size() - 1].si == xfer->dst)
-    {
-        return generate_response(ctx, COORD_SUCCESS);
-    }
-
-    if (reg->replicas.empty() || reg->replicas.back().si != xfer->src)
-    {
-        INVARIANT_BROKEN("transfer in a bad state");
-        return generate_response(ctx, COORD_SUCCESS);
-    }
-
-    reg->replicas.push_back(replica(xfer->dst, xfer->vdst));
-    rsm_log(ctx, "transfer(%" PRIu64 ") is live\n", xid.get());
-    generate_next_configuration(ctx);
-    return generate_response(ctx, COORD_SUCCESS);
+coordinator :: transfer_go_live(rsm_context *ctx,
+                                const transfer_id &xid)
+{
+	transfer *xfer = get_transfer(xid);
+	if (!xfer)
+	{
+		return;
+	}
+	region *reg = get_region(xfer->rid);
+	if (!reg)
+	{
+		rsm_log(ctx, "cannot make transfer(%" PRIu64 ") live because it doesn't exist\n", xid.get());
+		INVARIANT_BROKEN("transfer refers to nonexistent region");
+		return generate_response(ctx, COORD_SUCCESS);
+	}
+	// If the transfer is already live
+	if (reg->replicas.size() > 1 &&
+	    reg->replicas[reg->replicas.size() - 2].si == xfer->src &&
+	    reg->replicas[reg->replicas.size() - 1].si == xfer->dst)
+	{
+		return generate_response(ctx, COORD_SUCCESS);
+	}
+	if (reg->replicas.empty() || reg->replicas.back().si != xfer->src)
+	{
+		INVARIANT_BROKEN("transfer in a bad state");
+		return generate_response(ctx, COORD_SUCCESS);
+	}
+	reg->replicas.push_back(replica(xfer->dst, xfer->vdst));
+	rsm_log(ctx, "transfer(%" PRIu64 ") is live\n", xid.get());
+	generate_next_configuration(ctx);
+	return generate_response(ctx, COORD_SUCCESS);
 }
 
 void
-coordinator :: transfer_complete(rsm_context* ctx,
-                                 const transfer_id& xid)
-{
-    transfer* xfer = get_transfer(xid);
-
-    if (!xfer)
-    {
-        return;
-    }
-
-    region* reg = get_region(xfer->rid);
-
-    if (!reg)
-    {
-        rsm_log(ctx, "cannot complete transfer(%" PRIu64 ") because it doesn't exist\n", xid.get());
-        INVARIANT_BROKEN("transfer refers to nonexistent region");
-        return generate_response(ctx, COORD_SUCCESS);
-    }
-
-    if (!(reg->replicas.size() > 1 &&
-          reg->replicas[reg->replicas.size() - 2].si == xfer->src &&
-          reg->replicas[reg->replicas.size() - 1].si == xfer->dst))
-    {
-        rsm_log(ctx, "cannot complete transfer(%" PRIu64 ") because it is not live\n", xid.get());
-        return generate_response(ctx, COORD_SUCCESS);
-    }
-
-    del_transfer(xfer->id);
-    rsm_log(ctx, "transfer(%" PRIu64 ") is complete\n", xid.get());
-    converge_intent(ctx, reg);
-    generate_next_configuration(ctx);
-    return generate_response(ctx, COORD_SUCCESS);
+coordinator :: transfer_complete(rsm_context *ctx,
+                                 const transfer_id &xid)
+{
+	transfer *xfer = get_transfer(xid);
+	if (!xfer)
+	{
+		return;
+	}
+	region *reg = get_region(xfer->rid);
+	if (!reg)
+	{
+		rsm_log(ctx, "cannot complete transfer(%" PRIu64 ") because it doesn't exist\n", xid.get());
+		INVARIANT_BROKEN("transfer refers to nonexistent region");
+		return generate_response(ctx, COORD_SUCCESS);
+	}
+	if (!(reg->replicas.size() > 1 &&
+	      reg->replicas[reg->replicas.size() - 2].si == xfer->src &&
+	      reg->replicas[reg->replicas.size() - 1].si == xfer->dst))
+	{
+		rsm_log(ctx, "cannot complete transfer(%" PRIu64 ") because it is not live\n", xid.get());
+		return generate_response(ctx, COORD_SUCCESS);
+	}
+	del_transfer(xfer->id);
+	rsm_log(ctx, "transfer(%" PRIu64 ") is complete\n", xid.get());
+	converge_intent(ctx, reg);
+	generate_next_configuration(ctx);
+	return generate_response(ctx, COORD_SUCCESS);
 }
 
 void
-coordinator :: config_get(rsm_context* ctx)
+coordinator :: config_get(rsm_context *ctx)
 {
-    assert(m_cluster != 0 && m_version != 0);
-    assert(m_latest_config.get());
-    const char* output = reinterpret_cast<const char*>(m_latest_config->data());
-    size_t output_sz = m_latest_config->size();
-    rsm_set_output(ctx, output, output_sz);
+	assert(m_cluster != 0 && m_version != 0);
+	assert(m_latest_config.get());
+	const char *output = reinterpret_cast<const char *>(m_latest_config->data());
+	size_t output_sz = m_latest_config->size();
+	rsm_set_output(ctx, output, output_sz);
 }
 
 void
-coordinator :: config_ack(rsm_context* ctx,
-                          const server_id& sid, uint64_t version)
+coordinator :: config_ack(rsm_context *ctx,
+                          const server_id &sid, uint64_t version)
 {
-    m_config_ack_barrier.pass(version, sid);
-    check_ack_condition(ctx);
+	m_config_ack_barrier.pass(version, sid);
+	check_ack_condition(ctx);
 }
 
 void
-coordinator :: config_stable(rsm_context* ctx,
-                             const server_id& sid, uint64_t version)
+coordinator :: config_stable(rsm_context *ctx,
+                             const server_id &sid, uint64_t version)
 {
-    m_config_stable_barrier.pass(version, sid);
-    check_stable_condition(ctx);
+	m_config_stable_barrier.pass(version, sid);
+	check_stable_condition(ctx);
 }
 
 void
-coordinator :: checkpoint(rsm_context* ctx)
+coordinator :: checkpoint(rsm_context *ctx)
 {
-    ++m_checkpoint;
-    broadcast_checkpoint_information(ctx);
-    rsm_log(ctx, "establishing checkpoint %" PRIu64 "\n", m_checkpoint);
-    assert(m_checkpoint_stable_through <= m_checkpoint);
-    std::vector<server_id> sids;
-    servers_in_configuration(&sids);
-    m_checkpoint_stable_barrier.new_version(m_checkpoint, sids);
-    check_checkpoint_stable_condition(ctx, true);
+	++m_checkpoint;
+	broadcast_checkpoint_information(ctx);
+	rsm_log(ctx, "establishing checkpoint %" PRIu64 "\n", m_checkpoint);
+	assert(m_checkpoint_stable_through <= m_checkpoint);
+	std::vector<server_id> sids;
+	servers_in_configuration(&sids);
+	m_checkpoint_stable_barrier.new_version(m_checkpoint, sids);
+	check_checkpoint_stable_condition(ctx, true);
 }
 
 void
-coordinator :: checkpoint_stable(rsm_context* ctx,
-                                 const server_id& sid,
+coordinator :: checkpoint_stable(rsm_context *ctx,
+                                 const server_id &sid,
                                  uint64_t config,
                                  uint64_t number)
 {
-    if (config < m_version)
-    {
-        return generate_response(ctx, COORD_NO_CAN_DO);
-    }
-
-    m_checkpoint_stable_barrier.pass(number, sid);
-    check_checkpoint_stable_condition(ctx, false);
-    generate_response(ctx, COORD_SUCCESS);
+	if (config < m_version)
+	{
+		return generate_response(ctx, COORD_NO_CAN_DO);
+	}
+	m_checkpoint_stable_barrier.pass(number, sid);
+	check_checkpoint_stable_condition(ctx, false);
+	generate_response(ctx, COORD_SUCCESS);
 }
 
 void
-coordinator :: checkpoints(rsm_context* ctx)
+coordinator :: checkpoints(rsm_context *ctx)
 {
-    const size_t sz = sizeof(uint16_t) + 3 * sizeof(uint64_t);
-    m_response.reset(e::buffer::create(sz));
-    uint8_t* ptr = m_response->data();
-    ptr = e::pack16be(COORD_SUCCESS, ptr);
-    ptr = e::pack64be(m_checkpoint, ptr);
-    ptr = e::pack64be(m_checkpoint_stable_through, ptr);
-    ptr = e::pack64be(m_checkpoint_gc_through, ptr);
-    rsm_set_output(ctx, reinterpret_cast<const char*>(m_response->data()), sz);
+	const size_t sz = sizeof(uint16_t) + 3 * sizeof(uint64_t);
+	m_response.reset(e::buffer::create(sz));
+	uint8_t *ptr = m_response->data();
+	ptr = e::pack16be(COORD_SUCCESS, ptr);
+	ptr = e::pack64be(m_checkpoint, ptr);
+	ptr = e::pack64be(m_checkpoint_stable_through, ptr);
+	ptr = e::pack64be(m_checkpoint_gc_through, ptr);
+	rsm_set_output(ctx, reinterpret_cast<const char *>(m_response->data()), sz);
 }
 
 void
-coordinator :: periodic(rsm_context* ctx)
+coordinator :: periodic(rsm_context *ctx)
 {
-    checkpoint(ctx);
+	checkpoint(ctx);
 }
 
 void
-coordinator :: debug_dump(rsm_context* ctx)
-{
-    rsm_log(ctx, "=== begin debug dump ===========================================================\n");
-    rsm_log(ctx, "permutation:\n");
-
-    for (size_t i = 0; i < m_permutation.size(); ++i)
-    {
-        rsm_log(ctx, " - %" PRIu64 "\n", m_permutation[i].get());
-    }
-
-    rsm_log(ctx, "spares (desire %" PRIu64 "):\n", m_desired_spares);
-
-    for (size_t i = 0; i < m_spares.size(); ++i)
-    {
-        rsm_log(ctx, " - %" PRIu64 "\n", m_spares[i].get());
-    }
-
-    rsm_log(ctx, "intents:\n");
-
-    for (size_t i = 0; i < m_intents.size(); ++i)
-    {
-        rsm_log(ctx, " - region=%" PRIu64 ", checkpoint=%" PRIu64 " replicas=[", m_intents[i].id.get(), m_intents[i].checkpoint);
-
-        for (size_t j = 0; j < m_intents[i].replicas.size(); ++j)
-        {
-            if (j == 0)
-            {
-                rsm_log(ctx, "%" PRIu64 "", m_intents[i].replicas[j].get());
-            }
-            else
-            {
-                rsm_log(ctx, ", %" PRIu64 "", m_intents[i].replicas[j].get());
-            }
-        }
-
-        rsm_log(ctx, "]\n");
-    }
-
-    rsm_log(ctx, "transfers:\n");
-
-    for (size_t i = 0; i < m_transfers.size(); ++i)
-    {
-        rsm_log(ctx, " - id=%" PRIu64 " rid=%" PRIu64 " src=%" PRIu64 " vsrc=%" PRIu64 " dst=%" PRIu64 " vdst=%" PRIu64 "\n",
-                m_transfers[i].id.get(), m_transfers[i].rid.get(),
-                m_transfers[i].src.get(), m_transfers[i].vsrc.get(),
-                m_transfers[i].dst.get(), m_transfers[i].vdst.get());
-    }
-
-    rsm_log(ctx, "offline servers:\n");
-
-    for (size_t i = 0; i < m_offline.size(); ++i)
-    {
-        rsm_log(ctx, " - rid=%" PRIu64 " sid=%" PRIu64 "\n",
-                     m_offline[i].id.get(), m_offline[i].sid.get());
-    }
-
-    rsm_log(ctx, "config ack through: %" PRIu64 "\n", m_config_ack_through);
-    rsm_log(ctx, "config stable through: %" PRIu64 "\n", m_config_stable_through);
-    rsm_log(ctx, "checkpoint: latest=%" PRIu64 ", stable=%" PRIu64 ", gc=%" PRIu64 "\n",
-            m_checkpoint, m_checkpoint_stable_through, m_checkpoint_gc_through);
-    rsm_log(ctx, "=== end debug dump =============================================================\n");
-}
-
-coordinator*
-coordinator :: recreate(rsm_context* ctx,
-                        const char* data, size_t data_sz)
-{
-    std::auto_ptr<coordinator> c(new coordinator());
-
-    if (!c.get())
-    {
-        rsm_log(ctx, "memory allocation failed\n");
-        return NULL;
-    }
-
-    e::unpacker up(data, data_sz);
-    up = up >> c->m_cluster >> c->m_counter >> c->m_version >> c->m_flags >> c->m_servers
-            >> c->m_permutation >> c->m_spares >> c->m_desired_spares >> c->m_intents
-            >> c->m_deferred_init >> c->m_offline >> c->m_transfers
-            >> c->m_config_ack_through >> c->m_config_ack_barrier
-            >> c->m_config_stable_through >> c->m_config_stable_barrier
-            >> c->m_checkpoint >> c->m_checkpoint_stable_through
-            >> c->m_checkpoint_gc_through >> c->m_checkpoint_stable_barrier;
-
-    while (!up.error() && up.remain())
-    {
-        e::slice name;
-        space_ptr ptr(new space());
-        up = up >> name >> *ptr;
-        c->m_spaces[std::string(reinterpret_cast<const char*>(name.data()), name.size())] = ptr;
-    }
-
-    if (up.error())
-    {
-        rsm_log(ctx, "unpacking failed\n");
-        return NULL;
-    }
-
-    std::vector<std::pair<server_id, virtual_server_id> > region_tails;
-
-    for (space_map_t::iterator it = c->m_spaces.begin();
-            it != c->m_spaces.end(); ++it)
-    {
-        space* s(it->second.get());
-
-        for (size_t ss_idx = 0; ss_idx < s->subspaces.size(); ++ss_idx)
-        {
-            subspace* ss(&s->subspaces[ss_idx]);
-
-            for (size_t reg_idx = 0; reg_idx < ss->regions.size(); ++reg_idx)
-            {
-                region* reg = &ss->regions[reg_idx];
-
-                if (!reg->replicas.empty())
-                {
-                    region_tails.push_back(std::make_pair(reg->replicas.back().si,
-                                                          reg->replicas.back().vsi));
-                }
-            }
-        }
-    }
-
-    std::sort(region_tails.begin(), region_tails.end());
-
-    for (size_t i = 0; i < c->m_transfers.size(); )
-    {
-        const transfer* t = &c->m_transfers[i];
-        std::pair<server_id, virtual_server_id> src(std::make_pair(t->src, t->vsrc));
-        std::pair<server_id, virtual_server_id> dst(std::make_pair(t->dst, t->vdst));
-
-        if (!std::binary_search(region_tails.begin(), region_tails.end(), src) &&
-            !std::binary_search(region_tails.begin(), region_tails.end(), dst))
-        {
-            for (size_t j = i + 1; j < c->m_transfers.size(); ++j)
-            {
-                c->m_transfers[j - 1] = c->m_transfers[j];
-            }
-
-            c->m_transfers.pop_back();
-        }
-        else
-        {
-            ++i;
-        }
-    }
-
-    c->generate_cached_configuration(ctx);
-    return c.release();
+coordinator :: debug_dump(rsm_context *ctx)
+{
+	rsm_log(ctx, "=== begin debug dump ===========================================================\n");
+	rsm_log(ctx, "permutation:\n");
+	for (size_t i = 0; i < m_permutation.size(); ++i)
+	{
+		rsm_log(ctx, " - %" PRIu64 "\n", m_permutation[i].get());
+	}
+	rsm_log(ctx, "spares (desire %" PRIu64 "):\n", m_desired_spares);
+	for (size_t i = 0; i < m_spares.size(); ++i)
+	{
+		rsm_log(ctx, " - %" PRIu64 "\n", m_spares[i].get());
+	}
+	rsm_log(ctx, "intents:\n");
+	for (size_t i = 0; i < m_intents.size(); ++i)
+	{
+		rsm_log(ctx, " - region=%" PRIu64 ", checkpoint=%" PRIu64 " replicas=[", m_intents[i].id.get(), m_intents[i].checkpoint);
+		for (size_t j = 0; j < m_intents[i].replicas.size(); ++j)
+		{
+			if (j == 0)
+			{
+				rsm_log(ctx, "%" PRIu64 "", m_intents[i].replicas[j].get());
+			}
+			else
+			{
+				rsm_log(ctx, ", %" PRIu64 "", m_intents[i].replicas[j].get());
+			}
+		}
+		rsm_log(ctx, "]\n");
+	}
+	rsm_log(ctx, "transfers:\n");
+	for (size_t i = 0; i < m_transfers.size(); ++i)
+	{
+		rsm_log(ctx, " - id=%" PRIu64 " rid=%" PRIu64 " src=%" PRIu64 " vsrc=%" PRIu64 " dst=%" PRIu64 " vdst=%" PRIu64 "\n",
+		        m_transfers[i].id.get(), m_transfers[i].rid.get(),
+		        m_transfers[i].src.get(), m_transfers[i].vsrc.get(),
+		        m_transfers[i].dst.get(), m_transfers[i].vdst.get());
+	}
+	rsm_log(ctx, "offline servers:\n");
+	for (size_t i = 0; i < m_offline.size(); ++i)
+	{
+		rsm_log(ctx, " - rid=%" PRIu64 " sid=%" PRIu64 "\n",
+		        m_offline[i].id.get(), m_offline[i].sid.get());
+	}
+	rsm_log(ctx, "config ack through: %" PRIu64 "\n", m_config_ack_through);
+	rsm_log(ctx, "config stable through: %" PRIu64 "\n", m_config_stable_through);
+	rsm_log(ctx, "checkpoint: latest=%" PRIu64 ", stable=%" PRIu64 ", gc=%" PRIu64 "\n",
+	        m_checkpoint, m_checkpoint_stable_through, m_checkpoint_gc_through);
+	rsm_log(ctx, "=== end debug dump =============================================================\n");
+}
+
+coordinator *
+coordinator :: recreate(rsm_context *ctx,
+                        const char *data, size_t data_sz)
+{
+	std::auto_ptr<coordinator> c(new coordinator());
+	if (!c.get())
+	{
+		rsm_log(ctx, "memory allocation failed\n");
+		return NULL;
+	}
+	e::unpacker up(data, data_sz);
+	up = up >> c->m_cluster >> c->m_counter >> c->m_version >> c->m_flags >> c->m_servers
+	     >> c->m_permutation >> c->m_spares >> c->m_desired_spares >> c->m_intents
+	     >> c->m_deferred_init >> c->m_offline >> c->m_transfers
+	     >> c->m_config_ack_through >> c->m_config_ack_barrier
+	     >> c->m_config_stable_through >> c->m_config_stable_barrier
+	     >> c->m_checkpoint >> c->m_checkpoint_stable_through
+	     >> c->m_checkpoint_gc_through >> c->m_checkpoint_stable_barrier;
+	while (!up.error() && up.remain())
+	{
+		e::slice name;
+		space_ptr ptr(new space());
+		up = up >> name >> *ptr;
+		c->m_spaces[std::string(reinterpret_cast<const char *>(name.data()), name.size())] = ptr;
+	}
+	if (up.error())
+	{
+		rsm_log(ctx, "unpacking failed\n");
+		return NULL;
+	}
+	std::vector<std::pair<server_id, virtual_server_id> > region_tails;
+	for (space_map_t::iterator it = c->m_spaces.begin();
+	     it != c->m_spaces.end(); ++it)
+	{
+		space *s(it->second.get());
+		for (size_t ss_idx = 0; ss_idx < s->subspaces.size(); ++ss_idx)
+		{
+			subspace *ss(&s->subspaces[ss_idx]);
+			for (size_t reg_idx = 0; reg_idx < ss->regions.size(); ++reg_idx)
+			{
+				region *reg = &ss->regions[reg_idx];
+				if (!reg->replicas.empty())
+				{
+					region_tails.push_back(std::make_pair(reg->replicas.back().si,
+					                                      reg->replicas.back().vsi));
+				}
+			}
+		}
+	}
+	std::sort(region_tails.begin(), region_tails.end());
+	for (size_t i = 0; i < c->m_transfers.size(); )
+	{
+		const transfer *t = &c->m_transfers[i];
+		std::pair<server_id, virtual_server_id> src(std::make_pair(t->src, t->vsrc));
+		std::pair<server_id, virtual_server_id> dst(std::make_pair(t->dst, t->vdst));
+		if (!std::binary_search(region_tails.begin(), region_tails.end(), src) &&
+		    !std::binary_search(region_tails.begin(), region_tails.end(), dst))
+		{
+			for (size_t j = i + 1; j < c->m_transfers.size(); ++j)
+			{
+				c->m_transfers[j - 1] = c->m_transfers[j];
+			}
+			c->m_transfers.pop_back();
+		}
+		else
+		{
+			++i;
+		}
+	}
+	c->generate_cached_configuration(ctx);
+	return c.release();
 }
 
 int
-coordinator :: snapshot(rsm_context* /*ctx*/,
-                        char** data, size_t* data_sz)
-{
-    size_t sz = sizeof(m_cluster)
-              + sizeof(m_counter)
-              + sizeof(m_version)
-              + sizeof(m_flags)
-              + pack_size(m_servers)
-              + pack_size(m_permutation)
-              + pack_size(m_spares)
-              + sizeof(m_desired_spares)
-              + pack_size(m_intents)
-              + pack_size(m_deferred_init)
-              + pack_size(m_offline)
-              + pack_size(m_transfers)
-              + sizeof(m_config_ack_through)
-              + pack_size(m_config_ack_barrier)
-              + sizeof(m_config_stable_through)
-              + pack_size(m_config_stable_barrier)
-              + sizeof(m_checkpoint)
-              + sizeof(m_checkpoint_stable_through)
-              + sizeof(m_checkpoint_gc_through)
-              + pack_size(m_checkpoint_stable_barrier);
-
-    for (space_map_t::iterator it = m_spaces.begin();
-            it != m_spaces.end(); ++it)
-    {
-        e::slice name(it->first);
-        sz += pack_size(name) + pack_size(*it->second);
-    }
-
-    std::auto_ptr<e::buffer> buf(e::buffer::create(sz));
-    e::packer pa = buf->pack_at(0);
-    pa = pa << m_cluster << m_counter << m_version << m_flags << m_servers
-            << m_permutation << m_spares << m_desired_spares << m_intents
-            << m_deferred_init << m_offline << m_transfers
-            << m_config_ack_through << m_config_ack_barrier
-            << m_config_stable_through << m_config_stable_barrier
-            << m_checkpoint << m_checkpoint_stable_through
-            << m_checkpoint_gc_through << m_checkpoint_stable_barrier;
-
-    for (space_map_t::iterator it = m_spaces.begin();
-            it != m_spaces.end(); ++it)
-    {
-        e::slice name(it->first);
-        pa = pa << name << (*it->second);
-    }
-
-    char* ptr = static_cast<char*>(malloc(buf->size()));
-    *data = ptr;
-    *data_sz = buf->size();
-
-    if (*data)
-    {
-        memmove(ptr, buf->data(), buf->size());
-    }
-
-    return 0;
-}
-
-server*
-coordinator :: new_server(const server_id& sid)
-{
-    size_t idx = m_servers.size();
-    m_servers.push_back(server(sid));
-
-    for (; idx > 0; --idx)
-    {
-        if (m_servers[idx - 1].id < m_servers[idx].id)
-        {
-            break;
-        }
-
-        std::swap(m_servers[idx - 1], m_servers[idx]);
-    }
-
-    return &m_servers[idx];
-}
-
-server*
-coordinator :: get_server(const server_id& sid)
-{
-    for (size_t i = 0; i < m_servers.size(); ++i)
-    {
-        if (m_servers[i].id == sid)
-        {
-            return &m_servers[i];
-        }
-    }
-
-    return NULL;
+coordinator :: snapshot(rsm_context * /*ctx*/,
+                        char **data, size_t *data_sz)
+{
+	size_t sz = sizeof(m_cluster)
+	            + sizeof(m_counter)
+	            + sizeof(m_version)
+	            + sizeof(m_flags)
+	            + pack_size(m_servers)
+	            + pack_size(m_permutation)
+	            + pack_size(m_spares)
+	            + sizeof(m_desired_spares)
+	            + pack_size(m_intents)
+	            + pack_size(m_deferred_init)
+	            + pack_size(m_offline)
+	            + pack_size(m_transfers)
+	            + sizeof(m_config_ack_through)
+	            + pack_size(m_config_ack_barrier)
+	            + sizeof(m_config_stable_through)
+	            + pack_size(m_config_stable_barrier)
+	            + sizeof(m_checkpoint)
+	            + sizeof(m_checkpoint_stable_through)
+	            + sizeof(m_checkpoint_gc_through)
+	            + pack_size(m_checkpoint_stable_barrier);
+	for (space_map_t::iterator it = m_spaces.begin();
+	     it != m_spaces.end(); ++it)
+	{
+		e::slice name(it->first);
+		sz += pack_size(name) + pack_size(*it->second);
+	}
+	std::auto_ptr<e::buffer> buf(e::buffer::create(sz));
+	e::packer pa = buf->pack_at(0);
+	pa = pa << m_cluster << m_counter << m_version << m_flags << m_servers
+	     << m_permutation << m_spares << m_desired_spares << m_intents
+	     << m_deferred_init << m_offline << m_transfers
+	     << m_config_ack_through << m_config_ack_barrier
+	     << m_config_stable_through << m_config_stable_barrier
+	     << m_checkpoint << m_checkpoint_stable_through
+	     << m_checkpoint_gc_through << m_checkpoint_stable_barrier;
+	for (space_map_t::iterator it = m_spaces.begin();
+	     it != m_spaces.end(); ++it)
+	{
+		e::slice name(it->first);
+		pa = pa << name << (*it->second);
+	}
+	char *ptr = static_cast<char *>(malloc(buf->size()));
+	*data = ptr;
+	*data_sz = buf->size();
+	if (*data)
+	{
+		memmove(ptr, buf->data(), buf->size());
+	}
+	return 0;
+}
+
+server *
+coordinator :: new_server(const server_id &sid)
+{
+	size_t idx = m_servers.size();
+	m_servers.push_back(server(sid));
+	for (; idx > 0; --idx)
+	{
+		if (m_servers[idx - 1].id < m_servers[idx].id)
+		{
+			break;
+		}
+		std::swap(m_servers[idx - 1], m_servers[idx]);
+	}
+	return &m_servers[idx];
+}
+
+server *
+coordinator :: get_server(const server_id &sid)
+{
+	for (size_t i = 0; i < m_servers.size(); ++i)
+	{
+		if (m_servers[i].id == sid)
+		{
+			return &m_servers[i];
+		}
+	}
+	return NULL;
 }
 
 bool
-coordinator :: in_permutation(const server_id& sid)
-{
-    for (size_t i = 0; i < m_permutation.size(); ++i)
-    {
-        if (m_permutation[i] == sid)
-        {
-            return true;
-        }
-    }
-
-    for (size_t i = 0; i < m_spares.size(); ++i)
-    {
-        if (m_spares[i] == sid)
-        {
-            return true;
-        }
-    }
-
-    return false;
+coordinator :: in_permutation(const server_id &sid)
+{
+	for (size_t i = 0; i < m_permutation.size(); ++i)
+	{
+		if (m_permutation[i] == sid)
+		{
+			return true;
+		}
+	}
+	for (size_t i = 0; i < m_spares.size(); ++i)
+	{
+		if (m_spares[i] == sid)
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 void
-coordinator :: add_permutation(const server_id& sid)
+coordinator :: add_permutation(const server_id &sid)
 {
-    if (m_spares.size() < m_desired_spares)
-    {
-        m_spares.push_back(sid);
-    }
-    else
-    {
-        m_permutation.push_back(sid);
-    }
+	if (m_spares.size() < m_desired_spares)
+	{
+		m_spares.push_back(sid);
+	}
+	else
+	{
+		m_permutation.push_back(sid);
+	}
 }
 
 void
-coordinator :: remove_permutation(const server_id& sid)
-{
-    remove(sid, &m_spares);
-
-    for (size_t i = 0; i < m_permutation.size(); ++i)
-    {
-        if (m_permutation[i] != sid)
-        {
-            continue;
-        }
-
-        if (m_spares.empty())
-        {
-            shift_and_pop(i, &m_permutation);
-        }
-        else
-        {
-            m_permutation[i] = m_spares.back();
-            m_spares.pop_back();
-        }
-
-        break;
-    }
+coordinator :: remove_permutation(const server_id &sid)
+{
+	remove(sid, &m_spares);
+	for (size_t i = 0; i < m_permutation.size(); ++i)
+	{
+		if (m_permutation[i] != sid)
+		{
+			continue;
+		}
+		if (m_spares.empty())
+		{
+			shift_and_pop(i, &m_permutation);
+		}
+		else
+		{
+			m_permutation[i] = m_spares.back();
+			m_spares.pop_back();
+		}
+		break;
+	}
 }
 
 namespace
 {
 
 bool
-compare_space_ptr_by_r_p(const e::compat::shared_ptr<hyperdex::space>& lhs,
-                         const e::compat::shared_ptr<hyperdex::space>& rhs)
-{
-    if (lhs->fault_tolerance < rhs->fault_tolerance)
-    {
-        return true;
-    }
-    else if (lhs->fault_tolerance == rhs->fault_tolerance)
-    {
-        return lhs->predecessor_width < rhs->predecessor_width;
-    }
-    else
-    {
-        return false;
-    }
+compare_space_ptr_by_r_p(const e::compat::shared_ptr<hyperdex::space> &lhs,
+                         const e::compat::shared_ptr<hyperdex::space> &rhs)
+{
+	if (lhs->fault_tolerance < rhs->fault_tolerance)
+	{
+		return true;
+	}
+	else if (lhs->fault_tolerance == rhs->fault_tolerance)
+	{
+		return lhs->predecessor_width < rhs->predecessor_width;
+	}
+	else
+	{
+		return false;
+	}
 }
 
 } // namespace
 
 void
-coordinator :: rebalance_replica_sets(rsm_context* ctx)
-{
-    uint64_t R = 0;
-    uint64_t P = 0;
-    std::vector<server_id> replica_storage;
-    std::vector<replica_set> replica_sets;
-    std::vector<space_ptr> spaces;
-    spaces.reserve(m_spaces.size());
-
-    for (space_map_t::iterator it = m_spaces.begin();
-            it != m_spaces.end(); ++it)
-    {
-        spaces.push_back(it->second);
-    }
-
-    std::sort(spaces.begin(), spaces.end(), compare_space_ptr_by_r_p);
-
-    for (size_t i = 0; i < spaces.size(); ++i)
-    {
-        if (std::find(m_deferred_init.begin(),
-                      m_deferred_init.end(),
-                      spaces[i]->id) != m_deferred_init.end())
-        {
-            remove(spaces[i]->id, &m_deferred_init);
-            initial_space_layout(ctx, spaces[i].get());
-            continue;
-        }
-
-        if (spaces[i]->fault_tolerance + 1 != R ||
-            spaces[i]->predecessor_width != P)
-        {
-            R = spaces[i]->fault_tolerance + 1;
-            P = spaces[i]->predecessor_width;
-            compute_replica_sets(R, P, m_permutation, m_servers,
-                                 &replica_storage,
-                                 &replica_sets);
-        }
-
-        setup_intents(ctx, replica_sets, spaces[i].get(), false);
-    }
+coordinator :: rebalance_replica_sets(rsm_context *ctx)
+{
+	uint64_t R = 0;
+	uint64_t P = 0;
+	std::vector<server_id> replica_storage;
+	std::vector<replica_set> replica_sets;
+	std::vector<space_ptr> spaces;
+	spaces.reserve(m_spaces.size());
+	for (space_map_t::iterator it = m_spaces.begin();
+	     it != m_spaces.end(); ++it)
+	{
+		spaces.push_back(it->second);
+	}
+	std::sort(spaces.begin(), spaces.end(), compare_space_ptr_by_r_p);
+	for (size_t i = 0; i < spaces.size(); ++i)
+	{
+		if (std::find(m_deferred_init.begin(),
+		              m_deferred_init.end(),
+		              spaces[i]->id) != m_deferred_init.end())
+		{
+			remove(spaces[i]->id, &m_deferred_init);
+			initial_space_layout(ctx, spaces[i].get());
+			continue;
+		}
+		if (spaces[i]->fault_tolerance + 1 != R ||
+		    spaces[i]->predecessor_width != P)
+		{
+			R = spaces[i]->fault_tolerance + 1;
+			P = spaces[i]->predecessor_width;
+			compute_replica_sets(R, P, m_permutation, m_servers,
+			                     &replica_storage,
+			                     &replica_sets);
+		}
+		setup_intents(ctx, replica_sets, spaces[i].get(), false);
+	}
 }
 
 void
-coordinator :: initial_space_layout(rsm_context* ctx,
-                                    space* s)
-{
-    if (m_permutation.empty())
-    {
-        m_deferred_init.push_back(s->id);
-        return;
-    }
-
-    uint64_t R = s->fault_tolerance + 1;
-    uint64_t P = s->predecessor_width;
-    std::vector<server_id> replica_storage;
-    std::vector<replica_set> replica_sets;
-    compute_replica_sets(R, P, m_permutation, m_servers,
-                         &replica_storage,
-                         &replica_sets);
-    setup_intents(ctx, replica_sets, s, true);
-}
-
-region*
-coordinator :: get_region(const region_id& rid)
-{
-    for (space_map_t::iterator it = m_spaces.begin();
-            it != m_spaces.end(); ++it)
-    {
-        space& s(*it->second);
-
-        for (size_t i = 0; i < s.subspaces.size(); ++i)
-        {
-            subspace& ss(s.subspaces[i]);
-
-            for (size_t j = 0; j < ss.regions.size(); ++j)
-            {
-                if (ss.regions[j].id == rid)
-                {
-                    return &ss.regions[j];
-                }
-            }
-        }
-    }
-
-    return NULL;
+coordinator :: initial_space_layout(rsm_context *ctx,
+                                    space *s)
+{
+	if (m_permutation.empty())
+	{
+		m_deferred_init.push_back(s->id);
+		return;
+	}
+	uint64_t R = s->fault_tolerance + 1;
+	uint64_t P = s->predecessor_width;
+	std::vector<server_id> replica_storage;
+	std::vector<replica_set> replica_sets;
+	compute_replica_sets(R, P, m_permutation, m_servers,
+	                     &replica_storage,
+	                     &replica_sets);
+	setup_intents(ctx, replica_sets, s, true);
+}
+
+region *
+coordinator :: get_region(const region_id &rid)
+{
+	for (space_map_t::iterator it = m_spaces.begin();
+	     it != m_spaces.end(); ++it)
+	{
+		space &s(*it->second);
+		for (size_t i = 0; i < s.subspaces.size(); ++i)
+		{
+			subspace &ss(s.subspaces[i]);
+			for (size_t j = 0; j < ss.regions.size(); ++j)
+			{
+				if (ss.regions[j].id == rid)
+				{
+					return &ss.regions[j];
+				}
+			}
+		}
+	}
+	return NULL;
 }
 
 void
-coordinator :: setup_intents(rsm_context* ctx,
-                             const std::vector<replica_set>& replica_sets,
-                             space* s, bool skip_transfers)
-{
-    if (replica_sets.size() == 0)
-    {
-        return;
-    }
-
-    for (size_t ss_idx = 0; ss_idx < s->subspaces.size(); ++ss_idx)
-    {
-        subspace& ss(s->subspaces[ss_idx]);
-
-        for (size_t reg_idx = 0; reg_idx < ss.regions.size(); ++reg_idx)
-        {
-            region* reg = &ss.regions[reg_idx];
-            size_t idx = (reg_idx * replica_sets.size()) / ss.regions.size();
-            assert(idx < replica_sets.size());
-            bool need_change = replica_sets[idx].size() != reg->replicas.size();
-
-            for (size_t i = 0; !need_change && i < replica_sets[idx].size(); ++i)
-            {
-                need_change = replica_sets[idx][i] != reg->replicas[i].si;
-            }
-
-            if (!need_change)
-            {
-                del_region_intent(reg->id);
-                transfer* xfer = get_transfer(reg->id);
-
-                // delete the transfer if we're OK with 0 replicas, or the
-                // transfer is adding a replica (that is, it's not gone-live
-                // yet).
-                if (xfer && (reg->replicas.empty() || xfer->dst != reg->replicas.back().si))
-                {
-                    del_transfer(xfer->id);
-                }
-
-                continue;
-            }
-
-            if (skip_transfers)
-            {
-                assert(reg->replicas.empty());
-
-                for (size_t i = 0; i < replica_sets[idx].size(); ++i)
-                {
-                    reg->replicas.push_back(replica(replica_sets[idx][i], virtual_server_id(m_counter)));
-                    ++m_counter;
-                }
-            }
-            else
-            {
-                region_intent* ri = get_region_intent(reg->id);
-
-                if (!ri)
-                {
-                    ri = new_region_intent(reg->id);
-                }
-
-                ri->replicas.resize(replica_sets[idx].size());
-                ri->checkpoint = 0;
-
-                for (size_t i = 0; i < replica_sets[idx].size(); ++i)
-                {
-                    ri->replicas[i] = replica_sets[idx][i];
-                }
-
-                converge_intent(ctx, reg, ri);
-            }
-        }
-    }
+coordinator :: setup_intents(rsm_context *ctx,
+                             const std::vector<replica_set> &replica_sets,
+                             space *s, bool skip_transfers)
+{
+	if (replica_sets.size() == 0)
+	{
+		return;
+	}
+	for (size_t ss_idx = 0; ss_idx < s->subspaces.size(); ++ss_idx)
+	{
+		subspace &ss(s->subspaces[ss_idx]);
+		for (size_t reg_idx = 0; reg_idx < ss.regions.size(); ++reg_idx)
+		{
+			region *reg = &ss.regions[reg_idx];
+			size_t idx = (reg_idx * replica_sets.size()) / ss.regions.size();
+			assert(idx < replica_sets.size());
+			bool need_change = replica_sets[idx].size() != reg->replicas.size();
+			for (size_t i = 0; !need_change && i < replica_sets[idx].size(); ++i)
+			{
+				need_change = replica_sets[idx][i] != reg->replicas[i].si;
+			}
+			if (!need_change)
+			{
+				del_region_intent(reg->id);
+				transfer *xfer = get_transfer(reg->id);
+				// delete the transfer if we're OK with 0 replicas, or the
+				// transfer is adding a replica (that is, it's not gone-live
+				// yet).
+				if (xfer && (reg->replicas.empty() || xfer->dst != reg->replicas.back().si))
+				{
+					del_transfer(xfer->id);
+				}
+				continue;
+			}
+			if (skip_transfers)
+			{
+				assert(reg->replicas.empty());
+				for (size_t i = 0; i < replica_sets[idx].size(); ++i)
+				{
+					reg->replicas.push_back(replica(replica_sets[idx][i], virtual_server_id(m_counter)));
+					++m_counter;
+				}
+			}
+			else
+			{
+				region_intent *ri = get_region_intent(reg->id);
+				if (!ri)
+				{
+					ri = new_region_intent(reg->id);
+				}
+				ri->replicas.resize(replica_sets[idx].size());
+				ri->checkpoint = 0;
+				for (size_t i = 0; i < replica_sets[idx].size(); ++i)
+				{
+					ri->replicas[i] = replica_sets[idx][i];
+				}
+				converge_intent(ctx, reg, ri);
+			}
+		}
+	}
 }
 
 void
-coordinator :: converge_intent(rsm_context* ctx,
-                               region* reg)
+coordinator :: converge_intent(rsm_context *ctx,
+                               region *reg)
 {
-    region_intent* ri = get_region_intent(reg->id);
-
-    if (ri)
-    {
-        converge_intent(ctx, reg, ri);
-    }
+	region_intent *ri = get_region_intent(reg->id);
+	if (ri)
+	{
+		converge_intent(ctx, reg, ri);
+	}
 }
 
 void
-coordinator :: converge_intent(rsm_context* ctx,
-                               region* reg, region_intent* ri)
-{
-    // if there is a transfer
-    transfer* xfer = get_transfer(reg->id);
-
-    if (xfer)
-    {
-        for (size_t i = 0; i < ri->replicas.size(); ++i)
-        {
-            // there's already a transfer in progress that's helping this region
-            // converge to the region_intent
-            if (xfer->dst == ri->replicas[i])
-            {
-                return;
-            }
-        }
-
-        del_transfer(xfer->id);
-        xfer = NULL;
-    }
-
-    // there are no transfers for this region at this point
-
-    if (!reg->replicas.empty() &&
-        !((m_flags & HYPERDEX_CONFIG_READ_ONLY) && m_version == m_config_stable_through))
-    {
-        remove_offline(reg->id);
-    }
-
-    // remove every server that is not AVAILABLE
-    for (size_t i = 0; i < reg->replicas.size(); )
-    {
-        server* s = get_server(reg->replicas[i].si);
-
-        if (!s)
-        {
-            INVARIANT_BROKEN("server referenced but not found");
-            continue;
-        }
-
-        if (s->state != server::AVAILABLE)
-        {
-            if ((reg->replicas.size() == 1 ||
-                 ((m_flags & HYPERDEX_CONFIG_READ_ONLY) && m_version == m_config_stable_through)) &&
-                s->state == server::SHUTDOWN)
-            {
-                m_offline.push_back(offline_server(reg->id, s->id));
-            }
-            else if (reg->replicas.size() == 1)
-            {
-                rsm_log(ctx, "refusing to remove the last server from "
-                             "region(%" PRIu64 ") because it was not a clean shutdown\n",
-                             reg->id.get());
-                return;
-            }
-
-            rsm_log(ctx, "removing server(%" PRIu64 ") from region(%" PRIu64 ") "
-                         "because it is in state %s\n",
-                         reg->replicas[i].si.get(), reg->id.get(),
-                         server::to_string(s->state));
-            shift_and_pop(i, &reg->replicas);
-        }
-        else
-        {
-            ++i;
-        }
-    }
-
-    // now remove any excess replicas
-    for (size_t i = 0; i < reg->replicas.size(); )
-    {
-        // no excess exist yet
-        if (reg->replicas.size() <= ri->replicas.size())
-        {
-            break;
-        }
-
-        // if we don't intend to converge with this replica, remove it
-        if (std::find(ri->replicas.begin(),
-                      ri->replicas.end(),
-                      reg->replicas[i].si) == ri->replicas.end())
-        {
-            if (reg->replicas.size() == 1)
-            {
-                rsm_log(ctx, "refusing to remove the last server from "
-                             "region(%" PRIu64 ") because we need it to transfer data\n",
-                             reg->id.get());
-                return;
-            }
-
-            rsm_log(ctx, "removing server(%" PRIu64 ") from region(%" PRIu64 ") "
-                         "to make progress toward desired state\n",
-                         reg->replicas[i].si.get(), reg->id.get());
-            shift_and_pop(i, &reg->replicas);
-        }
-        else
-        {
-            ++i;
-        }
-    }
-
-    if (reg->replicas.empty() && ri->replicas.empty())
-    {
-        del_region_intent(reg->id);
-        return;
-    }
-
-    if (reg->replicas.empty())
-    {
-        for (size_t i = 0; i < m_offline.size(); ++i)
-        {
-            if (m_offline[i].id != reg->id)
-            {
-                continue;
-            }
-
-            server* s = get_server(m_offline[i].sid);
-
-            if (s && s->state == server::AVAILABLE)
-            {
-                reg->replicas.push_back(replica(m_offline[i].sid, virtual_server_id(m_counter)));
-                ++m_counter;
-                rsm_log(ctx, "restoring offline server(%" PRIu64 ") to region(%" PRIu64 ")\n",
-                             m_offline[i].sid.get(), reg->id.get());
-                remove_offline(reg->id);
-                break;
-            }
-        }
-    }
-
-    if (reg->replicas.empty())
-    {
-        rsm_log(ctx, "cannot transfer state to new servers in "
-                     "region(%" PRIu64 ") because all servers are offline\n",
-                     reg->id.get());
-        return;
-    }
-
-    // add up to one server from the region_intent
-    for (size_t i = 0; i < ri->replicas.size(); ++i)
-    {
-        bool found = false;
-
-        for (size_t j = 0; j < reg->replicas.size(); ++j)
-        {
-            if (ri->replicas[i] == reg->replicas[j].si)
-            {
-                found = true;
-                break;
-            }
-        }
-
-        if (found)
-        {
-            continue;
-        }
-
-        xfer = new_transfer(reg, ri->replicas[i]);
-        assert(xfer);
-        rsm_log(ctx, "adding server(%" PRIu64 ") to region(%" PRIu64 ") "
-                     "copying from server(%" PRIu64 ")/virtual_server(%" PRIu64 ") "
-                     "using transfer(%" PRIu64 ")/virtual_server(%" PRIu64 ")\n",
-                     xfer->dst.get(), reg->id.get(),
-                     xfer->src.get(), xfer->vsrc.get(),
-                     xfer->id.get(), xfer->vdst.get());
-        return;
-    }
-
-    if (ri->checkpoint == 0)
-    {
-        ri->checkpoint = m_checkpoint > 0 ? m_checkpoint : 1;
-    }
-
-    // now shuffle to make the order consistent with ri->replicas
-    for (size_t i = 1; i < reg->replicas.size(); ++i)
-    {
-        server_id* start = &ri->replicas[0];
-        server_id* limit = start + ri->replicas.size();
-        // idx1 is the index of reg->replicas[i - 1] in ri->replicas
-        size_t idx1 = std::find(start, limit, reg->replicas[i - 1].si) - start;
-        // idx2 is the index of reg->replicas[i - 0] in ri->replicas
-        size_t idx2 = std::find(start, limit, reg->replicas[i - 0].si) - start;
-
-        if (idx1 < idx2)
-        {
-            continue;
-        }
-
-        if (ri->checkpoint >= m_checkpoint_stable_through)
-        {
-            rsm_log(ctx, "postponing convergence until after checkpoint %" PRIu64 " is stable\n", ri->checkpoint);
-            return;
-        }
-
-        // grab the server id
-        server_id sid = reg->replicas[i - 1].si;
-        // remove the idx1 replica
-        shift_and_pop(i - 1, &reg->replicas);
-        // now do a transfer to roll it to the end
-        ri->checkpoint = 0;
-        xfer = new_transfer(reg, sid);
-        assert(xfer);
-        rsm_log(ctx, "rolling server(%" PRIu64 ") to the back of region(%" PRIu64 ") "
-                     "using transfer(%" PRIu64 ")/virtual_server(%" PRIu64 ")\n",
-                     xfer->dst.get(), reg->id.get(),
-                     xfer->id.get(), xfer->vdst.get());
-        return;
-    }
-
-    del_region_intent(reg->id);
-}
-
-region_intent*
-coordinator :: new_region_intent(const region_id& rid)
-{
-    size_t idx = m_intents.size();
-    m_intents.push_back(region_intent(rid));
-
-    for (; idx > 0; --idx)
-    {
-        if (m_intents[idx - 1].id < m_intents[idx].id)
-        {
-            break;
-        }
-
-        std::swap(m_intents[idx - 1], m_intents[idx]);
-    }
-
-    return &m_intents[idx];
-}
-
-region_intent*
-coordinator :: get_region_intent(const region_id& rid)
-{
-    for (size_t i = 0; i < m_intents.size(); ++i)
-    {
-        if (m_intents[i].id == rid)
-        {
-            return &m_intents[i];
-        }
-    }
-
-    return NULL;
+coordinator :: converge_intent(rsm_context *ctx,
+                               region *reg, region_intent *ri)
+{
+	// if there is a transfer
+	transfer *xfer = get_transfer(reg->id);
+	if (xfer)
+	{
+		for (size_t i = 0; i < ri->replicas.size(); ++i)
+		{
+			// there's already a transfer in progress that's helping this region
+			// converge to the region_intent
+			if (xfer->dst == ri->replicas[i])
+			{
+				return;
+			}
+		}
+		del_transfer(xfer->id);
+		xfer = NULL;
+	}
+	// there are no transfers for this region at this point
+	if (!reg->replicas.empty() &&
+	    !((m_flags & HYPERDEX_CONFIG_READ_ONLY) && m_version == m_config_stable_through))
+	{
+		remove_offline(reg->id);
+	}
+	// remove every server that is not AVAILABLE
+	for (size_t i = 0; i < reg->replicas.size(); )
+	{
+		server *s = get_server(reg->replicas[i].si);
+		if (!s)
+		{
+			INVARIANT_BROKEN("server referenced but not found");
+			continue;
+		}
+		if (s->state != server::AVAILABLE)
+		{
+			if ((reg->replicas.size() == 1 ||
+			     ((m_flags & HYPERDEX_CONFIG_READ_ONLY) && m_version == m_config_stable_through)) &&
+			    s->state == server::SHUTDOWN)
+			{
+				m_offline.push_back(offline_server(reg->id, s->id));
+			}
+			else if (reg->replicas.size() == 1)
+			{
+				rsm_log(ctx, "refusing to remove the last server from "
+				        "region(%" PRIu64 ") because it was not a clean shutdown\n",
+				        reg->id.get());
+				return;
+			}
+			rsm_log(ctx, "removing server(%" PRIu64 ") from region(%" PRIu64 ") "
+			        "because it is in state %s\n",
+			        reg->replicas[i].si.get(), reg->id.get(),
+			        server::to_string(s->state));
+			shift_and_pop(i, &reg->replicas);
+		}
+		else
+		{
+			++i;
+		}
+	}
+	// now remove any excess replicas
+	for (size_t i = 0; i < reg->replicas.size(); )
+	{
+		// no excess exist yet
+		if (reg->replicas.size() <= ri->replicas.size())
+		{
+			break;
+		}
+		// if we don't intend to converge with this replica, remove it
+		if (std::find(ri->replicas.begin(),
+		              ri->replicas.end(),
+		              reg->replicas[i].si) == ri->replicas.end())
+		{
+			if (reg->replicas.size() == 1)
+			{
+				rsm_log(ctx, "refusing to remove the last server from "
+				        "region(%" PRIu64 ") because we need it to transfer data\n",
+				        reg->id.get());
+				return;
+			}
+			rsm_log(ctx, "removing server(%" PRIu64 ") from region(%" PRIu64 ") "
+			        "to make progress toward desired state\n",
+			        reg->replicas[i].si.get(), reg->id.get());
+			shift_and_pop(i, &reg->replicas);
+		}
+		else
+		{
+			++i;
+		}
+	}
+	if (reg->replicas.empty() && ri->replicas.empty())
+	{
+		del_region_intent(reg->id);
+		return;
+	}
+	if (reg->replicas.empty())
+	{
+		for (size_t i = 0; i < m_offline.size(); ++i)
+		{
+			if (m_offline[i].id != reg->id)
+			{
+				continue;
+			}
+			server *s = get_server(m_offline[i].sid);
+			if (s && s->state == server::AVAILABLE)
+			{
+				reg->replicas.push_back(replica(m_offline[i].sid, virtual_server_id(m_counter)));
+				++m_counter;
+				rsm_log(ctx, "restoring offline server(%" PRIu64 ") to region(%" PRIu64 ")\n",
+				        m_offline[i].sid.get(), reg->id.get());
+				remove_offline(reg->id);
+				break;
+			}
+		}
+	}
+	if (reg->replicas.empty())
+	{
+		rsm_log(ctx, "cannot transfer state to new servers in "
+		        "region(%" PRIu64 ") because all servers are offline\n",
+		        reg->id.get());
+		return;
+	}
+	// add up to one server from the region_intent
+	for (size_t i = 0; i < ri->replicas.size(); ++i)
+	{
+		bool found = false;
+		for (size_t j = 0; j < reg->replicas.size(); ++j)
+		{
+			if (ri->replicas[i] == reg->replicas[j].si)
+			{
+				found = true;
+				break;
+			}
+		}
+		if (found)
+		{
+			continue;
+		}
+		xfer = new_transfer(reg, ri->replicas[i]);
+		assert(xfer);
+		rsm_log(ctx, "adding server(%" PRIu64 ") to region(%" PRIu64 ") "
+		        "copying from server(%" PRIu64 ")/virtual_server(%" PRIu64 ") "
+		        "using transfer(%" PRIu64 ")/virtual_server(%" PRIu64 ")\n",
+		        xfer->dst.get(), reg->id.get(),
+		        xfer->src.get(), xfer->vsrc.get(),
+		        xfer->id.get(), xfer->vdst.get());
+		return;
+	}
+	if (ri->checkpoint == 0)
+	{
+		ri->checkpoint = m_checkpoint > 0 ? m_checkpoint : 1;
+	}
+	// now shuffle to make the order consistent with ri->replicas
+	for (size_t i = 1; i < reg->replicas.size(); ++i)
+	{
+		server_id *start = &ri->replicas[0];
+		server_id *limit = start + ri->replicas.size();
+		// idx1 is the index of reg->replicas[i - 1] in ri->replicas
+		size_t idx1 = std::find(start, limit, reg->replicas[i - 1].si) - start;
+		// idx2 is the index of reg->replicas[i - 0] in ri->replicas
+		size_t idx2 = std::find(start, limit, reg->replicas[i - 0].si) - start;
+		if (idx1 < idx2)
+		{
+			continue;
+		}
+		if (ri->checkpoint >= m_checkpoint_stable_through)
+		{
+			rsm_log(ctx, "postponing convergence until after checkpoint %" PRIu64 " is stable\n", ri->checkpoint);
+			return;
+		}
+		// grab the server id
+		server_id sid = reg->replicas[i - 1].si;
+		// remove the idx1 replica
+		shift_and_pop(i - 1, &reg->replicas);
+		// now do a transfer to roll it to the end
+		ri->checkpoint = 0;
+		xfer = new_transfer(reg, sid);
+		assert(xfer);
+		rsm_log(ctx, "rolling server(%" PRIu64 ") to the back of region(%" PRIu64 ") "
+		        "using transfer(%" PRIu64 ")/virtual_server(%" PRIu64 ")\n",
+		        xfer->dst.get(), reg->id.get(),
+		        xfer->id.get(), xfer->vdst.get());
+		return;
+	}
+	del_region_intent(reg->id);
+}
+
+region_intent *
+coordinator :: new_region_intent(const region_id &rid)
+{
+	size_t idx = m_intents.size();
+	m_intents.push_back(region_intent(rid));
+	for (; idx > 0; --idx)
+	{
+		if (m_intents[idx - 1].id < m_intents[idx].id)
+		{
+			break;
+		}
+		std::swap(m_intents[idx - 1], m_intents[idx]);
+	}
+	return &m_intents[idx];
+}
+
+region_intent *
+coordinator :: get_region_intent(const region_id &rid)
+{
+	for (size_t i = 0; i < m_intents.size(); ++i)
+	{
+		if (m_intents[i].id == rid)
+		{
+			return &m_intents[i];
+		}
+	}
+	return NULL;
 }
 
 void
-coordinator :: del_region_intent(const region_id& rid)
+coordinator :: del_region_intent(const region_id &rid)
 {
-    remove_id(rid, &m_intents);
+	remove_id(rid, &m_intents);
 }
 
 void
-coordinator :: remove_offline(const region_id& rid)
+coordinator :: remove_offline(const region_id &rid)
 {
-    for (size_t i = 0; i < m_offline.size(); )
-    {
-        if (m_offline[i].id == rid)
-        {
-            shift_and_pop(i, &m_offline);
-        }
-        else
-        {
-            ++i;
-        }
-    }
+	for (size_t i = 0; i < m_offline.size(); )
+	{
+		if (m_offline[i].id == rid)
+		{
+			shift_and_pop(i, &m_offline);
+		}
+		else
+		{
+			++i;
+		}
+	}
 }
 
 void
-coordinator :: remove_offline(const server_id& sid)
-{
-    for (size_t i = 0; i < m_offline.size(); )
-    {
-        if (m_offline[i].sid == sid)
-        {
-            shift_and_pop(i, &m_offline);
-        }
-        else
-        {
-            ++i;
-        }
-    }
-}
-
-transfer*
-coordinator :: new_transfer(region* reg,
-                            const server_id& sid)
-{
-    assert(!reg->replicas.empty());
-    m_transfers.push_back(transfer());
-    transfer* t = &m_transfers.back();
-    t->id = transfer_id(m_counter);
-    ++m_counter;
-    t->rid = reg->id;
-    t->src = reg->replicas.back().si;
-    t->vsrc = reg->replicas.back().vsi;
-    t->dst = sid;
-    t->vdst = virtual_server_id(m_counter);
-    ++m_counter;
-    return t;
-}
-
-transfer*
-coordinator :: get_transfer(const region_id& rid)
-{
-    for (size_t i = 0; i < m_transfers.size(); ++i)
-    {
-        if (m_transfers[i].rid == rid)
-        {
-            return &m_transfers[i];
-        }
-    }
-
-    return NULL;
-}
-
-transfer*
-coordinator :: get_transfer(const transfer_id& xid)
-{
-    for (size_t i = 0; i < m_transfers.size(); ++i)
-    {
-        if (m_transfers[i].id == xid)
-        {
-            return &m_transfers[i];
-        }
-    }
-
-    return NULL;
+coordinator :: remove_offline(const server_id &sid)
+{
+	for (size_t i = 0; i < m_offline.size(); )
+	{
+		if (m_offline[i].sid == sid)
+		{
+			shift_and_pop(i, &m_offline);
+		}
+		else
+		{
+			++i;
+		}
+	}
+}
+
+transfer *
+coordinator :: new_transfer(region *reg,
+                            const server_id &sid)
+{
+	assert(!reg->replicas.empty());
+	m_transfers.push_back(transfer());
+	transfer *t = &m_transfers.back();
+	t->id = transfer_id(m_counter);
+	++m_counter;
+	t->rid = reg->id;
+	t->src = reg->replicas.back().si;
+	t->vsrc = reg->replicas.back().vsi;
+	t->dst = sid;
+	t->vdst = virtual_server_id(m_counter);
+	++m_counter;
+	return t;
+}
+
+transfer *
+coordinator :: get_transfer(const region_id &rid)
+{
+	for (size_t i = 0; i < m_transfers.size(); ++i)
+	{
+		if (m_transfers[i].rid == rid)
+		{
+			return &m_transfers[i];
+		}
+	}
+	return NULL;
+}
+
+transfer *
+coordinator :: get_transfer(const transfer_id &xid)
+{
+	for (size_t i = 0; i < m_transfers.size(); ++i)
+	{
+		if (m_transfers[i].id == xid)
+		{
+			return &m_transfers[i];
+		}
+	}
+	return NULL;
 }
 
 void
-coordinator :: del_transfer(const transfer_id& xid)
-{
-    for (size_t i = 0; i < m_transfers.size(); ++i)
-    {
-        if (m_transfers[i].id != xid)
-        {
-            continue;
-        }
-
-        for (size_t j = i + 1; j < m_transfers.size(); ++j)
-        {
-            m_transfers[j - 1] = m_transfers[j];
-        }
-
-        m_transfers.pop_back();
-        break;
-    }
+coordinator :: del_transfer(const transfer_id &xid)
+{
+	for (size_t i = 0; i < m_transfers.size(); ++i)
+	{
+		if (m_transfers[i].id != xid)
+		{
+			continue;
+		}
+		for (size_t j = i + 1; j < m_transfers.size(); ++j)
+		{
+			m_transfers[j - 1] = m_transfers[j];
+		}
+		m_transfers.pop_back();
+		break;
+	}
 }
 
 void
-coordinator :: check_ack_condition(rsm_context* ctx)
+coordinator :: check_ack_condition(rsm_context *ctx)
 {
-    if (m_config_ack_through < m_config_ack_barrier.min_version())
-    {
-        rsm_log(ctx, "acked through version %" PRIu64 "\n", m_config_ack_barrier.min_version());
-    }
-
-    while (m_config_ack_through < m_config_ack_barrier.min_version())
-    {
-        rsm_cond_broadcast(ctx, "ack");
-        ++m_config_ack_through;
-    }
+	if (m_config_ack_through < m_config_ack_barrier.min_version())
+	{
+		rsm_log(ctx, "acked through version %" PRIu64 "\n", m_config_ack_barrier.min_version());
+	}
+	while (m_config_ack_through < m_config_ack_barrier.min_version())
+	{
+		rsm_cond_broadcast(ctx, "ack");
+		++m_config_ack_through;
+	}
 }
 
 void
-coordinator :: check_stable_condition(rsm_context* ctx)
+coordinator :: check_stable_condition(rsm_context *ctx)
 {
-    if (m_config_stable_through < m_config_stable_barrier.min_version())
-    {
-        rsm_log(ctx, "stable through version %" PRIu64 "\n", m_config_stable_barrier.min_version());
-    }
-
-    while (m_intents.empty() && m_deferred_init.empty() &&
-            m_config_stable_through < m_config_stable_barrier.min_version())
-    {
-        rsm_cond_broadcast(ctx, "stable");
-        ++m_config_stable_through;
-    }
+	if (m_config_stable_through < m_config_stable_barrier.min_version())
+	{
+		rsm_log(ctx, "stable through version %" PRIu64 "\n", m_config_stable_barrier.min_version());
+	}
+	while (m_intents.empty() && m_deferred_init.empty() &&
+	       m_config_stable_through < m_config_stable_barrier.min_version())
+	{
+		rsm_cond_broadcast(ctx, "stable");
+		++m_config_stable_through;
+	}
 }
 
 void
-coordinator :: generate_next_configuration(rsm_context* ctx)
+coordinator :: generate_next_configuration(rsm_context *ctx)
 {
-    ++m_version;
-    rsm_log(ctx, "issuing new configuration version %" PRIu64 "\n", m_version);
-    std::vector<server_id> sids;
-    servers_in_configuration(&sids);
-    m_config_ack_barrier.new_version(m_version, sids);
-    m_config_stable_barrier.new_version(m_version, sids);
-    check_ack_condition(ctx);
-    check_stable_condition(ctx);
-    generate_cached_configuration(ctx);
-    rsm_cond_broadcast_data(ctx, "config", m_latest_config->cdata(), m_latest_config->size());
-    broadcast_checkpoint_information(ctx);
+	++m_version;
+	rsm_log(ctx, "issuing new configuration version %" PRIu64 "\n", m_version);
+	std::vector<server_id> sids;
+	servers_in_configuration(&sids);
+	m_config_ack_barrier.new_version(m_version, sids);
+	m_config_stable_barrier.new_version(m_version, sids);
+	check_ack_condition(ctx);
+	check_stable_condition(ctx);
+	generate_cached_configuration(ctx);
+	rsm_cond_broadcast_data(ctx, "config", m_latest_config->cdata(), m_latest_config->size());
+	broadcast_checkpoint_information(ctx);
 }
 
 void
-coordinator :: generate_cached_configuration(rsm_context*)
-{
-    m_latest_config.reset();
-    size_t sz = 7 * sizeof(uint64_t);
-
-    for (size_t i = 0; i < m_servers.size(); ++i)
-    {
-        sz += pack_size(m_servers[i]);
-    }
-
-    for (std::map<std::string, e::compat::shared_ptr<space> >::iterator it = m_spaces.begin();
-            it != m_spaces.end(); ++it)
-    {
-        sz += pack_size(*it->second);
-    }
-
-    for (size_t i = 0; i < m_transfers.size(); ++i)
-    {
-        sz += pack_size(m_transfers[i]);
-    }
-
-    std::vector<transfer> transfers_subset;
-    prioritized_transfer_subset(&transfers_subset);
-
-    std::auto_ptr<e::buffer> new_config(e::buffer::create(sz));
-    e::packer pa = new_config->pack_at(0);
-    pa = pa << m_cluster << m_version << m_flags
-            << uint64_t(m_servers.size())
-            << uint64_t(m_spaces.size())
-            << uint64_t(transfers_subset.size());
-
-    for (size_t i = 0; i < m_servers.size(); ++i)
-    {
-        pa = pa << m_servers[i];
-    }
-
-    for (std::map<std::string, e::compat::shared_ptr<space> >::iterator it = m_spaces.begin();
-            it != m_spaces.end(); ++it)
-    {
-        pa = pa << *it->second;
-    }
-
-    for (size_t i = 0; i < transfers_subset.size(); ++i)
-    {
-        pa = pa << transfers_subset[i];
-    }
-
-    m_latest_config = new_config;
+coordinator :: generate_cached_configuration(rsm_context *)
+{
+	m_latest_config.reset();
+	size_t sz = 7 * sizeof(uint64_t);
+	for (size_t i = 0; i < m_servers.size(); ++i)
+	{
+		sz += pack_size(m_servers[i]);
+	}
+	for (std::map<std::string, e::compat::shared_ptr<space> >::iterator it = m_spaces.begin();
+	     it != m_spaces.end(); ++it)
+	{
+		sz += pack_size(*it->second);
+	}
+	for (size_t i = 0; i < m_transfers.size(); ++i)
+	{
+		sz += pack_size(m_transfers[i]);
+	}
+	std::vector<transfer> transfers_subset;
+	prioritized_transfer_subset(&transfers_subset);
+	std::auto_ptr<e::buffer> new_config(e::buffer::create(sz));
+	e::packer pa = new_config->pack_at(0);
+	pa = pa << m_cluster << m_version << m_flags
+	     << uint64_t(m_servers.size())
+	     << uint64_t(m_spaces.size())
+	     << uint64_t(transfers_subset.size());
+	for (size_t i = 0; i < m_servers.size(); ++i)
+	{
+		pa = pa << m_servers[i];
+	}
+	for (std::map<std::string, e::compat::shared_ptr<space> >::iterator it = m_spaces.begin();
+	     it != m_spaces.end(); ++it)
+	{
+		pa = pa << *it->second;
+	}
+	for (size_t i = 0; i < transfers_subset.size(); ++i)
+	{
+		pa = pa << transfers_subset[i];
+	}
+	m_latest_config = new_config;
 }
 
 struct coordinator::transfer_sorter
 {
-    transfer_sorter(coordinator* c) : coord(c) {}
-    transfer_sorter(const transfer_sorter& other) : coord(other.coord) {}
-    bool operator () (const transfer& lhs, const transfer& rhs) const;
-    coordinator* coord;
+	transfer_sorter(coordinator *c) : coord(c) {}
+	transfer_sorter(const transfer_sorter &other) : coord(other.coord) {}
+	bool operator () (const transfer &lhs, const transfer &rhs) const;
+	coordinator *coord;
 
-    private:
-        transfer_sorter& operator = (const transfer_sorter&);
+private:
+	transfer_sorter &operator = (const transfer_sorter &);
 };
 
 bool
-coordinator :: transfer_sorter :: operator () (const transfer& lhs, const transfer& rhs) const
-{
-    region* rlhs = coord->get_region(lhs.rid);
-    region* rrhs = coord->get_region(rhs.rid);
-    bool live_lhs = !rlhs->replicas.empty() && rlhs->replicas.back().vsi == lhs.vdst;
-    bool live_rhs = !rrhs->replicas.empty() && rrhs->replicas.back().vsi == rhs.vdst;
-
-    if (live_lhs && !live_rhs)
-    {
-        return true;
-    }
-    else if (live_rhs && !live_lhs)
-    {
-        return false;
-    }
-    else
-    {
-        return rlhs->replicas.size() < rrhs->replicas.size();
-    }
+coordinator :: transfer_sorter :: operator () (const transfer &lhs, const transfer &rhs) const
+{
+	region *rlhs = coord->get_region(lhs.rid);
+	region *rrhs = coord->get_region(rhs.rid);
+	bool live_lhs = !rlhs->replicas.empty() && rlhs->replicas.back().vsi == lhs.vdst;
+	bool live_rhs = !rrhs->replicas.empty() && rrhs->replicas.back().vsi == rhs.vdst;
+	if (live_lhs && !live_rhs)
+	{
+		return true;
+	}
+	else if (live_rhs && !live_lhs)
+	{
+		return false;
+	}
+	else
+	{
+		return rlhs->replicas.size() < rrhs->replicas.size();
+	}
 }
 
 void
-coordinator :: prioritized_transfer_subset(std::vector<transfer>* transfers)
-{
-    std::vector<server_id> seen_src;
-    std::vector<server_id> seen_dst;
-    std::vector<transfer> tmp_transfers(m_transfers);
-    transfer_sorter ts(this);
-    std::stable_sort(tmp_transfers.begin(), tmp_transfers.end(), ts);
-    transfers->clear();
-    transfers->reserve(std::min(m_servers.size(), m_transfers.size()));
-
-    for (size_t i = 0; i < tmp_transfers.size(); ++i)
-    {
-        // if the src is not the dst of a transfer, and the dst is not a src of
-        // a transfer, then add the transfer
-        if (std::find(seen_dst.begin(), seen_dst.end(), tmp_transfers[i].src) == seen_dst.end() &&
-            std::find(seen_src.begin(), seen_src.end(), tmp_transfers[i].dst) == seen_src.end())
-        {
-            seen_src.push_back(tmp_transfers[i].src);
-            seen_dst.push_back(tmp_transfers[i].dst);
-            transfers->push_back(tmp_transfers[i]);
-        }
-    }
+coordinator :: prioritized_transfer_subset(std::vector<transfer> *transfers)
+{
+	std::vector<server_id> seen_src;
+	std::vector<server_id> seen_dst;
+	std::vector<transfer> tmp_transfers(m_transfers);
+	transfer_sorter ts(this);
+	std::stable_sort(tmp_transfers.begin(), tmp_transfers.end(), ts);
+	transfers->clear();
+	transfers->reserve(std::min(m_servers.size(), m_transfers.size()));
+	for (size_t i = 0; i < tmp_transfers.size(); ++i)
+	{
+		// if the src is not the dst of a transfer, and the dst is not a src of
+		// a transfer, then add the transfer
+		if (std::find(seen_dst.begin(), seen_dst.end(), tmp_transfers[i].src) == seen_dst.end() &&
+		    std::find(seen_src.begin(), seen_src.end(), tmp_transfers[i].dst) == seen_src.end())
+		{
+			seen_src.push_back(tmp_transfers[i].src);
+			seen_dst.push_back(tmp_transfers[i].dst);
+			transfers->push_back(tmp_transfers[i]);
+		}
+	}
 }
 
 void
-coordinator :: servers_in_configuration(std::vector<server_id>* sids)
-{
-    for (std::map<std::string, e::compat::shared_ptr<space> >::iterator it = m_spaces.begin();
-            it != m_spaces.end(); ++it)
-    {
-        space& s(*it->second);
-
-        for (size_t i = 0; i < s.subspaces.size(); ++i)
-        {
-            subspace& ss(s.subspaces[i]);
-
-            for (size_t j = 0; j < ss.regions.size(); ++j)
-            {
-                region& reg(ss.regions[j]);
-
-                for (size_t k = 0; k < reg.replicas.size(); ++k)
-                {
-                    sids->push_back(reg.replicas[k].si);
-                }
-            }
-        }
-    }
-
-    for (size_t i = 0; i < m_transfers.size(); ++i)
-    {
-        sids->push_back(m_transfers[i].src);
-        sids->push_back(m_transfers[i].dst);
-    }
-
-    std::sort(sids->begin(), sids->end());
-    std::vector<server_id>::iterator sit;
-    sit = std::unique(sids->begin(), sids->end());
-    sids->resize(sit - sids->begin());
+coordinator :: servers_in_configuration(std::vector<server_id> *sids)
+{
+	for (std::map<std::string, e::compat::shared_ptr<space> >::iterator it = m_spaces.begin();
+	     it != m_spaces.end(); ++it)
+	{
+		space &s(*it->second);
+		for (size_t i = 0; i < s.subspaces.size(); ++i)
+		{
+			subspace &ss(s.subspaces[i]);
+			for (size_t j = 0; j < ss.regions.size(); ++j)
+			{
+				region &reg(ss.regions[j]);
+				for (size_t k = 0; k < reg.replicas.size(); ++k)
+				{
+					sids->push_back(reg.replicas[k].si);
+				}
+			}
+		}
+	}
+	for (size_t i = 0; i < m_transfers.size(); ++i)
+	{
+		sids->push_back(m_transfers[i].src);
+		sids->push_back(m_transfers[i].dst);
+	}
+	std::sort(sids->begin(), sids->end());
+	std::vector<server_id>::iterator sit;
+	sit = std::unique(sids->begin(), sids->end());
+	sids->resize(sit - sids->begin());
 }
 
 void
-coordinator :: regions_in_space(space_ptr s, std::vector<region_id>* rids)
+coordinator :: regions_in_space(space_ptr s, std::vector<region_id> *rids)
 {
-    for (size_t i = 0; i < s->subspaces.size(); ++i)
-    {
-        subspace& ss(s->subspaces[i]);
-
-        for (size_t j = 0; j < ss.regions.size(); ++j)
-        {
-            rids->push_back(ss.regions[j].id);
-        }
-    }
+	for (size_t i = 0; i < s->subspaces.size(); ++i)
+	{
+		subspace &ss(s->subspaces[i]);
+		for (size_t j = 0; j < ss.regions.size(); ++j)
+		{
+			rids->push_back(ss.regions[j].id);
+		}
+	}
 }
 
 void
-coordinator :: check_checkpoint_stable_condition(rsm_context* ctx, bool reissue)
-{
-    assert(m_checkpoint_stable_through <= m_checkpoint);
-
-    if (m_checkpoint_stable_through < m_checkpoint_stable_barrier.min_version())
-    {
-        rsm_log(ctx, "checkpoint %" PRIu64 " done\n", m_checkpoint_stable_barrier.min_version());
-    }
-
-    bool stabilized = false;
-
-    while (m_checkpoint_stable_through < m_checkpoint_stable_barrier.min_version())
-    {
-        stabilized = true;
-        ++m_checkpoint_stable_through;
-        broadcast_checkpoint_information(ctx);
-    }
-
-    bool gc = false;
-    uint64_t outstanding_checkpoints = 120;
-
-    if (m_intents.empty())
-    {
-        bool all_available = true;
-
-        for (size_t i = 0; i < m_servers.size(); ++i)
-        {
-            if (m_servers[i].state != server::AVAILABLE)
-            {
-                all_available = false;
-                break;
-            }
-        }
-
-        if (all_available)
-        {
-            outstanding_checkpoints = 1;
-        }
-    }
-
-    while (m_checkpoint_gc_through + outstanding_checkpoints < m_checkpoint_stable_barrier.min_version())
-    {
-        gc = true;
-        ++m_checkpoint_gc_through;
-        broadcast_checkpoint_information(ctx);
-    }
-
-    if (gc && m_checkpoint_gc_through > 0)
-    {
-        rsm_log(ctx, "garbage collect <= checkpoint %" PRIu64 "\n", m_checkpoint_gc_through);
-    }
-
-    assert(m_checkpoint_gc_through <= m_checkpoint_stable_through);
-    assert(m_checkpoint_stable_through <= m_checkpoint);
-
-    if (stabilized)
-    {
-        std::vector<region_id> rids;
-        rids.reserve(m_intents.size());
-
-        // two pass because converge_intent can alter m_intents
-        for (size_t i = 0; i < m_intents.size(); ++i)
-        {
-            if (m_intents[i].checkpoint > 0 &&
-                m_intents[i].checkpoint < m_checkpoint_stable_through)
-            {
-                rids.push_back(m_intents[i].id);
-            }
-        }
-
-        for (size_t i = 0; i < rids.size(); ++i)
-        {
-            region* reg = get_region(rids[i]);
-            converge_intent(ctx, reg);
-        }
-
-        if (!rids.empty())
-        {
-            generate_next_configuration(ctx);
-        }
-    }
-
-    if (reissue && m_checkpoint_stable_through + 1 < m_checkpoint)
-    {
-        generate_next_configuration(ctx);
-    }
+coordinator :: check_checkpoint_stable_condition(rsm_context *ctx, bool reissue)
+{
+	assert(m_checkpoint_stable_through <= m_checkpoint);
+	if (m_checkpoint_stable_through < m_checkpoint_stable_barrier.min_version())
+	{
+		rsm_log(ctx, "checkpoint %" PRIu64 " done\n", m_checkpoint_stable_barrier.min_version());
+	}
+	bool stabilized = false;
+	while (m_checkpoint_stable_through < m_checkpoint_stable_barrier.min_version())
+	{
+		stabilized = true;
+		++m_checkpoint_stable_through;
+		broadcast_checkpoint_information(ctx);
+	}
+	bool gc = false;
+	uint64_t outstanding_checkpoints = 120;
+	if (m_intents.empty())
+	{
+		bool all_available = true;
+		for (size_t i = 0; i < m_servers.size(); ++i)
+		{
+			if (m_servers[i].state != server::AVAILABLE)
+			{
+				all_available = false;
+				break;
+			}
+		}
+		if (all_available)
+		{
+			outstanding_checkpoints = 1;
+		}
+	}
+	while (m_checkpoint_gc_through + outstanding_checkpoints < m_checkpoint_stable_barrier.min_version())
+	{
+		gc = true;
+		++m_checkpoint_gc_through;
+		broadcast_checkpoint_information(ctx);
+	}
+	if (gc && m_checkpoint_gc_through > 0)
+	{
+		rsm_log(ctx, "garbage collect <= checkpoint %" PRIu64 "\n", m_checkpoint_gc_through);
+	}
+	assert(m_checkpoint_gc_through <= m_checkpoint_stable_through);
+	assert(m_checkpoint_stable_through <= m_checkpoint);
+	if (stabilized)
+	{
+		std::vector<region_id> rids;
+		rids.reserve(m_intents.size());
+		// two pass because converge_intent can alter m_intents
+		for (size_t i = 0; i < m_intents.size(); ++i)
+		{
+			if (m_intents[i].checkpoint > 0 &&
+			    m_intents[i].checkpoint < m_checkpoint_stable_through)
+			{
+				rids.push_back(m_intents[i].id);
+			}
+		}
+		for (size_t i = 0; i < rids.size(); ++i)
+		{
+			region *reg = get_region(rids[i]);
+			converge_intent(ctx, reg);
+		}
+		if (!rids.empty())
+		{
+			generate_next_configuration(ctx);
+		}
+	}
+	if (reissue && m_checkpoint_stable_through + 1 < m_checkpoint)
+	{
+		generate_next_configuration(ctx);
+	}
 }
 
 void
-coordinator :: broadcast_checkpoint_information(rsm_context* ctx)
-{
-    std::string input;
-    e::packer(&input) << m_version
-                      << m_checkpoint
-                      << m_checkpoint_stable_through
-                      << m_checkpoint_gc_through;
-    rsm_cond_broadcast_data(ctx, "checkpoint", input.data(), input.size());
+coordinator :: broadcast_checkpoint_information(rsm_context *ctx)
+{
+	std::string input;
+	e::packer(&input) << m_version
+	                  << m_checkpoint
+	                  << m_checkpoint_stable_through
+	                  << m_checkpoint_gc_through;
+	rsm_cond_broadcast_data(ctx, "checkpoint", input.data(), input.size());
 }
diff --git a/coordinator/coordinator.h b/coordinator/coordinator.h
index 9b2a05ba8..e4330dd90 100644
--- a/coordinator/coordinator.h
+++ b/coordinator/coordinator.h
@@ -55,181 +55,181 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class coordinator
 {
-    public:
-        coordinator();
-        ~coordinator() throw ();
-
-    // identity
-    public:
-        void init(rsm_context* ctx, uint64_t token);
-        uint64_t cluster() const { return m_cluster; }
-
-    // cluster management
-    public:
-        void read_only(rsm_context* ctx, bool ro);
-        void fault_tolerance(rsm_context* ctx,
-                             const char* space, uint64_t consistency);
-
-    // server management
-    public:
-        void server_register(rsm_context* ctx,
-                             const server_id& sid,
-                             const po6::net::location& bind_to);
-        void server_online(rsm_context* ctx,
-                           const server_id& sid,
-                           const po6::net::location* bind_to);
-        void server_offline(rsm_context* ctx,
-                            const server_id& sid);
-        void server_shutdown(rsm_context* ctx,
-                             const server_id& sid);
-        void server_kill(rsm_context* ctx,
-                         const server_id& sid);
-        void server_forget(rsm_context* ctx,
-                           const server_id& sid);
-        void server_suspect(rsm_context* ctx,
-                            const server_id& sid);
-        void report_disconnect(rsm_context* ctx,
-                               const server_id& sid, uint64_t version);
-
-    // space management
-    public:
-        void space_add(rsm_context* ctx, const space& s);
-        void space_rm(rsm_context* ctx, const char* name);
-        void space_mv(rsm_context* ctx, const char* src, const char* dst);
-
-    // index management
-    public:
-        void index_add(rsm_context* ctx, const char* space, const char* attr);
-        void index_rm(rsm_context* ctx, index_id ii);
-
-    // transfers management
-    public:
-        void transfer_go_live(rsm_context* ctx,
-                              const transfer_id& xid);
-        void transfer_complete(rsm_context* ctx,
-                               const transfer_id& xid);
-
-    // config management
-    public:
-        void config_get(rsm_context* ctx);
-        void config_ack(rsm_context* ctx,
-                        const server_id& sid, uint64_t version);
-        void config_stable(rsm_context* ctx,
-                           const server_id& sid, uint64_t version);
-
-    // checkpoint management
-    public:
-        void checkpoint(rsm_context* ctx);
-        void checkpoint_stable(rsm_context* ctx,
-                               const server_id& sid,
-                               uint64_t config,
-                               uint64_t number);
-        void checkpoints(rsm_context* ctx);
-
-    // periodic
-    public:
-        void periodic(rsm_context* ctx);
-
-    // debug
-    public:
-        void debug_dump(rsm_context* ctx);
-
-    // backup/restore
-    public:
-        static coordinator* recreate(rsm_context* ctx,
-                                     const char* data, size_t data_sz);
-        int snapshot(rsm_context* ctx,
-                     char** data, size_t* data_sz);
-
-    private:
-        typedef e::compat::shared_ptr<space> space_ptr;
-        typedef std::map<std::string, space_ptr > space_map_t;
-        struct transfer_sorter;
-
-    // utilities
-    private:
-        // servers
-        server* new_server(const server_id& sid);
-        server* get_server(const server_id& sid);
-        // replica sets
-        bool in_permutation(const server_id& sid);
-        void add_permutation(const server_id& sid);
-        void remove_permutation(const server_id& sid);
-        void rebalance_replica_sets(rsm_context* ctx);
-        // hyperspace
-        void initial_space_layout(rsm_context* ctx,
-                                  space* s);
-        region* get_region(const region_id& rid);
-        // intents
-        void setup_intents(rsm_context* ctx,
-                           const std::vector<replica_set>& replica_sets,
-                           space* s, bool skip_transfers);
-        // looks up region_intent* ri, removing any possibility of the user
-        // using an invalid pointer
-        void converge_intent(rsm_context* ctx,
-                             region* reg);
-        // ri and m_intents may be changed after this call
-        void converge_intent(rsm_context* ctx,
-                             region* reg, region_intent* ri);
-        region_intent* new_region_intent(const region_id& rid);
-        region_intent* get_region_intent(const region_id& rid);
-        void del_region_intent(const region_id& rid);
-        void remove_offline(const region_id& rid);
-        void remove_offline(const server_id& sid);
-        // transfers
-        transfer* new_transfer(region* reg, const server_id& si);
-        transfer* get_transfer(const region_id& rid);
-        transfer* get_transfer(const transfer_id& xid);
-        void del_transfer(const transfer_id& xid);
-        // configuration
-        void check_ack_condition(rsm_context* ctx);
-        void check_stable_condition(rsm_context* ctx);
-        void generate_next_configuration(rsm_context* ctx);
-        void generate_cached_configuration(rsm_context* ctx);
-        void prioritized_transfer_subset(std::vector<transfer>* transfers);
-        void servers_in_configuration(std::vector<server_id>* sids);
-        void regions_in_space(space_ptr s, std::vector<region_id>* rids);
-        // checkpoints
-        void check_checkpoint_stable_condition(rsm_context* ctx, bool reissue);
-        void broadcast_checkpoint_information(rsm_context* ctx);
-
-    private:
-        // meta state
-        uint64_t m_cluster;
-        uint64_t m_counter;
-        uint64_t m_version;
-        uint64_t m_flags;
-        // servers
-        std::vector<server> m_servers;
-        // replica sets
-        std::vector<server_id> m_permutation;
-        std::vector<server_id> m_spares;
-        uint64_t m_desired_spares;
-        // spaces
-        space_map_t m_spaces;
-        // intents
-        std::vector<region_intent> m_intents;
-        std::vector<space_id> m_deferred_init;
-        std::vector<offline_server> m_offline;
-        // transfers
-        std::vector<transfer> m_transfers;
-        // barriers
-        uint64_t m_config_ack_through;
-        server_barrier m_config_ack_barrier;
-        uint64_t m_config_stable_through;
-        server_barrier m_config_stable_barrier;
-        // checkpoints
-        uint64_t m_checkpoint;
-        uint64_t m_checkpoint_stable_through;
-        uint64_t m_checkpoint_gc_through;
-        server_barrier m_checkpoint_stable_barrier;
-        // cached config
-        std::auto_ptr<e::buffer> m_latest_config;
-        std::auto_ptr<e::buffer> m_response;
-
-    private:
-        coordinator(const coordinator&);
-        coordinator& operator = (const coordinator&);
+public:
+	coordinator();
+	~coordinator() throw ();
+
+	// identity
+public:
+	void init(rsm_context *ctx, uint64_t token);
+	uint64_t cluster() const { return m_cluster; }
+
+	// cluster management
+public:
+	void read_only(rsm_context *ctx, bool ro);
+	void fault_tolerance(rsm_context *ctx,
+	                     const char *space, uint64_t consistency);
+
+	// server management
+public:
+	void server_register(rsm_context *ctx,
+	                     const server_id &sid,
+	                     const po6::net::location &bind_to);
+	void server_online(rsm_context *ctx,
+	                   const server_id &sid,
+	                   const po6::net::location *bind_to);
+	void server_offline(rsm_context *ctx,
+	                    const server_id &sid);
+	void server_shutdown(rsm_context *ctx,
+	                     const server_id &sid);
+	void server_kill(rsm_context *ctx,
+	                 const server_id &sid);
+	void server_forget(rsm_context *ctx,
+	                   const server_id &sid);
+	void server_suspect(rsm_context *ctx,
+	                    const server_id &sid);
+	void report_disconnect(rsm_context *ctx,
+	                       const server_id &sid, uint64_t version);
+
+	// space management
+public:
+	void space_add(rsm_context *ctx, const space &s);
+	void space_rm(rsm_context *ctx, const char *name);
+	void space_mv(rsm_context *ctx, const char *src, const char *dst);
+
+	// index management
+public:
+	void index_add(rsm_context *ctx, const char *space, const char *attr);
+	void index_rm(rsm_context *ctx, index_id ii);
+
+	// transfers management
+public:
+	void transfer_go_live(rsm_context *ctx,
+	                      const transfer_id &xid);
+	void transfer_complete(rsm_context *ctx,
+	                       const transfer_id &xid);
+
+	// config management
+public:
+	void config_get(rsm_context *ctx);
+	void config_ack(rsm_context *ctx,
+	                const server_id &sid, uint64_t version);
+	void config_stable(rsm_context *ctx,
+	                   const server_id &sid, uint64_t version);
+
+	// checkpoint management
+public:
+	void checkpoint(rsm_context *ctx);
+	void checkpoint_stable(rsm_context *ctx,
+	                       const server_id &sid,
+	                       uint64_t config,
+	                       uint64_t number);
+	void checkpoints(rsm_context *ctx);
+
+	// periodic
+public:
+	void periodic(rsm_context *ctx);
+
+	// debug
+public:
+	void debug_dump(rsm_context *ctx);
+
+	// backup/restore
+public:
+	static coordinator *recreate(rsm_context *ctx,
+	                             const char *data, size_t data_sz);
+	int snapshot(rsm_context *ctx,
+	             char **data, size_t *data_sz);
+
+private:
+	typedef e::compat::shared_ptr<space> space_ptr;
+	typedef std::map<std::string, space_ptr > space_map_t;
+	struct transfer_sorter;
+
+	// utilities
+private:
+	// servers
+	server *new_server(const server_id &sid);
+	server *get_server(const server_id &sid);
+	// replica sets
+	bool in_permutation(const server_id &sid);
+	void add_permutation(const server_id &sid);
+	void remove_permutation(const server_id &sid);
+	void rebalance_replica_sets(rsm_context *ctx);
+	// hyperspace
+	void initial_space_layout(rsm_context *ctx,
+	                          space *s);
+	region *get_region(const region_id &rid);
+	// intents
+	void setup_intents(rsm_context *ctx,
+	                   const std::vector<replica_set> &replica_sets,
+	                   space *s, bool skip_transfers);
+	// looks up region_intent* ri, removing any possibility of the user
+	// using an invalid pointer
+	void converge_intent(rsm_context *ctx,
+	                     region *reg);
+	// ri and m_intents may be changed after this call
+	void converge_intent(rsm_context *ctx,
+	                     region *reg, region_intent *ri);
+	region_intent *new_region_intent(const region_id &rid);
+	region_intent *get_region_intent(const region_id &rid);
+	void del_region_intent(const region_id &rid);
+	void remove_offline(const region_id &rid);
+	void remove_offline(const server_id &sid);
+	// transfers
+	transfer *new_transfer(region *reg, const server_id &si);
+	transfer *get_transfer(const region_id &rid);
+	transfer *get_transfer(const transfer_id &xid);
+	void del_transfer(const transfer_id &xid);
+	// configuration
+	void check_ack_condition(rsm_context *ctx);
+	void check_stable_condition(rsm_context *ctx);
+	void generate_next_configuration(rsm_context *ctx);
+	void generate_cached_configuration(rsm_context *ctx);
+	void prioritized_transfer_subset(std::vector<transfer> *transfers);
+	void servers_in_configuration(std::vector<server_id> *sids);
+	void regions_in_space(space_ptr s, std::vector<region_id> *rids);
+	// checkpoints
+	void check_checkpoint_stable_condition(rsm_context *ctx, bool reissue);
+	void broadcast_checkpoint_information(rsm_context *ctx);
+
+private:
+	// meta state
+	uint64_t m_cluster;
+	uint64_t m_counter;
+	uint64_t m_version;
+	uint64_t m_flags;
+	// servers
+	std::vector<server> m_servers;
+	// replica sets
+	std::vector<server_id> m_permutation;
+	std::vector<server_id> m_spares;
+	uint64_t m_desired_spares;
+	// spaces
+	space_map_t m_spaces;
+	// intents
+	std::vector<region_intent> m_intents;
+	std::vector<space_id> m_deferred_init;
+	std::vector<offline_server> m_offline;
+	// transfers
+	std::vector<transfer> m_transfers;
+	// barriers
+	uint64_t m_config_ack_through;
+	server_barrier m_config_ack_barrier;
+	uint64_t m_config_stable_through;
+	server_barrier m_config_stable_barrier;
+	// checkpoints
+	uint64_t m_checkpoint;
+	uint64_t m_checkpoint_stable_through;
+	uint64_t m_checkpoint_gc_through;
+	server_barrier m_checkpoint_stable_barrier;
+	// cached config
+	std::auto_ptr<e::buffer> m_latest_config;
+	std::auto_ptr<e::buffer> m_response;
+
+private:
+	coordinator(const coordinator &);
+	coordinator &operator = (const coordinator &);
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/coordinator/offline_server.h b/coordinator/offline_server.h
index ded70552e..1ccc34317 100644
--- a/coordinator/offline_server.h
+++ b/coordinator/offline_server.h
@@ -35,52 +35,52 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class offline_server
 {
-    public:
-        offline_server();
-        offline_server(const region_id& id, const server_id& sid);
-        offline_server(const offline_server& other);
+public:
+	offline_server();
+	offline_server(const region_id &id, const server_id &sid);
+	offline_server(const offline_server &other);
 
-    public:
-        region_id id;
-        server_id sid;
+public:
+	region_id id;
+	server_id sid;
 };
 
 inline size_t
-pack_size(const offline_server& os)
+pack_size(const offline_server &os)
 {
-    return pack_size(os.id) + pack_size(os.sid);
+	return pack_size(os.id) + pack_size(os.sid);
 }
 
 inline e::packer
-operator << (e::packer pa, const offline_server& os)
+operator << (e::packer pa, const offline_server &os)
 {
-    return pa << os.id << os.sid;
+	return pa << os.id << os.sid;
 }
 
 inline e::unpacker
-operator >> (e::unpacker up, offline_server& os)
+operator >> (e::unpacker up, offline_server &os)
 {
-    return up >> os.id >> os.sid;
+	return up >> os.id >> os.sid;
 }
 
 inline
 offline_server :: offline_server()
-    : id()
-    , sid()
+	: id()
+	, sid()
 {
 }
 
 inline
-offline_server :: offline_server(const region_id& _id, const server_id& _sid)
-    : id(_id)
-    , sid(_sid)
+offline_server :: offline_server(const region_id &_id, const server_id &_sid)
+	: id(_id)
+	, sid(_sid)
 {
 }
 
 inline
-offline_server :: offline_server(const offline_server& other)
-    : id(other.id)
-    , sid(other.sid)
+offline_server :: offline_server(const offline_server &other)
+	: id(other.id)
+	, sid(other.sid)
 {
 }
 
diff --git a/coordinator/region_intent.h b/coordinator/region_intent.h
index 270dc3ba9..d1e871963 100644
--- a/coordinator/region_intent.h
+++ b/coordinator/region_intent.h
@@ -35,73 +35,72 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class region_intent
 {
-    public:
-        region_intent();
-        region_intent(const region_id& id);
-        region_intent(const region_intent&);
-
-    public:
-        region_intent& operator = (const region_intent&);
-
-    public:
-        region_id id;
-        std::vector<server_id> replicas;
-        uint64_t checkpoint;
+public:
+	region_intent();
+	region_intent(const region_id &id);
+	region_intent(const region_intent &);
+
+public:
+	region_intent &operator = (const region_intent &);
+
+public:
+	region_id id;
+	std::vector<server_id> replicas;
+	uint64_t checkpoint;
 };
 
 inline size_t
-pack_size(const region_intent& ri)
+pack_size(const region_intent &ri)
 {
-    return pack_size(ri.id) + pack_size(ri.replicas) + sizeof(ri.checkpoint);
+	return pack_size(ri.id) + pack_size(ri.replicas) + sizeof(ri.checkpoint);
 }
 
 inline e::packer
-operator << (e::packer pa, const region_intent& ri)
+operator << (e::packer pa, const region_intent &ri)
 {
-    return pa << ri.id << ri.replicas << ri.checkpoint;
+	return pa << ri.id << ri.replicas << ri.checkpoint;
 }
 
 inline e::unpacker
-operator >> (e::unpacker up, region_intent& ri)
+operator >> (e::unpacker up, region_intent &ri)
 {
-    return up >> ri.id >> ri.replicas >> ri.checkpoint;
+	return up >> ri.id >> ri.replicas >> ri.checkpoint;
 }
 
 inline
 region_intent :: region_intent()
-    : id()
-    , replicas()
-    , checkpoint(0)
+	: id()
+	, replicas()
+	, checkpoint(0)
 {
 }
 
 inline
-region_intent :: region_intent(const region_id& ri)
-    : id(ri)
-    , replicas()
-    , checkpoint(0)
+region_intent :: region_intent(const region_id &ri)
+	: id(ri)
+	, replicas()
+	, checkpoint(0)
 {
 }
 
 inline
-region_intent :: region_intent(const region_intent& other)
-    : id(other.id)
-    , replicas(other.replicas)
-    , checkpoint(other.checkpoint)
+region_intent :: region_intent(const region_intent &other)
+	: id(other.id)
+	, replicas(other.replicas)
+	, checkpoint(other.checkpoint)
 {
 }
 
-inline region_intent&
-region_intent :: operator = (const region_intent& rhs)
+inline region_intent &
+region_intent :: operator = (const region_intent &rhs)
 {
-    if (this != &rhs)
-    {
-        id = rhs.id;
-        replicas = rhs.replicas;
-        checkpoint = rhs.checkpoint;
-    }
-
-    return *this;
+	if (this != &rhs)
+	{
+		id = rhs.id;
+		replicas = rhs.replicas;
+		checkpoint = rhs.checkpoint;
+	}
+	return *this;
 }
 
 END_HYPERDEX_NAMESPACE
diff --git a/coordinator/replica_sets.cc b/coordinator/replica_sets.cc
index 58f125fee..9e721691c 100644
--- a/coordinator/replica_sets.cc
+++ b/coordinator/replica_sets.cc
@@ -40,145 +40,134 @@ namespace
 
 void
 _small_replica_sets(uint64_t, uint64_t,
-                    const std::vector<server_id>& permutation,
-                    const std::vector<server_id>& servers,
-                    std::vector<server_id>* replica_storage,
-                    std::vector<replica_set>* replica_sets)
+                    const std::vector<server_id> &permutation,
+                    const std::vector<server_id> &servers,
+                    std::vector<server_id> *replica_storage,
+                    std::vector<replica_set> *replica_sets)
 {
-    for (size_t i = 0; i < permutation.size(); ++i)
-    {
-        size_t repls = 0;
-        size_t start = replica_storage->size();
-
-        for (size_t j = 0; j < permutation.size(); ++j)
-        {
-            size_t idx = (i + j) % permutation.size();
-
-            if (std::binary_search(servers.begin(),
-                                   servers.end(),
-                                   permutation[idx]))
-            {
-                replica_storage->push_back(permutation[idx]);
-                ++repls;
-            }
-        }
-
-        replica_sets->push_back(replica_set(start, repls, replica_storage));
-    }
+	for (size_t i = 0; i < permutation.size(); ++i)
+	{
+		size_t repls = 0;
+		size_t start = replica_storage->size();
+		for (size_t j = 0; j < permutation.size(); ++j)
+		{
+			size_t idx = (i + j) % permutation.size();
+			if (std::binary_search(servers.begin(),
+			                       servers.end(),
+			                       permutation[idx]))
+			{
+				replica_storage->push_back(permutation[idx]);
+				++repls;
+			}
+		}
+		replica_sets->push_back(replica_set(start, repls, replica_storage));
+	}
 }
 
 void
 _permutation_replica_sets(uint64_t R, uint64_t P,
-                          const std::vector<server_id>& permutation,
-                          const std::vector<server_id>& servers,
-                          std::vector<server_id>* replica_storage,
-                          std::vector<replica_set>* replica_sets)
+                          const std::vector<server_id> &permutation,
+                          const std::vector<server_id> &servers,
+                          std::vector<server_id> *replica_storage,
+                          std::vector<replica_set> *replica_sets)
 {
-    for (size_t n = 0; n < permutation.size(); ++n)
-    {
-        for (size_t p = 1; p <= P; ++p)
-        {
-            if (n + p * (R - 1) >= permutation.size())
-            {
-                break;
-            }
-
-            size_t repls = 0;
-            size_t start = replica_storage->size();
-
-            for (size_t r = 0; r < R; ++r)
-            {
-                size_t idx = n + p * r;
-
-                if (std::binary_search(servers.begin(),
-                                       servers.end(),
-                                       permutation[idx]))
-                {
-                    replica_storage->push_back(permutation[idx]);
-                    ++repls;
-                }
-            }
-
-            replica_sets->push_back(replica_set(start, repls, replica_storage));
-        }
-    }
+	for (size_t n = 0; n < permutation.size(); ++n)
+	{
+		for (size_t p = 1; p <= P; ++p)
+		{
+			if (n + p * (R - 1) >= permutation.size())
+			{
+				break;
+			}
+			size_t repls = 0;
+			size_t start = replica_storage->size();
+			for (size_t r = 0; r < R; ++r)
+			{
+				size_t idx = n + p * r;
+				if (std::binary_search(servers.begin(),
+				                       servers.end(),
+				                       permutation[idx]))
+				{
+					replica_storage->push_back(permutation[idx]);
+					++repls;
+				}
+			}
+			replica_sets->push_back(replica_set(start, repls, replica_storage));
+		}
+	}
 }
 
 } // namespace
 
 replica_set :: replica_set()
-    : m_start(0)
-    , m_size(0)
-    , m_storage(NULL)
+	: m_start(0)
+	, m_size(0)
+	, m_storage(NULL)
 {
 }
 
 replica_set :: replica_set(size_t start, size_t sz,
-                           std::vector<server_id>* storage)
-    : m_start(start)
-    , m_size(sz)
-    , m_storage(storage)
+                           std::vector<server_id> *storage)
+	: m_start(start)
+	, m_size(sz)
+	, m_storage(storage)
 {
 }
 
-replica_set :: replica_set(const replica_set& other)
-    : m_start(other.m_start)
-    , m_size(other.m_size)
-    , m_storage(other.m_storage)
+replica_set :: replica_set(const replica_set &other)
+	: m_start(other.m_start)
+	, m_size(other.m_size)
+	, m_storage(other.m_storage)
 {
 }
 
 size_t
 replica_set :: size() const
 {
-    return m_size;
+	return m_size;
 }
 
 server_id
 replica_set :: operator [] (size_t idx) const
 {
-    assert(idx < m_size);
-    return (*m_storage)[m_start + idx];
+	assert(idx < m_size);
+	return (*m_storage)[m_start + idx];
 }
 
-replica_set&
-replica_set :: operator = (const replica_set& rhs)
+replica_set &
+replica_set :: operator = (const replica_set &rhs)
 {
-    m_start = rhs.m_start;
-    m_size = rhs.m_size;
-    m_storage = rhs.m_storage;
-    return *this;
+	m_start = rhs.m_start;
+	m_size = rhs.m_size;
+	m_storage = rhs.m_storage;
+	return *this;
 }
 
 void
 hyperdex :: compute_replica_sets(uint64_t R, uint64_t P,
-                                 const std::vector<server_id>& permutation,
-                                 const std::vector<server>& _servers,
-                                 std::vector<server_id>* replica_storage,
-                                 std::vector<replica_set>* replica_sets)
+                                 const std::vector<server_id> &permutation,
+                                 const std::vector<server> &_servers,
+                                 std::vector<server_id> *replica_storage,
+                                 std::vector<replica_set> *replica_sets)
 {
-    assert(R > 0);
-    replica_storage->clear();
-    replica_sets->clear();
-
-    std::vector<server_id> servers;
-
-    for (size_t i = 0; i < _servers.size(); ++i)
-    {
-        if (_servers[i].state == server::AVAILABLE)
-        {
-            servers.push_back(_servers[i].id);
-        }
-    }
-
-    std::sort(servers.begin(), servers.end());
-
-    if (permutation.size() <= R)
-    {
-        _small_replica_sets(R, P, permutation, servers, replica_storage, replica_sets);
-    }
-    else
-    {
-        _permutation_replica_sets(R, P, permutation, servers, replica_storage, replica_sets);
-    }
+	assert(R > 0);
+	replica_storage->clear();
+	replica_sets->clear();
+	std::vector<server_id> servers;
+	for (size_t i = 0; i < _servers.size(); ++i)
+	{
+		if (_servers[i].state == server::AVAILABLE)
+		{
+			servers.push_back(_servers[i].id);
+		}
+	}
+	std::sort(servers.begin(), servers.end());
+	if (permutation.size() <= R)
+	{
+		_small_replica_sets(R, P, permutation, servers, replica_storage, replica_sets);
+	}
+	else
+	{
+		_permutation_replica_sets(R, P, permutation, servers, replica_storage, replica_sets);
+	}
 }
diff --git a/coordinator/replica_sets.h b/coordinator/replica_sets.h
index c7e366d9d..0c6ae0ddd 100644
--- a/coordinator/replica_sets.h
+++ b/coordinator/replica_sets.h
@@ -37,31 +37,31 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class replica_set
 {
-    public:
-        replica_set();
-        replica_set(size_t start, size_t size,
-                    std::vector<server_id>* storage);
-        replica_set(const replica_set&);
+public:
+	replica_set();
+	replica_set(size_t start, size_t size,
+	            std::vector<server_id> *storage);
+	replica_set(const replica_set &);
 
-    public:
-        size_t size() const;
+public:
+	size_t size() const;
 
-    public:
-        server_id operator [] (size_t idx) const;
-        replica_set& operator = (const replica_set&);
+public:
+	server_id operator [] (size_t idx) const;
+	replica_set &operator = (const replica_set &);
 
-    private:
-        size_t m_start;
-        size_t m_size;
-        std::vector<server_id>* m_storage;
+private:
+	size_t m_start;
+	size_t m_size;
+	std::vector<server_id> *m_storage;
 };
 
 void
 compute_replica_sets(uint64_t R, uint64_t P,
-                     const std::vector<server_id>& permutation,
-                     const std::vector<server>& servers,
-                     std::vector<server_id>* replica_storage,
-                     std::vector<replica_set>* replica_sets);
+                     const std::vector<server_id> &permutation,
+                     const std::vector<server> &servers,
+                     std::vector<server_id> *replica_storage,
+                     std::vector<replica_set> *replica_sets);
 
 END_HYPERDEX_NAMESPACE
 
diff --git a/coordinator/server_barrier.cc b/coordinator/server_barrier.cc
index 705998846..4847dc997 100644
--- a/coordinator/server_barrier.cc
+++ b/coordinator/server_barrier.cc
@@ -31,9 +31,9 @@
 using hyperdex::server_barrier;
 
 server_barrier :: server_barrier()
-    : m_versions()
+	: m_versions()
 {
-    m_versions.push_back(std::make_pair(uint64_t(0), std::vector<server_id>()));
+	m_versions.push_back(std::make_pair(uint64_t(0), std::vector<server_id>()));
 }
 
 server_barrier :: ~server_barrier() throw ()
@@ -43,122 +43,111 @@ server_barrier :: ~server_barrier() throw ()
 uint64_t
 server_barrier :: min_version() const
 {
-    return m_versions.front().first;
+	return m_versions.front().first;
 }
 
 void
 server_barrier :: new_version(uint64_t version,
-                              const std::vector<server_id>& servers)
+                              const std::vector<server_id> &servers)
 {
-    assert(!m_versions.empty());
-    assert(version > 0);
-    assert(m_versions.back().first < version);
-    m_versions.push_back(std::make_pair(version, servers));
-    maybe_clear_prefix();
+	assert(!m_versions.empty());
+	assert(version > 0);
+	assert(m_versions.back().first < version);
+	m_versions.push_back(std::make_pair(version, servers));
+	maybe_clear_prefix();
 }
 
 void
-server_barrier :: pass(uint64_t version, const server_id& sid)
+server_barrier :: pass(uint64_t version, const server_id &sid)
 {
-    for (version_list_t::iterator it = m_versions.begin();
-            it != m_versions.end(); ++it)
-    {
-        if (it->first < version)
-        {
-            continue;
-        }
-        else if (it->first > version)
-        {
-            break;
-        }
-
-        assert(it->first == version);
-
-        for (size_t i = 0; i < it->second.size(); )
-        {
-            if (it->second[i] == sid)
-            {
-                it->second[i] = it->second.back();
-                it->second.pop_back();
-            }
-            else
-            {
-                ++i;
-            }
-        }
-
-        maybe_clear_prefix();
-        return;
-    }
+	for (version_list_t::iterator it = m_versions.begin();
+	     it != m_versions.end(); ++it)
+	{
+		if (it->first < version)
+		{
+			continue;
+		}
+		else if (it->first > version)
+		{
+			break;
+		}
+		assert(it->first == version);
+		for (size_t i = 0; i < it->second.size(); )
+		{
+			if (it->second[i] == sid)
+			{
+				it->second[i] = it->second.back();
+				it->second.pop_back();
+			}
+			else
+			{
+				++i;
+			}
+		}
+		maybe_clear_prefix();
+		return;
+	}
 }
 
 void
 server_barrier :: maybe_clear_prefix()
 {
-    version_list_t::iterator last_empty = m_versions.end();
-
-    for (version_list_t::iterator it = m_versions.begin();
-            it != m_versions.end(); ++it)
-    {
-        if (it->second.empty())
-        {
-            last_empty = it;
-        }
-    }
-
-    if (last_empty != m_versions.end())
-    {
-        while (m_versions.begin() != last_empty)
-        {
-            m_versions.pop_front();
-        }
-    }
+	version_list_t::iterator last_empty = m_versions.end();
+	for (version_list_t::iterator it = m_versions.begin();
+	     it != m_versions.end(); ++it)
+	{
+		if (it->second.empty())
+		{
+			last_empty = it;
+		}
+	}
+	if (last_empty != m_versions.end())
+	{
+		while (m_versions.begin() != last_empty)
+		{
+			m_versions.pop_front();
+		}
+	}
 }
 
 size_t
-hyperdex :: pack_size(const server_barrier& ri)
+hyperdex :: pack_size(const server_barrier &ri)
 {
-    typedef server_barrier::version_list_t version_list_t;
-    size_t sz = sizeof(uint32_t);
-
-    for (version_list_t::const_iterator it = ri.m_versions.begin();
-            it != ri.m_versions.end(); ++it)
-    {
-        sz += sizeof(uint64_t) + pack_size(it->second);
-    }
-
-    return sz;
+	typedef server_barrier::version_list_t version_list_t;
+	size_t sz = sizeof(uint32_t);
+	for (version_list_t::const_iterator it = ri.m_versions.begin();
+	     it != ri.m_versions.end(); ++it)
+	{
+		sz += sizeof(uint64_t) + pack_size(it->second);
+	}
+	return sz;
 }
 
 e::packer
-hyperdex :: operator << (e::packer pa, const server_barrier& ri)
+hyperdex :: operator << (e::packer pa, const server_barrier &ri)
 {
-    typedef server_barrier::version_list_t version_list_t;
-    uint32_t x = ri.m_versions.size();
-    pa = pa << x;
-
-    for (version_list_t::const_iterator it = ri.m_versions.begin();
-            it != ri.m_versions.end(); ++it)
-    {
-        pa = pa << it->first << it->second;
-    }
-
-    return pa;
+	typedef server_barrier::version_list_t version_list_t;
+	uint32_t x = ri.m_versions.size();
+	pa = pa << x;
+	for (version_list_t::const_iterator it = ri.m_versions.begin();
+	     it != ri.m_versions.end(); ++it)
+	{
+		pa = pa << it->first << it->second;
+	}
+	return pa;
 }
 
 e::unpacker
-hyperdex :: operator >> (e::unpacker up, server_barrier& ri)
+hyperdex :: operator >> (e::unpacker up, server_barrier &ri)
 {
-    typedef server_barrier::version_t version_t;
-    uint32_t x = 0;
-    up = up >> x;
-
-    for (size_t i = 0; i < x && !up.error(); ++i)
-    {
-        ri.m_versions.push_back(version_t());
-        version_t& v(ri.m_versions.back());
-        up = up >> v.first >> v.second;
-    }
-
-    return up;
+	typedef server_barrier::version_t version_t;
+	uint32_t x = 0;
+	up = up >> x;
+	for (size_t i = 0; i < x && !up.error(); ++i)
+	{
+		ri.m_versions.push_back(version_t());
+		version_t &v(ri.m_versions.back());
+		up = up >> v.first >> v.second;
+	}
+	return up;
 }
diff --git a/coordinator/server_barrier.h b/coordinator/server_barrier.h
index 54bbb94b8..551ec8e51 100644
--- a/coordinator/server_barrier.h
+++ b/coordinator/server_barrier.h
@@ -42,34 +42,34 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class server_barrier
 {
-    public:
-        server_barrier();
-        ~server_barrier() throw ();
+public:
+	server_barrier();
+	~server_barrier() throw ();
 
-    public:
-        uint64_t min_version() const;
-        void new_version(uint64_t version,
-                         const std::vector<server_id>& servers);
-        void pass(uint64_t version, const server_id& sid);
+public:
+	uint64_t min_version() const;
+	void new_version(uint64_t version,
+	                 const std::vector<server_id> &servers);
+	void pass(uint64_t version, const server_id &sid);
 
-    private:
-        void maybe_clear_prefix();
+private:
+	void maybe_clear_prefix();
 
-    private:
-        friend size_t pack_size(const server_barrier& ri);
-        friend e::packer operator << (e::packer pa, const server_barrier& ri);
-        friend e::unpacker operator >> (e::unpacker up, server_barrier& ri);
-        typedef std::pair<uint64_t, std::vector<server_id> > version_t;
-        typedef std::list<version_t> version_list_t;
-        version_list_t m_versions;
+private:
+	friend size_t pack_size(const server_barrier &ri);
+	friend e::packer operator << (e::packer pa, const server_barrier &ri);
+	friend e::unpacker operator >> (e::unpacker up, server_barrier &ri);
+	typedef std::pair<uint64_t, std::vector<server_id> > version_t;
+	typedef std::list<version_t> version_list_t;
+	version_list_t m_versions;
 };
 
 size_t
-pack_size(const server_barrier& ri);
+pack_size(const server_barrier &ri);
 e::packer
-operator << (e::packer pa, const server_barrier& ri);
+operator << (e::packer pa, const server_barrier &ri);
 e::unpacker
-operator >> (e::unpacker up, server_barrier& ri);
+operator >> (e::unpacker up, server_barrier &ri);
 
 END_HYPERDEX_NAMESPACE
 
diff --git a/coordinator/symtable.c b/coordinator/symtable.c
index ae124b71c..8f0066ae0 100644
--- a/coordinator/symtable.c
+++ b/coordinator/symtable.c
@@ -36,36 +36,38 @@
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-pedantic"
 
-struct state_machine HYPERDEX_API rsm = {
-    hyperdex_coordinator_create,
-    hyperdex_coordinator_recreate,
-    hyperdex_coordinator_snapshot,
-    {{"config_get", hyperdex_coordinator_config_get},
-     {"config_ack", hyperdex_coordinator_config_ack},
-     {"config_stable", hyperdex_coordinator_config_stable},
-     {"server_register", hyperdex_coordinator_server_register},
-     {"server_online", hyperdex_coordinator_server_online},
-     {"server_offline", hyperdex_coordinator_server_offline},
-     {"server_shutdown", hyperdex_coordinator_server_shutdown},
-     {"server_kill", hyperdex_coordinator_server_kill},
-     {"server_forget", hyperdex_coordinator_server_forget},
-     {"server_suspect", hyperdex_coordinator_server_suspect},
-     {"report_disconnect", hyperdex_coordinator_report_disconnect},
-     {"space_add", hyperdex_coordinator_space_add},
-     {"space_rm", hyperdex_coordinator_space_rm},
-     {"space_mv", hyperdex_coordinator_space_mv},
-     {"index_add", hyperdex_coordinator_index_add},
-     {"index_rm", hyperdex_coordinator_index_rm},
-     {"transfer_go_live", hyperdex_coordinator_transfer_go_live},
-     {"transfer_complete", hyperdex_coordinator_transfer_complete},
-     {"checkpoint_stable", hyperdex_coordinator_checkpoint_stable},
-     {"periodic", hyperdex_coordinator_periodic},
-     {"read_only", hyperdex_coordinator_read_only},
-     {"fault_tolerance", hyperdex_coordinator_fault_tolerance},
-     {"checkpoints", hyperdex_coordinator_checkpoints},
-     {"debug_dump", hyperdex_coordinator_debug_dump},
-     {"init", hyperdex_coordinator_init},
-     {NULL, NULL}}
+struct state_machine HYPERDEX_API rsm =
+{
+	hyperdex_coordinator_create,
+	hyperdex_coordinator_recreate,
+	hyperdex_coordinator_snapshot,
+	{	{"config_get", hyperdex_coordinator_config_get},
+		{"config_ack", hyperdex_coordinator_config_ack},
+		{"config_stable", hyperdex_coordinator_config_stable},
+		{"server_register", hyperdex_coordinator_server_register},
+		{"server_online", hyperdex_coordinator_server_online},
+		{"server_offline", hyperdex_coordinator_server_offline},
+		{"server_shutdown", hyperdex_coordinator_server_shutdown},
+		{"server_kill", hyperdex_coordinator_server_kill},
+		{"server_forget", hyperdex_coordinator_server_forget},
+		{"server_suspect", hyperdex_coordinator_server_suspect},
+		{"report_disconnect", hyperdex_coordinator_report_disconnect},
+		{"space_add", hyperdex_coordinator_space_add},
+		{"space_rm", hyperdex_coordinator_space_rm},
+		{"space_mv", hyperdex_coordinator_space_mv},
+		{"index_add", hyperdex_coordinator_index_add},
+		{"index_rm", hyperdex_coordinator_index_rm},
+		{"transfer_go_live", hyperdex_coordinator_transfer_go_live},
+		{"transfer_complete", hyperdex_coordinator_transfer_complete},
+		{"checkpoint_stable", hyperdex_coordinator_checkpoint_stable},
+		{"periodic", hyperdex_coordinator_periodic},
+		{"read_only", hyperdex_coordinator_read_only},
+		{"fault_tolerance", hyperdex_coordinator_fault_tolerance},
+		{"checkpoints", hyperdex_coordinator_checkpoints},
+		{"debug_dump", hyperdex_coordinator_debug_dump},
+		{"init", hyperdex_coordinator_init},
+		{NULL, NULL}
+	}
 };
 
 #pragma GCC diagnostic pop
diff --git a/coordinator/transitions.cc b/coordinator/transitions.cc
index 3aa22de6e..42123f8d1 100644
--- a/coordinator/transitions.cc
+++ b/coordinator/transitions.cc
@@ -42,382 +42,370 @@
 using namespace hyperdex;
 
 #define PROTECT_UNINITIALIZED \
-    coordinator* c = static_cast<coordinator*>(obj); \
-    do \
-    { \
-        if (c->cluster() == 0) \
-        { \
-            rsm_log(ctx, "cluster not initialized\n"); \
-            return generate_response(ctx, hyperdex::COORD_UNINITIALIZED); \
-        } \
-    } \
-    while (0)
+	coordinator* c = static_cast<coordinator*>(obj); \
+	do \
+	{ \
+		if (c->cluster() == 0) \
+		{ \
+			rsm_log(ctx, "cluster not initialized\n"); \
+			return generate_response(ctx, hyperdex::COORD_UNINITIALIZED); \
+		} \
+	} \
+	while (0)
 
 #define CHECK_UNPACK(MSGTYPE) \
-    do \
-    { \
-        if (up.error() || up.remain()) \
-        { \
-            rsm_log(ctx, "received malformed \"" #MSGTYPE "\" message\n"); \
-            return generate_response(ctx, hyperdex::COORD_MALFORMED); \
-        } \
-    } while (0)
+	do \
+	{ \
+		if (up.error() || up.remain()) \
+		{ \
+			rsm_log(ctx, "received malformed \"" #MSGTYPE "\" message\n"); \
+			return generate_response(ctx, hyperdex::COORD_MALFORMED); \
+		} \
+	} while (0)
 
 extern "C"
 {
 
-void*
-hyperdex_coordinator_create(struct rsm_context* ctx)
-{
-    rsm_cond_create(ctx, "config");
-    rsm_cond_create(ctx, "ack");
-    rsm_cond_create(ctx, "stable");
-    rsm_cond_create(ctx, "checkpoint");
-    return new (std::nothrow) coordinator();
-}
-
-void*
-hyperdex_coordinator_recreate(struct rsm_context* ctx,
-                              const char* data, size_t data_sz)
-{
-    return coordinator::recreate(ctx, data, data_sz);
-}
-
-int
-hyperdex_coordinator_snapshot(struct rsm_context* ctx,
-                              void* obj, char** data, size_t* data_sz)
-{
-    coordinator* c = static_cast<coordinator*>(obj);
-    return c->snapshot(ctx, data, data_sz);
-}
-
-void
-hyperdex_coordinator_init(struct rsm_context* ctx,
-                          void* obj, const char* data, size_t data_sz)
-{
-    coordinator* c = static_cast<coordinator*>(obj);
-
-    std::string id(data, data_sz);
-    uint64_t cluster = strtoull(id.c_str(), NULL, 0);
-    c->init(ctx, cluster);
-}
-
-void
-hyperdex_coordinator_read_only(struct rsm_context* ctx,
-                               void* obj, const char* data, size_t data_sz)
-{
-    PROTECT_UNINITIALIZED;
-    uint8_t set;
-    e::unpacker up(data, data_sz);
-    up = up >> set;
-    CHECK_UNPACK(read_only);
-    c->read_only(ctx, set != 0);
-}
-
-void
-hyperdex_coordinator_fault_tolerance(struct rsm_context* ctx,
-                                     void* obj, const char* data, size_t data_sz)
-{
-    PROTECT_UNINITIALIZED;
-    uint64_t ft;
-    const char* ft_ptr = data + data_sz - sizeof(uint64_t);
-    e::unpacker up(ft_ptr, sizeof(uint64_t));
-    up = up >> ft;
-    CHECK_UNPACK(fault_tolerance);
-    c->fault_tolerance(ctx, data, ft);
-}
-
-void
-hyperdex_coordinator_config_get(struct rsm_context* ctx,
-                                void* obj, const char*, size_t)
-{
-    PROTECT_UNINITIALIZED;
-    c->config_get(ctx);
-}
-
-void
-hyperdex_coordinator_config_ack(struct rsm_context* ctx,
-                                void* obj, const char* data, size_t data_sz)
-{
-    PROTECT_UNINITIALIZED;
-    server_id sid;
-    uint64_t version;
-    e::unpacker up(data, data_sz);
-    up = up >> sid >> version;
-    CHECK_UNPACK(config_ack);
-    c->config_ack(ctx, sid, version);
-}
-
-void
-hyperdex_coordinator_config_stable(struct rsm_context* ctx,
-                                   void* obj, const char* data, size_t data_sz)
-{
-    PROTECT_UNINITIALIZED;
-    server_id sid;
-    uint64_t version;
-    e::unpacker up(data, data_sz);
-    up = up >> sid >> version;
-    CHECK_UNPACK(config_stable);
-    c->config_stable(ctx, sid, version);
-}
-
-void
-hyperdex_coordinator_server_register(struct rsm_context* ctx,
-                                     void* obj, const char* data, size_t data_sz)
-{
-    PROTECT_UNINITIALIZED;
-    server_id sid;
-    po6::net::location bind_to;
-    e::unpacker up(data, data_sz);
-    up = up >> sid >> bind_to;
-    CHECK_UNPACK(server_register);
-    c->server_register(ctx, sid, bind_to);
-}
-
-void
-hyperdex_coordinator_server_online(struct rsm_context* ctx,
-                                   void* obj, const char* data, size_t data_sz)
-{
-    PROTECT_UNINITIALIZED;
-    server_id sid;
-    po6::net::location bind_to;
-    e::unpacker up(data, data_sz);
-    up = up >> sid;
-
-    if (!up.error() && !up.remain())
-    {
-        c->server_online(ctx, sid, NULL);
-    }
-    else
-    {
-        up = up >> bind_to;
-        CHECK_UNPACK(server_online);
-        c->server_online(ctx, sid, &bind_to);
-    }
-}
-
-void
-hyperdex_coordinator_server_offline(struct rsm_context* ctx,
-                                    void* obj, const char* data, size_t data_sz)
-{
-    PROTECT_UNINITIALIZED;
-    server_id sid;
-    e::unpacker up(data, data_sz);
-    up = up >> sid;
-    CHECK_UNPACK(server_offline);
-    c->server_offline(ctx, sid);
-}
-
-void
-hyperdex_coordinator_server_shutdown(struct rsm_context* ctx,
-                                     void* obj, const char* data, size_t data_sz)
-{
-    PROTECT_UNINITIALIZED;
-    server_id sid;
-    e::unpacker up(data, data_sz);
-    up = up >> sid;
-    CHECK_UNPACK(server_shutdown);
-    c->server_shutdown(ctx, sid);
-}
-
-void
-hyperdex_coordinator_server_kill(struct rsm_context* ctx,
-                                 void* obj, const char* data, size_t data_sz)
-{
-    PROTECT_UNINITIALIZED;
-    server_id sid;
-    e::unpacker up(data, data_sz);
-    up = up >> sid;
-    CHECK_UNPACK(server_kill);
-    c->server_kill(ctx, sid);
-}
-
-void
-hyperdex_coordinator_server_forget(struct rsm_context* ctx,
-                                   void* obj, const char* data, size_t data_sz)
-{
-    PROTECT_UNINITIALIZED;
-    server_id sid;
-    e::unpacker up(data, data_sz);
-    up = up >> sid;
-    CHECK_UNPACK(server_forget);
-    c->server_forget(ctx, sid);
-}
-
-void
-hyperdex_coordinator_server_suspect(struct rsm_context* ctx,
-                                    void* obj, const char* data, size_t data_sz)
-{
-    PROTECT_UNINITIALIZED;
-    server_id sid;
-    e::unpacker up(data, data_sz);
-    up = up >> sid;
-    CHECK_UNPACK(server_suspect);
-    c->server_suspect(ctx, sid);
-}
-
-void
-hyperdex_coordinator_report_disconnect(struct rsm_context* ctx,
-                                       void* obj, const char* data, size_t data_sz)
-{
-    PROTECT_UNINITIALIZED;
-    server_id sid;
-    uint64_t version;
-    e::unpacker up(data, data_sz);
-    up = up >> sid >> version;
-    CHECK_UNPACK(report_disconnect);
-    c->report_disconnect(ctx, sid, version);
-}
-
-void
-hyperdex_coordinator_space_add(struct rsm_context* ctx,
-                               void* obj, const char* data, size_t data_sz)
-{
-    PROTECT_UNINITIALIZED;
-    space s;
-    e::unpacker up(data, data_sz);
-    up = up >> s;
-    CHECK_UNPACK(space_add);
-    c->space_add(ctx, s);
-}
-
-void
-hyperdex_coordinator_space_rm(struct rsm_context* ctx,
-                              void* obj, const char* data, size_t data_sz)
-{
-    PROTECT_UNINITIALIZED;
-
-    if (data_sz == 0 || data[data_sz - 1] != '\0')
-    {
-        rsm_log(ctx, "received malformed \"rm_space\" message\n");
-        return generate_response(ctx, COORD_MALFORMED);
-    }
-
-    c->space_rm(ctx, data);
-}
-
-void
-hyperdex_coordinator_space_mv(struct rsm_context* ctx,
-                              void* obj, const char* data, size_t data_sz)
-{
-    PROTECT_UNINITIALIZED;
-
-    if (data_sz < 2 || data[data_sz - 1] != '\0')
-    {
-        rsm_log(ctx, "received malformed \"mv_space\" message\n");
-        return generate_response(ctx, COORD_MALFORMED);
-    }
-
-    const char* src = data;
-    const char* dst = data + strlen(data) + 1;
-
-    if (dst >= data + data_sz)
-    {
-        rsm_log(ctx, "received malformed \"mv_space\" message\n");
-        return generate_response(ctx, COORD_MALFORMED);
-    }
-
-    c->space_mv(ctx, src, dst);
-}
-
-void
-hyperdex_coordinator_index_add(struct rsm_context* ctx,
-                               void* obj, const char* data, size_t data_sz)
-{
-    PROTECT_UNINITIALIZED;
-    const char* space = data;
-    size_t space_sz = strnlen(data, data_sz);
-
-    if (data_sz == 0 || data[data_sz - 1] != '\0' || space_sz + 2 >= data_sz)
-    {
-        rsm_log(ctx, "received malformed \"add_index\" message\n");
-        return generate_response(ctx, COORD_MALFORMED);
-    }
-
-    const char* attr = data + space_sz + 1;
-    size_t attr_sz = strnlen(attr, data_sz - space_sz - 1);
-
-    if (space_sz + attr_sz + 2 != data_sz)
-    {
-        rsm_log(ctx, "received malformed \"add_index\" message\n");
-        return generate_response(ctx, COORD_MALFORMED);
-    }
-
-    c->index_add(ctx, space, attr);
-}
-
-void
-hyperdex_coordinator_index_rm(struct rsm_context* ctx,
-                              void* obj, const char* data, size_t data_sz)
-{
-    PROTECT_UNINITIALIZED;
-    index_id ii;
-    e::unpacker up(data, data_sz);
-    up = up >> ii;
-    CHECK_UNPACK(index_rm);
-    c->index_rm(ctx, ii);
-}
-
-void
-hyperdex_coordinator_transfer_go_live(struct rsm_context* ctx,
-                                      void* obj, const char* data, size_t data_sz)
-{
-    PROTECT_UNINITIALIZED;
-    transfer_id xid;
-    e::unpacker up(data, data_sz);
-    up = up >> xid;
-    CHECK_UNPACK(transfer_go_live);
-    c->transfer_go_live(ctx, xid);
-}
-
-void
-hyperdex_coordinator_transfer_complete(struct rsm_context* ctx,
-                                       void* obj, const char* data, size_t data_sz)
-{
-    PROTECT_UNINITIALIZED;
-    transfer_id xid;
-    e::unpacker up(data, data_sz);
-    up = up >> xid;
-    CHECK_UNPACK(transfer_complete);
-    c->transfer_complete(ctx, xid);
-}
-
-void
-hyperdex_coordinator_checkpoint_stable(struct rsm_context* ctx,
-                                       void* obj, const char* data, size_t data_sz)
-{
-    PROTECT_UNINITIALIZED;
-    server_id sid;
-    uint64_t config;
-    uint64_t checkpoint;
-    e::unpacker up(data, data_sz);
-    up = up >> sid >> config >> checkpoint;
-    CHECK_UNPACK(checkpoint_stable);
-    c->checkpoint_stable(ctx, sid, config, checkpoint);
-}
-
-void
-hyperdex_coordinator_checkpoints(struct rsm_context* ctx,
-                                 void* obj, const char*, size_t)
-{
-    PROTECT_UNINITIALIZED;
-    c->checkpoints(ctx);
-}
-
-void
-hyperdex_coordinator_periodic(struct rsm_context* ctx,
-                              void* obj, const char*, size_t)
-{
-    PROTECT_UNINITIALIZED;
-    c->periodic(ctx);
-}
-
-void
-hyperdex_coordinator_debug_dump(struct rsm_context* ctx,
-                                void* obj, const char*, size_t)
-{
-    PROTECT_UNINITIALIZED;
-    c->debug_dump(ctx);
-}
+	void *
+	hyperdex_coordinator_create(struct rsm_context *ctx)
+	{
+		rsm_cond_create(ctx, "config");
+		rsm_cond_create(ctx, "ack");
+		rsm_cond_create(ctx, "stable");
+		rsm_cond_create(ctx, "checkpoint");
+		return new (std::nothrow) coordinator();
+	}
+
+	void *
+	hyperdex_coordinator_recreate(struct rsm_context *ctx,
+	                              const char *data, size_t data_sz)
+	{
+		return coordinator::recreate(ctx, data, data_sz);
+	}
+
+	int
+	hyperdex_coordinator_snapshot(struct rsm_context *ctx,
+	                              void *obj, char **data, size_t *data_sz)
+	{
+		coordinator *c = static_cast<coordinator *>(obj);
+		return c->snapshot(ctx, data, data_sz);
+	}
+
+	void
+	hyperdex_coordinator_init(struct rsm_context *ctx,
+	                          void *obj, const char *data, size_t data_sz)
+	{
+		coordinator *c = static_cast<coordinator *>(obj);
+		std::string id(data, data_sz);
+		uint64_t cluster = strtoull(id.c_str(), NULL, 0);
+		c->init(ctx, cluster);
+	}
+
+	void
+	hyperdex_coordinator_read_only(struct rsm_context *ctx,
+	                               void *obj, const char *data, size_t data_sz)
+	{
+		PROTECT_UNINITIALIZED;
+		uint8_t set;
+		e::unpacker up(data, data_sz);
+		up = up >> set;
+		CHECK_UNPACK(read_only);
+		c->read_only(ctx, set != 0);
+	}
+
+	void
+	hyperdex_coordinator_fault_tolerance(struct rsm_context *ctx,
+	                                     void *obj, const char *data, size_t data_sz)
+	{
+		PROTECT_UNINITIALIZED;
+		uint64_t ft;
+		const char *ft_ptr = data + data_sz - sizeof(uint64_t);
+		e::unpacker up(ft_ptr, sizeof(uint64_t));
+		up = up >> ft;
+		CHECK_UNPACK(fault_tolerance);
+		c->fault_tolerance(ctx, data, ft);
+	}
+
+	void
+	hyperdex_coordinator_config_get(struct rsm_context *ctx,
+	                                void *obj, const char *, size_t)
+	{
+		PROTECT_UNINITIALIZED;
+		c->config_get(ctx);
+	}
+
+	void
+	hyperdex_coordinator_config_ack(struct rsm_context *ctx,
+	                                void *obj, const char *data, size_t data_sz)
+	{
+		PROTECT_UNINITIALIZED;
+		server_id sid;
+		uint64_t version;
+		e::unpacker up(data, data_sz);
+		up = up >> sid >> version;
+		CHECK_UNPACK(config_ack);
+		c->config_ack(ctx, sid, version);
+	}
+
+	void
+	hyperdex_coordinator_config_stable(struct rsm_context *ctx,
+	                                   void *obj, const char *data, size_t data_sz)
+	{
+		PROTECT_UNINITIALIZED;
+		server_id sid;
+		uint64_t version;
+		e::unpacker up(data, data_sz);
+		up = up >> sid >> version;
+		CHECK_UNPACK(config_stable);
+		c->config_stable(ctx, sid, version);
+	}
+
+	void
+	hyperdex_coordinator_server_register(struct rsm_context *ctx,
+	                                     void *obj, const char *data, size_t data_sz)
+	{
+		PROTECT_UNINITIALIZED;
+		server_id sid;
+		po6::net::location bind_to;
+		e::unpacker up(data, data_sz);
+		up = up >> sid >> bind_to;
+		CHECK_UNPACK(server_register);
+		c->server_register(ctx, sid, bind_to);
+	}
+
+	void
+	hyperdex_coordinator_server_online(struct rsm_context *ctx,
+	                                   void *obj, const char *data, size_t data_sz)
+	{
+		PROTECT_UNINITIALIZED;
+		server_id sid;
+		po6::net::location bind_to;
+		e::unpacker up(data, data_sz);
+		up = up >> sid;
+		if (!up.error() && !up.remain())
+		{
+			c->server_online(ctx, sid, NULL);
+		}
+		else
+		{
+			up = up >> bind_to;
+			CHECK_UNPACK(server_online);
+			c->server_online(ctx, sid, &bind_to);
+		}
+	}
+
+	void
+	hyperdex_coordinator_server_offline(struct rsm_context *ctx,
+	                                    void *obj, const char *data, size_t data_sz)
+	{
+		PROTECT_UNINITIALIZED;
+		server_id sid;
+		e::unpacker up(data, data_sz);
+		up = up >> sid;
+		CHECK_UNPACK(server_offline);
+		c->server_offline(ctx, sid);
+	}
+
+	void
+	hyperdex_coordinator_server_shutdown(struct rsm_context *ctx,
+	                                     void *obj, const char *data, size_t data_sz)
+	{
+		PROTECT_UNINITIALIZED;
+		server_id sid;
+		e::unpacker up(data, data_sz);
+		up = up >> sid;
+		CHECK_UNPACK(server_shutdown);
+		c->server_shutdown(ctx, sid);
+	}
+
+	void
+	hyperdex_coordinator_server_kill(struct rsm_context *ctx,
+	                                 void *obj, const char *data, size_t data_sz)
+	{
+		PROTECT_UNINITIALIZED;
+		server_id sid;
+		e::unpacker up(data, data_sz);
+		up = up >> sid;
+		CHECK_UNPACK(server_kill);
+		c->server_kill(ctx, sid);
+	}
+
+	void
+	hyperdex_coordinator_server_forget(struct rsm_context *ctx,
+	                                   void *obj, const char *data, size_t data_sz)
+	{
+		PROTECT_UNINITIALIZED;
+		server_id sid;
+		e::unpacker up(data, data_sz);
+		up = up >> sid;
+		CHECK_UNPACK(server_forget);
+		c->server_forget(ctx, sid);
+	}
+
+	void
+	hyperdex_coordinator_server_suspect(struct rsm_context *ctx,
+	                                    void *obj, const char *data, size_t data_sz)
+	{
+		PROTECT_UNINITIALIZED;
+		server_id sid;
+		e::unpacker up(data, data_sz);
+		up = up >> sid;
+		CHECK_UNPACK(server_suspect);
+		c->server_suspect(ctx, sid);
+	}
+
+	void
+	hyperdex_coordinator_report_disconnect(struct rsm_context *ctx,
+	                                       void *obj, const char *data, size_t data_sz)
+	{
+		PROTECT_UNINITIALIZED;
+		server_id sid;
+		uint64_t version;
+		e::unpacker up(data, data_sz);
+		up = up >> sid >> version;
+		CHECK_UNPACK(report_disconnect);
+		c->report_disconnect(ctx, sid, version);
+	}
+
+	void
+	hyperdex_coordinator_space_add(struct rsm_context *ctx,
+	                               void *obj, const char *data, size_t data_sz)
+	{
+		PROTECT_UNINITIALIZED;
+		space s;
+		e::unpacker up(data, data_sz);
+		up = up >> s;
+		CHECK_UNPACK(space_add);
+		c->space_add(ctx, s);
+	}
+
+	void
+	hyperdex_coordinator_space_rm(struct rsm_context *ctx,
+	                              void *obj, const char *data, size_t data_sz)
+	{
+		PROTECT_UNINITIALIZED;
+		if (data_sz == 0 || data[data_sz - 1] != '\0')
+		{
+			rsm_log(ctx, "received malformed \"rm_space\" message\n");
+			return generate_response(ctx, COORD_MALFORMED);
+		}
+		c->space_rm(ctx, data);
+	}
+
+	void
+	hyperdex_coordinator_space_mv(struct rsm_context *ctx,
+	                              void *obj, const char *data, size_t data_sz)
+	{
+		PROTECT_UNINITIALIZED;
+		if (data_sz < 2 || data[data_sz - 1] != '\0')
+		{
+			rsm_log(ctx, "received malformed \"mv_space\" message\n");
+			return generate_response(ctx, COORD_MALFORMED);
+		}
+		const char *src = data;
+		const char *dst = data + strlen(data) + 1;
+		if (dst >= data + data_sz)
+		{
+			rsm_log(ctx, "received malformed \"mv_space\" message\n");
+			return generate_response(ctx, COORD_MALFORMED);
+		}
+		c->space_mv(ctx, src, dst);
+	}
+
+	void
+	hyperdex_coordinator_index_add(struct rsm_context *ctx,
+	                               void *obj, const char *data, size_t data_sz)
+	{
+		PROTECT_UNINITIALIZED;
+		const char *space = data;
+		size_t space_sz = strnlen(data, data_sz);
+		if (data_sz == 0 || data[data_sz - 1] != '\0' || space_sz + 2 >= data_sz)
+		{
+			rsm_log(ctx, "received malformed \"add_index\" message\n");
+			return generate_response(ctx, COORD_MALFORMED);
+		}
+		const char *attr = data + space_sz + 1;
+		size_t attr_sz = strnlen(attr, data_sz - space_sz - 1);
+		if (space_sz + attr_sz + 2 != data_sz)
+		{
+			rsm_log(ctx, "received malformed \"add_index\" message\n");
+			return generate_response(ctx, COORD_MALFORMED);
+		}
+		c->index_add(ctx, space, attr);
+	}
+
+	void
+	hyperdex_coordinator_index_rm(struct rsm_context *ctx,
+	                              void *obj, const char *data, size_t data_sz)
+	{
+		PROTECT_UNINITIALIZED;
+		index_id ii;
+		e::unpacker up(data, data_sz);
+		up = up >> ii;
+		CHECK_UNPACK(index_rm);
+		c->index_rm(ctx, ii);
+	}
+
+	void
+	hyperdex_coordinator_transfer_go_live(struct rsm_context *ctx,
+	                                      void *obj, const char *data, size_t data_sz)
+	{
+		PROTECT_UNINITIALIZED;
+		transfer_id xid;
+		e::unpacker up(data, data_sz);
+		up = up >> xid;
+		CHECK_UNPACK(transfer_go_live);
+		c->transfer_go_live(ctx, xid);
+	}
+
+	void
+	hyperdex_coordinator_transfer_complete(struct rsm_context *ctx,
+	                                       void *obj, const char *data, size_t data_sz)
+	{
+		PROTECT_UNINITIALIZED;
+		transfer_id xid;
+		e::unpacker up(data, data_sz);
+		up = up >> xid;
+		CHECK_UNPACK(transfer_complete);
+		c->transfer_complete(ctx, xid);
+	}
+
+	void
+	hyperdex_coordinator_checkpoint_stable(struct rsm_context *ctx,
+	                                       void *obj, const char *data, size_t data_sz)
+	{
+		PROTECT_UNINITIALIZED;
+		server_id sid;
+		uint64_t config;
+		uint64_t checkpoint;
+		e::unpacker up(data, data_sz);
+		up = up >> sid >> config >> checkpoint;
+		CHECK_UNPACK(checkpoint_stable);
+		c->checkpoint_stable(ctx, sid, config, checkpoint);
+	}
+
+	void
+	hyperdex_coordinator_checkpoints(struct rsm_context *ctx,
+	                                 void *obj, const char *, size_t)
+	{
+		PROTECT_UNINITIALIZED;
+		c->checkpoints(ctx);
+	}
+
+	void
+	hyperdex_coordinator_periodic(struct rsm_context *ctx,
+	                              void *obj, const char *, size_t)
+	{
+		PROTECT_UNINITIALIZED;
+		c->periodic(ctx);
+	}
+
+	void
+	hyperdex_coordinator_debug_dump(struct rsm_context *ctx,
+	                                void *obj, const char *, size_t)
+	{
+		PROTECT_UNINITIALIZED;
+		c->debug_dump(ctx);
+	}
 
 } // extern "C"
diff --git a/coordinator/transitions.h b/coordinator/transitions.h
index 08199fc34..f9b4b1dcc 100644
--- a/coordinator/transitions.h
+++ b/coordinator/transitions.h
@@ -36,20 +36,20 @@ extern "C"
 /* Replicant */
 #include <rsm.h>
 
-void*
-hyperdex_coordinator_create(struct rsm_context* ctx);
+void *
+hyperdex_coordinator_create(struct rsm_context *ctx);
 
-void*
-hyperdex_coordinator_recreate(struct rsm_context* ctx,
-                              const char* data, size_t data_sz);
+void *
+hyperdex_coordinator_recreate(struct rsm_context *ctx,
+                              const char *data, size_t data_sz);
 
 int
-hyperdex_coordinator_snapshot(struct rsm_context* ctx,
-                              void* obj, char** data, size_t* sz);
+hyperdex_coordinator_snapshot(struct rsm_context *ctx,
+                              void *obj, char **data, size_t *sz);
 
 #define TRANSITION(X) void \
-    hyperdex_coordinator_ ## X(struct rsm_context* ctx, \
-                               void* obj, const char* data, size_t data_sz)
+	hyperdex_coordinator_ ## X(struct rsm_context* ctx, \
+	                           void* obj, const char* data, size_t data_sz)
 
 TRANSITION(init);
 
diff --git a/coordinator/util.h b/coordinator/util.h
index 72ccda061..d874dbda5 100644
--- a/coordinator/util.h
+++ b/coordinator/util.h
@@ -35,40 +35,38 @@
 BEGIN_HYPERDEX_NAMESPACE
 
 static inline void
-generate_response(rsm_context* ctx, coordinator_returncode x)
+generate_response(rsm_context *ctx, coordinator_returncode x)
 {
-    const char* ptr = NULL;
-
-    switch (x)
-    {
-        case COORD_SUCCESS:
-            ptr = "\x22\x80";
-            break;
-        case COORD_MALFORMED:
-            ptr = "\x22\x81";
-            break;
-        case COORD_DUPLICATE:
-            ptr = "\x22\x82";
-            break;
-        case COORD_NOT_FOUND:
-            ptr = "\x22\x83";
-            break;
-        case COORD_UNINITIALIZED:
-            ptr = "\x22\x85";
-            break;
-        case COORD_NO_CAN_DO:
-            ptr = "\x22\x87";
-            break;
-        default:
-            ptr = "\xff\xff";
-            break;
-    }
-
-    rsm_set_output(ctx, ptr, 2);
+	const char *ptr = NULL;
+	switch (x)
+	{
+	case COORD_SUCCESS:
+		ptr = "\x22\x80";
+		break;
+	case COORD_MALFORMED:
+		ptr = "\x22\x81";
+		break;
+	case COORD_DUPLICATE:
+		ptr = "\x22\x82";
+		break;
+	case COORD_NOT_FOUND:
+		ptr = "\x22\x83";
+		break;
+	case COORD_UNINITIALIZED:
+		ptr = "\x22\x85";
+		break;
+	case COORD_NO_CAN_DO:
+		ptr = "\x22\x87";
+		break;
+	default:
+		ptr = "\xff\xff";
+		break;
+	}
+	rsm_set_output(ctx, ptr, 2);
 }
 
 #define INVARIANT_BROKEN(X) \
-    rsm_log(ctx, "invariant broken at " __FILE__ ":%d:  %s\n", __LINE__, X "\n")
+	rsm_log(ctx, "invariant broken at " __FILE__ ":%d:  %s\n", __LINE__, X "\n")
 
 END_HYPERDEX_NAMESPACE
 
diff --git a/daemon/auth.cc b/daemon/auth.cc
index 304f56a85..9739de709 100644
--- a/daemon/auth.cc
+++ b/daemon/auth.cc
@@ -37,185 +37,164 @@ BEGIN_HYPERDEX_NAMESPACE
 
 struct general_caveat
 {
-    general_caveat() : check(NULL), ptr(NULL) {}
-    general_caveat(int (*c)(void* f, const unsigned char* pred, size_t pred_sz), void* p) : check(c), ptr(p) {}
-    int (*check)(void* f, const unsigned char* pred, size_t pred_sz);
-    void* ptr;
+	general_caveat() : check(NULL), ptr(NULL) {}
+	general_caveat(int (*c)(void *f, const unsigned char *pred, size_t pred_sz), void *p) : check(c), ptr(p) {}
+	int (*check)(void *f, const unsigned char *pred, size_t pred_sz);
+	void *ptr;
 };
 
 END_HYPERDEX_NAMESPACE
 
 void
-hyperdex :: sanitize_secrets(const schema& sc, std::vector<e::slice>* value)
+hyperdex :: sanitize_secrets(const schema &sc, std::vector<e::slice> *value)
 {
-    for (size_t i = 1; i < sc.attrs_sz; ++i)
-    {
-        if (sc.attrs[i].type == HYPERDATATYPE_MACAROON_SECRET && i <= value->size())
-        {
-            (*value)[i - 1] = e::slice();
-        }
-    }
+	for (size_t i = 1; i < sc.attrs_sz; ++i)
+	{
+		if (sc.attrs[i].type == HYPERDATATYPE_MACAROON_SECRET && i <= value->size())
+		{
+			(*value)[i - 1] = e::slice();
+		}
+	}
 }
 
 static void
-destroy_macaroons(std::vector<macaroon*>* MS)
+destroy_macaroons(std::vector<macaroon *> *MS)
 {
-    for (size_t i = 0; i < MS->size(); ++i)
-    {
-        macaroon_destroy((*MS)[i]);
-    }
+	for (size_t i = 0; i < MS->size(); ++i)
+	{
+		macaroon_destroy((*MS)[i]);
+	}
 }
 
 bool
-hyperdex :: auth_verify(const schema& sc,
+hyperdex :: auth_verify(const schema &sc,
                         bool has_value,
-                        const std::vector<e::slice>* value,
-                        auth_wallet* aw,
-                        const char** exact,
-                        general_caveat* general)
+                        const std::vector<e::slice> *value,
+                        auth_wallet *aw,
+                        const char **exact,
+                        general_caveat *general)
 {
-    if (!sc.authorization)
-    {
-        return true;
-    }
-
-    if (!has_value || !aw)
-    {
-        return false;
-    }
-
-    bool has_secret = false;
-    e::slice secret;
-
-    for (size_t i = 1; i < sc.attrs_sz; ++i)
-    {
-        if (sc.attrs[i].type == HYPERDATATYPE_MACAROON_SECRET)
-        {
-            has_secret = true;
-            secret = (*value)[i - 1];
-        }
-    }
-
-    // build the verifier
-    struct macaroon_verifier* V = macaroon_verifier_create();
-
-    if (!V)
-    {
-        throw std::bad_alloc();
-    }
-
-    while (exact && *exact)
-    {
-        macaroon_returncode err;
-
-        if (macaroon_verifier_satisfy_exact(V, reinterpret_cast<const unsigned char*>(*exact), strlen(*exact), &err) < 0)
-        {
-            has_secret = false;
-        }
-
-        ++exact;
-    }
-
-    while (general && general->check)
-    {
-        macaroon_returncode err;
-
-        if (macaroon_verifier_satisfy_general(V, general->check, general->ptr, &err) < 0)
-        {
-            has_secret = false;
-        }
-
-        ++general;
-    }
-
-    e::guard g1 = e::makeguard(macaroon_verifier_destroy, V);
-    std::vector<macaroon*> MS;
-    e::guard g2 = e::makeguard(destroy_macaroons, &MS);
-
-    if (!aw->get_macaroons(&MS) || MS.empty())
-    {
-        return false;
-    }
-
-    macaroon_returncode err;
-    int rc = macaroon_verify(V, MS[0], secret.data(), secret.size(), &MS[1], MS.size() - 1, &err);
-    return rc == 0 && has_secret;
+	if (!sc.authorization)
+	{
+		return true;
+	}
+	if (!has_value || !aw)
+	{
+		return false;
+	}
+	bool has_secret = false;
+	e::slice secret;
+	for (size_t i = 1; i < sc.attrs_sz; ++i)
+	{
+		if (sc.attrs[i].type == HYPERDATATYPE_MACAROON_SECRET)
+		{
+			has_secret = true;
+			secret = (*value)[i - 1];
+		}
+	}
+	// build the verifier
+	struct macaroon_verifier *V = macaroon_verifier_create();
+	if (!V)
+	{
+		throw std::bad_alloc();
+	}
+	while (exact && *exact)
+	{
+		macaroon_returncode err;
+		if (macaroon_verifier_satisfy_exact(V, reinterpret_cast<const unsigned char *>(*exact), strlen(*exact), &err) < 0)
+		{
+			has_secret = false;
+		}
+		++exact;
+	}
+	while (general && general->check)
+	{
+		macaroon_returncode err;
+		if (macaroon_verifier_satisfy_general(V, general->check, general->ptr, &err) < 0)
+		{
+			has_secret = false;
+		}
+		++general;
+	}
+	e::guard g1 = e::makeguard(macaroon_verifier_destroy, V);
+	std::vector<macaroon *> MS;
+	e::guard g2 = e::makeguard(destroy_macaroons, &MS);
+	if (!aw->get_macaroons(&MS) || MS.empty())
+	{
+		return false;
+	}
+	macaroon_returncode err;
+	int rc = macaroon_verify(V, MS[0], secret.data(), secret.size(), &MS[1], MS.size() - 1, &err);
+	return rc == 0 && has_secret;
 }
 
 #define TIME_PRED "time < "
 #define TIME_PRED_SZ (sizeof(TIME_PRED) - 1)
 
 static int
-check_time(void* t, const unsigned char* pred, size_t pred_sz)
+check_time(void *t, const unsigned char *pred, size_t pred_sz)
 {
-    if (pred_sz < TIME_PRED_SZ ||
-        memcmp(pred, TIME_PRED, TIME_PRED_SZ) != 0)
-    {
-        return -1;
-    }
-
-    std::string tmp(reinterpret_cast<const char*>(pred) + TIME_PRED_SZ, pred_sz - TIME_PRED_SZ);
-    char* end = NULL;
-    unsigned long long expiry = strtoull(tmp.c_str(), &end, 10);
-
-    if (end == NULL || *end != '\0')
-    {
-        return -1;
-    }
-
-    return (*reinterpret_cast<uint64_t*>(t) < expiry) ? 0 : -1;
+	if (pred_sz < TIME_PRED_SZ ||
+	    memcmp(pred, TIME_PRED, TIME_PRED_SZ) != 0)
+	{
+		return -1;
+	}
+	std::string tmp(reinterpret_cast<const char *>(pred) + TIME_PRED_SZ, pred_sz - TIME_PRED_SZ);
+	char *end = NULL;
+	unsigned long long expiry = strtoull(tmp.c_str(), &end, 10);
+	if (end == NULL || *end != '\0')
+	{
+		return -1;
+	}
+	return (*reinterpret_cast<uint64_t *>(t) < expiry) ? 0 : -1;
 }
 
 bool
-hyperdex :: auth_verify_read(const schema& sc,
+hyperdex :: auth_verify_read(const schema &sc,
                              bool has_value,
-                             const std::vector<e::slice>* value,
-                             auth_wallet* aw)
+                             const std::vector<e::slice> *value,
+                             auth_wallet *aw)
 {
-    const char* exact[] = {"op = read", NULL};
-    uint64_t time = po6::time() / 1000000000ULL;
-    general_caveat general[] = {general_caveat(check_time, &time), general_caveat()};
-    return auth_verify(sc, has_value, value, aw, exact, general);
+	const char *exact[] = {"op = read", NULL};
+	uint64_t time = po6::time() / 1000000000ULL;
+	general_caveat general[] = {general_caveat(check_time, &time), general_caveat()};
+	return auth_verify(sc, has_value, value, aw, exact, general);
 }
 
 
 bool
-hyperdex :: auth_verify_write(const schema& sc,
+hyperdex :: auth_verify_write(const schema &sc,
                               bool has_value,
-                              const std::vector<e::slice>* value,
-                              const key_change& kc)
+                              const std::vector<e::slice> *value,
+                              const key_change &kc)
 {
-    if (!sc.authorization)
-    {
-        return true;
-    }
-
-    if (!has_value)
-    {
-        uint16_t attrnum = sc.lookup_attr(HYPERDEX_ATTRIBUTE_SECRET);
-
-        if (attrnum == sc.attrs_sz)
-        {
-            return false;
-        }
-
-        for (size_t i = 0; i < kc.funcs.size(); ++i)
-        {
-            if (kc.funcs[i].attr == attrnum &&
-                kc.funcs[i].name == FUNC_SET &&
-                kc.funcs[i].arg1_datatype == HYPERDATATYPE_MACAROON_SECRET)
-            {
-                return true;
-            }
-        }
-
-        return false;
-    }
-    else
-    {
-        const char* exact[] = {"op = write", NULL};
-        uint64_t time = po6::time() / 1000000000ULL;
-        general_caveat general[] = {general_caveat(check_time, &time), general_caveat()};
-        return auth_verify(sc, has_value, value, kc.auth.get(), exact, general);
-    }
+	if (!sc.authorization)
+	{
+		return true;
+	}
+	if (!has_value)
+	{
+		uint16_t attrnum = sc.lookup_attr(HYPERDEX_ATTRIBUTE_SECRET);
+		if (attrnum == sc.attrs_sz)
+		{
+			return false;
+		}
+		for (size_t i = 0; i < kc.funcs.size(); ++i)
+		{
+			if (kc.funcs[i].attr == attrnum &&
+			    kc.funcs[i].name == FUNC_SET &&
+			    kc.funcs[i].arg1_datatype == HYPERDATATYPE_MACAROON_SECRET)
+			{
+				return true;
+			}
+		}
+		return false;
+	}
+	else
+	{
+		const char *exact[] = {"op = write", NULL};
+		uint64_t time = po6::time() / 1000000000ULL;
+		general_caveat general[] = {general_caveat(check_time, &time), general_caveat()};
+		return auth_verify(sc, has_value, value, kc.auth.get(), exact, general);
+	}
 }
diff --git a/daemon/auth.h b/daemon/auth.h
index fd9537edc..63861d25f 100644
--- a/daemon/auth.h
+++ b/daemon/auth.h
@@ -40,27 +40,27 @@
 BEGIN_HYPERDEX_NAMESPACE
 
 void
-sanitize_secrets(const schema& sc, std::vector<e::slice>* value);
+sanitize_secrets(const schema &sc, std::vector<e::slice> *value);
 
 bool
-auth_verify(const schema& sc,
+auth_verify(const schema &sc,
             bool has_value,
-            const std::vector<e::slice>* value,
-            auth_wallet* aw,
-            const char** exact,
-            struct general_caveat* general);
+            const std::vector<e::slice> *value,
+            auth_wallet *aw,
+            const char **exact,
+            struct general_caveat *general);
 
 bool
-auth_verify_read(const schema& sc,
+auth_verify_read(const schema &sc,
                  bool has_value,
-                 const std::vector<e::slice>* value,
-                 auth_wallet* aw);
+                 const std::vector<e::slice> *value,
+                 auth_wallet *aw);
 
 bool
-auth_verify_write(const schema& sc,
+auth_verify_write(const schema &sc,
                   bool has_value,
-                  const std::vector<e::slice>* value,
-                  const key_change& kc);
+                  const std::vector<e::slice> *value,
+                  const key_change &kc);
 
 END_HYPERDEX_NAMESPACE
 
diff --git a/daemon/background_thread.cc b/daemon/background_thread.cc
index 09ed7a57b..b68c3e58b 100644
--- a/daemon/background_thread.cc
+++ b/daemon/background_thread.cc
@@ -43,169 +43,153 @@
 using po6::threads::make_thread_wrapper;
 using hyperdex::background_thread;
 
-background_thread :: background_thread(daemon* d)
-    : m_thread(make_thread_wrapper(&background_thread::run, this))
-    , m_gc(&d->m_gc)
-    , m_protect()
-    , m_wakeup_thread(&m_protect)
-    , m_wakeup_pauser(&m_protect)
-    , m_shutdown(true)
-    , m_pause_count(0)
-    , m_paused(false)
-    , m_offline(false)
+background_thread :: background_thread(daemon *d)
+	: m_thread(make_thread_wrapper(&background_thread::run, this))
+	, m_gc(&d->m_gc)
+	, m_protect()
+	, m_wakeup_thread(&m_protect)
+	, m_wakeup_pauser(&m_protect)
+	, m_shutdown(true)
+	, m_pause_count(0)
+	, m_paused(false)
+	, m_offline(false)
 {
-    po6::threads::mutex::hold hold(&m_protect);
+	po6::threads::mutex::hold hold(&m_protect);
 }
 
 background_thread :: ~background_thread() throw ()
 {
-    shutdown();
+	shutdown();
 }
 
 void
 background_thread :: start()
 {
-    po6::threads::mutex::hold hold(&m_protect);
-    m_thread.start();
-    m_shutdown = false;
+	po6::threads::mutex::hold hold(&m_protect);
+	m_thread.start();
+	m_shutdown = false;
 }
 
 void
 background_thread :: initiate_pause()
 {
-    po6::threads::mutex::hold hold(&m_protect);
-    ++m_pause_count;
+	po6::threads::mutex::hold hold(&m_protect);
+	++m_pause_count;
 }
 
 void
 background_thread :: wait_until_paused()
 {
-    po6::threads::mutex::hold hold(&m_protect);
-    assert(m_pause_count > 0);
-
-    while (!m_paused && !m_offline)
-    {
-        m_wakeup_pauser.wait();
-    }
+	po6::threads::mutex::hold hold(&m_protect);
+	assert(m_pause_count > 0);
+	while (!m_paused && !m_offline)
+	{
+		m_wakeup_pauser.wait();
+	}
 }
 
 void
 background_thread :: unpause()
 {
-    po6::threads::mutex::hold hold(&m_protect);
-    assert(m_pause_count > 0);
-    --m_pause_count;
-    m_wakeup_thread.broadcast();
+	po6::threads::mutex::hold hold(&m_protect);
+	assert(m_pause_count > 0);
+	--m_pause_count;
+	m_wakeup_thread.broadcast();
 }
 
 void
 background_thread :: shutdown()
 {
-    bool already_shutdown;
-
-    {
-        po6::threads::mutex::hold hold(&m_protect);
-        m_wakeup_thread.broadcast();
-        already_shutdown = m_shutdown;
-        m_shutdown = true;
-    }
-
-    if (!already_shutdown)
-    {
-        m_thread.join();
-    }
+	bool already_shutdown;
+	{
+		po6::threads::mutex::hold hold(&m_protect);
+		m_wakeup_thread.broadcast();
+		already_shutdown = m_shutdown;
+		m_shutdown = true;
+	}
+	if (!already_shutdown)
+	{
+		m_thread.join();
+	}
 }
 
 void
 background_thread :: offline()
 {
-    po6::threads::mutex::hold hold(&m_protect);
-    assert(!m_offline);
-    m_offline = true;
-
-    if (m_pause_count > 0)
-    {
-        m_wakeup_pauser.broadcast();
-    }
+	po6::threads::mutex::hold hold(&m_protect);
+	assert(!m_offline);
+	m_offline = true;
+	if (m_pause_count > 0)
+	{
+		m_wakeup_pauser.broadcast();
+	}
 }
 
 void
 background_thread :: online()
 {
-    po6::threads::mutex::hold hold(&m_protect);
-    assert(m_offline);
-    m_offline = false;
-
-    while (m_pause_count > 0 && !m_shutdown)
-    {
-        m_paused = true;
-        m_wakeup_thread.wait();
-        m_paused = false;
-    }
+	po6::threads::mutex::hold hold(&m_protect);
+	assert(m_offline);
+	m_offline = false;
+	while (m_pause_count > 0 && !m_shutdown)
+	{
+		m_paused = true;
+		m_wakeup_thread.wait();
+		m_paused = false;
+	}
 }
 
 void
 background_thread :: run()
 {
-    LOG(INFO) << this->thread_name() << " thread started";
-    block_signals();
-    e::garbage_collector::thread_state ts;
-    m_gc->register_thread(&ts);
-
-    while (true)
-    {
-        {
-            m_gc->quiescent_state(&ts);
-            po6::threads::mutex::hold hold(&m_protect);
-
-            while ((!this->have_work() && !m_shutdown) || m_pause_count > 0)
-            {
-                m_paused = true;
-
-                if (m_pause_count > 0)
-                {
-                    m_wakeup_pauser.signal();
-                }
-
-                m_gc->offline(&ts);
-                m_wakeup_thread.wait();
-                m_gc->online(&ts);
-                m_paused = false;
-            }
-
-            if (m_shutdown)
-            {
-                break;
-            }
-
-            this->copy_work();
-        }
-
-        this->do_work();
-    }
-
-    m_gc->deregister_thread(&ts);
-    LOG(INFO) << this->thread_name() << " thread stopped";
+	LOG(INFO) << this->thread_name() << " thread started";
+	block_signals();
+	e::garbage_collector::thread_state ts;
+	m_gc->register_thread(&ts);
+	while (true)
+	{
+		{
+			m_gc->quiescent_state(&ts);
+			po6::threads::mutex::hold hold(&m_protect);
+			while ((!this->have_work() && !m_shutdown) || m_pause_count > 0)
+			{
+				m_paused = true;
+				if (m_pause_count > 0)
+				{
+					m_wakeup_pauser.signal();
+				}
+				m_gc->offline(&ts);
+				m_wakeup_thread.wait();
+				m_gc->online(&ts);
+				m_paused = false;
+			}
+			if (m_shutdown)
+			{
+				break;
+			}
+			this->copy_work();
+		}
+		this->do_work();
+	}
+	m_gc->deregister_thread(&ts);
+	LOG(INFO) << this->thread_name() << " thread stopped";
 }
 
 void
 background_thread :: block_signals()
 {
-    sigset_t ss;
-
-    if (sigfillset(&ss) < 0)
-    {
-        PLOG(ERROR) << "sigfillset";
-        LOG(ERROR) << "could not successfully block signals; this could result in undefined behavior";
-        return;
-    }
-
-    sigdelset(&ss, SIGPROF);
-
-    if (pthread_sigmask(SIG_BLOCK, &ss, NULL) < 0)
-    {
-        PLOG(ERROR) << "could not block signals";
-        LOG(ERROR) << "could not successfully block signals; this could result in undefined behavior";
-        return;
-    }
+	sigset_t ss;
+	if (sigfillset(&ss) < 0)
+	{
+		PLOG(ERROR) << "sigfillset";
+		LOG(ERROR) << "could not successfully block signals; this could result in undefined behavior";
+		return;
+	}
+	sigdelset(&ss, SIGPROF);
+	if (pthread_sigmask(SIG_BLOCK, &ss, NULL) < 0)
+	{
+		PLOG(ERROR) << "could not block signals";
+		LOG(ERROR) << "could not successfully block signals; this could result in undefined behavior";
+		return;
+	}
 }
diff --git a/daemon/background_thread.h b/daemon/background_thread.h
index 574fe5f85..7fbf58f6d 100644
--- a/daemon/background_thread.h
+++ b/daemon/background_thread.h
@@ -44,52 +44,52 @@ class daemon;
 
 class background_thread
 {
-    public:
-        background_thread(daemon* d);
-        virtual ~background_thread() throw ();
+public:
+	background_thread(daemon *d);
+	virtual ~background_thread() throw ();
 
-    public:
-        void start();
-        void initiate_pause();
-        void wait_until_paused();
-        void unpause();
-        void shutdown();
+public:
+	void start();
+	void initiate_pause();
+	void wait_until_paused();
+	void unpause();
+	void shutdown();
 
-    protected:
-        virtual const char* thread_name() = 0;
-        virtual bool have_work() = 0;
-        virtual void copy_work() = 0;
-        virtual void do_work() = 0;
+protected:
+	virtual const char *thread_name() = 0;
+	virtual bool have_work() = 0;
+	virtual void copy_work() = 0;
+	virtual void do_work() = 0;
 
-    protected:
-        // take the thread offline.  pause will appear to work right away
-        void offline();
-        // bring the thread back online.  will block if paused
-        void online();
-        bool is_paused() { return m_paused; } // call with lock()
-        bool is_shutdown() { return m_shutdown; } // call with lock()
-        void lock() { m_protect.lock(); }
-        void unlock() { m_protect.unlock(); }
-        void wakeup() { m_wakeup_thread.broadcast(); }
+protected:
+	// take the thread offline.  pause will appear to work right away
+	void offline();
+	// bring the thread back online.  will block if paused
+	void online();
+	bool is_paused() { return m_paused; } // call with lock()
+	bool is_shutdown() { return m_shutdown; } // call with lock()
+	void lock() { m_protect.lock(); }
+	void unlock() { m_protect.unlock(); }
+	void wakeup() { m_wakeup_thread.broadcast(); }
 
-    private:
-        void run();
-        void block_signals();
+private:
+	void run();
+	void block_signals();
 
-    private:
-        background_thread(const background_thread&);
-        background_thread& operator = (const background_thread&);
+private:
+	background_thread(const background_thread &);
+	background_thread &operator = (const background_thread &);
 
-    private:
-        po6::threads::thread m_thread;
-        e::garbage_collector* m_gc;
-        po6::threads::mutex m_protect;
-        po6::threads::cond m_wakeup_thread;
-        po6::threads::cond m_wakeup_pauser;
-        bool m_shutdown;
-        int m_pause_count;
-        bool m_paused;
-        bool m_offline;
+private:
+	po6::threads::thread m_thread;
+	e::garbage_collector *m_gc;
+	po6::threads::mutex m_protect;
+	po6::threads::cond m_wakeup_thread;
+	po6::threads::cond m_wakeup_pauser;
+	bool m_shutdown;
+	int m_pause_count;
+	bool m_paused;
+	bool m_offline;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/daemon/communication.cc b/daemon/communication.cc
index a0166e787..e324e578a 100644
--- a/daemon/communication.cc
+++ b/daemon/communication.cc
@@ -45,31 +45,31 @@ using hyperdex::reconfigure_returncode;
 
 class communication::early_message
 {
-    public:
-        early_message();
-        early_message(uint64_t version, uint64_t id,
-                      std::auto_ptr<e::buffer> m);
-        ~early_message() throw ();
-
-    public:
-        uint64_t config_version;
-        uint64_t id;
-        std::auto_ptr<e::buffer> msg;
+public:
+	early_message();
+	early_message(uint64_t version, uint64_t id,
+	              std::auto_ptr<e::buffer> m);
+	~early_message() throw ();
+
+public:
+	uint64_t config_version;
+	uint64_t id;
+	std::auto_ptr<e::buffer> msg;
 };
 
 communication :: early_message :: early_message()
-    : config_version(0)
-    , id()
-    , msg()
+	: config_version(0)
+	, id()
+	, msg()
 {
 }
 
 communication :: early_message :: early_message(uint64_t v,
                                                 uint64_t i,
                                                 std::auto_ptr<e::buffer> m)
-    : config_version(v)
-    , id(i)
-    , msg(m)
+	: config_version(v)
+	, id(i)
+	, msg(m)
 {
 }
 
@@ -79,11 +79,11 @@ communication :: early_message :: ~early_message() throw ()
 
 ///////////////////////////////// Public Class /////////////////////////////////
 
-communication :: communication(daemon* d)
-    : m_daemon(d)
-    , m_busybee_mapper(&m_daemon->m_config)
-    , m_busybee()
-    , m_early_messages()
+communication :: communication(daemon *d)
+	: m_daemon(d)
+	, m_busybee_mapper(&m_daemon->m_config)
+	, m_busybee()
+	, m_early_messages()
 {
 }
 
@@ -92,12 +92,12 @@ communication :: ~communication() throw ()
 }
 
 bool
-communication :: setup(const po6::net::location& bind_to,
+communication :: setup(const po6::net::location &bind_to,
                        unsigned threads)
 {
-    m_busybee.reset(new busybee_mta(&m_daemon->m_gc, &m_busybee_mapper, bind_to, m_daemon->m_us.get(), threads));
-    m_busybee->set_ignore_signals();
-    return true;
+	m_busybee.reset(new busybee_mta(&m_daemon->m_gc, &m_busybee_mapper, bind_to, m_daemon->m_us.get(), threads));
+	m_busybee->set_ignore_signals();
+	return true;
 }
 
 void
@@ -106,417 +106,372 @@ communication :: teardown()
 }
 
 void
-communication :: reconfigure(const configuration&,
-                             const configuration& new_config,
-                             const server_id&)
+communication :: reconfigure(const configuration &,
+                             const configuration &new_config,
+                             const server_id &)
 {
-    e::lockfree_fifo<early_message> ems;
-    early_message em;
-
-    while (m_early_messages.pop(&em))
-    {
-        if (em.config_version <= new_config.version())
-        {
-            m_busybee->deliver(em.id, em.msg);
-        }
-        else
-        {
-            ems.push(em);
-        }
-    }
-
-    while (ems.pop(&em))
-    {
-        m_early_messages.push(em);
-    }
+	e::lockfree_fifo<early_message> ems;
+	early_message em;
+	while (m_early_messages.pop(&em))
+	{
+		if (em.config_version <= new_config.version())
+		{
+			m_busybee->deliver(em.id, em.msg);
+		}
+		else
+		{
+			ems.push(em);
+		}
+	}
+	while (ems.pop(&em))
+	{
+		m_early_messages.push(em);
+	}
 }
 
 bool
-communication :: send_client(const virtual_server_id& from,
-                             const server_id& to,
+communication :: send_client(const virtual_server_id &from,
+                             const server_id &to,
                              network_msgtype msg_type,
                              std::auto_ptr<e::buffer> msg)
 {
-    assert(msg->size() >= HYPERDEX_HEADER_SIZE_VC);
-
-    if (m_daemon->m_us != m_daemon->m_config.get_server_id(from) &&
-        from != virtual_server_id(UINT64_MAX))
-    {
-        return false;
-    }
-
-    uint8_t mt = static_cast<uint8_t>(msg_type);
-    msg->pack_at(BUSYBEE_HEADER_SIZE) << mt << from.get();
-
+	assert(msg->size() >= HYPERDEX_HEADER_SIZE_VC);
+	if (m_daemon->m_us != m_daemon->m_config.get_server_id(from) &&
+	    from != virtual_server_id(UINT64_MAX))
+	{
+		return false;
+	}
+	uint8_t mt = static_cast<uint8_t>(msg_type);
+	msg->pack_at(BUSYBEE_HEADER_SIZE) << mt << from.get();
 #ifdef HD_LOG_ALL_MESSAGES
-    LOG(INFO) << "SEND " << from << "->" << to << " " << msg_type << " " << msg->hex();
+	LOG(INFO) << "SEND " << from << "->" << to << " " << msg_type << " " << msg->hex();
 #endif
-
-    if (to == m_daemon->m_us)
-    {
-        m_busybee->deliver(to.get(), msg);
-    }
-    else
-    {
-        busybee_returncode rc = m_busybee->send(to.get(), msg);
-
-        switch (rc)
-        {
-            case BUSYBEE_SUCCESS:
-                break;
-            case BUSYBEE_DISRUPTED:
-                handle_disruption(to.get());
-                return false;
-            case BUSYBEE_SHUTDOWN:
-            case BUSYBEE_POLLFAILED:
-            case BUSYBEE_ADDFDFAIL:
-            case BUSYBEE_TIMEOUT:
-            case BUSYBEE_EXTERNAL:
-            case BUSYBEE_INTERRUPTED:
-            default:
-                LOG(ERROR) << "BusyBee unexpectedly returned " << rc;
-                return false;
-        }
-    }
-
-    return true;
+	if (to == m_daemon->m_us)
+	{
+		m_busybee->deliver(to.get(), msg);
+	}
+	else
+	{
+		busybee_returncode rc = m_busybee->send(to.get(), msg);
+		switch (rc)
+		{
+		case BUSYBEE_SUCCESS:
+			break;
+		case BUSYBEE_DISRUPTED:
+			handle_disruption(to.get());
+			return false;
+		case BUSYBEE_SHUTDOWN:
+		case BUSYBEE_POLLFAILED:
+		case BUSYBEE_ADDFDFAIL:
+		case BUSYBEE_TIMEOUT:
+		case BUSYBEE_EXTERNAL:
+		case BUSYBEE_INTERRUPTED:
+		default:
+			LOG(ERROR) << "BusyBee unexpectedly returned " << rc;
+			return false;
+		}
+	}
+	return true;
 }
 
 bool
-communication :: send(const virtual_server_id& from,
-                      const server_id& to,
+communication :: send(const virtual_server_id &from,
+                      const server_id &to,
                       network_msgtype msg_type,
                       std::auto_ptr<e::buffer> msg)
 {
-    assert(msg->size() >= HYPERDEX_HEADER_SIZE_VV);
-
-    if (m_daemon->m_us != m_daemon->m_config.get_server_id(from))
-    {
-        return false;
-    }
-
-    uint8_t mt = static_cast<uint8_t>(msg_type);
-    uint8_t flags = 1;
-    virtual_server_id vto(UINT64_MAX);
-    msg->pack_at(BUSYBEE_HEADER_SIZE) << mt << flags << m_daemon->m_config.version() << vto.get() << from.get();
-
-    if (to == server_id())
-    {
-        return false;
-    }
-
+	assert(msg->size() >= HYPERDEX_HEADER_SIZE_VV);
+	if (m_daemon->m_us != m_daemon->m_config.get_server_id(from))
+	{
+		return false;
+	}
+	uint8_t mt = static_cast<uint8_t>(msg_type);
+	uint8_t flags = 1;
+	virtual_server_id vto(UINT64_MAX);
+	msg->pack_at(BUSYBEE_HEADER_SIZE) << mt << flags << m_daemon->m_config.version() << vto.get() << from.get();
+	if (to == server_id())
+	{
+		return false;
+	}
 #ifdef HD_LOG_ALL_MESSAGES
-    LOG(INFO) << "SEND " << from << "->" << to << " " << msg_type << " " << msg->hex();
+	LOG(INFO) << "SEND " << from << "->" << to << " " << msg_type << " " << msg->hex();
 #endif
-
-    if (to == m_daemon->m_us)
-    {
-        m_busybee->deliver(to.get(), msg);
-    }
-    else
-    {
-        busybee_returncode rc = m_busybee->send(to.get(), msg);
-
-        switch (rc)
-        {
-            case BUSYBEE_SUCCESS:
-                break;
-            case BUSYBEE_DISRUPTED:
-                handle_disruption(to.get());
-                return false;
-            case BUSYBEE_SHUTDOWN:
-            case BUSYBEE_POLLFAILED:
-            case BUSYBEE_ADDFDFAIL:
-            case BUSYBEE_TIMEOUT:
-            case BUSYBEE_EXTERNAL:
-            case BUSYBEE_INTERRUPTED:
-            default:
-                LOG(ERROR) << "BusyBee unexpectedly returned " << rc;
-                return false;
-        }
-    }
-
-    return true;
+	if (to == m_daemon->m_us)
+	{
+		m_busybee->deliver(to.get(), msg);
+	}
+	else
+	{
+		busybee_returncode rc = m_busybee->send(to.get(), msg);
+		switch (rc)
+		{
+		case BUSYBEE_SUCCESS:
+			break;
+		case BUSYBEE_DISRUPTED:
+			handle_disruption(to.get());
+			return false;
+		case BUSYBEE_SHUTDOWN:
+		case BUSYBEE_POLLFAILED:
+		case BUSYBEE_ADDFDFAIL:
+		case BUSYBEE_TIMEOUT:
+		case BUSYBEE_EXTERNAL:
+		case BUSYBEE_INTERRUPTED:
+		default:
+			LOG(ERROR) << "BusyBee unexpectedly returned " << rc;
+			return false;
+		}
+	}
+	return true;
 }
 
 bool
-communication :: send(const virtual_server_id& from,
-                      const virtual_server_id& vto,
+communication :: send(const virtual_server_id &from,
+                      const virtual_server_id &vto,
                       network_msgtype msg_type,
                       std::auto_ptr<e::buffer> msg)
 {
-    assert(msg->size() >= HYPERDEX_HEADER_SIZE_VV);
-
-    if (m_daemon->m_us != m_daemon->m_config.get_server_id(from))
-    {
-        return false;
-    }
-
-    uint8_t mt = static_cast<uint8_t>(msg_type);
-    uint8_t flags = 1;
-    msg->pack_at(BUSYBEE_HEADER_SIZE) << mt << flags << m_daemon->m_config.version() << vto.get() << from.get();
-    server_id to = m_daemon->m_config.get_server_id(vto);
-
-    if (to == server_id())
-    {
-        return false;
-    }
-
+	assert(msg->size() >= HYPERDEX_HEADER_SIZE_VV);
+	if (m_daemon->m_us != m_daemon->m_config.get_server_id(from))
+	{
+		return false;
+	}
+	uint8_t mt = static_cast<uint8_t>(msg_type);
+	uint8_t flags = 1;
+	msg->pack_at(BUSYBEE_HEADER_SIZE) << mt << flags << m_daemon->m_config.version() << vto.get() << from.get();
+	server_id to = m_daemon->m_config.get_server_id(vto);
+	if (to == server_id())
+	{
+		return false;
+	}
 #ifdef HD_LOG_ALL_MESSAGES
-    LOG(INFO) << "SEND " << from << "->" << vto << " " << msg_type << " " << msg->hex();
+	LOG(INFO) << "SEND " << from << "->" << vto << " " << msg_type << " " << msg->hex();
 #endif
-
-    if (to == m_daemon->m_us)
-    {
-        m_busybee->deliver(to.get(), msg);
-    }
-    else
-    {
-        busybee_returncode rc = m_busybee->send(to.get(), msg);
-
-        switch (rc)
-        {
-            case BUSYBEE_SUCCESS:
-                break;
-            case BUSYBEE_DISRUPTED:
-                handle_disruption(to.get());
-                return false;
-            case BUSYBEE_SHUTDOWN:
-            case BUSYBEE_POLLFAILED:
-            case BUSYBEE_ADDFDFAIL:
-            case BUSYBEE_TIMEOUT:
-            case BUSYBEE_EXTERNAL:
-            case BUSYBEE_INTERRUPTED:
-            default:
-                LOG(ERROR) << "BusyBee unexpectedly returned " << rc;
-                return false;
-        }
-    }
-
-    return true;
+	if (to == m_daemon->m_us)
+	{
+		m_busybee->deliver(to.get(), msg);
+	}
+	else
+	{
+		busybee_returncode rc = m_busybee->send(to.get(), msg);
+		switch (rc)
+		{
+		case BUSYBEE_SUCCESS:
+			break;
+		case BUSYBEE_DISRUPTED:
+			handle_disruption(to.get());
+			return false;
+		case BUSYBEE_SHUTDOWN:
+		case BUSYBEE_POLLFAILED:
+		case BUSYBEE_ADDFDFAIL:
+		case BUSYBEE_TIMEOUT:
+		case BUSYBEE_EXTERNAL:
+		case BUSYBEE_INTERRUPTED:
+		default:
+			LOG(ERROR) << "BusyBee unexpectedly returned " << rc;
+			return false;
+		}
+	}
+	return true;
 }
 
 bool
-communication :: send(const virtual_server_id& vto,
+communication :: send(const virtual_server_id &vto,
                       network_msgtype msg_type,
                       std::auto_ptr<e::buffer> msg)
 {
-    assert(msg->size() >= HYPERDEX_HEADER_SIZE_SV);
-
-    uint8_t mt = static_cast<uint8_t>(msg_type);
-    uint8_t flags = 0;
-    msg->pack_at(BUSYBEE_HEADER_SIZE) << mt << flags << m_daemon->m_config.version() << vto.get();
-    server_id to = m_daemon->m_config.get_server_id(vto);
-
-    if (to == server_id())
-    {
-        return false;
-    }
-
+	assert(msg->size() >= HYPERDEX_HEADER_SIZE_SV);
+	uint8_t mt = static_cast<uint8_t>(msg_type);
+	uint8_t flags = 0;
+	msg->pack_at(BUSYBEE_HEADER_SIZE) << mt << flags << m_daemon->m_config.version() << vto.get();
+	server_id to = m_daemon->m_config.get_server_id(vto);
+	if (to == server_id())
+	{
+		return false;
+	}
 #ifdef HD_LOG_ALL_MESSAGES
-    LOG(INFO) << "SEND ->" << vto << " " << msg_type << " " << msg->hex();
+	LOG(INFO) << "SEND ->" << vto << " " << msg_type << " " << msg->hex();
 #endif
-
-    if (to == m_daemon->m_us)
-    {
-        m_busybee->deliver(to.get(), msg);
-    }
-    else
-    {
-        busybee_returncode rc = m_busybee->send(to.get(), msg);
-
-        switch (rc)
-        {
-            case BUSYBEE_SUCCESS:
-                break;
-            case BUSYBEE_DISRUPTED:
-                handle_disruption(to.get());
-                return false;
-            case BUSYBEE_SHUTDOWN:
-            case BUSYBEE_POLLFAILED:
-            case BUSYBEE_ADDFDFAIL:
-            case BUSYBEE_TIMEOUT:
-            case BUSYBEE_EXTERNAL:
-            case BUSYBEE_INTERRUPTED:
-            default:
-                LOG(ERROR) << "BusyBee unexpectedly returned " << rc;
-                return false;
-        }
-    }
-
-    return true;
+	if (to == m_daemon->m_us)
+	{
+		m_busybee->deliver(to.get(), msg);
+	}
+	else
+	{
+		busybee_returncode rc = m_busybee->send(to.get(), msg);
+		switch (rc)
+		{
+		case BUSYBEE_SUCCESS:
+			break;
+		case BUSYBEE_DISRUPTED:
+			handle_disruption(to.get());
+			return false;
+		case BUSYBEE_SHUTDOWN:
+		case BUSYBEE_POLLFAILED:
+		case BUSYBEE_ADDFDFAIL:
+		case BUSYBEE_TIMEOUT:
+		case BUSYBEE_EXTERNAL:
+		case BUSYBEE_INTERRUPTED:
+		default:
+			LOG(ERROR) << "BusyBee unexpectedly returned " << rc;
+			return false;
+		}
+	}
+	return true;
 }
 
 bool
-communication :: send_exact(const virtual_server_id& from,
-                            const virtual_server_id& vto,
+communication :: send_exact(const virtual_server_id &from,
+                            const virtual_server_id &vto,
                             network_msgtype msg_type,
                             std::auto_ptr<e::buffer> msg)
 {
-    assert(msg->size() >= HYPERDEX_HEADER_SIZE_VV);
-
-    if (m_daemon->m_us != m_daemon->m_config.get_server_id(from))
-    {
-        return false;
-    }
-
-    uint8_t mt = static_cast<uint8_t>(msg_type);
-    uint8_t flags = 1 | 2;
-    msg->pack_at(BUSYBEE_HEADER_SIZE) << mt << flags << m_daemon->m_config.version() << vto.get() << from.get();
-    server_id to = m_daemon->m_config.get_server_id(vto);
-
-    if (to == server_id())
-    {
-        return false;
-    }
-
+	assert(msg->size() >= HYPERDEX_HEADER_SIZE_VV);
+	if (m_daemon->m_us != m_daemon->m_config.get_server_id(from))
+	{
+		return false;
+	}
+	uint8_t mt = static_cast<uint8_t>(msg_type);
+	uint8_t flags = 1 | 2;
+	msg->pack_at(BUSYBEE_HEADER_SIZE) << mt << flags << m_daemon->m_config.version() << vto.get() << from.get();
+	server_id to = m_daemon->m_config.get_server_id(vto);
+	if (to == server_id())
+	{
+		return false;
+	}
 #ifdef HD_LOG_ALL_MESSAGES
-    LOG(INFO) << "SEND " << from << "->" << vto << " " << msg_type << " " << msg->hex();
+	LOG(INFO) << "SEND " << from << "->" << vto << " " << msg_type << " " << msg->hex();
 #endif
-
-    if (to == m_daemon->m_us)
-    {
-        m_busybee->deliver(to.get(), msg);
-    }
-    else
-    {
-        busybee_returncode rc = m_busybee->send(to.get(), msg);
-
-        switch (rc)
-        {
-            case BUSYBEE_SUCCESS:
-                break;
-            case BUSYBEE_DISRUPTED:
-                handle_disruption(to.get());
-                return false;
-            case BUSYBEE_SHUTDOWN:
-            case BUSYBEE_POLLFAILED:
-            case BUSYBEE_ADDFDFAIL:
-            case BUSYBEE_TIMEOUT:
-            case BUSYBEE_EXTERNAL:
-            case BUSYBEE_INTERRUPTED:
-            default:
-                LOG(ERROR) << "BusyBee unexpectedly returned " << rc;
-                return false;
-        }
-    }
-
-    return true;
+	if (to == m_daemon->m_us)
+	{
+		m_busybee->deliver(to.get(), msg);
+	}
+	else
+	{
+		busybee_returncode rc = m_busybee->send(to.get(), msg);
+		switch (rc)
+		{
+		case BUSYBEE_SUCCESS:
+			break;
+		case BUSYBEE_DISRUPTED:
+			handle_disruption(to.get());
+			return false;
+		case BUSYBEE_SHUTDOWN:
+		case BUSYBEE_POLLFAILED:
+		case BUSYBEE_ADDFDFAIL:
+		case BUSYBEE_TIMEOUT:
+		case BUSYBEE_EXTERNAL:
+		case BUSYBEE_INTERRUPTED:
+		default:
+			LOG(ERROR) << "BusyBee unexpectedly returned " << rc;
+			return false;
+		}
+	}
+	return true;
 }
 
 bool
-communication :: recv(e::garbage_collector::thread_state* ts,
-                      server_id* from,
-                      virtual_server_id* vfrom,
-                      virtual_server_id* vto,
-                      network_msgtype* msg_type,
-                      std::auto_ptr<e::buffer>* msg,
-                      e::unpacker* up)
+communication :: recv(e::garbage_collector::thread_state *ts,
+                      server_id *from,
+                      virtual_server_id *vfrom,
+                      virtual_server_id *vto,
+                      network_msgtype *msg_type,
+                      std::auto_ptr<e::buffer> *msg,
+                      e::unpacker *up)
 {
-    // Read messages from the network until we get one that meets the following
-    // constraints:
-    //  - It is addressed to a virtual_server_id
-    //  - The virtual_server_id destination maps to us
-    //  - If it comes from a virtual_server_id, that id maps to the sender
-    //  - The message version is less than or equal to our current config
-    while (true)
-    {
-        uint64_t id;
-        busybee_returncode rc = m_busybee->recv(ts, &id, msg);
-
-        switch (rc)
-        {
-            case BUSYBEE_SUCCESS:
-                break;
-            case BUSYBEE_SHUTDOWN:
-                return false;
-            case BUSYBEE_DISRUPTED:
-                handle_disruption(id);
-                continue;
-            case BUSYBEE_INTERRUPTED:
-                continue;
-            case BUSYBEE_POLLFAILED:
-            case BUSYBEE_ADDFDFAIL:
-            case BUSYBEE_TIMEOUT:
-            case BUSYBEE_EXTERNAL:
-            default:
-                LOG(ERROR) << "busybee unexpectedly returned " << rc;
-                continue;
-        }
-
-        uint8_t mt;
-        uint8_t flags;
-        uint64_t version;
-        uint64_t vidf;
-        uint64_t vidt;
-        *up = (*msg)->unpack_from(BUSYBEE_HEADER_SIZE);
-        *up = *up >> mt >> flags >> version >> vidt;
-        *msg_type = static_cast<network_msgtype>(mt);
-        *from = server_id(id);
-        *vto = virtual_server_id(vidt);
-
-        if ((flags & 0x1))
-        {
-            *up = *up >> vidf;
-            *vfrom = virtual_server_id(vidf);
-        }
-        else
-        {
-            *vfrom = virtual_server_id();
-        }
-
-        if (up->error())
-        {
-            LOG(WARNING) << "dropping message that has a malformed header; here's some hex: " << (*msg)->hex();
-            continue;
-        }
-
-        bool from_valid = true;
-        bool to_valid = m_daemon->m_us == m_daemon->m_config.get_server_id(*vto) ||
-                        *vto == virtual_server_id(UINT64_MAX);
-
-        // If this is a virtual-virtual message
-        if ((flags & 0x1))
-        {
-            from_valid = *from == m_daemon->m_config.get_server_id(virtual_server_id(vidf));
-        }
-
-        // No matter what, wait for the config the sender saw
-        if (version > m_daemon->m_config.version())
-        {
-            early_message em(version, id, *msg);
-            m_early_messages.push(em);
-            continue;
-        }
-
-        if ((flags & 0x2) && version < m_daemon->m_config.version())
-        {
-            continue;
-        }
-
-        if (from_valid && to_valid)
-        {
+	// Read messages from the network until we get one that meets the following
+	// constraints:
+	//  - It is addressed to a virtual_server_id
+	//  - The virtual_server_id destination maps to us
+	//  - If it comes from a virtual_server_id, that id maps to the sender
+	//  - The message version is less than or equal to our current config
+	while (true)
+	{
+		uint64_t id;
+		busybee_returncode rc = m_busybee->recv(ts, &id, msg);
+		switch (rc)
+		{
+		case BUSYBEE_SUCCESS:
+			break;
+		case BUSYBEE_SHUTDOWN:
+			return false;
+		case BUSYBEE_DISRUPTED:
+			handle_disruption(id);
+			continue;
+		case BUSYBEE_INTERRUPTED:
+			continue;
+		case BUSYBEE_POLLFAILED:
+		case BUSYBEE_ADDFDFAIL:
+		case BUSYBEE_TIMEOUT:
+		case BUSYBEE_EXTERNAL:
+		default:
+			LOG(ERROR) << "busybee unexpectedly returned " << rc;
+			continue;
+		}
+		uint8_t mt;
+		uint8_t flags;
+		uint64_t version;
+		uint64_t vidf;
+		uint64_t vidt;
+		*up = (*msg)->unpack_from(BUSYBEE_HEADER_SIZE);
+		*up = *up >> mt >> flags >> version >> vidt;
+		*msg_type = static_cast<network_msgtype>(mt);
+		*from = server_id(id);
+		*vto = virtual_server_id(vidt);
+		if ((flags & 0x1))
+		{
+			*up = *up >> vidf;
+			*vfrom = virtual_server_id(vidf);
+		}
+		else
+		{
+			*vfrom = virtual_server_id();
+		}
+		if (up->error())
+		{
+			LOG(WARNING) << "dropping message that has a malformed header; here's some hex: " << (*msg)->hex();
+			continue;
+		}
+		bool from_valid = true;
+		bool to_valid = m_daemon->m_us == m_daemon->m_config.get_server_id(*vto) ||
+		                *vto == virtual_server_id(UINT64_MAX);
+		// If this is a virtual-virtual message
+		if ((flags & 0x1))
+		{
+			from_valid = *from == m_daemon->m_config.get_server_id(virtual_server_id(vidf));
+		}
+		// No matter what, wait for the config the sender saw
+		if (version > m_daemon->m_config.version())
+		{
+			early_message em(version, id, *msg);
+			m_early_messages.push(em);
+			continue;
+		}
+		if ((flags & 0x2) && version < m_daemon->m_config.version())
+		{
+			continue;
+		}
+		if (from_valid && to_valid)
+		{
 #ifdef HD_LOG_ALL_MESSAGES
-            LOG(INFO) << "RECV " << *from << "/" << *vfrom << "->" << *vto << " " << *msg_type << " " << (*msg)->hex();
+			LOG(INFO) << "RECV " << *from << "/" << *vfrom << "->" << *vto << " " << *msg_type << " " << (*msg)->hex();
 #endif
-            return true;
-        }
-
-        // Shove the message back at the client so it fails with a reconfigure.
-        if (!(flags & 0x1))
-        {
-            mt = static_cast<uint8_t>(CONFIGMISMATCH);
-            (*msg)->pack_at(BUSYBEE_HEADER_SIZE) << mt;
-            m_busybee->send(id, *msg);
-        }
-    }
+			return true;
+		}
+		// Shove the message back at the client so it fails with a reconfigure.
+		if (!(flags & 0x1))
+		{
+			mt = static_cast<uint8_t>(CONFIGMISMATCH);
+			(*msg)->pack_at(BUSYBEE_HEADER_SIZE) << mt;
+			m_busybee->send(id, *msg);
+		}
+	}
 }
 
 void
 communication :: handle_disruption(uint64_t id)
 {
-    if (m_daemon->m_config.get_address(server_id(id)) != po6::net::location())
-    {
-        m_daemon->m_coord->report_tcp_disconnect(m_daemon->m_config.version(), server_id(id));
-    }
+	if (m_daemon->m_config.get_address(server_id(id)) != po6::net::location())
+	{
+		m_daemon->m_coord->report_tcp_disconnect(m_daemon->m_config.version(), server_id(id));
+	}
 }
diff --git a/daemon/communication.h b/daemon/communication.h
index 0a8b88c57..47fffed25 100644
--- a/daemon/communication.h
+++ b/daemon/communication.h
@@ -67,68 +67,68 @@ class daemon;
 
 class communication
 {
-    public:
-        communication(daemon* d);
-        ~communication() throw ();
-
-    public:
-        void pause() { m_busybee->pause(); }
-        void unpause() { m_busybee->unpause(); }
-        void shutdown() { m_busybee->shutdown(); }
-        void wake_one() { m_busybee->wake_one(); }
-
-    public:
-        bool setup(const po6::net::location& bind_to,
-                   unsigned threads);
-        void teardown();
-        void reconfigure(const configuration& old_config,
-                         const configuration& new_config,
-                         const server_id& us);
-
-    public:
-        // Send data to another server (pretending to be a client)
-        bool send_client(const virtual_server_id& from,
-                         const server_id& to,
-                         network_msgtype msg_type,
-                         std::auto_ptr<e::buffer> msg);
-        bool send(const virtual_server_id& from,
-                  const server_id& to,
-                  network_msgtype msg_type,
-                  std::auto_ptr<e::buffer> msg);
-        bool send(const virtual_server_id& from,
-                  const virtual_server_id& to,
-                  network_msgtype msg_type,
-                  std::auto_ptr<e::buffer> msg);
-        bool send(const virtual_server_id& to,
-                  network_msgtype msg_type,
-                  std::auto_ptr<e::buffer> msg);
-        bool send_exact(const virtual_server_id& from,
-                        const virtual_server_id& to,
-                        network_msgtype msg_type,
-                        std::auto_ptr<e::buffer> msg);
-        bool recv(e::garbage_collector::thread_state* ts,
-                  server_id* from,
-                  virtual_server_id* vfrom,
-                  virtual_server_id* vto,
-                  network_msgtype* msg_type,
-                  std::auto_ptr<e::buffer>* msg,
-                  e::unpacker* up);
-
-    private:
-        class early_message;
-
-    private:
-        void handle_disruption(uint64_t id);
-
-    private:
-        communication(const communication&);
-        communication& operator = (const communication&);
-
-    private:
-        daemon* m_daemon;
-        mapper m_busybee_mapper;
-        std::auto_ptr<busybee_mta> m_busybee;
-        e::lockfree_fifo<early_message> m_early_messages;
+public:
+	communication(daemon *d);
+	~communication() throw ();
+
+public:
+	void pause() { m_busybee->pause(); }
+	void unpause() { m_busybee->unpause(); }
+	void shutdown() { m_busybee->shutdown(); }
+	void wake_one() { m_busybee->wake_one(); }
+
+public:
+	bool setup(const po6::net::location &bind_to,
+	           unsigned threads);
+	void teardown();
+	void reconfigure(const configuration &old_config,
+	                 const configuration &new_config,
+	                 const server_id &us);
+
+public:
+	// Send data to another server (pretending to be a client)
+	bool send_client(const virtual_server_id &from,
+	                 const server_id &to,
+	                 network_msgtype msg_type,
+	                 std::auto_ptr<e::buffer> msg);
+	bool send(const virtual_server_id &from,
+	          const server_id &to,
+	          network_msgtype msg_type,
+	          std::auto_ptr<e::buffer> msg);
+	bool send(const virtual_server_id &from,
+	          const virtual_server_id &to,
+	          network_msgtype msg_type,
+	          std::auto_ptr<e::buffer> msg);
+	bool send(const virtual_server_id &to,
+	          network_msgtype msg_type,
+	          std::auto_ptr<e::buffer> msg);
+	bool send_exact(const virtual_server_id &from,
+	                const virtual_server_id &to,
+	                network_msgtype msg_type,
+	                std::auto_ptr<e::buffer> msg);
+	bool recv(e::garbage_collector::thread_state *ts,
+	          server_id *from,
+	          virtual_server_id *vfrom,
+	          virtual_server_id *vto,
+	          network_msgtype *msg_type,
+	          std::auto_ptr<e::buffer> *msg,
+	          e::unpacker *up);
+
+private:
+	class early_message;
+
+private:
+	void handle_disruption(uint64_t id);
+
+private:
+	communication(const communication &);
+	communication &operator = (const communication &);
+
+private:
+	daemon *m_daemon;
+	mapper m_busybee_mapper;
+	std::auto_ptr<busybee_mta> m_busybee;
+	e::lockfree_fifo<early_message> m_early_messages;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/daemon/coordinator_link.cc b/daemon/coordinator_link.cc
index 48d4931b7..05c1fa4d3 100644
--- a/daemon/coordinator_link.cc
+++ b/daemon/coordinator_link.cc
@@ -48,28 +48,28 @@ using hyperdex::coordinator_link;
 
 struct coordinator_link::rpc
 {
-    rpc();
-    ~rpc() throw ();
-
-    std::string func;
-    std::string input;
-    unsigned flags;
-    replicant_returncode status;
-    char* output;
-    size_t output_sz;
-
-    private:
-        rpc(const rpc&);
-        rpc& operator = (const rpc&);
+	rpc();
+	~rpc() throw ();
+
+	std::string func;
+	std::string input;
+	unsigned flags;
+	replicant_returncode status;
+	char *output;
+	size_t output_sz;
+
+private:
+	rpc(const rpc &);
+	rpc &operator = (const rpc &);
 };
 
 coordinator_link :: rpc :: rpc()
-    : func()
-    , input()
-    , flags(0)
-    , status(REPLICANT_GARBAGE)
-    , output(NULL)
-    , output_sz(0)
+	: func()
+	, input()
+	, flags(0)
+	, status(REPLICANT_GARBAGE)
+	, output(NULL)
+	, output_sz(0)
 {
 }
 
@@ -77,33 +77,33 @@ coordinator_link :: rpc :: ~rpc() throw ()
 {
 }
 
-coordinator_link :: coordinator_link(daemon* d, const char* host, uint16_t port)
-    : m_daemon(d)
-    , m_sleep_ms(0)
-    , m_config()
-    , m_config_id(-1)
-    , m_config_status()
-    , m_config_state(0)
-    , m_config_data(NULL)
-    , m_config_data_sz(0)
-    , m_checkpoint_id(-1)
-    , m_checkpoint_status()
-    , m_checkpoint_state(0)
-    , m_checkpoint_data(NULL)
-    , m_checkpoint_data_sz(0)
-    , m_value_checkpoint_config_version(0)
-    , m_value_checkpoint(0)
-    , m_value_checkpoint_stable(0)
-    , m_value_checkpoint_gc(0)
-    , m_throwaway_status()
-    , m_mtx()
-    , m_repl(replicant_client_create(host, port))
-    , m_rpcs()
+coordinator_link :: coordinator_link(daemon *d, const char *host, uint16_t port)
+	: m_daemon(d)
+	, m_sleep_ms(0)
+	, m_config()
+	, m_config_id(-1)
+	, m_config_status()
+	, m_config_state(0)
+	, m_config_data(NULL)
+	, m_config_data_sz(0)
+	, m_checkpoint_id(-1)
+	, m_checkpoint_status()
+	, m_checkpoint_state(0)
+	, m_checkpoint_data(NULL)
+	, m_checkpoint_data_sz(0)
+	, m_value_checkpoint_config_version(0)
+	, m_value_checkpoint(0)
+	, m_value_checkpoint_stable(0)
+	, m_value_checkpoint_gc(0)
+	, m_throwaway_status()
+	, m_mtx()
+	, m_repl(replicant_client_create(host, port))
+	, m_rpcs()
 {
-    if (!m_repl)
-    {
-        throw std::bad_alloc();
-    }
+	if (!m_repl)
+	{
+		throw std::bad_alloc();
+	}
 }
 
 coordinator_link :: ~coordinator_link() throw ()
@@ -111,444 +111,404 @@ coordinator_link :: ~coordinator_link() throw ()
 }
 
 bool
-coordinator_link :: register_server(server_id us, const po6::net::location& bind_to)
+coordinator_link :: register_server(server_id us, const po6::net::location &bind_to)
 {
-    std::string register_msg;
-    e::packer(&register_msg) << us << bind_to;
-    char* output = NULL;
-    size_t output_sz = 0;
-    std::ostringstream ostr;
-    ostr << "register as " << us;
-
-    if (!synchronous_call(ostr.str().c_str(), "server_register",
-                          register_msg.data(), register_msg.size(),
-                          &output, &output_sz))
-    {
-        return false;
-    }
-
-    assert(output);
-    e::guard g_output = e::makeguard(free, output);
-
-    if (output_sz >= 2)
-    {
-        uint16_t x;
-        e::unpack16be(output, &x);
-        coordinator_returncode rc = static_cast<coordinator_returncode>(x);
-
-        switch (rc)
-        {
-            case COORD_SUCCESS:
-                return true;
-            case COORD_DUPLICATE:
-                LOG(ERROR) << "could not register as " << us << ": another server has this ID";
-                return false;
-            case COORD_UNINITIALIZED:
-                LOG(ERROR) << "could not register as " << us << ": coordinator not initialized";
-                return false;
-            case COORD_MALFORMED:
-            case COORD_NOT_FOUND:
-            case COORD_NO_CAN_DO:
-            default:
-                LOG(ERROR) << "could not register as " << us << ": coordinator returned " << rc;
-                return false;
-        }
-    }
-    else
-    {
-        LOG(ERROR) << "could not register as " << us << ": coordinator returned invalid message";
-        return false;
-    }
+	std::string register_msg;
+	e::packer(&register_msg) << us << bind_to;
+	char *output = NULL;
+	size_t output_sz = 0;
+	std::ostringstream ostr;
+	ostr << "register as " << us;
+	if (!synchronous_call(ostr.str().c_str(), "server_register",
+	                      register_msg.data(), register_msg.size(),
+	                      &output, &output_sz))
+	{
+		return false;
+	}
+	assert(output);
+	e::guard g_output = e::makeguard(free, output);
+	if (output_sz >= 2)
+	{
+		uint16_t x;
+		e::unpack16be(output, &x);
+		coordinator_returncode rc = static_cast<coordinator_returncode>(x);
+		switch (rc)
+		{
+		case COORD_SUCCESS:
+			return true;
+		case COORD_DUPLICATE:
+			LOG(ERROR) << "could not register as " << us << ": another server has this ID";
+			return false;
+		case COORD_UNINITIALIZED:
+			LOG(ERROR) << "could not register as " << us << ": coordinator not initialized";
+			return false;
+		case COORD_MALFORMED:
+		case COORD_NOT_FOUND:
+		case COORD_NO_CAN_DO:
+		default:
+			LOG(ERROR) << "could not register as " << us << ": coordinator returned " << rc;
+			return false;
+		}
+	}
+	else
+	{
+		LOG(ERROR) << "could not register as " << us << ": coordinator returned invalid message";
+		return false;
+	}
 }
 
 bool
 coordinator_link :: initialize()
 {
-    char* output = NULL;
-    size_t output_sz = 0;
-
-    if (!synchronous_call("get current configuration", "config_get", NULL, 0, &output, &output_sz))
-    {
-        return false;
-    }
-
-    assert(output);
-    e::guard g_output = e::makeguard(free, output);
-
-    if (!process_configuration(output, output_sz))
-    {
-        LOG(ERROR) << "could not get initial configuration; it appears to be invalid";
-        return false;
-    }
-
-    if (!bring_online())
-    {
-        return false;
-    }
-
-    return true;
+	char *output = NULL;
+	size_t output_sz = 0;
+	if (!synchronous_call("get current configuration", "config_get", NULL, 0, &output, &output_sz))
+	{
+		return false;
+	}
+	assert(output);
+	e::guard g_output = e::makeguard(free, output);
+	if (!process_configuration(output, output_sz))
+	{
+		LOG(ERROR) << "could not get initial configuration; it appears to be invalid";
+		return false;
+	}
+	if (!bring_online())
+	{
+		return false;
+	}
+	return true;
 }
 
 void
-increment_sleep(unsigned* x)
+increment_sleep(unsigned *x)
 {
-    if (*x == 0)
-    {
-        *x = 100;
-    }
-    else
-    {
-        *x = std::min(*x * 2, 20000U);
-    }
+	if (*x == 0)
+	{
+		*x = 100;
+	}
+	else
+	{
+		*x = std::min(*x * 2, 20000U);
+	}
 }
 
 static bool
 atomically_allow_pending_blocked_signals()
 {
-    sigset_t ss;
-    sigemptyset(&ss);
-
-    if (sigpending(&ss) == 0 &&
-        (sigismember(&ss, SIGHUP) == 1 ||
-         sigismember(&ss, SIGINT) == 1 ||
-         sigismember(&ss, SIGTERM) == 1 ||
-         sigismember(&ss, SIGQUIT) == 1 ||
-         sigismember(&ss, SIGALRM) == 1))
-    {
-        sigemptyset(&ss);
-        sigsuspend(&ss);
-        return true;
-    }
-
-    return false;
+	sigset_t ss;
+	sigemptyset(&ss);
+	if (sigpending(&ss) == 0 &&
+	    (sigismember(&ss, SIGHUP) == 1 ||
+	     sigismember(&ss, SIGINT) == 1 ||
+	     sigismember(&ss, SIGTERM) == 1 ||
+	     sigismember(&ss, SIGQUIT) == 1 ||
+	     sigismember(&ss, SIGALRM) == 1))
+	{
+		sigemptyset(&ss);
+		sigsuspend(&ss);
+		return true;
+	}
+	return false;
 }
 
 bool
 coordinator_link :: maintain()
 {
-    while (true)
-    {
-        if (m_sleep_ms > 0)
-        {
-            timespec ts;
-            ts.tv_sec = m_sleep_ms / 1000;
-            ts.tv_nsec = (m_sleep_ms % 1000) * 1000ULL * 1000ULL;
-            nanosleep(&ts, NULL);
-
-            if (atomically_allow_pending_blocked_signals())
-            {
-                return false;
-            }
-        }
-
-        {
-            po6::threads::mutex::hold hold(&m_mtx);
-
-            if (m_config_status != REPLICANT_SUCCESS)
-            {
-                replicant_client_kill(m_repl, m_config_id);
-                m_config_id = -1;
-            }
-
-            if (m_config_id < 0)
-            {
-                m_config_status = REPLICANT_SUCCESS;
-                m_config_id = replicant_client_cond_follow(m_repl, "hyperdex", "config",
-                                                           &m_config_status, &m_config_state,
-                                                           &m_config_data, &m_config_data_sz);
-            }
-
-            if (m_checkpoint_status != REPLICANT_SUCCESS)
-            {
-                replicant_client_kill(m_repl, m_checkpoint_id);
-                m_checkpoint_id = -1;
-            }
-
-            if (m_checkpoint_id < 0)
-            {
-                m_checkpoint_status = REPLICANT_SUCCESS;
-                m_checkpoint_id = replicant_client_cond_follow(m_repl, "hyperdex", "checkpoint",
-                                                               &m_checkpoint_status, &m_checkpoint_state,
-                                                               &m_checkpoint_data, &m_checkpoint_data_sz);
-            }
-        }
-
-        if (replicant_client_block(m_repl, 50) < 0)
-        {
-            return false;
-        }
-
-        int64_t id;
-        replicant_returncode rc;
-        po6::threads::mutex::hold hold(&m_mtx);
-        id = replicant_client_loop(m_repl, 0, &rc);
-
-        if (id < 0)
-        {
-            if (rc == REPLICANT_INTERRUPTED)
-            {
-                return false;
-            }
-            else if (rc != REPLICANT_NONE_PENDING && rc != REPLICANT_TIMEOUT)
-            {
-                LOG(ERROR) << "coordinator failure: " << replicant_client_error_message(m_repl);
-                LOG(INFO) << "error [" << replicant_returncode_to_string(rc)
-                          << "] at " << replicant_client_error_location(m_repl);
-                increment_sleep(&m_sleep_ms);
-                return false;
-            }
-        }
-
-        m_sleep_ms = 0;
-
-        if (id == m_config_id && m_config_status == REPLICANT_SUCCESS)
-        {
-            if (!process_configuration(m_config_data, m_config_data_sz))
-            {
-                increment_sleep(&m_sleep_ms);
-                LOG(ERROR) << "received an invalid configuration from the coordinator";
-                return false;
-            }
-
-            if (m_config.get_state(m_daemon->m_us) == server::NOT_AVAILABLE)
-            {
-                if (!bring_online())
-                {
-                    return false;
-                }
-            }
-
-            return true;
-        }
-        else if (id == m_checkpoint_id && m_checkpoint_status == REPLICANT_SUCCESS)
-        {
-            uint64_t value_checkpoint_config_version;
-            uint64_t value_checkpoint;
-            uint64_t value_checkpoint_stable;
-            uint64_t value_checkpoint_gc;
-            e::unpacker up(m_checkpoint_data, m_checkpoint_data_sz);
-            up = up >> value_checkpoint_config_version
-                    >> value_checkpoint
-                    >> value_checkpoint_stable
-                    >> value_checkpoint_gc;
-
-            if (!up.error())
-            {
-                // set the values and force the main thread out of here to act
-                // on new checkpoints
-                m_value_checkpoint_config_version = value_checkpoint_config_version;
-                m_value_checkpoint = value_checkpoint;
-                m_value_checkpoint_stable = value_checkpoint_stable;
-                m_value_checkpoint_gc = value_checkpoint_gc;
-                return false;
-            }
-        }
-        else
-        {
-            std::map<int64_t, e::compat::shared_ptr<rpc> >::iterator rit;
-            rit = m_rpcs.find(id);
-
-            if (rit == m_rpcs.end())
-            {
-                continue;
-            }
-
-            e::compat::shared_ptr<rpc> r = rit->second;
-            m_rpcs.erase(rit);
-
-            if (r->status != REPLICANT_SUCCESS)
-            {
-                increment_sleep(&m_sleep_ms);
-                LOG(ERROR) << "call to coordinator method \"" << r->func
-                           << "\" failed: " << replicant_client_error_message(m_repl);
-
-                if ((r->flags & REPLICANT_CALL_IDEMPOTENT))
-                {
-                    LOG(ERROR) << "retrying call to coordinator method \"" << r->func << "\"";
-                    make_rpc_no_synchro(r);
-                }
-            }
-        }
-    }
+	while (true)
+	{
+		if (m_sleep_ms > 0)
+		{
+			timespec ts;
+			ts.tv_sec = m_sleep_ms / 1000;
+			ts.tv_nsec = (m_sleep_ms % 1000) * 1000ULL * 1000ULL;
+			nanosleep(&ts, NULL);
+			if (atomically_allow_pending_blocked_signals())
+			{
+				return false;
+			}
+		}
+		{
+			po6::threads::mutex::hold hold(&m_mtx);
+			if (m_config_status != REPLICANT_SUCCESS)
+			{
+				replicant_client_kill(m_repl, m_config_id);
+				m_config_id = -1;
+			}
+			if (m_config_id < 0)
+			{
+				m_config_status = REPLICANT_SUCCESS;
+				m_config_id = replicant_client_cond_follow(m_repl, "hyperdex", "config",
+				                                           &m_config_status, &m_config_state,
+				                                           &m_config_data, &m_config_data_sz);
+			}
+			if (m_checkpoint_status != REPLICANT_SUCCESS)
+			{
+				replicant_client_kill(m_repl, m_checkpoint_id);
+				m_checkpoint_id = -1;
+			}
+			if (m_checkpoint_id < 0)
+			{
+				m_checkpoint_status = REPLICANT_SUCCESS;
+				m_checkpoint_id = replicant_client_cond_follow(m_repl, "hyperdex", "checkpoint",
+				                                               &m_checkpoint_status, &m_checkpoint_state,
+				                                               &m_checkpoint_data, &m_checkpoint_data_sz);
+			}
+		}
+		if (replicant_client_block(m_repl, 50) < 0)
+		{
+			return false;
+		}
+		int64_t id;
+		replicant_returncode rc;
+		po6::threads::mutex::hold hold(&m_mtx);
+		id = replicant_client_loop(m_repl, 0, &rc);
+		if (id < 0)
+		{
+			if (rc == REPLICANT_INTERRUPTED)
+			{
+				return false;
+			}
+			else if (rc != REPLICANT_NONE_PENDING && rc != REPLICANT_TIMEOUT)
+			{
+				LOG(ERROR) << "coordinator failure: " << replicant_client_error_message(m_repl);
+				LOG(INFO) << "error [" << replicant_returncode_to_string(rc)
+				          << "] at " << replicant_client_error_location(m_repl);
+				increment_sleep(&m_sleep_ms);
+				return false;
+			}
+		}
+		m_sleep_ms = 0;
+		if (id == m_config_id && m_config_status == REPLICANT_SUCCESS)
+		{
+			if (!process_configuration(m_config_data, m_config_data_sz))
+			{
+				increment_sleep(&m_sleep_ms);
+				LOG(ERROR) << "received an invalid configuration from the coordinator";
+				return false;
+			}
+			if (m_config.get_state(m_daemon->m_us) == server::NOT_AVAILABLE)
+			{
+				if (!bring_online())
+				{
+					return false;
+				}
+			}
+			return true;
+		}
+		else if (id == m_checkpoint_id && m_checkpoint_status == REPLICANT_SUCCESS)
+		{
+			uint64_t value_checkpoint_config_version;
+			uint64_t value_checkpoint;
+			uint64_t value_checkpoint_stable;
+			uint64_t value_checkpoint_gc;
+			e::unpacker up(m_checkpoint_data, m_checkpoint_data_sz);
+			up = up >> value_checkpoint_config_version
+			     >> value_checkpoint
+			     >> value_checkpoint_stable
+			     >> value_checkpoint_gc;
+			if (!up.error())
+			{
+				// set the values and force the main thread out of here to act
+				// on new checkpoints
+				m_value_checkpoint_config_version = value_checkpoint_config_version;
+				m_value_checkpoint = value_checkpoint;
+				m_value_checkpoint_stable = value_checkpoint_stable;
+				m_value_checkpoint_gc = value_checkpoint_gc;
+				return false;
+			}
+		}
+		else
+		{
+			std::map<int64_t, e::compat::shared_ptr<rpc> >::iterator rit;
+			rit = m_rpcs.find(id);
+			if (rit == m_rpcs.end())
+			{
+				continue;
+			}
+			e::compat::shared_ptr<rpc> r = rit->second;
+			m_rpcs.erase(rit);
+			if (r->status != REPLICANT_SUCCESS)
+			{
+				increment_sleep(&m_sleep_ms);
+				LOG(ERROR) << "call to coordinator method \"" << r->func
+				           << "\" failed: " << replicant_client_error_message(m_repl);
+				if ((r->flags & REPLICANT_CALL_IDEMPOTENT))
+				{
+					LOG(ERROR) << "retrying call to coordinator method \"" << r->func << "\"";
+					make_rpc_no_synchro(r);
+				}
+			}
+		}
+	}
 }
 
 void
 coordinator_link :: shutdown()
 {
-    e::compat::shared_ptr<rpc> r(new rpc());
-    r->func = "server_shutdown";
-    r->flags = REPLICANT_CALL_IDEMPOTENT;
-    e::packer(&r->input) << m_daemon->m_us;
-    make_rpc(r);
+	e::compat::shared_ptr<rpc> r(new rpc());
+	r->func = "server_shutdown";
+	r->flags = REPLICANT_CALL_IDEMPOTENT;
+	e::packer(&r->input) << m_daemon->m_us;
+	make_rpc(r);
 }
 
 void
 coordinator_link :: config_ack(uint64_t config_version)
 {
-    e::compat::shared_ptr<rpc> r(new rpc());
-    r->func = "config_ack";
-    r->flags = REPLICANT_CALL_IDEMPOTENT;
-    e::packer(&r->input) << m_daemon->m_us << config_version;
-    make_rpc(r);
+	e::compat::shared_ptr<rpc> r(new rpc());
+	r->func = "config_ack";
+	r->flags = REPLICANT_CALL_IDEMPOTENT;
+	e::packer(&r->input) << m_daemon->m_us << config_version;
+	make_rpc(r);
 }
 
 void
 coordinator_link :: config_stable(uint64_t config_version)
 {
-    e::compat::shared_ptr<rpc> r(new rpc());
-    r->func = "config_stable";
-    r->flags = REPLICANT_CALL_IDEMPOTENT;
-    e::packer(&r->input) << m_daemon->m_us << config_version;
-    make_rpc(r);
+	e::compat::shared_ptr<rpc> r(new rpc());
+	r->func = "config_stable";
+	r->flags = REPLICANT_CALL_IDEMPOTENT;
+	e::packer(&r->input) << m_daemon->m_us << config_version;
+	make_rpc(r);
 }
 
 void
 coordinator_link :: checkpoint_report_stable(uint64_t config_version)
 {
-    e::compat::shared_ptr<rpc> r(new rpc());
-    r->func = "checkpoint_stable";
-    r->flags = REPLICANT_CALL_IDEMPOTENT;
-    e::packer(&r->input) << m_daemon->m_us
-                         << m_value_checkpoint_config_version
-                         << config_version;
-    make_rpc(r);
+	e::compat::shared_ptr<rpc> r(new rpc());
+	r->func = "checkpoint_stable";
+	r->flags = REPLICANT_CALL_IDEMPOTENT;
+	e::packer(&r->input) << m_daemon->m_us
+	                     << m_value_checkpoint_config_version
+	                     << config_version;
+	make_rpc(r);
 }
 
 void
-coordinator_link :: transfer_go_live(const transfer_id& id)
+coordinator_link :: transfer_go_live(const transfer_id &id)
 {
-    e::compat::shared_ptr<rpc> r(new rpc());
-    r->func = "transfer_go_live";
-    r->flags = REPLICANT_CALL_IDEMPOTENT;
-    e::packer(&r->input) << id;
-    make_rpc(r);
+	e::compat::shared_ptr<rpc> r(new rpc());
+	r->func = "transfer_go_live";
+	r->flags = REPLICANT_CALL_IDEMPOTENT;
+	e::packer(&r->input) << id;
+	make_rpc(r);
 }
 
 void
-coordinator_link :: transfer_complete(const transfer_id& id)
+coordinator_link :: transfer_complete(const transfer_id &id)
 {
-    e::compat::shared_ptr<rpc> r(new rpc());
-    r->func = "transfer_complete";
-    r->flags = REPLICANT_CALL_IDEMPOTENT;
-    e::packer(&r->input) << id;
-    make_rpc(r);
+	e::compat::shared_ptr<rpc> r(new rpc());
+	r->func = "transfer_complete";
+	r->flags = REPLICANT_CALL_IDEMPOTENT;
+	e::packer(&r->input) << id;
+	make_rpc(r);
 }
 
 void
-coordinator_link :: report_tcp_disconnect(uint64_t config_version, const server_id& id)
+coordinator_link :: report_tcp_disconnect(uint64_t config_version, const server_id &id)
 {
-    e::compat::shared_ptr<rpc> r(new rpc());
-    r->func = "report_disconnect";
-    r->flags = REPLICANT_CALL_IDEMPOTENT;
-    e::packer(&r->input) << config_version << id;
-    make_rpc(r);
+	e::compat::shared_ptr<rpc> r(new rpc());
+	r->func = "report_disconnect";
+	r->flags = REPLICANT_CALL_IDEMPOTENT;
+	e::packer(&r->input) << config_version << id;
+	make_rpc(r);
 }
 
 void
 coordinator_link :: make_rpc(e::compat::shared_ptr<rpc> r)
 {
-    po6::threads::mutex::hold hold(&m_mtx);
-    make_rpc_no_synchro(r);
+	po6::threads::mutex::hold hold(&m_mtx);
+	make_rpc_no_synchro(r);
 }
 
 void
 coordinator_link :: make_rpc_no_synchro(e::compat::shared_ptr<rpc> r)
 {
-    int64_t id = replicant_client_call(m_repl, "hyperdex", r->func.c_str(),
-                                       r->input.data(), r->input.size(), r->flags,
-                                       &r->status, &r->output, &r->output_sz);
-
-    if (id < 0)
-    {
-        LOG(ERROR) << "call to coordinator method \"" << r->func
-                   << "\" failed: " << replicant_client_error_message(m_repl);
-    }
-    else
-    {
-        m_rpcs.insert(std::make_pair(id, r));
-    }
+	int64_t id = replicant_client_call(m_repl, "hyperdex", r->func.c_str(),
+	                                   r->input.data(), r->input.size(), r->flags,
+	                                   &r->status, &r->output, &r->output_sz);
+	if (id < 0)
+	{
+		LOG(ERROR) << "call to coordinator method \"" << r->func
+		           << "\" failed: " << replicant_client_error_message(m_repl);
+	}
+	else
+	{
+		m_rpcs.insert(std::make_pair(id, r));
+	}
 }
 
 bool
-coordinator_link :: synchronous_call(const char* log_action, const char* func,
-                                     const char* input, size_t input_sz,
-                                     char** output, size_t* output_sz)
+coordinator_link :: synchronous_call(const char *log_action, const char *func,
+                                     const char *input, size_t input_sz,
+                                     char **output, size_t *output_sz)
 {
-    po6::threads::mutex::hold hold(&m_mtx);
-    replicant_returncode status;
-    int64_t rid = replicant_client_call(m_repl, "hyperdex", func, input, input_sz,
-                                        REPLICANT_CALL_ROBUST, &status, output, output_sz);
-
-    if (rid < 0)
-    {
-        LOG(ERROR) << "could not " << log_action << ": "
-                   << replicant_client_error_message(m_repl);
-        LOG(INFO) << "error [" << replicant_returncode_to_string(status)
-                  << "] at " << replicant_client_error_location(m_repl);
-        return false;
-    }
-
-    replicant_returncode lstatus = REPLICANT_GARBAGE;
-    int64_t lid = replicant_client_wait(m_repl, rid, -1, &lstatus);
-
-    if (lid < 0)
-    {
-        LOG(ERROR) << "could not " << log_action << ": "
-                   << replicant_client_error_message(m_repl);
-        LOG(INFO) << "error [" << replicant_returncode_to_string(status)
-                  << "] at " << replicant_client_error_location(m_repl);
-        return false;
-    }
-
-    assert(lid == rid);
-
-    if (status != REPLICANT_SUCCESS)
-    {
-        LOG(ERROR) << "could not " << log_action << ": "
-                   << replicant_client_error_message(m_repl);
-        LOG(INFO) << "error [" << replicant_returncode_to_string(status)
-                  << "] at " << replicant_client_error_location(m_repl);
-        return false;
-    }
-
-    return true;
+	po6::threads::mutex::hold hold(&m_mtx);
+	replicant_returncode status;
+	int64_t rid = replicant_client_call(m_repl, "hyperdex", func, input, input_sz,
+	                                    REPLICANT_CALL_ROBUST, &status, output, output_sz);
+	if (rid < 0)
+	{
+		LOG(ERROR) << "could not " << log_action << ": "
+		           << replicant_client_error_message(m_repl);
+		LOG(INFO) << "error [" << replicant_returncode_to_string(status)
+		          << "] at " << replicant_client_error_location(m_repl);
+		return false;
+	}
+	replicant_returncode lstatus = REPLICANT_GARBAGE;
+	int64_t lid = replicant_client_wait(m_repl, rid, -1, &lstatus);
+	if (lid < 0)
+	{
+		LOG(ERROR) << "could not " << log_action << ": "
+		           << replicant_client_error_message(m_repl);
+		LOG(INFO) << "error [" << replicant_returncode_to_string(status)
+		          << "] at " << replicant_client_error_location(m_repl);
+		return false;
+	}
+	assert(lid == rid);
+	if (status != REPLICANT_SUCCESS)
+	{
+		LOG(ERROR) << "could not " << log_action << ": "
+		           << replicant_client_error_message(m_repl);
+		LOG(INFO) << "error [" << replicant_returncode_to_string(status)
+		          << "] at " << replicant_client_error_location(m_repl);
+		return false;
+	}
+	return true;
 }
 
 bool
-coordinator_link :: process_configuration(const char* str, size_t str_sz)
+coordinator_link :: process_configuration(const char *str, size_t str_sz)
 {
-    e::unpacker up(str, str_sz);
-    configuration config;
-    up = up >> config;
-
-    if (up.error())
-    {
-        return false;
-    }
-
-    m_config = config;
-    return true;
+	e::unpacker up(str, str_sz);
+	configuration config;
+	up = up >> config;
+	if (up.error())
+	{
+		return false;
+	}
+	m_config = config;
+	return true;
 }
 
 bool
 coordinator_link :: bring_online()
 {
-    std::string enter_input;
-    e::packer(&enter_input) << m_daemon->m_us << m_daemon->m_bind_to;
-    std::string exit_input;
-    e::packer(&exit_input) << m_daemon->m_us;
-    
-    if (replicant_client_defended_call(m_repl, "hyperdex",
-                                       "server_online", enter_input.data(), enter_input.size(),
-                                       "server_suspect", exit_input.data(), exit_input.size(),
-                                       &m_throwaway_status) < 0)
-    {
-        LOG(ERROR) << "error bringing server online: " << replicant_client_error_message(m_repl);
-        LOG(INFO) << "error [" << replicant_returncode_to_string(m_throwaway_status)
-                  << "] at " << replicant_client_error_location(m_repl);
-        increment_sleep(&m_sleep_ms);
-        return false;
-    }
-
-    return true;
+	std::string enter_input;
+	e::packer(&enter_input) << m_daemon->m_us << m_daemon->m_bind_to;
+	std::string exit_input;
+	e::packer(&exit_input) << m_daemon->m_us;
+	if (replicant_client_defended_call(m_repl, "hyperdex",
+	                                   "server_online", enter_input.data(), enter_input.size(),
+	                                   "server_suspect", exit_input.data(), exit_input.size(),
+	                                   &m_throwaway_status) < 0)
+	{
+		LOG(ERROR) << "error bringing server online: " << replicant_client_error_message(m_repl);
+		LOG(INFO) << "error [" << replicant_returncode_to_string(m_throwaway_status)
+		          << "] at " << replicant_client_error_location(m_repl);
+		increment_sleep(&m_sleep_ms);
+		return false;
+	}
+	return true;
 }
diff --git a/daemon/coordinator_link.h b/daemon/coordinator_link.h
index 0b74e88ab..f4c9111b9 100644
--- a/daemon/coordinator_link.h
+++ b/daemon/coordinator_link.h
@@ -50,71 +50,71 @@ class daemon;
 
 class coordinator_link
 {
-    public:
-        coordinator_link(daemon* d, const char* host, uint16_t port);
-        coordinator_link(daemon* d, const char* conn_str);
-        ~coordinator_link() throw ();
+public:
+	coordinator_link(daemon *d, const char *host, uint16_t port);
+	coordinator_link(daemon *d, const char *conn_str);
+	~coordinator_link() throw ();
 
-    // external synchro required
-    public:
-        bool register_server(server_id us, const po6::net::location& bind_to);
-        bool initialize();
-        bool maintain();
-        void shutdown();
-        const configuration& config() { return m_config; }
-        uint64_t checkpoint_config_version() { return m_value_checkpoint_config_version; }
-        uint64_t checkpoint() { return m_value_checkpoint; }
-        uint64_t checkpoint_stable() { return m_value_checkpoint_stable; }
-        uint64_t checkpoint_gc() { return m_value_checkpoint_gc; }
+	// external synchro required
+public:
+	bool register_server(server_id us, const po6::net::location &bind_to);
+	bool initialize();
+	bool maintain();
+	void shutdown();
+	const configuration &config() { return m_config; }
+	uint64_t checkpoint_config_version() { return m_value_checkpoint_config_version; }
+	uint64_t checkpoint() { return m_value_checkpoint; }
+	uint64_t checkpoint_stable() { return m_value_checkpoint_stable; }
+	uint64_t checkpoint_gc() { return m_value_checkpoint_gc; }
 
-    // internally synchronized
-    public:
-        void config_ack(uint64_t config_version);
-        void config_stable(uint64_t config_version);
-        void checkpoint_report_stable(uint64_t config_version);
-        void transfer_go_live(const transfer_id& id);
-        void transfer_complete(const transfer_id& id);
-        void report_tcp_disconnect(uint64_t config_version, const server_id& id);
+	// internally synchronized
+public:
+	void config_ack(uint64_t config_version);
+	void config_stable(uint64_t config_version);
+	void checkpoint_report_stable(uint64_t config_version);
+	void transfer_go_live(const transfer_id &id);
+	void transfer_complete(const transfer_id &id);
+	void report_tcp_disconnect(uint64_t config_version, const server_id &id);
 
-    private:
-        struct rpc;
-        void make_rpc(e::compat::shared_ptr<rpc> r);
-        void make_rpc_no_synchro(e::compat::shared_ptr<rpc> r);
-        bool synchronous_call(const char* log_action, const char* func,
-                              const char* input, size_t input_sz,
-                              char** output, size_t* output_sz);
-        bool process_configuration(const char* config, size_t config_sz);
-        bool bring_online();
+private:
+	struct rpc;
+	void make_rpc(e::compat::shared_ptr<rpc> r);
+	void make_rpc_no_synchro(e::compat::shared_ptr<rpc> r);
+	bool synchronous_call(const char *log_action, const char *func,
+	                      const char *input, size_t input_sz,
+	                      char **output, size_t *output_sz);
+	bool process_configuration(const char *config, size_t config_sz);
+	bool bring_online();
 
-    private:
-        daemon* m_daemon;
-        unsigned m_sleep_ms;
-        // configuration
-        configuration m_config;
-        int64_t m_config_id;
-        replicant_returncode m_config_status;
-        uint64_t m_config_state;
-        char* m_config_data;
-        size_t m_config_data_sz;
-        // checkpoints
-        int64_t m_checkpoint_id;
-        replicant_returncode m_checkpoint_status;
-        uint64_t m_checkpoint_state;
-        char* m_checkpoint_data;
-        size_t m_checkpoint_data_sz;
-        uint64_t m_value_checkpoint_config_version;
-        uint64_t m_value_checkpoint;
-        uint64_t m_value_checkpoint_stable;
-        uint64_t m_value_checkpoint_gc;
-        // other RPCs
-        replicant_returncode m_throwaway_status;
-        po6::threads::mutex m_mtx;
-        replicant_client* m_repl;
-        std::map<int64_t, e::compat::shared_ptr<rpc> > m_rpcs;
+private:
+	daemon *m_daemon;
+	unsigned m_sleep_ms;
+	// configuration
+	configuration m_config;
+	int64_t m_config_id;
+	replicant_returncode m_config_status;
+	uint64_t m_config_state;
+	char *m_config_data;
+	size_t m_config_data_sz;
+	// checkpoints
+	int64_t m_checkpoint_id;
+	replicant_returncode m_checkpoint_status;
+	uint64_t m_checkpoint_state;
+	char *m_checkpoint_data;
+	size_t m_checkpoint_data_sz;
+	uint64_t m_value_checkpoint_config_version;
+	uint64_t m_value_checkpoint;
+	uint64_t m_value_checkpoint_stable;
+	uint64_t m_value_checkpoint_gc;
+	// other RPCs
+	replicant_returncode m_throwaway_status;
+	po6::threads::mutex m_mtx;
+	replicant_client *m_repl;
+	std::map<int64_t, e::compat::shared_ptr<rpc> > m_rpcs;
 
-    private:
-        coordinator_link(const coordinator_link&);
-        coordinator_link& operator = (const coordinator_link&);
+private:
+	coordinator_link(const coordinator_link &);
+	coordinator_link &operator = (const coordinator_link &);
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/daemon/daemon.cc b/daemon/daemon.cc
index bfcfb298d..b2f768e63 100644
--- a/daemon/daemon.cc
+++ b/daemon/daemon.cc
@@ -70,107 +70,104 @@ bool s_debug = false;
 static void
 exit_on_signal(int /*signum*/)
 {
-    if (__sync_fetch_and_add(&s_interrupts, 1) == 0)
-    {
-        RAW_LOG(ERROR, "interrupted: initiating shutdown; we'll try for up to 10 seconds (interrupt again to exit immediately)");
-    }
-    else
-    {
-        RAW_LOG(ERROR, "interrupted again: exiting immediately");
-    }
+	if (__sync_fetch_and_add(&s_interrupts, 1) == 0)
+	{
+		RAW_LOG(ERROR, "interrupted: initiating shutdown; we'll try for up to 10 seconds (interrupt again to exit immediately)");
+	}
+	else
+	{
+		RAW_LOG(ERROR, "interrupted again: exiting immediately");
+	}
 }
 
 static void
 exit_after_timeout(int /*signum*/)
 {
-    __sync_fetch_and_add(&s_interrupts, 1);
-    RAW_LOG(ERROR, "took too long to shutdown; just exiting");
+	__sync_fetch_and_add(&s_interrupts, 1);
+	RAW_LOG(ERROR, "took too long to shutdown; just exiting");
 }
 
 static void
 handle_debug(int /*signum*/)
 {
-    s_debug = true;
+	s_debug = true;
 }
 
 daemon :: daemon()
-    : m_us()
-    , m_bind_to()
-    , m_threads()
-    , m_gc()
-    , m_gc_ts()
-    , m_coord()
-    , m_data_dir()
-    , m_data(this)
-    , m_comm(this)
-    , m_repl(this)
-    , m_stm(this)
-    , m_sm(this)
-    , m_config()
-    , m_protect_pause()
-    , m_can_pause(&m_protect_pause)
-    , m_paused(false)
-    , m_perf_req_get()
-    , m_perf_req_get_partial()
-    , m_perf_req_atomic()
-    , m_perf_req_search_start()
-    , m_perf_req_search_next()
-    , m_perf_req_search_stop()
-    , m_perf_req_sorted_search()
-    , m_perf_req_count()
-    , m_perf_req_search_describe()
-    , m_perf_req_group_atomic()
-    , m_perf_chain_op()
-    , m_perf_chain_subspace()
-    , m_perf_chain_ack()
-    , m_perf_xfer_handshake_syn()
-    , m_perf_xfer_handshake_synack()
-    , m_perf_xfer_handshake_ack()
-    , m_perf_xfer_handshake_wiped()
-    , m_perf_xfer_op()
-    , m_perf_xfer_ack()
-    , m_perf_backup()
-    , m_perf_perf_counters()
-    , m_block_stat_path()
-    , m_stat_collector(make_thread_wrapper(&daemon::collect_stats, this))
-    , m_protect_stats()
-    , m_stats_start(0)
-    , m_stats()
+	: m_us()
+	, m_bind_to()
+	, m_threads()
+	, m_gc()
+	, m_gc_ts()
+	, m_coord()
+	, m_data_dir()
+	, m_data(this)
+	, m_comm(this)
+	, m_repl(this)
+	, m_stm(this)
+	, m_sm(this)
+	, m_config()
+	, m_protect_pause()
+	, m_can_pause(&m_protect_pause)
+	, m_paused(false)
+	, m_perf_req_get()
+	, m_perf_req_get_partial()
+	, m_perf_req_atomic()
+	, m_perf_req_search_start()
+	, m_perf_req_search_next()
+	, m_perf_req_search_stop()
+	, m_perf_req_sorted_search()
+	, m_perf_req_count()
+	, m_perf_req_search_describe()
+	, m_perf_req_group_atomic()
+	, m_perf_chain_op()
+	, m_perf_chain_subspace()
+	, m_perf_chain_ack()
+	, m_perf_xfer_handshake_syn()
+	, m_perf_xfer_handshake_synack()
+	, m_perf_xfer_handshake_ack()
+	, m_perf_xfer_handshake_wiped()
+	, m_perf_xfer_op()
+	, m_perf_xfer_ack()
+	, m_perf_backup()
+	, m_perf_perf_counters()
+	, m_block_stat_path()
+	, m_stat_collector(make_thread_wrapper(&daemon::collect_stats, this))
+	, m_protect_stats()
+	, m_stats_start(0)
+	, m_stats()
 {
-    m_gc.register_thread(&m_gc_ts);
+	m_gc.register_thread(&m_gc_ts);
 }
 
 daemon :: ~daemon() throw ()
 {
-    m_gc.deregister_thread(&m_gc_ts);
+	m_gc.deregister_thread(&m_gc_ts);
 }
 
 static bool
 install_signal_handler(int signum, void (*f)(int))
 {
-    struct sigaction handle;
-    handle.sa_handler = f;
-    sigfillset(&handle.sa_mask);
-    handle.sa_flags = SA_RESTART;
-    return sigaction(signum, &handle, NULL) >= 0;
+	struct sigaction handle;
+	handle.sa_handler = f;
+	sigfillset(&handle.sa_mask);
+	handle.sa_flags = SA_RESTART;
+	return sigaction(signum, &handle, NULL) >= 0;
 }
 
 static bool
-generate_token(uint64_t* token)
+generate_token(uint64_t *token)
 {
-    po6::io::fd sysrand(open("/dev/urandom", O_RDONLY));
-
-    if (sysrand.get() < 0)
-    {
-        return false;
-    }
-
-    if (sysrand.read(token, sizeof(*token)) != sizeof(*token))
-    {
-        return false;
-    }
-
-    return true;
+	po6::io::fd sysrand(open("/dev/urandom", O_RDONLY));
+	if (sysrand.get() < 0)
+	{
+		return false;
+	}
+	if (sysrand.read(token, sizeof(*token)) != sizeof(*token))
+	{
+		return false;
+	}
+	return true;
 }
 
 int
@@ -185,507 +182,453 @@ daemon :: run(bool daemonize,
               po6::net::hostname coordinator,
               unsigned threads)
 {
-    if (!install_signal_handler(SIGHUP, exit_on_signal) ||
-        !install_signal_handler(SIGINT, exit_on_signal) ||
-        !install_signal_handler(SIGTERM, exit_on_signal) ||
-        !install_signal_handler(SIGUSR2, handle_debug))
-    {
-        std::cerr << "could not install signal handlers: " << po6::strerror(errno) << std::endl;
-        return EXIT_FAILURE;
-    }
-
-    sigset_t ss;
-
-    if (sigfillset(&ss) < 0 ||
-        pthread_sigmask(SIG_SETMASK, &ss, NULL) < 0)
-    {
-        std::cerr << "could not block signals: " << po6::strerror(errno) << std::endl;
-        return EXIT_FAILURE;
-    }
-
-    google::LogToStderr();
-
-    if (daemonize)
-    {
-        struct stat x;
-
-        if (lstat(log.c_str(), &x) < 0 || !S_ISDIR(x.st_mode))
-        {
-            LOG(ERROR) << "cannot fork off to the background because "
-                       << log.c_str() << " does not exist or is not writable";
-            return EXIT_FAILURE;
-        }
-
-        if (!has_pidfile)
-        {
-            LOG(INFO) << "forking off to the background";
-            LOG(INFO) << "you can find the log at " << log.c_str() << "/hyperdex-daemon-YYYYMMDD-HHMMSS.sssss";
-            LOG(INFO) << "provide \"--foreground\" on the command-line if you want to run in the foreground";
-        }
-
-        google::SetLogSymlink(google::INFO, "");
-        google::SetLogSymlink(google::WARNING, "");
-        google::SetLogSymlink(google::ERROR, "");
-        google::SetLogSymlink(google::FATAL, "");
-        log = po6::path::join(log, "hyperdex-daemon-");
-        google::SetLogDestination(google::INFO, log.c_str());
-
-        if (::daemon(1, 0) < 0)
-        {
-            PLOG(ERROR) << "could not daemonize";
-            return EXIT_FAILURE;
-        }
-
-        if (has_pidfile)
-        {
-            char buf[21];
-            ssize_t buf_sz = sprintf(buf, "%d\n", getpid());
-            assert(buf_sz < static_cast<ssize_t>(sizeof(buf)));
-            po6::io::fd pid(open(pidfile.c_str(), O_WRONLY|O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR));
-
-            if (pid.get() < 0 || pid.xwrite(buf, buf_sz) != buf_sz)
-            {
-                PLOG(ERROR) << "could not create pidfile " << pidfile.c_str();
-                return EXIT_FAILURE;
-            }
-        }
-    }
-    else
-    {
-        LOG(INFO) << "running in the foreground";
-        LOG(INFO) << "no log will be generated; instead, the log messages will print to the terminal";
-        LOG(INFO) << "provide \"--daemon\" on the command-line if you want to run in the background";
-    }
-
-    bool saved = false;
-    server_id saved_us;
-    po6::net::location saved_bind_to;
-    po6::net::hostname saved_coordinator;
-    LOG(INFO) << "initializing local storage";
-    m_data_dir = data;
-
-    if (!m_data.initialize(data, &saved, &saved_us, &saved_bind_to, &saved_coordinator))
-    {
-        return EXIT_FAILURE;
-    }
-
-    if (po6::path::dirname(data).size())
-    {
-        if (chdir(po6::path::dirname(data).c_str()) < 0)
-        {
-            PLOG(ERROR) << "could not change cwd to data directory";
-            return EXIT_FAILURE;
-        }
-    }
-
-    if (saved)
-    {
-        if (set_bind_to && bind_to != saved_bind_to)
-        {
-            LOG(INFO) << "changing bind address from "
-                      << saved_bind_to << " to " << bind_to;
-        }
-        else
-        {
-            bind_to = saved_bind_to;
-        }
-
-        if (set_coordinator && coordinator != saved_coordinator)
-        {
-            LOG(INFO) << "changing coordinator address from "
-                      << saved_coordinator << " to " << coordinator;
-        }
-        else
-        {
-            coordinator = saved_coordinator;
-        }
-
-        m_us = saved_us;
-    }
-
-    m_bind_to = bind_to;
-    m_coord.reset(new coordinator_link(this, coordinator.address.c_str(), coordinator.port));
-
-    if (!saved)
-    {
-        uint64_t sid;
-
-        if (!generate_token(&sid))
-        {
-            PLOG(ERROR) << "could not read random token from /dev/urandom";
-            return EXIT_FAILURE;
-        }
-
-        LOG(INFO) << "generated new random token:  " << sid;
-
-        if (!m_coord->register_server(server_id(sid), bind_to))
-        {
-            return EXIT_FAILURE;
-        }
-
-        m_us = server_id(sid);
-    }
-
-    if (!m_data.save_state(m_us, bind_to, coordinator))
-    {
-        return EXIT_FAILURE;
-    }
-
-    if (!m_coord->initialize())
-    {
-        return EXIT_FAILURE;
-    }
-
-    determine_block_stat_path(data);
-    m_comm.setup(bind_to, threads);
-    m_repl.setup();
-    m_stm.setup();
-    m_sm.setup();
-
-    for (size_t i = 0; i < threads; ++i)
-    {
-        using namespace po6::threads;
-        e::compat::shared_ptr<thread> t(new thread(make_thread_wrapper(&daemon::loop, this, i)));
-        m_threads.push_back(t);
-        t->start();
-    }
-
-    m_stat_collector.start();
-    uint64_t checkpoint = 0;
-    uint64_t checkpoint_stable = 0;
-    uint64_t checkpoint_gc = 0;
-
-    while (__sync_fetch_and_add(&s_interrupts, 0) < 2)
-    {
-        if (s_debug)
-        {
-            s_debug = false;
-            LOG(INFO) << "recieved SIGUSR2; dumping internal tables";
-            m_data.debug_dump();
-            m_repl.debug_dump();
-            m_stm.debug_dump();
-            LOG(INFO) << "end debug dump";
-        }
-
-        if (__sync_fetch_and_add(&s_interrupts, 0) == 1)
-        {
-            if (!install_signal_handler(SIGALRM, exit_after_timeout))
-            {
-                __sync_fetch_and_add(&s_interrupts, 2);
-                break;
-            }
-
-            alarm(10);
-            m_coord->shutdown();
-        }
-
-        if (m_config.version() > 0 &&
-            m_config.version() == m_coord->checkpoint_config_version() &&
-            checkpoint < m_coord->checkpoint())
-        {
-            checkpoint = m_coord->checkpoint();
-            m_repl.begin_checkpoint(checkpoint);
-        }
-
-        if (m_config.version() > 0 &&
-            m_config.version() == m_coord->checkpoint_config_version() &&
-            checkpoint_stable < m_coord->checkpoint_stable())
-        {
-            checkpoint_stable = m_coord->checkpoint_stable();
-            m_repl.end_checkpoint(checkpoint_stable);
-        }
-
-        if (m_config.version() > 0 &&
-            m_config.version() == m_coord->checkpoint_config_version() &&
-            checkpoint_gc < m_coord->checkpoint_gc())
-        {
-            checkpoint_gc = m_coord->checkpoint_gc();
-            m_data.set_checkpoint_gc(checkpoint_gc);
-        }
-
-
-        m_gc.offline(&m_gc_ts);
-        bool have_config = m_coord->maintain();
-        m_gc.online(&m_gc_ts);
-
-        if (!have_config)
-        {
-            continue;
-        }
-
-        const configuration& old_config(m_config);
-        const configuration& new_config(m_coord->config());
-
-        if (old_config.cluster() != 0 &&
-            old_config.cluster() != new_config.cluster())
-        {
-            LOG(ERROR) << "================================================================================";
-            LOG(ERROR) << "Exiting because the coordinator changed on us.";
-            LOG(ERROR) << "This is most likely the result of deploying a new cluster in place of an";
-            LOG(ERROR) << "existing cluster, and then switching daemons from the old cluster to the new";
-            LOG(ERROR) << "cluster.  To protect data on this node, it will exit.";
-            LOG(ERROR) << "To fix this issue, use the --coordinator flag to specify the coordinator";
-            LOG(ERROR) << "that this HyperDex data node was originally connected to.";
-            LOG(ERROR) << "================================================================================";
-            break;
-        }
-
-        if (__sync_fetch_and_add(&s_interrupts, 0) > 0 &&
-            m_coord->config().get_state(m_us) == server::SHUTDOWN)
-        {
-            break;
-        }
-
-        if (!new_config.exists(m_us))
-        {
-            LOG(ERROR) << "================================================================================";
-            LOG(ERROR) << "Exiting because the coordinator does not know about this node.";
-            LOG(ERROR) << "This is most likely the result of running the command";
-            LOG(ERROR) << "\t\"hyperdex server-forget " << m_us.get() << "\"";
-            LOG(ERROR) << "If you can verify that the cluster is otherwise operational,";
-            LOG(ERROR) << "you should be able to delete the data directory of this node";
-            LOG(ERROR) << "and re-connect it to the cluster under a different identity.";
-            LOG(ERROR) << "================================================================================";
-            break;
-        }
-
-        if (old_config.version() > new_config.version())
-        {
-            LOG(ERROR) << "received new configuration version=" << new_config.version()
-                       << " that's older than our current configuration version="
-                       << old_config.version();
-            continue;
-        }
-        else if (old_config.version() >= new_config.version())
-        {
-            continue;
-        }
-
-        LOG(INFO) << "moving to configuration version=" << new_config.version()
-                  << "; pausing all activity while we reconfigure";
-        this->pause();
-        m_comm.reconfigure(old_config, new_config, m_us);
-        m_data.reconfigure(old_config, new_config, m_us);
-        m_repl.reconfigure(old_config, new_config, m_us);
-        m_stm.reconfigure(old_config, new_config, m_us);
-        m_sm.reconfigure(old_config, new_config, m_us);
-        m_config = new_config;
-        this->unpause();
-        LOG(INFO) << "reconfiguration complete; resuming normal operation";
-
-        // let the coordinator know we've moved to this config
-        m_coord->config_ack(new_config.version());
-    }
-
-    __sync_fetch_and_add(&s_interrupts, 2);
-    m_stat_collector.join();
-    m_comm.shutdown();
-
-    for (size_t i = 0; i < m_threads.size(); ++i)
-    {
-        m_threads[i]->join();
-    }
-
-    m_sm.teardown();
-    m_stm.teardown();
-    m_repl.teardown();
-    m_comm.teardown();
-    m_data.teardown();
-    LOG(INFO) << "hyperdex-daemon will now terminate";
-    return EXIT_SUCCESS;
+	if (!install_signal_handler(SIGHUP, exit_on_signal) ||
+	    !install_signal_handler(SIGINT, exit_on_signal) ||
+	    !install_signal_handler(SIGTERM, exit_on_signal) ||
+	    !install_signal_handler(SIGUSR2, handle_debug))
+	{
+		std::cerr << "could not install signal handlers: " << po6::strerror(errno) << std::endl;
+		return EXIT_FAILURE;
+	}
+	sigset_t ss;
+	if (sigfillset(&ss) < 0 ||
+	    pthread_sigmask(SIG_SETMASK, &ss, NULL) < 0)
+	{
+		std::cerr << "could not block signals: " << po6::strerror(errno) << std::endl;
+		return EXIT_FAILURE;
+	}
+	google::LogToStderr();
+	if (daemonize)
+	{
+		struct stat x;
+		if (lstat(log.c_str(), &x) < 0 || !S_ISDIR(x.st_mode))
+		{
+			LOG(ERROR) << "cannot fork off to the background because "
+			           << log.c_str() << " does not exist or is not writable";
+			return EXIT_FAILURE;
+		}
+		if (!has_pidfile)
+		{
+			LOG(INFO) << "forking off to the background";
+			LOG(INFO) << "you can find the log at " << log.c_str() << "/hyperdex-daemon-YYYYMMDD-HHMMSS.sssss";
+			LOG(INFO) << "provide \"--foreground\" on the command-line if you want to run in the foreground";
+		}
+		google::SetLogSymlink(google::INFO, "");
+		google::SetLogSymlink(google::WARNING, "");
+		google::SetLogSymlink(google::ERROR, "");
+		google::SetLogSymlink(google::FATAL, "");
+		log = po6::path::join(log, "hyperdex-daemon-");
+		google::SetLogDestination(google::INFO, log.c_str());
+		if (::daemon(1, 0) < 0)
+		{
+			PLOG(ERROR) << "could not daemonize";
+			return EXIT_FAILURE;
+		}
+		if (has_pidfile)
+		{
+			char buf[21];
+			ssize_t buf_sz = sprintf(buf, "%d\n", getpid());
+			assert(buf_sz < static_cast<ssize_t>(sizeof(buf)));
+			po6::io::fd pid(open(pidfile.c_str(), O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR));
+			if (pid.get() < 0 || pid.xwrite(buf, buf_sz) != buf_sz)
+			{
+				PLOG(ERROR) << "could not create pidfile " << pidfile.c_str();
+				return EXIT_FAILURE;
+			}
+		}
+	}
+	else
+	{
+		LOG(INFO) << "running in the foreground";
+		LOG(INFO) << "no log will be generated; instead, the log messages will print to the terminal";
+		LOG(INFO) << "provide \"--daemon\" on the command-line if you want to run in the background";
+	}
+	bool saved = false;
+	server_id saved_us;
+	po6::net::location saved_bind_to;
+	po6::net::hostname saved_coordinator;
+	LOG(INFO) << "initializing local storage";
+	m_data_dir = data;
+	if (!m_data.initialize(data, &saved, &saved_us, &saved_bind_to, &saved_coordinator))
+	{
+		return EXIT_FAILURE;
+	}
+	if (po6::path::dirname(data).size())
+	{
+		if (chdir(po6::path::dirname(data).c_str()) < 0)
+		{
+			PLOG(ERROR) << "could not change cwd to data directory";
+			return EXIT_FAILURE;
+		}
+	}
+	if (saved)
+	{
+		if (set_bind_to && bind_to != saved_bind_to)
+		{
+			LOG(INFO) << "changing bind address from "
+			          << saved_bind_to << " to " << bind_to;
+		}
+		else
+		{
+			bind_to = saved_bind_to;
+		}
+		if (set_coordinator && coordinator != saved_coordinator)
+		{
+			LOG(INFO) << "changing coordinator address from "
+			          << saved_coordinator << " to " << coordinator;
+		}
+		else
+		{
+			coordinator = saved_coordinator;
+		}
+		m_us = saved_us;
+	}
+	m_bind_to = bind_to;
+	m_coord.reset(new coordinator_link(this, coordinator.address.c_str(), coordinator.port));
+	if (!saved)
+	{
+		uint64_t sid;
+		if (!generate_token(&sid))
+		{
+			PLOG(ERROR) << "could not read random token from /dev/urandom";
+			return EXIT_FAILURE;
+		}
+		LOG(INFO) << "generated new random token:  " << sid;
+		if (!m_coord->register_server(server_id(sid), bind_to))
+		{
+			return EXIT_FAILURE;
+		}
+		m_us = server_id(sid);
+	}
+	if (!m_data.save_state(m_us, bind_to, coordinator))
+	{
+		return EXIT_FAILURE;
+	}
+	if (!m_coord->initialize())
+	{
+		return EXIT_FAILURE;
+	}
+	determine_block_stat_path(data);
+	m_comm.setup(bind_to, threads);
+	m_repl.setup();
+	m_stm.setup();
+	m_sm.setup();
+	for (size_t i = 0; i < threads; ++i)
+	{
+		using namespace po6::threads;
+		e::compat::shared_ptr<thread> t(new thread(make_thread_wrapper(&daemon::loop, this, i)));
+		m_threads.push_back(t);
+		t->start();
+	}
+	m_stat_collector.start();
+	uint64_t checkpoint = 0;
+	uint64_t checkpoint_stable = 0;
+	uint64_t checkpoint_gc = 0;
+	while (__sync_fetch_and_add(&s_interrupts, 0) < 2)
+	{
+		if (s_debug)
+		{
+			s_debug = false;
+			LOG(INFO) << "recieved SIGUSR2; dumping internal tables";
+			m_data.debug_dump();
+			m_repl.debug_dump();
+			m_stm.debug_dump();
+			LOG(INFO) << "end debug dump";
+		}
+		if (__sync_fetch_and_add(&s_interrupts, 0) == 1)
+		{
+			if (!install_signal_handler(SIGALRM, exit_after_timeout))
+			{
+				__sync_fetch_and_add(&s_interrupts, 2);
+				break;
+			}
+			alarm(10);
+			m_coord->shutdown();
+		}
+		if (m_config.version() > 0 &&
+		    m_config.version() == m_coord->checkpoint_config_version() &&
+		    checkpoint < m_coord->checkpoint())
+		{
+			checkpoint = m_coord->checkpoint();
+			m_repl.begin_checkpoint(checkpoint);
+		}
+		if (m_config.version() > 0 &&
+		    m_config.version() == m_coord->checkpoint_config_version() &&
+		    checkpoint_stable < m_coord->checkpoint_stable())
+		{
+			checkpoint_stable = m_coord->checkpoint_stable();
+			m_repl.end_checkpoint(checkpoint_stable);
+		}
+		if (m_config.version() > 0 &&
+		    m_config.version() == m_coord->checkpoint_config_version() &&
+		    checkpoint_gc < m_coord->checkpoint_gc())
+		{
+			checkpoint_gc = m_coord->checkpoint_gc();
+			m_data.set_checkpoint_gc(checkpoint_gc);
+		}
+		m_gc.offline(&m_gc_ts);
+		bool have_config = m_coord->maintain();
+		m_gc.online(&m_gc_ts);
+		if (!have_config)
+		{
+			continue;
+		}
+		const configuration &old_config(m_config);
+		const configuration &new_config(m_coord->config());
+		if (old_config.cluster() != 0 &&
+		    old_config.cluster() != new_config.cluster())
+		{
+			LOG(ERROR) << "================================================================================";
+			LOG(ERROR) << "Exiting because the coordinator changed on us.";
+			LOG(ERROR) << "This is most likely the result of deploying a new cluster in place of an";
+			LOG(ERROR) << "existing cluster, and then switching daemons from the old cluster to the new";
+			LOG(ERROR) << "cluster.  To protect data on this node, it will exit.";
+			LOG(ERROR) << "To fix this issue, use the --coordinator flag to specify the coordinator";
+			LOG(ERROR) << "that this HyperDex data node was originally connected to.";
+			LOG(ERROR) << "================================================================================";
+			break;
+		}
+		if (__sync_fetch_and_add(&s_interrupts, 0) > 0 &&
+		    m_coord->config().get_state(m_us) == server::SHUTDOWN)
+		{
+			break;
+		}
+		if (!new_config.exists(m_us))
+		{
+			LOG(ERROR) << "================================================================================";
+			LOG(ERROR) << "Exiting because the coordinator does not know about this node.";
+			LOG(ERROR) << "This is most likely the result of running the command";
+			LOG(ERROR) << "\t\"hyperdex server-forget " << m_us.get() << "\"";
+			LOG(ERROR) << "If you can verify that the cluster is otherwise operational,";
+			LOG(ERROR) << "you should be able to delete the data directory of this node";
+			LOG(ERROR) << "and re-connect it to the cluster under a different identity.";
+			LOG(ERROR) << "================================================================================";
+			break;
+		}
+		if (old_config.version() > new_config.version())
+		{
+			LOG(ERROR) << "received new configuration version=" << new_config.version()
+			           << " that's older than our current configuration version="
+			           << old_config.version();
+			continue;
+		}
+		else if (old_config.version() >= new_config.version())
+		{
+			continue;
+		}
+		LOG(INFO) << "moving to configuration version=" << new_config.version()
+		          << "; pausing all activity while we reconfigure";
+		this->pause();
+		m_comm.reconfigure(old_config, new_config, m_us);
+		m_data.reconfigure(old_config, new_config, m_us);
+		m_repl.reconfigure(old_config, new_config, m_us);
+		m_stm.reconfigure(old_config, new_config, m_us);
+		m_sm.reconfigure(old_config, new_config, m_us);
+		m_config = new_config;
+		this->unpause();
+		LOG(INFO) << "reconfiguration complete; resuming normal operation";
+		// let the coordinator know we've moved to this config
+		m_coord->config_ack(new_config.version());
+	}
+	__sync_fetch_and_add(&s_interrupts, 2);
+	m_stat_collector.join();
+	m_comm.shutdown();
+	for (size_t i = 0; i < m_threads.size(); ++i)
+	{
+		m_threads[i]->join();
+	}
+	m_sm.teardown();
+	m_stm.teardown();
+	m_repl.teardown();
+	m_comm.teardown();
+	m_data.teardown();
+	LOG(INFO) << "hyperdex-daemon will now terminate";
+	return EXIT_SUCCESS;
 }
 
 void
 daemon :: pause()
 {
-    po6::threads::mutex::hold hold(&m_protect_pause);
-
-    while (m_paused)
-    {
-        m_can_pause.wait();
-    }
-
-    m_paused = true;
-    m_sm.pause();
-    m_stm.pause();
-    m_repl.pause();
-    m_data.pause();
-    m_comm.pause();
+	po6::threads::mutex::hold hold(&m_protect_pause);
+	while (m_paused)
+	{
+		m_can_pause.wait();
+	}
+	m_paused = true;
+	m_sm.pause();
+	m_stm.pause();
+	m_repl.pause();
+	m_data.pause();
+	m_comm.pause();
 }
 
 void
 daemon :: unpause()
 {
-    po6::threads::mutex::hold hold(&m_protect_pause);
-    m_comm.unpause();
-    m_data.unpause();
-    m_repl.unpause();
-    m_stm.unpause();
-    m_sm.unpause();
-    assert(m_paused);
-    m_paused = false;
-    m_can_pause.signal();
+	po6::threads::mutex::hold hold(&m_protect_pause);
+	m_comm.unpause();
+	m_data.unpause();
+	m_repl.unpause();
+	m_stm.unpause();
+	m_sm.unpause();
+	assert(m_paused);
+	m_paused = false;
+	m_can_pause.signal();
 }
 
 void
 daemon :: loop(size_t thread)
 {
-    sigset_t ss;
-
-    size_t core = thread % sysconf(_SC_NPROCESSORS_ONLN);
+	sigset_t ss;
+	size_t core = thread % sysconf(_SC_NPROCESSORS_ONLN);
 #ifdef __LINUX__
-    cpu_set_t cpuset;
-    CPU_ZERO(&cpuset);
-    CPU_SET(core, &cpuset);
-    pthread_t cur = pthread_self();
-    int x = pthread_setaffinity_np(cur, sizeof(cpu_set_t), &cpuset);
-    assert(x == 0);
+	cpu_set_t cpuset;
+	CPU_ZERO(&cpuset);
+	CPU_SET(core, &cpuset);
+	pthread_t cur = pthread_self();
+	int x = pthread_setaffinity_np(cur, sizeof(cpu_set_t), &cpuset);
+	assert(x == 0);
 #elif defined(__APPLE__)
-    thread_affinity_policy_data_t policy;
-    policy.affinity_tag = 0;
-    thread_policy_set(mach_thread_self(),
-                      THREAD_AFFINITY_POLICY,
-                      (thread_policy_t)&policy,
-                      THREAD_AFFINITY_POLICY_COUNT);
+	thread_affinity_policy_data_t policy;
+	policy.affinity_tag = 0;
+	thread_policy_set(mach_thread_self(),
+	                  THREAD_AFFINITY_POLICY,
+	                  (thread_policy_t)&policy,
+	                  THREAD_AFFINITY_POLICY_COUNT);
 #endif
-
-    LOG(INFO) << "network thread " << thread << " started on core " << core;
-
-    if (sigfillset(&ss) < 0)
-    {
-        PLOG(ERROR) << "sigfillset";
-        return;
-    }
-
-    sigdelset(&ss, SIGPROF);
-
-    if (pthread_sigmask(SIG_SETMASK, &ss, NULL) < 0)
-    {
-        PLOG(ERROR) << "could not block signals";
-        return;
-    }
-
-    e::garbage_collector::thread_state ts;
-    m_gc.register_thread(&ts);
-
-    server_id from;
-    virtual_server_id vfrom;
-    virtual_server_id vto;
-    network_msgtype type;
-    std::auto_ptr<e::buffer> msg;
-    e::unpacker up;
-
-    while (m_comm.recv(&ts, &from, &vfrom, &vto, &type, &msg, &up))
-    {
-        assert(from != server_id());
-        assert(vto != virtual_server_id());
-
-        switch (type)
-        {
-            case REQ_GET:
-                process_req_get(from, vfrom, vto, msg, up);
-                m_perf_req_get.tap();
-                break;
-            case REQ_GET_PARTIAL:
-                process_req_get_partial(from, vfrom, vto, msg, up);
-                m_perf_req_get_partial.tap();
-                break;
-            case REQ_ATOMIC:
-                process_req_atomic(from, vfrom, vto, msg, up);
-                m_perf_req_atomic.tap();
-                break;
-            case REQ_SEARCH_START:
-                process_req_search_start(from, vfrom, vto, msg, up);
-                m_perf_req_search_start.tap();
-                break;
-            case REQ_SEARCH_NEXT:
-                process_req_search_next(from, vfrom, vto, msg, up);
-                m_perf_req_search_next.tap();
-                break;
-            case REQ_SEARCH_STOP:
-                process_req_search_stop(from, vfrom, vto, msg, up);
-                m_perf_req_search_stop.tap();
-                break;
-            case REQ_SORTED_SEARCH:
-                process_req_sorted_search(from, vfrom, vto, msg, up);
-                m_perf_req_sorted_search.tap();
-                break;
-            case REQ_COUNT:
-                process_req_count(from, vfrom, vto, msg, up);
-                m_perf_req_count.tap();
-                break;
-            case REQ_SEARCH_DESCRIBE:
-                process_req_search_describe(from, vfrom, vto, msg, up);
-                m_perf_req_search_describe.tap();
-                break;
-            case REQ_GROUP_ATOMIC:
-                process_req_group_atomic(from, vfrom, vto, msg, up);
-                m_perf_req_group_atomic.tap();
-                break;
-            case CHAIN_OP:
-                process_chain_op(from, vfrom, vto, msg, up);
-                m_perf_chain_op.tap();
-                break;
-            case CHAIN_SUBSPACE:
-                process_chain_subspace(from, vfrom, vto, msg, up);
-                m_perf_chain_subspace.tap();
-                break;
-            case CHAIN_ACK:
-                process_chain_ack(from, vfrom, vto, msg, up);
-                m_perf_chain_ack.tap();
-                break;
-            case XFER_HS:
-                process_xfer_handshake_syn(from, vfrom, vto, msg, up);
-                m_perf_xfer_handshake_syn.tap();
-                break;
-            case XFER_HSA:
-                process_xfer_handshake_synack(from, vfrom, vto, msg, up);
-                m_perf_xfer_handshake_synack.tap();
-                break;
-            case XFER_HA:
-                process_xfer_handshake_ack(from, vfrom, vto, msg, up);
-                m_perf_xfer_handshake_ack.tap();
-                break;
-            case XFER_HW:
-                process_xfer_handshake_wiped(from, vfrom, vto, msg, up);
-                m_perf_xfer_handshake_wiped.tap();
-                break;
-            case XFER_OP:
-                process_xfer_op(from, vfrom, vto, msg, up);
-                m_perf_xfer_op.tap();
-                break;
-            case XFER_ACK:
-                process_xfer_ack(from, vfrom, vto, msg, up);
-                m_perf_xfer_ack.tap();
-                break;
-            case BACKUP:
-                process_backup(from, vfrom, vto, msg, up);
-                m_perf_backup.tap();
-            case PERF_COUNTERS:
-                process_perf_counters(from, vfrom, vto, msg, up);
-                m_perf_perf_counters.tap();
-                break;
-            case RESP_GET:
-            case RESP_GET_PARTIAL:
-            case RESP_ATOMIC:
-            case RESP_GROUP_ATOMIC:
-            case RESP_SEARCH_ITEM:
-            case RESP_SEARCH_DONE:
-            case RESP_SORTED_SEARCH:
-            case RESP_COUNT:
-            case RESP_SEARCH_DESCRIBE:
-            case CONFIGMISMATCH:
-            case PACKET_NOP:
-            default:
-                LOG(INFO) << "received " << type << " message which servers do not process";
-                break;
-        }
-
-        m_gc.quiescent_state(&ts);
-    }
-
-    m_gc.deregister_thread(&ts);
-    LOG(INFO) << "network thread shutting down";
+	LOG(INFO) << "network thread " << thread << " started on core " << core;
+	if (sigfillset(&ss) < 0)
+	{
+		PLOG(ERROR) << "sigfillset";
+		return;
+	}
+	sigdelset(&ss, SIGPROF);
+	if (pthread_sigmask(SIG_SETMASK, &ss, NULL) < 0)
+	{
+		PLOG(ERROR) << "could not block signals";
+		return;
+	}
+	e::garbage_collector::thread_state ts;
+	m_gc.register_thread(&ts);
+	server_id from;
+	virtual_server_id vfrom;
+	virtual_server_id vto;
+	network_msgtype type;
+	std::auto_ptr<e::buffer> msg;
+	e::unpacker up;
+	while (m_comm.recv(&ts, &from, &vfrom, &vto, &type, &msg, &up))
+	{
+		assert(from != server_id());
+		assert(vto != virtual_server_id());
+		switch (type)
+		{
+		case REQ_GET:
+			process_req_get(from, vfrom, vto, msg, up);
+			m_perf_req_get.tap();
+			break;
+		case REQ_GET_PARTIAL:
+			process_req_get_partial(from, vfrom, vto, msg, up);
+			m_perf_req_get_partial.tap();
+			break;
+		case REQ_ATOMIC:
+			process_req_atomic(from, vfrom, vto, msg, up);
+			m_perf_req_atomic.tap();
+			break;
+		case REQ_SEARCH_START:
+			process_req_search_start(from, vfrom, vto, msg, up);
+			m_perf_req_search_start.tap();
+			break;
+		case REQ_SEARCH_NEXT:
+			process_req_search_next(from, vfrom, vto, msg, up);
+			m_perf_req_search_next.tap();
+			break;
+		case REQ_SEARCH_STOP:
+			process_req_search_stop(from, vfrom, vto, msg, up);
+			m_perf_req_search_stop.tap();
+			break;
+		case REQ_SORTED_SEARCH:
+			process_req_sorted_search(from, vfrom, vto, msg, up);
+			m_perf_req_sorted_search.tap();
+			break;
+		case REQ_COUNT:
+			process_req_count(from, vfrom, vto, msg, up);
+			m_perf_req_count.tap();
+			break;
+		case REQ_SUM:
+			process_req_sum(from, vfrom, vto, msg, up);
+			m_perf_req_sum.tap();
+			break;
+		case REQ_SEARCH_DESCRIBE:
+			process_req_search_describe(from, vfrom, vto, msg, up);
+			m_perf_req_search_describe.tap();
+			break;
+		case REQ_GROUP_ATOMIC:
+			process_req_group_atomic(from, vfrom, vto, msg, up);
+			m_perf_req_group_atomic.tap();
+			break;
+		case CHAIN_OP:
+			process_chain_op(from, vfrom, vto, msg, up);
+			m_perf_chain_op.tap();
+			break;
+		case CHAIN_SUBSPACE:
+			process_chain_subspace(from, vfrom, vto, msg, up);
+			m_perf_chain_subspace.tap();
+			break;
+		case CHAIN_ACK:
+			process_chain_ack(from, vfrom, vto, msg, up);
+			m_perf_chain_ack.tap();
+			break;
+		case XFER_HS:
+			process_xfer_handshake_syn(from, vfrom, vto, msg, up);
+			m_perf_xfer_handshake_syn.tap();
+			break;
+		case XFER_HSA:
+			process_xfer_handshake_synack(from, vfrom, vto, msg, up);
+			m_perf_xfer_handshake_synack.tap();
+			break;
+		case XFER_HA:
+			process_xfer_handshake_ack(from, vfrom, vto, msg, up);
+			m_perf_xfer_handshake_ack.tap();
+			break;
+		case XFER_HW:
+			process_xfer_handshake_wiped(from, vfrom, vto, msg, up);
+			m_perf_xfer_handshake_wiped.tap();
+			break;
+		case XFER_OP:
+			process_xfer_op(from, vfrom, vto, msg, up);
+			m_perf_xfer_op.tap();
+			break;
+		case XFER_ACK:
+			process_xfer_ack(from, vfrom, vto, msg, up);
+			m_perf_xfer_ack.tap();
+			break;
+		case BACKUP:
+			process_backup(from, vfrom, vto, msg, up);
+			m_perf_backup.tap();
+		case PERF_COUNTERS:
+			process_perf_counters(from, vfrom, vto, msg, up);
+			m_perf_perf_counters.tap();
+			break;
+		case RESP_GET:
+		case RESP_GET_PARTIAL:
+		case RESP_ATOMIC:
+		case RESP_GROUP_ATOMIC:
+		case RESP_SEARCH_ITEM:
+		case RESP_SEARCH_DONE:
+		case RESP_SORTED_SEARCH:
+		case RESP_COUNT:
+		case RESP_SUM:
+		case RESP_SEARCH_DESCRIBE:
+		case CONFIGMISMATCH:
+		case PACKET_NOP:
+		default:
+			LOG(INFO) << "received " << type << " message which servers do not process";
+			break;
+		}
+		m_gc.quiescent_state(&ts);
+	}
+	m_gc.deregister_thread(&ts);
+	LOG(INFO) << "network thread shutting down";
 }
 
 void
@@ -695,78 +638,70 @@ daemon :: process_req_get(server_id from,
                           std::auto_ptr<e::buffer> msg,
                           e::unpacker up)
 {
-    uint64_t nonce;
-    e::slice key;
-    bool has_auth = false;
-    auth_wallet aw;
-    up = up >> nonce >> key;
-
-    if (up.remain())
-    {
-        has_auth = true;
-        up = up >> aw;
-    }
-
-    if (up.error())
-    {
-        LOG(WARNING) << "unpack of REQ_GET failed; here's some hex:  " << msg->hex();
-        return;
-    }
-
-    region_id ri = m_config.get_region_id(vto);
-    bool has_value = false;
-    std::vector<e::slice> value;
-    uint64_t version;
-    datalayer::reference ref;
-    network_returncode result;
-
-    switch (m_data.get(ri, key, &value, &version, &ref))
-    {
-        case datalayer::SUCCESS:
-            has_value = true;
-            result = NET_SUCCESS;
-            break;
-        case datalayer::NOT_FOUND:
-            result = NET_NOTFOUND;
-            break;
-        case datalayer::BAD_ENCODING:
-        case datalayer::CORRUPTION:
-        case datalayer::IO_ERROR:
-        case datalayer::LEVELDB_ERROR:
-        default:
-            LOG(ERROR) << "GET returned unacceptable error code.";
-            result = NET_SERVERERROR;
-            break;
-    }
-
-    const schema* sc = m_config.get_schema(ri);
-
-    if (!auth_verify_read(*sc, has_value, &value, (has_auth ? &aw : NULL)))
-    {
-        size_t sz = HYPERDEX_HEADER_SIZE_VC
-                  + sizeof(uint64_t)
-                  + sizeof(uint16_t);
-        msg.reset(e::buffer::create(sz));
-        msg->pack_at(HYPERDEX_HEADER_SIZE_VC) << nonce << static_cast<uint16_t>(NET_UNAUTHORIZED);
-    }
-    else
-    {
-        sanitize_secrets(*sc, &value);
-        size_t sz = HYPERDEX_HEADER_SIZE_VC
-                  + sizeof(uint64_t)
-                  + sizeof(uint16_t)
-                  + pack_size(value);
-        msg.reset(e::buffer::create(sz));
-        e::packer pa = msg->pack_at(HYPERDEX_HEADER_SIZE_VC);
-        pa = pa << nonce << static_cast<uint16_t>(result);
-
-        if (result == NET_SUCCESS)
-        {
-            pa = pa << value;
-        }
-    }
-
-    m_comm.send_client(vto, from, RESP_GET, msg);
+	uint64_t nonce;
+	e::slice key;
+	bool has_auth = false;
+	auth_wallet aw;
+	up = up >> nonce >> key;
+	if (up.remain())
+	{
+		has_auth = true;
+		up = up >> aw;
+	}
+	if (up.error())
+	{
+		LOG(WARNING) << "unpack of REQ_GET failed; here's some hex:  " << msg->hex();
+		return;
+	}
+	region_id ri = m_config.get_region_id(vto);
+	bool has_value = false;
+	std::vector<e::slice> value;
+	uint64_t version;
+	datalayer::reference ref;
+	network_returncode result;
+	switch (m_data.get(ri, key, &value, &version, &ref))
+	{
+	case datalayer::SUCCESS:
+		has_value = true;
+		result = NET_SUCCESS;
+		break;
+	case datalayer::NOT_FOUND:
+		result = NET_NOTFOUND;
+		break;
+	case datalayer::BAD_ENCODING:
+	case datalayer::CORRUPTION:
+	case datalayer::IO_ERROR:
+	case datalayer::LEVELDB_ERROR:
+	default:
+		LOG(ERROR) << "GET returned unacceptable error code.";
+		result = NET_SERVERERROR;
+		break;
+	}
+	const schema *sc = m_config.get_schema(ri);
+	if (!auth_verify_read(*sc, has_value, &value, (has_auth ? &aw : NULL)))
+	{
+		size_t sz = HYPERDEX_HEADER_SIZE_VC
+		            + sizeof(uint64_t)
+		            + sizeof(uint16_t);
+		msg.reset(e::buffer::create(sz));
+		msg->pack_at(HYPERDEX_HEADER_SIZE_VC) << nonce << static_cast<uint16_t>(NET_UNAUTHORIZED);
+	}
+	else
+	{
+		sanitize_secrets(*sc, &value);
+		size_t sz = HYPERDEX_HEADER_SIZE_VC
+		            + sizeof(uint64_t)
+		            + sizeof(uint16_t)
+		            + pack_size(value);
+		msg.reset(e::buffer::create(sz));
+		e::packer pa = msg->pack_at(HYPERDEX_HEADER_SIZE_VC);
+		pa = pa << nonce << static_cast<uint16_t>(result);
+		if (result == NET_SUCCESS)
+		{
+			pa = pa << value;
+		}
+	}
+	m_comm.send_client(vto, from, RESP_GET, msg);
 }
 
 void
@@ -776,89 +711,80 @@ daemon :: process_req_get_partial(server_id from,
                                   std::auto_ptr<e::buffer> msg,
                                   e::unpacker up)
 {
-    uint64_t nonce;
-    e::slice key;
-    std::vector<uint16_t> attrs;
-    bool has_auth = false;
-    auth_wallet aw;
-    up = up >> nonce >> key >> attrs;
-
-    if (up.remain())
-    {
-        has_auth = true;
-        up = up >> aw;
-    }
-
-    if (up.error())
-    {
-        LOG(WARNING) << "unpack of REQ_GET_PARTIAL failed; here's some hex:  " << msg->hex();
-        return;
-    }
-
-    region_id ri = m_config.get_region_id(vto);
-    std::sort(attrs.begin(), attrs.end());
-    bool has_value = false;
-    std::vector<e::slice> value;
-    uint64_t version;
-    datalayer::reference ref;
-    network_returncode result;
-
-    switch (m_data.get(ri, key, &value, &version, &ref))
-    {
-        case datalayer::SUCCESS:
-            has_value = true;
-            result = NET_SUCCESS;
-            break;
-        case datalayer::NOT_FOUND:
-            result = NET_NOTFOUND;
-            break;
-        case datalayer::BAD_ENCODING:
-        case datalayer::CORRUPTION:
-        case datalayer::IO_ERROR:
-        case datalayer::LEVELDB_ERROR:
-        default:
-            LOG(ERROR) << "GET returned unacceptable error code.";
-            result = NET_SERVERERROR;
-            break;
-    }
-
-    const schema* sc = m_config.get_schema(ri);
-
-    if (!auth_verify_read(*sc, has_value, &value, (has_auth ? &aw : NULL)))
-    {
-        size_t sz = HYPERDEX_HEADER_SIZE_VC
-                  + sizeof(uint64_t)
-                  + sizeof(uint16_t);
-        msg.reset(e::buffer::create(sz));
-        msg->pack_at(HYPERDEX_HEADER_SIZE_VC) << nonce << static_cast<uint16_t>(NET_UNAUTHORIZED);
-    }
-    else
-    {
-        sanitize_secrets(*sc, &value);
-        size_t sz = HYPERDEX_HEADER_SIZE_VC
-                  + sizeof(uint64_t)
-                  + sizeof(uint16_t)
-                  + pack_size(value)
-                  + value.size() * sizeof(uint16_t);
-        msg.reset(e::buffer::create(sz));
-        e::packer pa = msg->pack_at(HYPERDEX_HEADER_SIZE_VC);
-        pa = pa << nonce << static_cast<uint16_t>(result);
-
-        if (result == NET_SUCCESS)
-        {
-            for (size_t i = 0; i < value.size(); ++i)
-            {
-                uint16_t attr = i + 1;
-
-                if (std::binary_search(attrs.begin(), attrs.end(), attr))
-                {
-                    pa = pa << attr << value[i];
-                }
-            }
-        }
-    }
-
-    m_comm.send_client(vto, from, RESP_GET_PARTIAL, msg);
+	uint64_t nonce;
+	e::slice key;
+	std::vector<uint16_t> attrs;
+	bool has_auth = false;
+	auth_wallet aw;
+	up = up >> nonce >> key >> attrs;
+	if (up.remain())
+	{
+		has_auth = true;
+		up = up >> aw;
+	}
+	if (up.error())
+	{
+		LOG(WARNING) << "unpack of REQ_GET_PARTIAL failed; here's some hex:  " << msg->hex();
+		return;
+	}
+	region_id ri = m_config.get_region_id(vto);
+	std::sort(attrs.begin(), attrs.end());
+	bool has_value = false;
+	std::vector<e::slice> value;
+	uint64_t version;
+	datalayer::reference ref;
+	network_returncode result;
+	switch (m_data.get(ri, key, &value, &version, &ref))
+	{
+	case datalayer::SUCCESS:
+		has_value = true;
+		result = NET_SUCCESS;
+		break;
+	case datalayer::NOT_FOUND:
+		result = NET_NOTFOUND;
+		break;
+	case datalayer::BAD_ENCODING:
+	case datalayer::CORRUPTION:
+	case datalayer::IO_ERROR:
+	case datalayer::LEVELDB_ERROR:
+	default:
+		LOG(ERROR) << "GET returned unacceptable error code.";
+		result = NET_SERVERERROR;
+		break;
+	}
+	const schema *sc = m_config.get_schema(ri);
+	if (!auth_verify_read(*sc, has_value, &value, (has_auth ? &aw : NULL)))
+	{
+		size_t sz = HYPERDEX_HEADER_SIZE_VC
+		            + sizeof(uint64_t)
+		            + sizeof(uint16_t);
+		msg.reset(e::buffer::create(sz));
+		msg->pack_at(HYPERDEX_HEADER_SIZE_VC) << nonce << static_cast<uint16_t>(NET_UNAUTHORIZED);
+	}
+	else
+	{
+		sanitize_secrets(*sc, &value);
+		size_t sz = HYPERDEX_HEADER_SIZE_VC
+		            + sizeof(uint64_t)
+		            + sizeof(uint16_t)
+		            + pack_size(value)
+		            + value.size() * sizeof(uint16_t);
+		msg.reset(e::buffer::create(sz));
+		e::packer pa = msg->pack_at(HYPERDEX_HEADER_SIZE_VC);
+		pa = pa << nonce << static_cast<uint16_t>(result);
+		if (result == NET_SUCCESS)
+		{
+			for (size_t i = 0; i < value.size(); ++i)
+			{
+				uint16_t attr = i + 1;
+				if (std::binary_search(attrs.begin(), attrs.end(), attr))
+				{
+					pa = pa << attr << value[i];
+				}
+			}
+		}
+	}
+	m_comm.send_client(vto, from, RESP_GET_PARTIAL, msg);
 }
 
 void
@@ -868,19 +794,16 @@ daemon :: process_req_atomic(server_id from,
                              std::auto_ptr<e::buffer> msg,
                              e::unpacker up)
 {
-    // initialize nonce from pseudo-random memory
-    uint64_t nonce;
-
-    std::auto_ptr<key_change> kc(new key_change());
-    up = up >> nonce >> *kc;
-
-    if (up.error())
-    {
-        LOG(WARNING) << "unpack of REQ_ATOMIC failed; here's some hex:  " << msg->hex();
-        return;
-    }
-
-    m_repl.client_atomic(from, vto, nonce, kc, msg);
+	// initialize nonce from pseudo-random memory
+	uint64_t nonce;
+	std::auto_ptr<key_change> kc(new key_change());
+	up = up >> nonce >> *kc;
+	if (up.error())
+	{
+		LOG(WARNING) << "unpack of REQ_ATOMIC failed; here's some hex:  " << msg->hex();
+		return;
+	}
+	m_repl.client_atomic(from, vto, nonce, kc, msg);
 }
 
 void
@@ -890,17 +813,15 @@ daemon :: process_req_search_start(server_id from,
                                    std::auto_ptr<e::buffer> msg,
                                    e::unpacker up)
 {
-    uint64_t nonce;
-    uint64_t search_id;
-    std::vector<attribute_check> checks;
-
-    if ((up >> nonce >> search_id >> checks).error())
-    {
-        LOG(WARNING) << "unpack of REQ_SEARCH_START failed; here's some hex:  " << msg->hex();
-        return;
-    }
-
-    m_sm.start(from, vto, msg, nonce, search_id, &checks);
+	uint64_t nonce;
+	uint64_t search_id;
+	std::vector<attribute_check> checks;
+	if ((up >> nonce >> search_id >> checks).error())
+	{
+		LOG(WARNING) << "unpack of REQ_SEARCH_START failed; here's some hex:  " << msg->hex();
+		return;
+	}
+	m_sm.start(from, vto, msg, nonce, search_id, &checks);
 }
 
 void
@@ -910,16 +831,14 @@ daemon :: process_req_search_next(server_id from,
                                   std::auto_ptr<e::buffer> msg,
                                   e::unpacker up)
 {
-    uint64_t nonce;
-    uint64_t search_id;
-
-    if ((up >> nonce >> search_id).error())
-    {
-        LOG(WARNING) << "unpack of REQ_SEARCH_NEXT failed; here's some hex:  " << msg->hex();
-        return;
-    }
-
-    m_sm.next(from, vto, nonce, search_id);
+	uint64_t nonce;
+	uint64_t search_id;
+	if ((up >> nonce >> search_id).error())
+	{
+		LOG(WARNING) << "unpack of REQ_SEARCH_NEXT failed; here's some hex:  " << msg->hex();
+		return;
+	}
+	m_sm.next(from, vto, nonce, search_id);
 }
 
 void
@@ -929,16 +848,14 @@ daemon :: process_req_search_stop(server_id from,
                                   std::auto_ptr<e::buffer> msg,
                                   e::unpacker up)
 {
-    uint64_t nonce;
-    uint64_t search_id;
-
-    if ((up >> nonce >> search_id).error())
-    {
-        LOG(WARNING) << "unpack of REQ_SEARCH_STOP failed; here's some hex:  " << msg->hex();
-        return;
-    }
-
-    m_sm.stop(from, vto, search_id);
+	uint64_t nonce;
+	uint64_t search_id;
+	if ((up >> nonce >> search_id).error())
+	{
+		LOG(WARNING) << "unpack of REQ_SEARCH_STOP failed; here's some hex:  " << msg->hex();
+		return;
+	}
+	m_sm.stop(from, vto, search_id);
 }
 
 void
@@ -948,19 +865,17 @@ daemon :: process_req_sorted_search(server_id from,
                                     std::auto_ptr<e::buffer> msg,
                                     e::unpacker up)
 {
-    uint64_t nonce;
-    std::vector<attribute_check> checks;
-    uint64_t limit;
-    uint16_t sort_by;
-    uint8_t flags;
-
-    if ((up >> nonce >> checks >> limit >> sort_by >> flags).error())
-    {
-        LOG(WARNING) << "unpack of REQ_SORTED_SEARCH failed; here's some hex:  " << msg->hex();
-        return;
-    }
-
-    m_sm.sorted_search(from, vto, nonce, &checks, limit, sort_by, flags & 0x1);
+	uint64_t nonce;
+	std::vector<attribute_check> checks;
+	uint64_t limit;
+	uint16_t sort_by;
+	uint8_t flags;
+	if ((up >> nonce >> checks >> limit >> sort_by >> flags).error())
+	{
+		LOG(WARNING) << "unpack of REQ_SORTED_SEARCH failed; here's some hex:  " << msg->hex();
+		return;
+	}
+	m_sm.sorted_search(from, vto, nonce, &checks, limit, sort_by, flags & 0x1);
 }
 
 void
@@ -970,16 +885,32 @@ daemon :: process_req_count(server_id from,
                             std::auto_ptr<e::buffer> msg,
                             e::unpacker up)
 {
-    uint64_t nonce;
-    std::vector<attribute_check> checks;
-
-    if ((up >> nonce >> checks).error())
-    {
-        LOG(WARNING) << "unpack of REQ_COUNT failed; here's some hex:  " << msg->hex();
-        return;
-    }
+	uint64_t nonce;
+	std::vector<attribute_check> checks;
+	if ((up >> nonce >> checks).error())
+	{
+		LOG(WARNING) << "unpack of REQ_COUNT failed; here's some hex:  " << msg->hex();
+		return;
+	}
+	m_sm.count(from, vto, nonce, &checks);
+}
 
-    m_sm.count(from, vto, nonce, &checks);
+void
+daemon :: process_req_sum(server_id from,
+                          virtual_server_id,
+                          virtual_server_id vto,
+                          std::auto_ptr<e::buffer> msg,
+                          e::unpacker up)
+{
+	uint64_t nonce;
+	std::vector<attribute_check> checks;
+	uint16_t sum_idx;
+	if ((up >> nonce >> checks >> sum_idx).error())
+	{
+		LOG(WARNING) << "unpack of REQ_SUM failed; here's some hex:  " << msg->hex();
+		return;
+	}
+	m_sm.sum(from, vto, nonce, &checks, sum_idx);
 }
 
 void
@@ -989,16 +920,14 @@ daemon :: process_req_search_describe(server_id from,
                                       std::auto_ptr<e::buffer> msg,
                                       e::unpacker up)
 {
-    uint64_t nonce;
-    std::vector<attribute_check> checks;
-
-    if ((up >> nonce >> checks).error())
-    {
-        LOG(WARNING) << "unpack of REQ_SEARCH_DESCRIBE failed; here's some hex:  " << msg->hex();
-        return;
-    }
-
-    m_sm.search_describe(from, vto, nonce, &checks);
+	uint64_t nonce;
+	std::vector<attribute_check> checks;
+	if ((up >> nonce >> checks).error())
+	{
+		LOG(WARNING) << "unpack of REQ_SEARCH_DESCRIBE failed; here's some hex:  " << msg->hex();
+		return;
+	}
+	m_sm.search_describe(from, vto, nonce, &checks);
 }
 
 void
@@ -1008,19 +937,17 @@ daemon :: process_req_group_atomic(server_id from,
                                    std::auto_ptr<e::buffer> msg,
                                    e::unpacker up)
 {
-    uint64_t nonce;
-    std::vector<attribute_check> checks;
-    up = up >> nonce >> checks;
-
-    if (up.error())
-    {
-        LOG(WARNING) << "unpack of REQ_GROUP_ATOMIC failed; here's some hex:  " << msg->hex();
-        return;
-    }
-
-    // Only forward the actual atomic operation
-    e::slice sl = up.remainder();
-    m_sm.group_keyop(from, vto, nonce, &checks, REQ_ATOMIC, sl, RESP_GROUP_ATOMIC);
+	uint64_t nonce;
+	std::vector<attribute_check> checks;
+	up = up >> nonce >> checks;
+	if (up.error())
+	{
+		LOG(WARNING) << "unpack of REQ_GROUP_ATOMIC failed; here's some hex:  " << msg->hex();
+		return;
+	}
+	// Only forward the actual atomic operation
+	e::slice sl = up.remainder();
+	m_sm.group_keyop(from, vto, nonce, &checks, REQ_ATOMIC, sl, RESP_GROUP_ATOMIC);
 }
 
 void
@@ -1030,21 +957,19 @@ daemon :: process_chain_op(server_id,
                            std::auto_ptr<e::buffer> msg,
                            e::unpacker up)
 {
-    uint8_t flags;
-    uint64_t old_version;
-    uint64_t new_version;
-    e::slice key;
-    std::vector<e::slice> value;
-
-    if ((up >> flags >> old_version >> new_version >> key >> value).error())
-    {
-        LOG(WARNING) << "unpack of CHAIN_OP failed; here's some hex:  " << msg->hex();
-        return;
-    }
-
-    bool fresh = flags & 1;
-    bool has_value = flags & 2;
-    m_repl.chain_op(vfrom, vto, old_version, new_version, fresh, has_value, key, value, msg);
+	uint8_t flags;
+	uint64_t old_version;
+	uint64_t new_version;
+	e::slice key;
+	std::vector<e::slice> value;
+	if ((up >> flags >> old_version >> new_version >> key >> value).error())
+	{
+		LOG(WARNING) << "unpack of CHAIN_OP failed; here's some hex:  " << msg->hex();
+		return;
+	}
+	bool fresh = flags & 1;
+	bool has_value = flags & 2;
+	m_repl.chain_op(vfrom, vto, old_version, new_version, fresh, has_value, key, value, msg);
 }
 
 void
@@ -1054,24 +979,22 @@ daemon :: process_chain_subspace(server_id,
                                  std::auto_ptr<e::buffer> msg,
                                  e::unpacker up)
 {
-    uint64_t old_version;
-    uint64_t new_version;
-    e::slice key;
-    std::vector<e::slice> value;
-    region_id prev_region;
-    region_id this_old_region;
-    region_id this_new_region;
-    region_id next_region;
-
-    if ((up >> old_version >> new_version >> key >> value >>
-               prev_region >> this_old_region >> this_new_region >> next_region).error())
-    {
-        LOG(WARNING) << "unpack of CHAIN_SUBSPACE failed; here's some hex:  " << msg->hex();
-        return;
-    }
-
-    m_repl.chain_subspace(vfrom, vto, old_version, new_version, key, value, msg,
-                          prev_region, this_old_region, this_new_region, next_region);
+	uint64_t old_version;
+	uint64_t new_version;
+	e::slice key;
+	std::vector<e::slice> value;
+	region_id prev_region;
+	region_id this_old_region;
+	region_id this_new_region;
+	region_id next_region;
+	if ((up >> old_version >> new_version >> key >> value >>
+	     prev_region >> this_old_region >> this_new_region >> next_region).error())
+	{
+		LOG(WARNING) << "unpack of CHAIN_SUBSPACE failed; here's some hex:  " << msg->hex();
+		return;
+	}
+	m_repl.chain_subspace(vfrom, vto, old_version, new_version, key, value, msg,
+	                      prev_region, this_old_region, this_new_region, next_region);
 }
 
 void
@@ -1081,16 +1004,14 @@ daemon :: process_chain_ack(server_id,
                             std::auto_ptr<e::buffer> msg,
                             e::unpacker up)
 {
-    uint64_t version;
-    e::slice key;
-
-    if ((up >> version >> key).error())
-    {
-        LOG(WARNING) << "unpack of CHAIN_ACK failed; here's some hex:  " << msg->hex();
-        return;
-    }
-
-    m_repl.chain_ack(vfrom, vto, version, key);
+	uint64_t version;
+	e::slice key;
+	if ((up >> version >> key).error())
+	{
+		LOG(WARNING) << "unpack of CHAIN_ACK failed; here's some hex:  " << msg->hex();
+		return;
+	}
+	m_repl.chain_ack(vfrom, vto, version, key);
 }
 
 void
@@ -1100,15 +1021,13 @@ daemon :: process_xfer_handshake_syn(server_id,
                                      std::auto_ptr<e::buffer> msg,
                                      e::unpacker up)
 {
-    transfer_id xid;
-
-    if ((up >> xid).error())
-    {
-        LOG(WARNING) << "unpack of XFER_HS failed; here's some hex:  " << msg->hex();
-        return;
-    }
-
-    m_stm.handshake_syn(vfrom, xid);
+	transfer_id xid;
+	if ((up >> xid).error())
+	{
+		LOG(WARNING) << "unpack of XFER_HS failed; here's some hex:  " << msg->hex();
+		return;
+	}
+	m_stm.handshake_syn(vfrom, xid);
 }
 
 void
@@ -1118,16 +1037,14 @@ daemon :: process_xfer_handshake_synack(server_id from,
                                         std::auto_ptr<e::buffer> msg,
                                         e::unpacker up)
 {
-    transfer_id xid;
-    uint64_t timestamp;
-
-    if ((up >> xid >> timestamp).error())
-    {
-        LOG(WARNING) << "unpack of XFER_HSA failed; here's some hex:  " << msg->hex();
-        return;
-    }
-
-    m_stm.handshake_synack(from, to, xid, timestamp);
+	transfer_id xid;
+	uint64_t timestamp;
+	if ((up >> xid >> timestamp).error())
+	{
+		LOG(WARNING) << "unpack of XFER_HSA failed; here's some hex:  " << msg->hex();
+		return;
+	}
+	m_stm.handshake_synack(from, to, xid, timestamp);
 }
 
 void
@@ -1137,17 +1054,15 @@ daemon :: process_xfer_handshake_ack(server_id,
                                      std::auto_ptr<e::buffer> msg,
                                      e::unpacker up)
 {
-    transfer_id xid;
-    uint8_t flags;
-
-    if ((up >> xid >> flags).error())
-    {
-        LOG(WARNING) << "unpack of XFER_HA failed; here's some hex:  " << msg->hex();
-        return;
-    }
-
-    bool wipe = flags & 0x1;
-    m_stm.handshake_ack(vfrom, xid, wipe);
+	transfer_id xid;
+	uint8_t flags;
+	if ((up >> xid >> flags).error())
+	{
+		LOG(WARNING) << "unpack of XFER_HA failed; here's some hex:  " << msg->hex();
+		return;
+	}
+	bool wipe = flags & 0x1;
+	m_stm.handshake_ack(vfrom, xid, wipe);
 }
 
 void
@@ -1157,15 +1072,13 @@ daemon :: process_xfer_handshake_wiped(server_id from,
                                        std::auto_ptr<e::buffer> msg,
                                        e::unpacker up)
 {
-    transfer_id xid;
-
-    if ((up >> xid).error())
-    {
-        LOG(WARNING) << "unpack of XFER_HW failed; here's some hex:  " << msg->hex();
-        return;
-    }
-
-    m_stm.handshake_wiped(from, to, xid);
+	transfer_id xid;
+	if ((up >> xid).error())
+	{
+		LOG(WARNING) << "unpack of XFER_HW failed; here's some hex:  " << msg->hex();
+		return;
+	}
+	m_stm.handshake_wiped(from, to, xid);
 }
 
 void
@@ -1175,21 +1088,19 @@ daemon :: process_xfer_op(server_id,
                           std::auto_ptr<e::buffer> msg,
                           e::unpacker up)
 {
-    uint8_t flags;
-    uint64_t xid;
-    uint64_t seq_no;
-    uint64_t version;
-    e::slice key;
-    std::vector<e::slice> value;
-
-    if ((up >> flags >> xid >> seq_no >> version >> key >> value).error())
-    {
-        LOG(WARNING) << "unpack of XFER_OP failed; here's some hex:  " << msg->hex();
-        return;
-    }
-
-    bool has_value = flags & 1;
-    m_stm.xfer_op(vfrom, transfer_id(xid), seq_no, has_value, version, msg, key, value);
+	uint8_t flags;
+	uint64_t xid;
+	uint64_t seq_no;
+	uint64_t version;
+	e::slice key;
+	std::vector<e::slice> value;
+	if ((up >> flags >> xid >> seq_no >> version >> key >> value).error())
+	{
+		LOG(WARNING) << "unpack of XFER_OP failed; here's some hex:  " << msg->hex();
+		return;
+	}
+	bool has_value = flags & 1;
+	m_stm.xfer_op(vfrom, transfer_id(xid), seq_no, has_value, version, msg, key, value);
 }
 
 void
@@ -1199,17 +1110,15 @@ daemon :: process_xfer_ack(server_id from,
                            std::auto_ptr<e::buffer> msg,
                            e::unpacker up)
 {
-    uint8_t flags;
-    uint64_t xid;
-    uint64_t seq_no;
-
-    if ((up >> flags >> xid >> seq_no).error())
-    {
-        LOG(WARNING) << "unpack of XFER_ACK failed; here's some hex:  " << msg->hex();
-        return;
-    }
-
-    m_stm.xfer_ack(from, vto, transfer_id(xid), seq_no);
+	uint8_t flags;
+	uint64_t xid;
+	uint64_t seq_no;
+	if ((up >> flags >> xid >> seq_no).error())
+	{
+		LOG(WARNING) << "unpack of XFER_ACK failed; here's some hex:  " << msg->hex();
+		return;
+	}
+	m_stm.xfer_ack(from, vto, transfer_id(xid), seq_no);
 }
 
 void
@@ -1219,48 +1128,41 @@ daemon :: process_backup(server_id from,
                          std::auto_ptr<e::buffer> msg,
                          e::unpacker up)
 {
-    uint64_t nonce;
-    e::slice _name;
-
-    if ((up >> nonce >> _name).error() ||
-        strnlen(reinterpret_cast<const char*>(_name.data()), _name.size()) == _name.size())
-    {
-        LOG(WARNING) << "unpack of BACKUP failed; here's some hex:  " << msg->hex();
-        return;
-    }
-
-    std::string name(reinterpret_cast<const char*>(_name.data()));
-    network_returncode result = NET_SUCCESS;
-
-    if (!m_data.backup(e::slice(name)))
-    {
-        result = NET_SERVERERROR;
-    }
-    else
-    {
-        LOG(INFO) << "Backup succeeded and is available in the directory \"backup-"
-                  << e::strescape(name) << "\" within the data directory."
-                  << "  Copy the complete directory to elsewhere so your backup is safe.";
-    }
-
-    using po6::path::join;
-    std::string _path(join(m_data_dir, "backup-" + name));
-
-    if (!po6::path::realpath(_path, &_path))
-    {
-        // XXX
-    }
-
-    e::slice path(_path.c_str());
-
-    size_t sz = HYPERDEX_HEADER_SIZE_VC
-              + sizeof(uint64_t)
-              + sizeof(uint16_t)
-              + pack_size(path);
-    msg.reset(e::buffer::create(sz));
-    e::packer pa = msg->pack_at(HYPERDEX_HEADER_SIZE_VC);
-    pa = pa << nonce << static_cast<uint16_t>(result) << path;
-    m_comm.send_client(vto, from, BACKUP, msg);
+	uint64_t nonce;
+	e::slice _name;
+	if ((up >> nonce >> _name).error() ||
+	    strnlen(reinterpret_cast<const char *>(_name.data()), _name.size()) == _name.size())
+	{
+		LOG(WARNING) << "unpack of BACKUP failed; here's some hex:  " << msg->hex();
+		return;
+	}
+	std::string name(reinterpret_cast<const char *>(_name.data()));
+	network_returncode result = NET_SUCCESS;
+	if (!m_data.backup(e::slice(name)))
+	{
+		result = NET_SERVERERROR;
+	}
+	else
+	{
+		LOG(INFO) << "Backup succeeded and is available in the directory \"backup-"
+		          << e::strescape(name) << "\" within the data directory."
+		          << "  Copy the complete directory to elsewhere so your backup is safe.";
+	}
+	using po6::path::join;
+	std::string _path(join(m_data_dir, "backup-" + name));
+	if (!po6::path::realpath(_path, &_path))
+	{
+		// XXX
+	}
+	e::slice path(_path.c_str());
+	size_t sz = HYPERDEX_HEADER_SIZE_VC
+	            + sizeof(uint64_t)
+	            + sizeof(uint16_t)
+	            + pack_size(path);
+	msg.reset(e::buffer::create(sz));
+	e::packer pa = msg->pack_at(HYPERDEX_HEADER_SIZE_VC);
+	pa = pa << nonce << static_cast<uint16_t>(result) << path;
+	m_comm.send_client(vto, from, BACKUP, msg);
 }
 
 void
@@ -1270,49 +1172,42 @@ daemon :: process_perf_counters(server_id from,
                                 std::auto_ptr<e::buffer> msg,
                                 e::unpacker up)
 {
-    uint64_t nonce;
-    uint64_t when;
-    up = up >> nonce >> when;
-
-    if (up.error())
-    {
-        LOG(WARNING) << "unpack of PERF_COUNTERS failed; here's some hex:  " << msg->hex();
-        return;
-    }
-
-    std::string out;
-
-    {
-        po6::threads::mutex::hold hold(&m_protect_stats);
-        std::list<std::pair<uint64_t, std::string> >::iterator it;
-        it = m_stats.begin();
-
-        while (it != m_stats.end() && it->first <= when)
-        {
-            ++it;
-        }
-
-        if (it == m_stats.begin())
-        {
-            std::ostringstream ret;
-            ret << m_stats_start << " reset=" << m_stats_start << "\n";
-            out += ret.str();
-        }
-
-        while (it != m_stats.end())
-        {
-            out += it->second;
-            ++it;
-        }
-    }
-
-    size_t sz = HYPERDEX_HEADER_SIZE_VC
-              + sizeof(uint64_t)
-              + out.size() + 1;
-    msg.reset(e::buffer::create(sz));
-    msg->pack_at(HYPERDEX_HEADER_SIZE_VC)
-        << nonce << e::pack_memmove(out.c_str(), out.size() + 1);
-    m_comm.send_client(vto, from, PERF_COUNTERS, msg);
+	uint64_t nonce;
+	uint64_t when;
+	up = up >> nonce >> when;
+	if (up.error())
+	{
+		LOG(WARNING) << "unpack of PERF_COUNTERS failed; here's some hex:  " << msg->hex();
+		return;
+	}
+	std::string out;
+	{
+		po6::threads::mutex::hold hold(&m_protect_stats);
+		std::list<std::pair<uint64_t, std::string> >::iterator it;
+		it = m_stats.begin();
+		while (it != m_stats.end() && it->first <= when)
+		{
+			++it;
+		}
+		if (it == m_stats.begin())
+		{
+			std::ostringstream ret;
+			ret << m_stats_start << " reset=" << m_stats_start << "\n";
+			out += ret.str();
+		}
+		while (it != m_stats.end())
+		{
+			out += it->second;
+			++it;
+		}
+	}
+	size_t sz = HYPERDEX_HEADER_SIZE_VC
+	            + sizeof(uint64_t)
+	            + out.size() + 1;
+	msg.reset(e::buffer::create(sz));
+	msg->pack_at(HYPERDEX_HEADER_SIZE_VC)
+	        << nonce << e::pack_memmove(out.c_str(), out.size() + 1);
+	m_comm.send_client(vto, from, PERF_COUNTERS, msg);
 }
 
 #define INTERVAL 100000000ULL
@@ -1320,69 +1215,62 @@ daemon :: process_perf_counters(server_id from,
 void
 daemon :: collect_stats()
 {
-    uint64_t target = po6::monotonic_time();
-    target = target - (target % INTERVAL) + INTERVAL;
-
-    {
-        po6::threads::mutex::hold hold(&m_protect_stats);
-        m_stats_start = target;
-    }
-
-    while (__sync_fetch_and_add(&s_interrupts, 0) == 0)
-    {
-        // every INTERVAL nanoseconds collect stats
-        uint64_t now = po6::monotonic_time();
-
-        if (now < target)
-        {
-            struct timespec ts;
-            ts.tv_sec = 0;
-            ts.tv_nsec = std::min(target - now, (uint64_t)50000000UL);
-            nanosleep(&ts, NULL);
-            continue;
-        }
-
-        // collect the stats
-        std::ostringstream ret;
-        ret << target;
-        collect_stats_msgs(&ret);
-        collect_stats_leveldb(&ret);
-        collect_stats_io(&ret);
-        ret << "\n";
-        std::string out = ret.str();
-
-        po6::threads::mutex::hold hold(&m_protect_stats);
-        m_stats.push_back(std::make_pair(target, out));
-
-        if (m_stats.size() > 600)
-        {
-            m_stats.pop_front();
-        }
-
-        // next interval
-        target += INTERVAL;
-    }
+	uint64_t target = po6::monotonic_time();
+	target = target - (target % INTERVAL) + INTERVAL;
+	{
+		po6::threads::mutex::hold hold(&m_protect_stats);
+		m_stats_start = target;
+	}
+	while (__sync_fetch_and_add(&s_interrupts, 0) == 0)
+	{
+		// every INTERVAL nanoseconds collect stats
+		uint64_t now = po6::monotonic_time();
+		if (now < target)
+		{
+			struct timespec ts;
+			ts.tv_sec = 0;
+			ts.tv_nsec = std::min(target - now, (uint64_t)50000000UL);
+			nanosleep(&ts, NULL);
+			continue;
+		}
+		// collect the stats
+		std::ostringstream ret;
+		ret << target;
+		collect_stats_msgs(&ret);
+		collect_stats_leveldb(&ret);
+		collect_stats_io(&ret);
+		ret << "\n";
+		std::string out = ret.str();
+		po6::threads::mutex::hold hold(&m_protect_stats);
+		m_stats.push_back(std::make_pair(target, out));
+		if (m_stats.size() > 600)
+		{
+			m_stats.pop_front();
+		}
+		// next interval
+		target += INTERVAL;
+	}
 }
 
 void
-daemon :: collect_stats_msgs(std::ostringstream* ret)
+daemon :: collect_stats_msgs(std::ostringstream *ret)
 {
-    *ret << " msgs.req_get=" << m_perf_req_get.read();
-    *ret << " msgs.req_get_partial=" << m_perf_req_get_partial.read();
-    *ret << " msgs.req_atomic=" << m_perf_req_atomic.read();
-    *ret << " msgs.req_search_start=" << m_perf_req_search_start.read();
-    *ret << " msgs.req_search_next=" << m_perf_req_search_next.read();
-    *ret << " msgs.req_search_stop=" << m_perf_req_search_stop.read();
-    *ret << " msgs.req_sorted_search=" << m_perf_req_sorted_search.read();
-    *ret << " msgs.req_count=" << m_perf_req_count.read();
-    *ret << " msgs.req_search_describe=" << m_perf_req_search_describe.read();
-    *ret << " msgs.req_group_atomic=" << m_perf_req_group_atomic.read();
-    *ret << " msgs.chain_op=" << m_perf_chain_op.read();
-    *ret << " msgs.chain_subspace=" << m_perf_chain_subspace.read();
-    *ret << " msgs.chain_ack=" << m_perf_chain_ack.read();
-    *ret << " msgs.xfer_op=" << m_perf_xfer_op.read();
-    *ret << " msgs.xfer_ack=" << m_perf_xfer_ack.read();
-    *ret << " msgs.perf_counters=" << m_perf_perf_counters.read();
+	*ret << " msgs.req_get=" << m_perf_req_get.read();
+	*ret << " msgs.req_get_partial=" << m_perf_req_get_partial.read();
+	*ret << " msgs.req_atomic=" << m_perf_req_atomic.read();
+	*ret << " msgs.req_search_start=" << m_perf_req_search_start.read();
+	*ret << " msgs.req_search_next=" << m_perf_req_search_next.read();
+	*ret << " msgs.req_search_stop=" << m_perf_req_search_stop.read();
+	*ret << " msgs.req_sorted_search=" << m_perf_req_sorted_search.read();
+	*ret << " msgs.req_count=" << m_perf_req_count.read();
+	*ret << " msgs.req_search_describe=" << m_perf_req_search_describe.read();
+	*ret << " msgs.req_group_atomic=" << m_perf_req_group_atomic.read();
+	*ret << " msgs.chain_op=" << m_perf_chain_op.read();
+	*ret << " msgs.chain_subspace=" << m_perf_chain_subspace.read();
+	*ret << " msgs.chain_ack=" << m_perf_chain_ack.read();
+	*ret << " msgs.xfer_op=" << m_perf_xfer_op.read();
+	*ret << " msgs.xfer_ack=" << m_perf_xfer_ack.read();
+	*ret << " msgs.perf_counters=" << m_perf_perf_counters.read();
 }
 
 namespace
@@ -1390,243 +1278,210 @@ namespace
 
 struct leveldb_stat
 {
-    leveldb_stat() : files(0), size(0), time(0), read(0), write(0) {}
-    uint64_t files;
-    uint64_t size;
-    uint64_t time;
-    uint64_t read;
-    uint64_t write;
+	leveldb_stat() : files(0), size(0), time(0), read(0), write(0) {}
+	uint64_t files;
+	uint64_t size;
+	uint64_t time;
+	uint64_t read;
+	uint64_t write;
 };
 
 } // namespace
 
 void
-daemon :: collect_stats_leveldb(std::ostringstream* ret)
+daemon :: collect_stats_leveldb(std::ostringstream *ret)
 {
-    *ret << " leveldb.size=" << m_data.approximate_size();
-    std::string tmp;
-
-    if (m_data.get_property(e::slice("leveldb.stats"), &tmp))
-    {
-        std::vector<char> lines(tmp.c_str(), tmp.c_str() + tmp.size() + 1);
-        char* ptr = &lines.front();
-        char* end = ptr + lines.size() - 1;
-        leveldb_stat stats[7];
-
-        while (ptr < end)
-        {
-            char* eol = strchr(ptr, '\n');
-            eol = eol ? eol : end;
-            *eol = 0;
-            int level;
-            int files;
-            double size;
-            double time;
-            double read;
-            double write;
-
-            if (sscanf(ptr, "%d %d %lf %lf %lf %lf",
-                            &level, &files, &size, &time, &read, &write) == 6 &&
-                level < 7)
-            {
-                stats[level].files = files;
-                stats[level].size = size * 1048576ULL;
-                stats[level].time = time;
-                stats[level].read = read * 1048576ULL;
-                stats[level].write = write * 1048576ULL;
-            }
-
-            ptr = eol + 1;
-        }
-
-        for (size_t i = 0; i < 7; ++i)
-        {
-            *ret << " leveldb.files" << i << "=" << stats[i].files;
-            *ret << " leveldb.size" << i << "=" << stats[i].size;
-            *ret << " leveldb.time" << i << "=" << stats[i].time;
-            *ret << " leveldb.read" << i << "=" << stats[i].read;
-            *ret << " leveldb.write" << i << "=" << stats[i].write;
-        }
-    }
+	*ret << " leveldb.size=" << m_data.approximate_size();
+	std::string tmp;
+	if (m_data.get_property(e::slice("leveldb.stats"), &tmp))
+	{
+		std::vector<char> lines(tmp.c_str(), tmp.c_str() + tmp.size() + 1);
+		char *ptr = &lines.front();
+		char *end = ptr + lines.size() - 1;
+		leveldb_stat stats[7];
+		while (ptr < end)
+		{
+			char *eol = strchr(ptr, '\n');
+			eol = eol ? eol : end;
+			*eol = 0;
+			int level;
+			int files;
+			double size;
+			double time;
+			double read;
+			double write;
+			if (sscanf(ptr, "%d %d %lf %lf %lf %lf",
+			           &level, &files, &size, &time, &read, &write) == 6 &&
+			    level < 7)
+			{
+				stats[level].files = files;
+				stats[level].size = size * 1048576ULL;
+				stats[level].time = time;
+				stats[level].read = read * 1048576ULL;
+				stats[level].write = write * 1048576ULL;
+			}
+			ptr = eol + 1;
+		}
+		for (size_t i = 0; i < 7; ++i)
+		{
+			*ret << " leveldb.files" << i << "=" << stats[i].files;
+			*ret << " leveldb.size" << i << "=" << stats[i].size;
+			*ret << " leveldb.time" << i << "=" << stats[i].time;
+			*ret << " leveldb.read" << i << "=" << stats[i].read;
+			*ret << " leveldb.write" << i << "=" << stats[i].write;
+		}
+	}
 }
 
 namespace
 {
 
 bool
-read_sys_block_star(std::vector<std::string>* blocks)
+read_sys_block_star(std::vector<std::string> *blocks)
 {
-    DIR* dir = opendir("/sys/block");
-    struct dirent* ent = NULL;
-
-    if (dir == NULL)
-    {
-        return false;
-    }
-
-    errno = 0;
-
-    while ((ent = readdir(dir)) != NULL)
-    {
-        blocks->push_back(ent->d_name);
-    }
-
-    closedir(dir);
-    return errno == 0;
+	DIR *dir = opendir("/sys/block");
+	struct dirent *ent = NULL;
+	if (dir == NULL)
+	{
+		return false;
+	}
+	errno = 0;
+	while ((ent = readdir(dir)) != NULL)
+	{
+		blocks->push_back(ent->d_name);
+	}
+	closedir(dir);
+	return errno == 0;
 }
 
 } // namespace
 
 void
-daemon :: determine_block_stat_path(const std::string& data)
+daemon :: determine_block_stat_path(const std::string &data)
 {
-    std::string dir;
-
-    if (!po6::path::realpath(data, &dir))
-    {
-        LOG(ERROR) << "could not resolve true path for data: " << po6::strerror(errno);
-        LOG(ERROR) << "iostat-like statistics will not be reported";
-        return;
-    }
-
-    std::vector<std::string> block_devs;
-
-    if (!read_sys_block_star(&block_devs))
-    {
-        LOG(ERROR) << "could not ls /sys/block";
-        LOG(ERROR) << "iostat-like statistics will not be reported";
-        return;
-    }
-
-    FILE* mounts = fopen("/proc/mounts", "r");
-
-    if (!mounts)
-    {
-        LOG(ERROR) << "could not open /proc/mounts: " << po6::strerror(errno);
-        LOG(ERROR) << "iostat-like statistics will not be reported";
-        return;
-    }
-
-    char* line = NULL;
-    size_t line_sz = 0;
-    size_t max_mnt_sz = 0;
-
-    while (true)
-    {
-        ssize_t amt = getline(&line, &line_sz, mounts);
-
-        if (amt < 0)
-        {
-            if (ferror(mounts) != 0)
-            {
-                LOG(WARNING) << "could not read from /proc/mounts: " << po6::strerror(errno);
-                break;
-            }
-
-            if (feof(mounts) != 0)
-            {
-                break;
-            }
-
-            LOG(WARNING) << "unknown error when reading from /proc/mounts\n";
-            break;
-        }
-
-        char dev[4096];
-        char mnt[4096];
-        int pts = sscanf(line, "%4095s %4095s", dev, mnt);
-
-        if (pts != 2)
-        {
-            continue;
-        }
-
-        size_t msz = strlen(mnt);
-
-        if (strncmp(mnt, dir.c_str(), msz) != 0 ||
-            msz < max_mnt_sz)
-        {
-            continue;
-        }
-
-        std::string stat_path = po6::path::basename(dev);
-
-        for (size_t i = 0; i < block_devs.size(); ++i)
-        {
-            size_t dsz = std::min(stat_path.size(), block_devs[i].size());
-
-            if (strncmp(block_devs[i].c_str(), stat_path.c_str(), dsz) == 0)
-            {
-                max_mnt_sz = msz;
-                m_block_stat_path = std::string("/sys/block/") + block_devs[i] + "/stat";
-            }
-        }
-    }
-
-    if (!m_block_stat_path.empty())
-    {
-        LOG(INFO) << "using " << m_block_stat_path << " for reporting io.* stats";
-    }
-    else
-    {
-        LOG(WARNING) << "cannot determine device name for reporting io.* stats";
-        LOG(WARNING) << "iostat-like statistics will not be reported";
-    }
-
-    if (line)
-    {
-        free(line);
-    }
-
-    fclose(mounts);
+	std::string dir;
+	if (!po6::path::realpath(data, &dir))
+	{
+		LOG(ERROR) << "could not resolve true path for data: " << po6::strerror(errno);
+		LOG(ERROR) << "iostat-like statistics will not be reported";
+		return;
+	}
+	std::vector<std::string> block_devs;
+	if (!read_sys_block_star(&block_devs))
+	{
+		LOG(ERROR) << "could not ls /sys/block";
+		LOG(ERROR) << "iostat-like statistics will not be reported";
+		return;
+	}
+	FILE *mounts = fopen("/proc/mounts", "r");
+	if (!mounts)
+	{
+		LOG(ERROR) << "could not open /proc/mounts: " << po6::strerror(errno);
+		LOG(ERROR) << "iostat-like statistics will not be reported";
+		return;
+	}
+	char *line = NULL;
+	size_t line_sz = 0;
+	size_t max_mnt_sz = 0;
+	while (true)
+	{
+		ssize_t amt = getline(&line, &line_sz, mounts);
+		if (amt < 0)
+		{
+			if (ferror(mounts) != 0)
+			{
+				LOG(WARNING) << "could not read from /proc/mounts: " << po6::strerror(errno);
+				break;
+			}
+			if (feof(mounts) != 0)
+			{
+				break;
+			}
+			LOG(WARNING) << "unknown error when reading from /proc/mounts\n";
+			break;
+		}
+		char dev[4096];
+		char mnt[4096];
+		int pts = sscanf(line, "%4095s %4095s", dev, mnt);
+		if (pts != 2)
+		{
+			continue;
+		}
+		size_t msz = strlen(mnt);
+		if (strncmp(mnt, dir.c_str(), msz) != 0 ||
+		    msz < max_mnt_sz)
+		{
+			continue;
+		}
+		std::string stat_path = po6::path::basename(dev);
+		for (size_t i = 0; i < block_devs.size(); ++i)
+		{
+			size_t dsz = std::min(stat_path.size(), block_devs[i].size());
+			if (strncmp(block_devs[i].c_str(), stat_path.c_str(), dsz) == 0)
+			{
+				max_mnt_sz = msz;
+				m_block_stat_path = std::string("/sys/block/") + block_devs[i] + "/stat";
+			}
+		}
+	}
+	if (!m_block_stat_path.empty())
+	{
+		LOG(INFO) << "using " << m_block_stat_path << " for reporting io.* stats";
+	}
+	else
+	{
+		LOG(WARNING) << "cannot determine device name for reporting io.* stats";
+		LOG(WARNING) << "iostat-like statistics will not be reported";
+	}
+	if (line)
+	{
+		free(line);
+	}
+	fclose(mounts);
 }
 
 void
-daemon :: collect_stats_io(std::ostringstream* ret)
+daemon :: collect_stats_io(std::ostringstream *ret)
 {
-    if (m_block_stat_path.empty())
-    {
-        return;
-    }
-
-    FILE* fin = fopen(m_block_stat_path.c_str(), "r");
-
-    if (!fin)
-    {
-        LOG(ERROR) << "could not open " << m_block_stat_path << " for reading block-device stats; io.* stats will not be reported";
-        m_block_stat_path = "";
-        return;
-    }
-
-    uint64_t read_ios;
-    uint64_t read_merges;
-    uint64_t read_sectors;
-    uint64_t read_ticks;
-    uint64_t write_ios;
-    uint64_t write_merges;
-    uint64_t write_sectors;
-    uint64_t write_ticks;
-    uint64_t in_flight;
-    uint64_t io_ticks;
-    uint64_t time_in_queue;
-    int x = fscanf(fin, "%lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu",
-                   &read_ios, &read_merges, &read_sectors, &read_ticks,
-                   &write_ios, &write_merges, &write_sectors, &write_ticks,
-                   &in_flight, &io_ticks, &time_in_queue);
-    fclose(fin);
-
-    if (x == 11)
-    {
-        *ret << " io.read_ios=" << read_ios;
-        *ret << " io.read_merges=" << read_merges;
-        *ret << " io.read_bytes=" << read_sectors * 512;
-        *ret << " io.read_ticks=" << read_ticks;
-        *ret << " io.write_ios=" << write_ios;
-        *ret << " io.write_merges=" << write_merges;
-        *ret << " io.write_bytes=" << write_sectors * 512;
-        *ret << " io.write_ticks=" << write_ticks;
-        *ret << " io.in_flight=" << in_flight;
-        *ret << " io.io_ticks=" << io_ticks;
-        *ret << " io.time_in_queue=" << time_in_queue;
-    }
+	if (m_block_stat_path.empty())
+	{
+		return;
+	}
+	FILE *fin = fopen(m_block_stat_path.c_str(), "r");
+	if (!fin)
+	{
+		LOG(ERROR) << "could not open " << m_block_stat_path << " for reading block-device stats; io.* stats will not be reported";
+		m_block_stat_path = "";
+		return;
+	}
+	uint64_t read_ios;
+	uint64_t read_merges;
+	uint64_t read_sectors;
+	uint64_t read_ticks;
+	uint64_t write_ios;
+	uint64_t write_merges;
+	uint64_t write_sectors;
+	uint64_t write_ticks;
+	uint64_t in_flight;
+	uint64_t io_ticks;
+	uint64_t time_in_queue;
+	int x = fscanf(fin, "%lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu",
+	               &read_ios, &read_merges, &read_sectors, &read_ticks,
+	               &write_ios, &write_merges, &write_sectors, &write_ticks,
+	               &in_flight, &io_ticks, &time_in_queue);
+	fclose(fin);
+	if (x == 11)
+	{
+		*ret << " io.read_ios=" << read_ios;
+		*ret << " io.read_merges=" << read_merges;
+		*ret << " io.read_bytes=" << read_sectors * 512;
+		*ret << " io.read_ticks=" << read_ticks;
+		*ret << " io.write_ios=" << write_ios;
+		*ret << " io.write_merges=" << write_merges;
+		*ret << " io.write_bytes=" << write_sectors * 512;
+		*ret << " io.write_ticks=" << write_ticks;
+		*ret << " io.in_flight=" << in_flight;
+		*ret << " io.io_ticks=" << io_ticks;
+		*ret << " io.time_in_queue=" << time_in_queue;
+	}
 }
diff --git a/daemon/daemon.h b/daemon/daemon.h
index e56175ed4..380bd5d9e 100644
--- a/daemon/daemon.h
+++ b/daemon/daemon.h
@@ -56,116 +56,118 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class daemon
 {
-    public:
-        daemon();
-        ~daemon() throw ();
+public:
+	daemon();
+	~daemon() throw ();
 
-    public:
-        int run(bool daemonize,
-                std::string data,
-                std::string log,
-                std::string pidfile,
-                bool has_pidfile,
-                bool set_bind_to,
-                po6::net::location bind_to,
-                bool set_coordinator,
-                po6::net::hostname coordinator,
-                unsigned threads);
+public:
+	int run(bool daemonize,
+	        std::string data,
+	        std::string log,
+	        std::string pidfile,
+	        bool has_pidfile,
+	        bool set_bind_to,
+	        po6::net::location bind_to,
+	        bool set_coordinator,
+	        po6::net::hostname coordinator,
+	        unsigned threads);
 
-    private:
-        // Pause and unpause all activity, e.g. for reconfiguration or
-        // installing new indices.  If called from a background thread, the
-        // thread must remain offline for entire time between pause/unpause.
-        void pause();
-        void unpause();
-        // process messages from the network threads
-        void loop(size_t thread);
-        void process_req_get(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
-        void process_req_get_partial(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
-        void process_req_atomic(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
-        void process_req_search_start(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
-        void process_req_search_next(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
-        void process_req_search_stop(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
-        void process_req_sorted_search(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
-        void process_req_count(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
-        void process_req_search_describe(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
-        void process_req_group_atomic(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
-        void process_chain_op(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
-        void process_chain_subspace(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
-        void process_chain_ack(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
-        void process_xfer_handshake_syn(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
-        void process_xfer_handshake_synack(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
-        void process_xfer_handshake_ack(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
-        void process_xfer_handshake_wiped(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
-        void process_xfer_op(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
-        void process_xfer_ack(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
-        void process_backup(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
-        void process_perf_counters(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
+private:
+	// Pause and unpause all activity, e.g. for reconfiguration or
+	// installing new indices.  If called from a background thread, the
+	// thread must remain offline for entire time between pause/unpause.
+	void pause();
+	void unpause();
+	// process messages from the network threads
+	void loop(size_t thread);
+	void process_req_get(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
+	void process_req_get_partial(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
+	void process_req_atomic(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
+	void process_req_search_start(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
+	void process_req_search_next(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
+	void process_req_search_stop(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
+	void process_req_sorted_search(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
+	void process_req_count(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
+	void process_req_sum(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
+	void process_req_search_describe(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
+	void process_req_group_atomic(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
+	void process_chain_op(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
+	void process_chain_subspace(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
+	void process_chain_ack(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
+	void process_xfer_handshake_syn(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
+	void process_xfer_handshake_synack(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
+	void process_xfer_handshake_ack(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
+	void process_xfer_handshake_wiped(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
+	void process_xfer_op(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
+	void process_xfer_ack(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
+	void process_backup(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
+	void process_perf_counters(server_id from, virtual_server_id vfrom, virtual_server_id vto, std::auto_ptr<e::buffer> msg, e::unpacker up);
 
-    private:
-        void collect_stats();
-        void collect_stats_msgs(std::ostringstream* ret);
-        void collect_stats_leveldb(std::ostringstream* ret);
-        void determine_block_stat_path(const std::string& data);
-        void collect_stats_io(std::ostringstream* ret);
+private:
+	void collect_stats();
+	void collect_stats_msgs(std::ostringstream *ret);
+	void collect_stats_leveldb(std::ostringstream *ret);
+	void determine_block_stat_path(const std::string &data);
+	void collect_stats_io(std::ostringstream *ret);
 
-    private:
-        friend class background_thread;
-        friend class communication;
-        friend class coordinator_link;
-        friend class datalayer;
-        friend class key_state;
-        friend class replication_manager;
-        friend class search_manager;
-        friend class state_transfer_manager;
+private:
+	friend class background_thread;
+	friend class communication;
+	friend class coordinator_link;
+	friend class datalayer;
+	friend class key_state;
+	friend class replication_manager;
+	friend class search_manager;
+	friend class state_transfer_manager;
 
-    private:
-        server_id m_us;
-        po6::net::location m_bind_to;
-        std::vector<e::compat::shared_ptr<po6::threads::thread> > m_threads;
-        e::garbage_collector m_gc;
-        e::garbage_collector::thread_state m_gc_ts;
-        std::auto_ptr<coordinator_link> m_coord;
-        std::string m_data_dir;
-        datalayer m_data;
-        communication m_comm;
-        replication_manager m_repl;
-        state_transfer_manager m_stm;
-        search_manager m_sm;
-        configuration m_config;
-        // pause management
-        po6::threads::mutex m_protect_pause;
-        po6::threads::cond m_can_pause;
-        bool m_paused;
-        // counters
-        performance_counter m_perf_req_get;
-        performance_counter m_perf_req_get_partial;
-        performance_counter m_perf_req_atomic;
-        performance_counter m_perf_req_search_start;
-        performance_counter m_perf_req_search_next;
-        performance_counter m_perf_req_search_stop;
-        performance_counter m_perf_req_sorted_search;
-        performance_counter m_perf_req_count;
-        performance_counter m_perf_req_search_describe;
-        performance_counter m_perf_req_group_atomic;
-        performance_counter m_perf_chain_op;
-        performance_counter m_perf_chain_subspace;
-        performance_counter m_perf_chain_ack;
-        performance_counter m_perf_xfer_handshake_syn;
-        performance_counter m_perf_xfer_handshake_synack;
-        performance_counter m_perf_xfer_handshake_ack;
-        performance_counter m_perf_xfer_handshake_wiped;
-        performance_counter m_perf_xfer_op;
-        performance_counter m_perf_xfer_ack;
-        performance_counter m_perf_backup;
-        performance_counter m_perf_perf_counters;
-        // iostat-like stats
-        std::string m_block_stat_path;
-        // historical data
-        po6::threads::thread m_stat_collector;
-        po6::threads::mutex m_protect_stats;
-        uint64_t m_stats_start;
-        std::list<std::pair<uint64_t, std::string> > m_stats;
+private:
+	server_id m_us;
+	po6::net::location m_bind_to;
+	std::vector<e::compat::shared_ptr<po6::threads::thread> > m_threads;
+	e::garbage_collector m_gc;
+	e::garbage_collector::thread_state m_gc_ts;
+	std::auto_ptr<coordinator_link> m_coord;
+	std::string m_data_dir;
+	datalayer m_data;
+	communication m_comm;
+	replication_manager m_repl;
+	state_transfer_manager m_stm;
+	search_manager m_sm;
+	configuration m_config;
+	// pause management
+	po6::threads::mutex m_protect_pause;
+	po6::threads::cond m_can_pause;
+	bool m_paused;
+	// counters
+	performance_counter m_perf_req_get;
+	performance_counter m_perf_req_get_partial;
+	performance_counter m_perf_req_atomic;
+	performance_counter m_perf_req_search_start;
+	performance_counter m_perf_req_search_next;
+	performance_counter m_perf_req_search_stop;
+	performance_counter m_perf_req_sorted_search;
+	performance_counter m_perf_req_count;
+	performance_counter m_perf_req_sum;
+	performance_counter m_perf_req_search_describe;
+	performance_counter m_perf_req_group_atomic;
+	performance_counter m_perf_chain_op;
+	performance_counter m_perf_chain_subspace;
+	performance_counter m_perf_chain_ack;
+	performance_counter m_perf_xfer_handshake_syn;
+	performance_counter m_perf_xfer_handshake_synack;
+	performance_counter m_perf_xfer_handshake_ack;
+	performance_counter m_perf_xfer_handshake_wiped;
+	performance_counter m_perf_xfer_op;
+	performance_counter m_perf_xfer_ack;
+	performance_counter m_perf_backup;
+	performance_counter m_perf_perf_counters;
+	// iostat-like stats
+	std::string m_block_stat_path;
+	// historical data
+	po6::threads::thread m_stat_collector;
+	po6::threads::mutex m_protect_stats;
+	uint64_t m_stats_start;
+	std::list<std::pair<uint64_t, std::string> > m_stats;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/daemon/datalayer.cc b/daemon/datalayer.cc
index 67cfd126f..d3c3edb2b 100644
--- a/daemon/datalayer.cc
+++ b/daemon/datalayer.cc
@@ -78,818 +78,730 @@ using hyperdex::reconfigure_returncode;
 
 const hyperdex::region_id datalayer::defaultri;
 
-datalayer :: datalayer(daemon* d)
-    : m_daemon(d)
-    , m_db()
-    , m_indices()
-    , m_versions()
-    , m_checkpointer(new checkpointer_thread(d))
-    , m_mediator(new wiper_indexer_mediator())
-    , m_indexer(new indexer_thread(d, m_mediator.get()))
-    , m_wiper(new wiper_thread(d, m_mediator.get()))
+datalayer :: datalayer(daemon *d)
+	: m_daemon(d)
+	, m_db()
+	, m_indices()
+	, m_versions()
+	, m_checkpointer(new checkpointer_thread(d))
+	, m_mediator(new wiper_indexer_mediator())
+	, m_indexer(new indexer_thread(d, m_mediator.get()))
+	, m_wiper(new wiper_thread(d, m_mediator.get()))
 {
 }
 
 datalayer :: ~datalayer() throw ()
 {
-    m_checkpointer->shutdown();
-    m_indexer->shutdown();
-    m_wiper->shutdown();
+	m_checkpointer->shutdown();
+	m_indexer->shutdown();
+	m_wiper->shutdown();
 }
 
 #define FORMAT_1_6 "v1.6.0 format"
 
 bool
-datalayer :: initialize(const std::string& path,
-                        bool* saved,
-                        server_id* saved_us,
-                        po6::net::location* saved_bind_to,
-                        po6::net::hostname* saved_coordinator)
+datalayer :: initialize(const std::string &path,
+                        bool *saved,
+                        server_id *saved_us,
+                        po6::net::location *saved_bind_to,
+                        po6::net::hostname *saved_coordinator)
 {
-    leveldb::Options opts;
-    opts.write_buffer_size = 16ULL * 1024ULL * 1024ULL;
-    opts.create_if_missing = true;
-    opts.filter_policy = leveldb::NewBloomFilterPolicy(10);
-    opts.manual_garbage_collection = true;
-    opts.max_open_files = std::max(sysconf(_SC_OPEN_MAX) >> 1, 1024L);
-    std::string name(path);
-    leveldb::DB* tmp_db;
-    leveldb::Status st = leveldb::DB::Open(opts, name, &tmp_db);
-
-    if (!st.ok())
-    {
-        LOG(ERROR) << "could not open LevelDB: " << st.ToString();
-        return false;
-    }
-
-    m_db.reset(tmp_db);
-    leveldb::ReadOptions ropts;
-    ropts.fill_cache = true;
-    ropts.verify_checksums = true;
-    leveldb::WriteOptions wopts;
-    wopts.sync = true;
-
-    // read the "hyperdex" key and check the version
-    std::string rbacking;
-    st = m_db->Get(ropts, leveldb::Slice("hyperdex", 8), &rbacking);
-    bool first_time = false;
-
-    if (st.ok())
-    {
-        first_time = false;
-
-        if (rbacking != FORMAT_1_6)
-        {
-            LOG(ERROR) << "could not restore daemon "
-                       << "the existing data was created with"
-                       << "HyperDex " << rbacking << " but "
-                       << "this is requires the v1.6.0-compatible format";
-            return false;
-        }
-    }
-    else if (st.IsNotFound())
-    {
-        first_time = true;
-        leveldb::Slice k("hyperdex", 8);
-        leveldb::Slice v(FORMAT_1_6, STRLENOF(FORMAT_1_6));
-        st = m_db->Put(wopts, k, v);
-
-        if (!st.ok())
-        {
-            LOG(ERROR) << "could not save \"hyperdex\" key to disk: " << st.ToString();
-            return false;
-        }
-    }
-    else
-    {
-        LOG(ERROR) << "could not read \"hyperdex\" key from LevelDB: " << st.ToString();
-        return false;
-    }
-
-    // read the "state" key and parse it
-    std::string sbacking;
-    st = m_db->Get(ropts, leveldb::Slice("state", 5), &sbacking);
-
-    if (st.ok())
-    {
-        if (first_time)
-        {
-            LOG(ERROR) << "could not restore from LevelDB because a previous "
-                       << "execution crashed and the database was tampered with; "
-                       << "you'll need to manually erase this DB and create a new one";
-            return false;
-        }
-
-        e::unpacker up(sbacking.data(), sbacking.size());
-        uint64_t us;
-        up = up >> us >> *saved_bind_to >> *saved_coordinator;
-        *saved_us = server_id(us);
-
-        if (up.error())
-        {
-            LOG(ERROR) << "could not restore from LevelDB because a previous "
-                       << "execution wrote an invalid state; "
-                       << "you'll need to manually erase this DB and create a new one";
-            return false;
-        }
-    }
-    else if (st.IsNotFound())
-    {
-        if (!only_key_is_hyperdex_key())
-        {
-            LOG(ERROR) << "could not restore from LevelDB because a previous "
-                       << "execution didn't save state and wrote other data; "
-                       << "you'll need to manually erase this DB and create a new one";
-            return false;
-        }
-    }
-    else
-    {
-        LOG(ERROR) << "could not read \"hyperdex\" key from LevelDB: " << st.ToString();
-        return false;
-    }
-
-    m_checkpointer->start();
-    m_indexer->start();
-    m_wiper->start();
-    *saved = !first_time;
-    return true;
+	leveldb::Options opts;
+	opts.write_buffer_size = 16ULL * 1024ULL * 1024ULL;
+	opts.create_if_missing = true;
+	opts.filter_policy = leveldb::NewBloomFilterPolicy(10);
+	opts.manual_garbage_collection = true;
+	opts.max_open_files = std::max(sysconf(_SC_OPEN_MAX) >> 1, 1024L);
+	std::string name(path);
+	leveldb::DB *tmp_db;
+	leveldb::Status st = leveldb::DB::Open(opts, name, &tmp_db);
+	if (!st.ok())
+	{
+		LOG(ERROR) << "could not open LevelDB: " << st.ToString();
+		return false;
+	}
+	m_db.reset(tmp_db);
+	leveldb::ReadOptions ropts;
+	ropts.fill_cache = true;
+	ropts.verify_checksums = true;
+	leveldb::WriteOptions wopts;
+	wopts.sync = true;
+	// read the "hyperdex" key and check the version
+	std::string rbacking;
+	st = m_db->Get(ropts, leveldb::Slice("hyperdex", 8), &rbacking);
+	bool first_time = false;
+	if (st.ok())
+	{
+		first_time = false;
+		if (rbacking != FORMAT_1_6)
+		{
+			LOG(ERROR) << "could not restore daemon "
+			           << "the existing data was created with"
+			           << "HyperDex " << rbacking << " but "
+			           << "this is requires the v1.6.0-compatible format";
+			return false;
+		}
+	}
+	else if (st.IsNotFound())
+	{
+		first_time = true;
+		leveldb::Slice k("hyperdex", 8);
+		leveldb::Slice v(FORMAT_1_6, STRLENOF(FORMAT_1_6));
+		st = m_db->Put(wopts, k, v);
+		if (!st.ok())
+		{
+			LOG(ERROR) << "could not save \"hyperdex\" key to disk: " << st.ToString();
+			return false;
+		}
+	}
+	else
+	{
+		LOG(ERROR) << "could not read \"hyperdex\" key from LevelDB: " << st.ToString();
+		return false;
+	}
+	// read the "state" key and parse it
+	std::string sbacking;
+	st = m_db->Get(ropts, leveldb::Slice("state", 5), &sbacking);
+	if (st.ok())
+	{
+		if (first_time)
+		{
+			LOG(ERROR) << "could not restore from LevelDB because a previous "
+			           << "execution crashed and the database was tampered with; "
+			           << "you'll need to manually erase this DB and create a new one";
+			return false;
+		}
+		e::unpacker up(sbacking.data(), sbacking.size());
+		uint64_t us;
+		up = up >> us >> *saved_bind_to >> *saved_coordinator;
+		*saved_us = server_id(us);
+		if (up.error())
+		{
+			LOG(ERROR) << "could not restore from LevelDB because a previous "
+			           << "execution wrote an invalid state; "
+			           << "you'll need to manually erase this DB and create a new one";
+			return false;
+		}
+	}
+	else if (st.IsNotFound())
+	{
+		if (!only_key_is_hyperdex_key())
+		{
+			LOG(ERROR) << "could not restore from LevelDB because a previous "
+			           << "execution didn't save state and wrote other data; "
+			           << "you'll need to manually erase this DB and create a new one";
+			return false;
+		}
+	}
+	else
+	{
+		LOG(ERROR) << "could not read \"hyperdex\" key from LevelDB: " << st.ToString();
+		return false;
+	}
+	m_checkpointer->start();
+	m_indexer->start();
+	m_wiper->start();
+	*saved = !first_time;
+	return true;
 }
 
 void
 datalayer :: teardown()
 {
-    m_checkpointer->shutdown();
-    m_indexer->shutdown();
-    m_wiper->shutdown();
+	m_checkpointer->shutdown();
+	m_indexer->shutdown();
+	m_wiper->shutdown();
 }
 
 bool
-datalayer :: save_state(const server_id& us,
-                        const po6::net::location& bind_to,
-                        const po6::net::hostname& coordinator)
+datalayer :: save_state(const server_id &us,
+                        const po6::net::location &bind_to,
+                        const po6::net::hostname &coordinator)
 {
-    leveldb::WriteOptions wopts;
-    wopts.sync = true;
-    size_t sz = sizeof(uint64_t)
-              + pack_size(bind_to)
-              + pack_size(coordinator);
-    std::auto_ptr<e::buffer> state(e::buffer::create(sz));
-    state->pack() << us << bind_to << coordinator;
-    leveldb::Status st = m_db->Put(wopts, leveldb::Slice("state", 5),
-                                   leveldb::Slice(reinterpret_cast<const char*>(state->data()), state->size()));
-
-    if (st.ok())
-    {
-        return true;
-    }
-    else
-    {
-        LOG(ERROR) << "could not save state: " << st.ToString();
-        return false;
-    }
+	leveldb::WriteOptions wopts;
+	wopts.sync = true;
+	size_t sz = sizeof(uint64_t)
+	            + pack_size(bind_to)
+	            + pack_size(coordinator);
+	std::auto_ptr<e::buffer> state(e::buffer::create(sz));
+	state->pack() << us << bind_to << coordinator;
+	leveldb::Status st = m_db->Put(wopts, leveldb::Slice("state", 5),
+	                               leveldb::Slice(reinterpret_cast<const char *>(state->data()), state->size()));
+	if (st.ok())
+	{
+		return true;
+	}
+	else
+	{
+		LOG(ERROR) << "could not save state: " << st.ToString();
+		return false;
+	}
 }
 
 void
 datalayer :: pause()
 {
-    m_checkpointer->initiate_pause();
-    m_indexer->initiate_pause();
-    m_wiper->initiate_pause();
+	m_checkpointer->initiate_pause();
+	m_indexer->initiate_pause();
+	m_wiper->initiate_pause();
 }
 
 void
 datalayer :: unpause()
 {
-    m_checkpointer->unpause();
-    m_indexer->unpause();
-    m_wiper->unpause();
+	m_checkpointer->unpause();
+	m_indexer->unpause();
+	m_wiper->unpause();
 }
 
 void
-datalayer :: reconfigure(const configuration&,
-                         const configuration& config,
-                         const server_id&)
+datalayer :: reconfigure(const configuration &,
+                         const configuration &config,
+                         const server_id &)
 {
-    m_checkpointer->wait_until_paused();
-    m_indexer->wait_until_paused();
-    m_wiper->wait_until_paused();
-
-    // indices that must exist
-    std::vector<std::pair<region_id, index_id> > indices;
-    config.all_indices(m_daemon->m_us, &indices);
-    std::sort(indices.begin(), indices.end());
-    std::vector<std::pair<region_id, index_id> >::iterator it;
-    it = std::unique(indices.begin(), indices.end());
-    indices.resize(it - indices.begin());
-
-    // iterate and create indices where necessary
-    std::vector<index_state> next_indices;
-    size_t old_idx = 0;
-    size_t new_idx = 0;
-
-    while (new_idx < indices.size())
-    {
-        int cmp = 1;
-
-        if (old_idx < m_indices.size())
-        {
-            cmp = e::tuple_compare(m_indices[old_idx].ri, m_indices[old_idx].ii,
-                                   indices[new_idx].first, indices[old_idx].second);
-        }
-
-        if (cmp == 0)
-        {
-            // Case B
-            next_indices.push_back(m_indices[old_idx]);
-            ++old_idx;
-            ++new_idx;
-        }
-        else if (cmp < 0)
-        {
-            // Case A
-            ++old_idx;
-        }
-        else if (cmp > 0)
-        {
-            next_indices.push_back(index_state(indices[new_idx].first,
-                                               indices[new_idx].second));
-            ++new_idx;
-            region_id ri(indices[new_idx].first);
-            index_id ii(indices[new_idx].second);
-            char buf[sizeof(uint8_t) + 2 * VARINT_64_MAX_SIZE];
-            char* ptr = buf;
-            ptr = e::pack8be('I', ptr);
-            ptr = e::packvarint64(ri.get(), ptr);
-            ptr = e::packvarint64(ii.get(), ptr);
-            leveldb::ReadOptions ro;
-            leveldb::Slice key(buf, ptr - buf);
-            std::string val;
-            leveldb::Status st = m_db->Get(ro, key, &val);
-
-            if (st.ok())
-            {
-                next_indices.back().set_usable();
-            }
-            else if (!st.IsNotFound())
-            {
-                handle_error(st);
-            }
-        }
-    }
-
-    m_indices.swap(next_indices);
-
-    // update the versions
-    std::vector<region_id> key_regions;
-    config.key_regions(m_daemon->m_us, &key_regions);
-    std::vector<region_id> xfer_regions;
-    config.transfers_in_regions(m_daemon->m_us, &xfer_regions);
-
-    for (size_t i = 0; i < xfer_regions.size(); ++i)
-    {
-        if (config.is_point_leader(config.head_of_region(xfer_regions[i])))
-        {
-            key_regions.push_back(xfer_regions[i]);
-        }
-    }
-
-    e::ao_hash_map<region_id, uint64_t, id, defaultri> new_versions;
-
-    for (size_t i = 0; i < key_regions.size(); ++i)
-    {
-        uint64_t val = 0;
-
-        if (!m_versions.get(key_regions[i], &val))
-        {
-            val = disk_version(key_regions[i]);
-        }
-
-        new_versions.put(key_regions[i], val);
-    }
-
-    m_versions.swap(&new_versions);
-    m_indexer->kick();
-    m_wiper->kick();
+	m_checkpointer->wait_until_paused();
+	m_indexer->wait_until_paused();
+	m_wiper->wait_until_paused();
+	// indices that must exist
+	std::vector<std::pair<region_id, index_id> > indices;
+	config.all_indices(m_daemon->m_us, &indices);
+	std::sort(indices.begin(), indices.end());
+	std::vector<std::pair<region_id, index_id> >::iterator it;
+	it = std::unique(indices.begin(), indices.end());
+	indices.resize(it - indices.begin());
+	// iterate and create indices where necessary
+	std::vector<index_state> next_indices;
+	size_t old_idx = 0;
+	size_t new_idx = 0;
+	while (new_idx < indices.size())
+	{
+		int cmp = 1;
+		if (old_idx < m_indices.size())
+		{
+			cmp = e::tuple_compare(m_indices[old_idx].ri, m_indices[old_idx].ii,
+			                       indices[new_idx].first, indices[old_idx].second);
+		}
+		if (cmp == 0)
+		{
+			// Case B
+			next_indices.push_back(m_indices[old_idx]);
+			++old_idx;
+			++new_idx;
+		}
+		else if (cmp < 0)
+		{
+			// Case A
+			++old_idx;
+		}
+		else if (cmp > 0)
+		{
+			next_indices.push_back(index_state(indices[new_idx].first,
+			                                   indices[new_idx].second));
+			++new_idx;
+			region_id ri(indices[new_idx].first);
+			index_id ii(indices[new_idx].second);
+			char buf[sizeof(uint8_t) + 2 * VARINT_64_MAX_SIZE];
+			char *ptr = buf;
+			ptr = e::pack8be('I', ptr);
+			ptr = e::packvarint64(ri.get(), ptr);
+			ptr = e::packvarint64(ii.get(), ptr);
+			leveldb::ReadOptions ro;
+			leveldb::Slice key(buf, ptr - buf);
+			std::string val;
+			leveldb::Status st = m_db->Get(ro, key, &val);
+			if (st.ok())
+			{
+				next_indices.back().set_usable();
+			}
+			else if (!st.IsNotFound())
+			{
+				handle_error(st);
+			}
+		}
+	}
+	m_indices.swap(next_indices);
+	// update the versions
+	std::vector<region_id> key_regions;
+	config.key_regions(m_daemon->m_us, &key_regions);
+	std::vector<region_id> xfer_regions;
+	config.transfers_in_regions(m_daemon->m_us, &xfer_regions);
+	for (size_t i = 0; i < xfer_regions.size(); ++i)
+	{
+		if (config.is_point_leader(config.head_of_region(xfer_regions[i])))
+		{
+			key_regions.push_back(xfer_regions[i]);
+		}
+	}
+	e::ao_hash_map<region_id, uint64_t, id, defaultri> new_versions;
+	for (size_t i = 0; i < key_regions.size(); ++i)
+	{
+		uint64_t val = 0;
+		if (!m_versions.get(key_regions[i], &val))
+		{
+			val = disk_version(key_regions[i]);
+		}
+		new_versions.put(key_regions[i], val);
+	}
+	m_versions.swap(&new_versions);
+	m_indexer->kick();
+	m_wiper->kick();
 }
 
 void
 datalayer :: debug_dump()
 {
-    LOG(INFO) << "index state ===================================================================";
-
-    for (size_t i = 0; i < m_indices.size(); ++i)
-    {
-        LOG(INFO) << "index id=" << m_indices[i].ii.get()
-                  << " region=" << m_indices[i].ri.get()
-                  << " usable=" << (m_indices[i].is_usable() ? "yes" : "no");
-    }
-
-    m_checkpointer->debug_dump();
-    m_mediator->debug_dump();
-    m_indexer->debug_dump();
-    m_wiper->debug_dump();
+	LOG(INFO) << "index state ===================================================================";
+	for (size_t i = 0; i < m_indices.size(); ++i)
+	{
+		LOG(INFO) << "index id=" << m_indices[i].ii.get()
+		          << " region=" << m_indices[i].ri.get()
+		          << " usable=" << (m_indices[i].is_usable() ? "yes" : "no");
+	}
+	m_checkpointer->debug_dump();
+	m_mediator->debug_dump();
+	m_indexer->debug_dump();
+	m_wiper->debug_dump();
 }
 
 bool
-datalayer :: get_property(const e::slice& property,
-                          std::string* value)
+datalayer :: get_property(const e::slice &property,
+                          std::string *value)
 {
-    leveldb::Slice prop(reinterpret_cast<const char*>(property.data()), property.size());
-    return m_db->GetProperty(prop, value);
+	leveldb::Slice prop(reinterpret_cast<const char *>(property.data()), property.size());
+	return m_db->GetProperty(prop, value);
 }
 
 std::string
 datalayer :: get_timestamp()
 {
-    std::string timestamp;
-    m_db->GetReplayTimestamp(&timestamp);
-    return timestamp;
+	std::string timestamp;
+	m_db->GetReplayTimestamp(&timestamp);
+	return timestamp;
 }
 
 uint64_t
 datalayer :: approximate_size()
 {
-    leveldb::Slice start("\x00", 1);
-    leveldb::Slice limit("\xff", 1);
-    leveldb::Range r(start, limit);
-    uint64_t ret = 0;
-    m_db->GetApproximateSizes(&r, 1, &ret);
-    return ret;
+	leveldb::Slice start("\x00", 1);
+	leveldb::Slice limit("\xff", 1);
+	leveldb::Range r(start, limit);
+	uint64_t ret = 0;
+	m_db->GetApproximateSizes(&r, 1, &ret);
+	return ret;
 }
 
 datalayer::returncode
-datalayer :: get(const region_id& ri,
-                 const e::slice& key,
-                 std::vector<e::slice>* value,
-                 uint64_t* version,
-                 reference* ref)
+datalayer :: get(const region_id &ri,
+                 const e::slice &key,
+                 std::vector<e::slice> *value,
+                 uint64_t *version,
+                 reference *ref)
 {
-    const schema& sc(*m_daemon->m_config.get_schema(ri));
-    std::vector<char> scratch;
-
-    // create the encoded key
-    leveldb::Slice lkey;
-    encode_key(ri, sc.attrs[0].type, key, &scratch, &lkey);
-
-    // perform the read
-    leveldb::ReadOptions opts;
-    opts.fill_cache = true;
-    opts.verify_checksums = true;
-    leveldb::Status st = m_db->Get(opts, lkey, &ref->m_backing);
-
-    if (st.ok())
-    {
-        e::slice v(ref->m_backing.data(), ref->m_backing.size());
-        return decode_value(v, value, version);
-    }
-    else if (st.IsNotFound())
-    {
-        return NOT_FOUND;
-    }
-    else
-    {
-        return handle_error(st);
-    }
+	const schema &sc(*m_daemon->m_config.get_schema(ri));
+	std::vector<char> scratch;
+	// create the encoded key
+	leveldb::Slice lkey;
+	encode_key(ri, sc.attrs[0].type, key, &scratch, &lkey);
+	// perform the read
+	leveldb::ReadOptions opts;
+	opts.fill_cache = true;
+	opts.verify_checksums = true;
+	leveldb::Status st = m_db->Get(opts, lkey, &ref->m_backing);
+	if (st.ok())
+	{
+		e::slice v(ref->m_backing.data(), ref->m_backing.size());
+		return decode_value(v, value, version);
+	}
+	else if (st.IsNotFound())
+	{
+		return NOT_FOUND;
+	}
+	else
+	{
+		return handle_error(st);
+	}
 }
 
 datalayer::returncode
-datalayer :: del(const region_id& ri,
-                 const e::slice& key,
-                 const std::vector<e::slice>& old_value)
+datalayer :: del(const region_id &ri,
+                 const e::slice &key,
+                 const std::vector<e::slice> &old_value)
 {
-    leveldb::WriteBatch updates;
-    const schema& sc(*m_daemon->m_config.get_schema(ri));
-    std::vector<char> scratch;
-
-    // create the encoded key
-    leveldb::Slice lkey;
-    encode_key(ri, sc.attrs[0].type, key, &scratch, &lkey);
-
-    // delete the actual object
-    updates.Delete(lkey);
-
-    // delete the index entries
-    std::vector<const index*> indices;
-    find_indices(ri, &indices);
-    create_index_changes(sc, ri, indices, key, &old_value, NULL, &updates);
-
-    // Perform the write
-    leveldb::WriteOptions opts;
-    opts.sync = false;
-    leveldb::Status st = m_db->Write(opts, &updates);
-
-    if (st.ok())
-    {
-        return SUCCESS;
-    }
-    else if (st.IsNotFound())
-    {
-        return NOT_FOUND;
-    }
-    else
-    {
-        return handle_error(st);
-    }
+	leveldb::WriteBatch updates;
+	const schema &sc(*m_daemon->m_config.get_schema(ri));
+	std::vector<char> scratch;
+	// create the encoded key
+	leveldb::Slice lkey;
+	encode_key(ri, sc.attrs[0].type, key, &scratch, &lkey);
+	// delete the actual object
+	updates.Delete(lkey);
+	// delete the index entries
+	std::vector<const index *> indices;
+	find_indices(ri, &indices);
+	create_index_changes(sc, ri, indices, key, &old_value, NULL, &updates);
+	// Perform the write
+	leveldb::WriteOptions opts;
+	opts.sync = false;
+	leveldb::Status st = m_db->Write(opts, &updates);
+	if (st.ok())
+	{
+		return SUCCESS;
+	}
+	else if (st.IsNotFound())
+	{
+		return NOT_FOUND;
+	}
+	else
+	{
+		return handle_error(st);
+	}
 }
 
 datalayer::returncode
-datalayer :: put(const region_id& ri,
-                 const e::slice& key,
-                 const std::vector<e::slice>& new_value,
+datalayer :: put(const region_id &ri,
+                 const e::slice &key,
+                 const std::vector<e::slice> &new_value,
                  uint64_t version)
 {
-    leveldb::WriteBatch updates;
-    const schema& sc(*m_daemon->m_config.get_schema(ri));
-    std::vector<char> scratch1;
-    std::vector<char> scratch2;
-
-    // create the encoded key
-    leveldb::Slice lkey;
-    encode_key(ri, sc.attrs[0].type, key, &scratch1, &lkey);
-
-    // create the encoded value
-    leveldb::Slice lval;
-    encode_value(new_value, version, &scratch2, &lval);
-
-    // put the actual object
-    updates.Put(lkey, lval);
-
-    // put the index entries
-    std::vector<const index*> indices;
-    find_indices(ri, &indices);
-    create_index_changes(sc, ri, indices, key, NULL, &new_value, &updates);
-
-    // ensure we've recorded a version at least as high as this key
-    write_version(ri, version, &updates);
-
-    // Perform the write
-    leveldb::WriteOptions opts;
-    opts.sync = false;
-    leveldb::Status st = m_db->Write(opts, &updates);
-
-    if (st.ok())
-    {
-        update_memory_version(ri, version);
-        return SUCCESS;
-    }
-    else
-    {
-        return handle_error(st);
-    }
+	leveldb::WriteBatch updates;
+	const schema &sc(*m_daemon->m_config.get_schema(ri));
+	std::vector<char> scratch1;
+	std::vector<char> scratch2;
+	// create the encoded key
+	leveldb::Slice lkey;
+	encode_key(ri, sc.attrs[0].type, key, &scratch1, &lkey);
+	// create the encoded value
+	leveldb::Slice lval;
+	encode_value(new_value, version, &scratch2, &lval);
+	// put the actual object
+	updates.Put(lkey, lval);
+	// put the index entries
+	std::vector<const index *> indices;
+	find_indices(ri, &indices);
+	create_index_changes(sc, ri, indices, key, NULL, &new_value, &updates);
+	// ensure we've recorded a version at least as high as this key
+	write_version(ri, version, &updates);
+	// Perform the write
+	leveldb::WriteOptions opts;
+	opts.sync = false;
+	leveldb::Status st = m_db->Write(opts, &updates);
+	if (st.ok())
+	{
+		update_memory_version(ri, version);
+		return SUCCESS;
+	}
+	else
+	{
+		return handle_error(st);
+	}
 }
 
 datalayer::returncode
-datalayer :: overput(const region_id& ri,
-                     const e::slice& key,
-                     const std::vector<e::slice>& old_value,
-                     const std::vector<e::slice>& new_value,
+datalayer :: overput(const region_id &ri,
+                     const e::slice &key,
+                     const std::vector<e::slice> &old_value,
+                     const std::vector<e::slice> &new_value,
                      uint64_t version)
 {
-    leveldb::WriteBatch updates;
-    const schema& sc(*m_daemon->m_config.get_schema(ri));
-    std::vector<char> scratch1;
-    std::vector<char> scratch2;
-
-    // create the encoded key
-    leveldb::Slice lkey;
-    encode_key(ri, sc.attrs[0].type, key, &scratch1, &lkey);
-
-    // create the encoded value
-    leveldb::Slice lval;
-    encode_value(new_value, version, &scratch2, &lval);
-
-    // put the actual object
-    updates.Put(lkey, lval);
-
-    // put the index entries
-    std::vector<const index*> indices;
-    find_indices(ri, &indices);
-    create_index_changes(sc, ri, indices, key, &old_value, &new_value, &updates);
-
-    // ensure we've recorded a version at least as high as this key
-    write_version(ri, version, &updates);
-
-    // Perform the write
-    leveldb::WriteOptions opts;
-    opts.sync = false;
-    leveldb::Status st = m_db->Write(opts, &updates);
-
-    if (st.ok())
-    {
-        update_memory_version(ri, version);
-        return SUCCESS;
-    }
-    else
-    {
-        return handle_error(st);
-    }
+	leveldb::WriteBatch updates;
+	const schema &sc(*m_daemon->m_config.get_schema(ri));
+	std::vector<char> scratch1;
+	std::vector<char> scratch2;
+	// create the encoded key
+	leveldb::Slice lkey;
+	encode_key(ri, sc.attrs[0].type, key, &scratch1, &lkey);
+	// create the encoded value
+	leveldb::Slice lval;
+	encode_value(new_value, version, &scratch2, &lval);
+	// put the actual object
+	updates.Put(lkey, lval);
+	// put the index entries
+	std::vector<const index *> indices;
+	find_indices(ri, &indices);
+	create_index_changes(sc, ri, indices, key, &old_value, &new_value, &updates);
+	// ensure we've recorded a version at least as high as this key
+	write_version(ri, version, &updates);
+	// Perform the write
+	leveldb::WriteOptions opts;
+	opts.sync = false;
+	leveldb::Status st = m_db->Write(opts, &updates);
+	if (st.ok())
+	{
+		update_memory_version(ri, version);
+		return SUCCESS;
+	}
+	else
+	{
+		return handle_error(st);
+	}
 }
 
 datalayer::returncode
-datalayer :: uncertain_del(const region_id& ri,
-                           const e::slice& key)
+datalayer :: uncertain_del(const region_id &ri,
+                           const e::slice &key)
 {
-    const schema& sc(*m_daemon->m_config.get_schema(ri));
-    std::vector<char> scratch;
-
-    // create the encoded key
-    leveldb::Slice lkey;
-    encode_key(ri, sc.attrs[0].type, key, &scratch, &lkey);
-
-    // perform the read
-    std::string ref;
-    leveldb::ReadOptions opts;
-    opts.fill_cache = true;
-    opts.verify_checksums = true;
-    leveldb::Status st = m_db->Get(opts, lkey, &ref);
-
-    if (st.ok())
-    {
-        std::vector<e::slice> old_value;
-        uint64_t old_version;
-        returncode rc = decode_value(e::slice(ref.data(), ref.size()),
-                                     &old_value, &old_version);
-
-        if (rc != SUCCESS)
-        {
-            return rc;
-        }
-
-        if (old_value.size() + 1 != sc.attrs_sz)
-        {
-            return BAD_ENCODING;
-        }
-
-        return del(ri, key, old_value);
-    }
-    else if (st.IsNotFound())
-    {
-        return SUCCESS;
-    }
-    else
-    {
-        return handle_error(st);
-    }
+	const schema &sc(*m_daemon->m_config.get_schema(ri));
+	std::vector<char> scratch;
+	// create the encoded key
+	leveldb::Slice lkey;
+	encode_key(ri, sc.attrs[0].type, key, &scratch, &lkey);
+	// perform the read
+	std::string ref;
+	leveldb::ReadOptions opts;
+	opts.fill_cache = true;
+	opts.verify_checksums = true;
+	leveldb::Status st = m_db->Get(opts, lkey, &ref);
+	if (st.ok())
+	{
+		std::vector<e::slice> old_value;
+		uint64_t old_version;
+		returncode rc = decode_value(e::slice(ref.data(), ref.size()),
+		                             &old_value, &old_version);
+		if (rc != SUCCESS)
+		{
+			return rc;
+		}
+		if (old_value.size() + 1 != sc.attrs_sz)
+		{
+			return BAD_ENCODING;
+		}
+		return del(ri, key, old_value);
+	}
+	else if (st.IsNotFound())
+	{
+		return SUCCESS;
+	}
+	else
+	{
+		return handle_error(st);
+	}
 }
 
 datalayer::returncode
-datalayer :: uncertain_put(const region_id& ri,
-                           const e::slice& key,
-                           const std::vector<e::slice>& new_value,
+datalayer :: uncertain_put(const region_id &ri,
+                           const e::slice &key,
+                           const std::vector<e::slice> &new_value,
                            uint64_t version)
 {
-    const schema& sc(*m_daemon->m_config.get_schema(ri));
-    std::vector<char> scratch;
-
-    // create the encoded key
-    leveldb::Slice lkey;
-    encode_key(ri, sc.attrs[0].type, key, &scratch, &lkey);
-
-    // perform the read
-    std::string ref;
-    leveldb::ReadOptions opts;
-    opts.fill_cache = true;
-    opts.verify_checksums = true;
-    leveldb::Status st = m_db->Get(opts, lkey, &ref);
-
-    if (st.ok())
-    {
-        std::vector<e::slice> old_value;
-        uint64_t old_version;
-        returncode rc = decode_value(e::slice(ref.data(), ref.size()),
-                                     &old_value, &old_version);
-
-        if (rc != SUCCESS)
-        {
-            return rc;
-        }
-
-        if (old_value.size() + 1 != sc.attrs_sz)
-        {
-            return BAD_ENCODING;
-        }
-
-        return overput(ri, key, old_value, new_value, version);
-    }
-    else if (st.IsNotFound())
-    {
-        return put(ri, key, new_value, version);
-    }
-    else
-    {
-        return handle_error(st);
-    }
+	const schema &sc(*m_daemon->m_config.get_schema(ri));
+	std::vector<char> scratch;
+	// create the encoded key
+	leveldb::Slice lkey;
+	encode_key(ri, sc.attrs[0].type, key, &scratch, &lkey);
+	// perform the read
+	std::string ref;
+	leveldb::ReadOptions opts;
+	opts.fill_cache = true;
+	opts.verify_checksums = true;
+	leveldb::Status st = m_db->Get(opts, lkey, &ref);
+	if (st.ok())
+	{
+		std::vector<e::slice> old_value;
+		uint64_t old_version;
+		returncode rc = decode_value(e::slice(ref.data(), ref.size()),
+		                             &old_value, &old_version);
+		if (rc != SUCCESS)
+		{
+			return rc;
+		}
+		if (old_value.size() + 1 != sc.attrs_sz)
+		{
+			return BAD_ENCODING;
+		}
+		return overput(ri, key, old_value, new_value, version);
+	}
+	else if (st.IsNotFound())
+	{
+		return put(ri, key, new_value, version);
+	}
+	else
+	{
+		return handle_error(st);
+	}
 }
 
 datalayer::snapshot
 datalayer :: make_snapshot()
 {
-    return leveldb_snapshot_ptr(m_db, m_db->GetSnapshot());
+	return leveldb_snapshot_ptr(m_db, m_db->GetSnapshot());
 }
 
-datalayer::iterator*
+datalayer::iterator *
 datalayer :: make_search_iterator(snapshot snap,
-                                  const region_id& ri,
-                                  const std::vector<attribute_check>& checks,
-                                  std::ostringstream* ostr)
+                                  const region_id &ri,
+                                  const std::vector<attribute_check> &checks,
+                                  std::ostringstream *ostr)
 {
-    const schema& sc(*m_daemon->m_config.get_schema(ri));
-    std::vector<e::intrusive_ptr<index_iterator> > iterators;
-
-    // pull a set of range queries from checks
-    std::vector<range> ranges;
-    range_searches(sc, checks, &ranges);
-    const index_encoding* key_ie = index_encoding::lookup(sc.attrs[0].type);
-    const index_info* key_ii = index_info::lookup(sc.attrs[0].type);
-
-    // for each range query, construct an iterator
-    for (size_t i = 0; i < ranges.size(); ++i)
-    {
-        if (ranges[i].invalid)
-        {
-            if (ostr) *ostr << "encountered invalid range; returning no results\n";
-            return new dummy_iterator();
-        }
-
-        assert(ranges[i].attr < sc.attrs_sz);
-        assert(ranges[i].type == sc.attrs[ranges[i].attr].type);
-        std::vector<const index*> indices;
-        find_indices(ri, ranges[i].attr, &indices);
-
-        for (size_t j = 0; j < indices.size(); ++j)
-        {
-            assert(indices[j]->attr == ranges[i].attr);
-            const index* idx = indices[j];
-            const index_info* ii = index_info::lookup(ranges[i].type);
-
-            if (!ii)
-            {
-                continue;
-            }
-
-            e::intrusive_ptr<index_iterator> it = ii->iterator_from_range(snap, ri, idx->id, ranges[i], key_ie);
-
-            if (it)
-            {
-                iterators.push_back(it);
-
-                if (ostr) *ostr << " considering attr " << ranges[i].attr << " Range("
-                                << ranges[i].start.hex() << ", " << ranges[i].end.hex() << ") " << ranges[i].type << " "
-                                << (ranges[i].has_start ? "[" : "<") << "-" << (ranges[i].has_end ? "]" : ">")
-                                << " " << (ranges[i].invalid ? "invalid" : "valid") << "\n";
-            }
-        }
-    }
-
-    // For each index
-    for (size_t i = 0; i < checks.size(); ++i)
-    {
-        std::vector<const index*> indices;
-        find_indices(ri, checks[i].attr, &indices);
-
-        for (size_t j = 0; j < indices.size(); ++j)
-        {
-            const index* idx = indices[j];
-            const index_info* ii = index_info::lookup(sc.attrs[checks[i].attr].type);
-
-            if (!ii)
-            {
-                continue;
-            }
-
-            e::intrusive_ptr<index_iterator> it = ii->iterator_from_check(snap, ri, idx->id, checks[i], key_ie);
-
-            if (it)
-            {
-                iterators.push_back(it);
-            }
-        }
-    }
-
-    // figure out the cost of accessing all objects
-    e::intrusive_ptr<index_iterator> full_scan;
-    full_scan = key_ii->iterator_for_keys(snap, ri);
-    if (ostr) *ostr << " accessing all objects has cost " << full_scan->cost(m_db.get()) << "\n";
-
-    // figure out the cost of each iterator
-    // we do this here and not below so that iterators can cache the size and we
-    // don't ping-pong between HyperDex and LevelDB.
-    for (size_t i = 0; i < iterators.size(); ++i)
-    {
-        uint64_t iterator_cost = iterators[i]->cost(m_db.get());
-        if (ostr) *ostr << " iterator " << *iterators[i] << " has cost " << iterator_cost << "\n";
-    }
-
-    std::vector<e::intrusive_ptr<index_iterator> > sorted;
-    std::vector<e::intrusive_ptr<index_iterator> > unsorted;
-
-    for (size_t i = 0; i < iterators.size(); ++i)
-    {
-        if (iterators[i]->sorted())
-        {
-            sorted.push_back(iterators[i]);
-        }
-        else
-        {
-            unsorted.push_back(iterators[i]);
-        }
-    }
-
-    e::intrusive_ptr<index_iterator> best;
-
-    if (!best && !sorted.empty())
-    {
-        best = new intersect_iterator(snap, sorted);
-    }
-    else if (!best && !unsorted.empty())
-    {
-        best = unsorted[0];
-    }
-    else
-    {
-        best = full_scan;
-    }
-
-    assert(best);
-    uint64_t cost = best->cost(m_db.get());
-
-    if (cost > 0 && cost * 4 > full_scan->cost(m_db.get()))
-    {
-        best = full_scan;
-    }
-
-    if (ostr) *ostr << " choosing to use " << *best << "\n";
-    return new search_iterator(this, ri, best, ostr, &checks);
+	const schema &sc(*m_daemon->m_config.get_schema(ri));
+	std::vector<e::intrusive_ptr<index_iterator> > iterators;
+	// pull a set of range queries from checks
+	std::vector<range> ranges;
+	range_searches(sc, checks, &ranges);
+	const index_encoding *key_ie = index_encoding::lookup(sc.attrs[0].type);
+	const index_info *key_ii = index_info::lookup(sc.attrs[0].type);
+	// for each range query, construct an iterator
+	for (size_t i = 0; i < ranges.size(); ++i)
+	{
+		if (ranges[i].invalid)
+		{
+			if (ostr) *ostr << "encountered invalid range; returning no results\n";
+			return new dummy_iterator();
+		}
+		assert(ranges[i].attr < sc.attrs_sz);
+		assert(ranges[i].type == sc.attrs[ranges[i].attr].type);
+		std::vector<const index *> indices;
+		find_indices(ri, ranges[i].attr, &indices);
+		for (size_t j = 0; j < indices.size(); ++j)
+		{
+			assert(indices[j]->attr == ranges[i].attr);
+			const index *idx = indices[j];
+			const index_info *ii = index_info::lookup(ranges[i].type);
+			if (!ii)
+			{
+				continue;
+			}
+			e::intrusive_ptr<index_iterator> it = ii->iterator_from_range(snap, ri, idx->id, ranges[i], key_ie);
+			if (it)
+			{
+				iterators.push_back(it);
+				if (ostr) *ostr << " considering attr " << ranges[i].attr << " Range("
+					                << ranges[i].start.hex() << ", " << ranges[i].end.hex() << ") " << ranges[i].type << " "
+					                << (ranges[i].has_start ? "[" : "<") << "-" << (ranges[i].has_end ? "]" : ">")
+					                << " " << (ranges[i].invalid ? "invalid" : "valid") << "\n";
+			}
+		}
+	}
+	// For each index
+	for (size_t i = 0; i < checks.size(); ++i)
+	{
+		std::vector<const index *> indices;
+		find_indices(ri, checks[i].attr, &indices);
+		for (size_t j = 0; j < indices.size(); ++j)
+		{
+			const index *idx = indices[j];
+			const index_info *ii = index_info::lookup(sc.attrs[checks[i].attr].type);
+			if (!ii)
+			{
+				continue;
+			}
+			e::intrusive_ptr<index_iterator> it = ii->iterator_from_check(snap, ri, idx->id, checks[i], key_ie);
+			if (it)
+			{
+				iterators.push_back(it);
+			}
+		}
+	}
+	// figure out the cost of accessing all objects
+	e::intrusive_ptr<index_iterator> full_scan;
+	full_scan = key_ii->iterator_for_keys(snap, ri);
+	if (ostr) *ostr << " accessing all objects has cost " << full_scan->cost(m_db.get()) << "\n";
+	// figure out the cost of each iterator
+	// we do this here and not below so that iterators can cache the size and we
+	// don't ping-pong between HyperDex and LevelDB.
+	for (size_t i = 0; i < iterators.size(); ++i)
+	{
+		uint64_t iterator_cost = iterators[i]->cost(m_db.get());
+		if (ostr) *ostr << " iterator " << *iterators[i] << " has cost " << iterator_cost << "\n";
+	}
+	std::vector<e::intrusive_ptr<index_iterator> > sorted;
+	std::vector<e::intrusive_ptr<index_iterator> > unsorted;
+	for (size_t i = 0; i < iterators.size(); ++i)
+	{
+		if (iterators[i]->sorted())
+		{
+			sorted.push_back(iterators[i]);
+		}
+		else
+		{
+			unsorted.push_back(iterators[i]);
+		}
+	}
+	e::intrusive_ptr<index_iterator> best;
+	if (!best && !sorted.empty())
+	{
+		best = new intersect_iterator(snap, sorted);
+	}
+	else if (!best && !unsorted.empty())
+	{
+		best = unsorted[0];
+	}
+	else
+	{
+		best = full_scan;
+	}
+	assert(best);
+	uint64_t cost = best->cost(m_db.get());
+	if (cost > 0 && cost * 4 > full_scan->cost(m_db.get()))
+	{
+		best = full_scan;
+	}
+	if (ostr) *ostr << " choosing to use " << *best << "\n";
+	return new search_iterator(this, ri, best, ostr, &checks);
 }
 
 bool
-datalayer :: backup(const e::slice& _name)
+datalayer :: backup(const e::slice &_name)
 {
-    leveldb::Slice name(reinterpret_cast<const char*>(_name.data()), _name.size());
-    leveldb::Status st = m_db->LiveBackup(name);
-
-    if (st.ok())
-    {
-        return true;
-    }
-    else if (st.IsCorruption())
-    {
-        LOG(ERROR) << "corruption while taking a backup: " << st.ToString();
-        return false;
-    }
-    else if (st.IsIOError())
-    {
-        LOG(ERROR) << "IO error while taking a backup: " << st.ToString();
-        return false;
-    }
-    else
-    {
-        LOG(ERROR) << "LevelDB returned an unknown error that we don't know how to handle: " << st.ToString();
-        return false;
-    }
+	leveldb::Slice name(reinterpret_cast<const char *>(_name.data()), _name.size());
+	leveldb::Status st = m_db->LiveBackup(name);
+	if (st.ok())
+	{
+		return true;
+	}
+	else if (st.IsCorruption())
+	{
+		LOG(ERROR) << "corruption while taking a backup: " << st.ToString();
+		return false;
+	}
+	else if (st.IsIOError())
+	{
+		LOG(ERROR) << "IO error while taking a backup: " << st.ToString();
+		return false;
+	}
+	else
+	{
+		LOG(ERROR) << "LevelDB returned an unknown error that we don't know how to handle: " << st.ToString();
+		return false;
+	}
 }
 
 datalayer::returncode
-datalayer :: get_from_iterator(const region_id& ri,
-                               const schema& sc,
-                               iterator* iter,
-                               e::slice* key,
-                               std::vector<e::slice>* value,
-                               uint64_t* version,
-                               reference* ref)
+datalayer :: get_from_iterator(const region_id &ri,
+                               const schema &sc,
+                               iterator *iter,
+                               e::slice *key,
+                               std::vector<e::slice> *value,
+                               uint64_t *version,
+                               reference *ref)
 {
-    std::vector<char> scratch;
-
-    // create the encoded key
-    leveldb::Slice lkey;
-    encode_key(ri, sc.attrs[0].type, iter->key(), &scratch, &lkey);
-
-    // perform the read
-    leveldb::ReadOptions opts;
-    opts.fill_cache = true;
-    opts.verify_checksums = true;
-    opts.snapshot = iter->snap().get();
-    leveldb::Status st = m_db->Get(opts, lkey, &ref->m_backing);
-
-    if (st.ok())
-    {
-        ref->m_backing += std::string(reinterpret_cast<const char*>(iter->key().data()), iter->key().size());
-        *key = e::slice(ref->m_backing.data()
-                        + ref->m_backing.size()
-                        - iter->key().size(),
-                        iter->key().size());
-        e::slice v(ref->m_backing.data(), ref->m_backing.size() - iter->key().size());
-        return decode_value(v, value, version);
-    }
-    else if (st.IsNotFound())
-    {
-        return NOT_FOUND;
-    }
-    else
-    {
-        return handle_error(st);
-    }
+	std::vector<char> scratch;
+	// create the encoded key
+	leveldb::Slice lkey;
+	encode_key(ri, sc.attrs[0].type, iter->key(), &scratch, &lkey);
+	// perform the read
+	leveldb::ReadOptions opts;
+	opts.fill_cache = true;
+	opts.verify_checksums = true;
+	opts.snapshot = iter->snap().get();
+	leveldb::Status st = m_db->Get(opts, lkey, &ref->m_backing);
+	if (st.ok())
+	{
+		ref->m_backing += std::string(reinterpret_cast<const char *>(iter->key().data()), iter->key().size());
+		*key = e::slice(ref->m_backing.data()
+		                + ref->m_backing.size()
+		                - iter->key().size(),
+		                iter->key().size());
+		e::slice v(ref->m_backing.data(), ref->m_backing.size() - iter->key().size());
+		return decode_value(v, value, version);
+	}
+	else if (st.IsNotFound())
+	{
+		return NOT_FOUND;
+	}
+	else
+	{
+		return handle_error(st);
+	}
 }
 
 namespace
@@ -898,524 +810,462 @@ namespace
 uint64_t
 roundup_version(uint64_t v)
 {
-    const static uint64_t REGION_PERIODIC = hyperdex::datalayer::REGION_PERIODIC;
-    v += REGION_PERIODIC;
-    v  = v & ~(REGION_PERIODIC - 1);
-    return v;
+	const static uint64_t REGION_PERIODIC = hyperdex::datalayer::REGION_PERIODIC;
+	v += REGION_PERIODIC;
+	v  = v & ~(REGION_PERIODIC - 1);
+	return v;
 }
 
 }
 
 bool
-datalayer :: write_version(const region_id& ri,
+datalayer :: write_version(const region_id &ri,
                            uint64_t version,
-                           leveldb::WriteBatch* updates)
+                           leveldb::WriteBatch *updates)
 {
-    version = roundup_version(version);
-    uint64_t* current = NULL;
-
-    if (!m_versions.mod(ri, &current) ||
-        e::atomic::load_64_nobarrier(current) >= version)
-    {
-        return false;
-    }
-
-    char vbacking[VERSION_BUF_SIZE];
-    encode_version(ri, version, vbacking);
-    updates->Put(leveldb::Slice(vbacking, VERSION_BUF_SIZE), leveldb::Slice());
-    return true;
+	version = roundup_version(version);
+	uint64_t *current = NULL;
+	if (!m_versions.mod(ri, &current) ||
+	    e::atomic::load_64_nobarrier(current) >= version)
+	{
+		return false;
+	}
+	char vbacking[VERSION_BUF_SIZE];
+	encode_version(ri, version, vbacking);
+	updates->Put(leveldb::Slice(vbacking, VERSION_BUF_SIZE), leveldb::Slice());
+	return true;
 }
 
 void
-datalayer :: update_memory_version(const region_id& ri, uint64_t version)
+datalayer :: update_memory_version(const region_id &ri, uint64_t version)
 {
-    version = roundup_version(version);
-    uint64_t* current = NULL;
-    m_versions.mod(ri, &current);
-
-    if (current == NULL)
-    {
-        return;
-    }
-
-    uint64_t expected = e::atomic::load_64_nobarrier(current);
-    uint64_t witness  = 0;
-
-    while ((witness = e::atomic::compare_and_swap_64_nobarrier(current, expected, version)) < version)
-    {
-        expected = witness;
-    }
+	version = roundup_version(version);
+	uint64_t *current = NULL;
+	m_versions.mod(ri, &current);
+	if (current == NULL)
+	{
+		return;
+	}
+	uint64_t expected = e::atomic::load_64_nobarrier(current);
+	uint64_t witness  = 0;
+	while ((witness = e::atomic::compare_and_swap_64_nobarrier(current, expected, version)) < version)
+	{
+		expected = witness;
+	}
 }
 
 void
-datalayer :: bump_version(const region_id& ri, uint64_t version)
+datalayer :: bump_version(const region_id &ri, uint64_t version)
 {
-    leveldb::WriteBatch updates;
-
-    if (!write_version(ri, version, &updates))
-    {
-        return;
-    }
-
-    // Perform the write
-    leveldb::WriteOptions opts;
-    opts.sync = false;
-    leveldb::Status st = m_db->Write(opts, &updates);
-
-    if (!st.ok())
-    {
-        handle_error(st);
-    }
-
-    update_memory_version(ri, version);
+	leveldb::WriteBatch updates;
+	if (!write_version(ri, version, &updates))
+	{
+		return;
+	}
+	// Perform the write
+	leveldb::WriteOptions opts;
+	opts.sync = false;
+	leveldb::Status st = m_db->Write(opts, &updates);
+	if (!st.ok())
+	{
+		handle_error(st);
+	}
+	update_memory_version(ri, version);
 }
 
 uint64_t
-datalayer :: max_version(const region_id& ri)
+datalayer :: max_version(const region_id &ri)
 {
-    uint64_t val;
-
-    if (!m_versions.get(ri, &val))
-    {
-        val = disk_version(ri);
-    }
-
-    return val;
+	uint64_t val;
+	if (!m_versions.get(ri, &val))
+	{
+		val = disk_version(ri);
+	}
+	return val;
 }
 
 uint64_t
-datalayer :: disk_version(const region_id& ri)
+datalayer :: disk_version(const region_id &ri)
 {
-    leveldb::ReadOptions opts;
-    opts.fill_cache = false;
-    opts.verify_checksums = true;
-    opts.snapshot = NULL;
-    std::auto_ptr<leveldb::Iterator> it(m_db->NewIterator(opts));
-    char vbacking[VERSION_BUF_SIZE];
-    encode_version(ri, UINT64_MAX, vbacking);
-    leveldb::Slice key(vbacking, VERSION_BUF_SIZE);
-    it->Seek(key);
-
-    if (!it->Valid())
-    {
-        // XXX err
-        return 0;
-    }
-
-    key = it->key();
-    region_id tmp_ri;
-    uint64_t tmp_version;
-    datalayer::returncode rc = decode_version(e::slice(key.data(), key.size()),
-                                              &tmp_ri, &tmp_version);
-
-    if (rc != SUCCESS)
-    {
-        // XXX err
-        return 0;
-    }
-
-    if (tmp_ri != ri)
-    {
-        return 0;
-    }
-
-    return tmp_version;
+	leveldb::ReadOptions opts;
+	opts.fill_cache = false;
+	opts.verify_checksums = true;
+	opts.snapshot = NULL;
+	std::auto_ptr<leveldb::Iterator> it(m_db->NewIterator(opts));
+	char vbacking[VERSION_BUF_SIZE];
+	encode_version(ri, UINT64_MAX, vbacking);
+	leveldb::Slice key(vbacking, VERSION_BUF_SIZE);
+	it->Seek(key);
+	if (!it->Valid())
+	{
+		// XXX err
+		return 0;
+	}
+	key = it->key();
+	region_id tmp_ri;
+	uint64_t tmp_version;
+	datalayer::returncode rc = decode_version(e::slice(key.data(), key.size()),
+	                                          &tmp_ri, &tmp_version);
+	if (rc != SUCCESS)
+	{
+		// XXX err
+		return 0;
+	}
+	if (tmp_ri != ri)
+	{
+		return 0;
+	}
+	return tmp_version;
 }
 
 datalayer::returncode
-datalayer :: create_checkpoint(const region_timestamp& rt)
+datalayer :: create_checkpoint(const region_timestamp &rt)
 {
-    m_wiper->inhibit_wiping();
-    e::guard g = e::makeobjguard(*m_wiper, &wiper_thread::permit_wiping);
-    g.use_variable();
-
-    if (m_wiper->region_will_be_wiped(rt.rid))
-    {
-        return SUCCESS;
-    }
-
-    char cbacking[CHECKPOINT_BUF_SIZE];
-    encode_checkpoint(rt.rid, rt.checkpoint, cbacking);
-    leveldb::WriteOptions opts;
-    opts.sync = false;
-    leveldb::Slice ckey(cbacking, CHECKPOINT_BUF_SIZE);
-    leveldb::Slice val(rt.local_timestamp);
-    leveldb::Status st = m_db->Put(opts, ckey, val);
-
-    if (!st.ok())
-    {
-        return handle_error(st);
-    }
-
-    return SUCCESS;
+	m_wiper->inhibit_wiping();
+	e::guard g = e::makeobjguard(*m_wiper, &wiper_thread::permit_wiping);
+	g.use_variable();
+	if (m_wiper->region_will_be_wiped(rt.rid))
+	{
+		return SUCCESS;
+	}
+	char cbacking[CHECKPOINT_BUF_SIZE];
+	encode_checkpoint(rt.rid, rt.checkpoint, cbacking);
+	leveldb::WriteOptions opts;
+	opts.sync = false;
+	leveldb::Slice ckey(cbacking, CHECKPOINT_BUF_SIZE);
+	leveldb::Slice val(rt.local_timestamp);
+	leveldb::Status st = m_db->Put(opts, ckey, val);
+	if (!st.ok())
+	{
+		return handle_error(st);
+	}
+	return SUCCESS;
 }
 
 void
 datalayer :: set_checkpoint_gc(uint64_t checkpoint_gc)
 {
-    m_checkpointer->set_checkpoint_gc(checkpoint_gc);
+	m_checkpointer->set_checkpoint_gc(checkpoint_gc);
 }
 
 void
-datalayer :: largest_checkpoint_for(const region_id& ri, uint64_t* checkpoint)
+datalayer :: largest_checkpoint_for(const region_id &ri, uint64_t *checkpoint)
 {
-    m_wiper->inhibit_wiping();
-    e::guard g = e::makeobjguard(*m_wiper, &wiper_thread::permit_wiping);
-    g.use_variable();
-
-    if (m_wiper->region_will_be_wiped(ri))
-    {
-        *checkpoint = 0;
-        return;
-    }
-
-    leveldb::ReadOptions opts;
-    opts.verify_checksums = true;
-    std::auto_ptr<leveldb::Iterator> it;
-    it.reset(m_db->NewIterator(opts));
-    char cbacking[CHECKPOINT_BUF_SIZE];
-    encode_checkpoint(ri, 0, cbacking);
-    it->Seek(leveldb::Slice(cbacking, CHECKPOINT_BUF_SIZE));
-    *checkpoint = 0;
-
-    while (it->Valid())
-    {
-        region_timestamp rt;
-        e::slice key(it->key().data(), it->key().size());
-        returncode rc = decode_checkpoint(key, &rt.rid, &rt.checkpoint);
-
-        if (rc != datalayer::SUCCESS)
-        {
-            break;
-        }
-
-        if (rt.rid != ri)
-        {
-            break;
-        }
-
-        *checkpoint = std::max(*checkpoint, rt.checkpoint);
-        it->Next();
-    }
+	m_wiper->inhibit_wiping();
+	e::guard g = e::makeobjguard(*m_wiper, &wiper_thread::permit_wiping);
+	g.use_variable();
+	if (m_wiper->region_will_be_wiped(ri))
+	{
+		*checkpoint = 0;
+		return;
+	}
+	leveldb::ReadOptions opts;
+	opts.verify_checksums = true;
+	std::auto_ptr<leveldb::Iterator> it;
+	it.reset(m_db->NewIterator(opts));
+	char cbacking[CHECKPOINT_BUF_SIZE];
+	encode_checkpoint(ri, 0, cbacking);
+	it->Seek(leveldb::Slice(cbacking, CHECKPOINT_BUF_SIZE));
+	*checkpoint = 0;
+	while (it->Valid())
+	{
+		region_timestamp rt;
+		e::slice key(it->key().data(), it->key().size());
+		returncode rc = decode_checkpoint(key, &rt.rid, &rt.checkpoint);
+		if (rc != datalayer::SUCCESS)
+		{
+			break;
+		}
+		if (rt.rid != ri)
+		{
+			break;
+		}
+		*checkpoint = std::max(*checkpoint, rt.checkpoint);
+		it->Next();
+	}
 }
 
 bool
 datalayer :: region_will_be_wiped(region_id rid)
 {
-    return m_wiper->region_will_be_wiped(rid);
+	return m_wiper->region_will_be_wiped(rid);
 }
 
 void
-datalayer :: request_wipe(const transfer_id& xid,
-                          const region_id& ri)
+datalayer :: request_wipe(const transfer_id &xid,
+                          const region_id &ri)
 {
-    m_wiper->request_wipe(xid, ri);
+	m_wiper->request_wipe(xid, ri);
 }
 
 void
 datalayer :: inhibit_wiping()
 {
-    m_wiper->inhibit_wiping();
+	m_wiper->inhibit_wiping();
 }
 
 void
 datalayer :: permit_wiping()
 {
-    m_wiper->permit_wiping();
+	m_wiper->permit_wiping();
 }
 
-datalayer::replay_iterator*
-datalayer :: replay_region_from_checkpoint(const region_id& ri,
+datalayer::replay_iterator *
+datalayer :: replay_region_from_checkpoint(const region_id &ri,
                                            uint64_t checkpoint,
-                                           bool* wipe)
+                                           bool *wipe)
 {
-    m_wiper->inhibit_wiping();
-    e::guard g1 = e::makeobjguard(*m_wiper, &wiper_thread::permit_wiping);
-    g1.use_variable();
-    m_checkpointer->inhibit_gc();
-    e::guard g2 = e::makeobjguard(*m_checkpointer, &checkpointer_thread::permit_gc);
-    g2.use_variable();
-
-    leveldb::ReadOptions opts;
-    opts.verify_checksums = true;
-    std::auto_ptr<leveldb::Iterator> it;
-    it.reset(m_db->NewIterator(opts));
-    char cbacking[CHECKPOINT_BUF_SIZE];
-    encode_checkpoint(ri, 0, cbacking);
-    it->Seek(leveldb::Slice(cbacking, CHECKPOINT_BUF_SIZE));
-    std::string local_timestamp("all");
-
-    while (it->Valid())
-    {
-        region_timestamp rt;
-        e::slice key(it->key().data(), it->key().size());
-        returncode rc = decode_checkpoint(key, &rt.rid, &rt.checkpoint);
-
-        if (rc != datalayer::SUCCESS)
-        {
-            break;
-        }
-
-        if (rt.rid != ri || rt.checkpoint > checkpoint)
-        {
-            break;
-        }
-
-        local_timestamp.assign(it->value().data(), it->value().size());
-        it->Next();
-    }
-
-    assert(!m_wiper->region_will_be_wiped(ri));
-    *wipe = local_timestamp == "all";
-    leveldb::ReplayIterator* iter;
-    leveldb::Status st = m_db->GetReplayIterator(local_timestamp, &iter);
-
-    if (!st.ok())
-    {
-        LOG(ERROR) << "LevelDB corruption: invalid timestamp";
-        abort();
-    }
-
-    leveldb_replay_iterator_ptr ptr(m_db, iter);
-    const schema& sc(*m_daemon->m_config.get_schema(ri));
-    return new replay_iterator(ri, ptr, index_encoding::lookup(sc.attrs[0].type));
+	m_wiper->inhibit_wiping();
+	e::guard g1 = e::makeobjguard(*m_wiper, &wiper_thread::permit_wiping);
+	g1.use_variable();
+	m_checkpointer->inhibit_gc();
+	e::guard g2 = e::makeobjguard(*m_checkpointer, &checkpointer_thread::permit_gc);
+	g2.use_variable();
+	leveldb::ReadOptions opts;
+	opts.verify_checksums = true;
+	std::auto_ptr<leveldb::Iterator> it;
+	it.reset(m_db->NewIterator(opts));
+	char cbacking[CHECKPOINT_BUF_SIZE];
+	encode_checkpoint(ri, 0, cbacking);
+	it->Seek(leveldb::Slice(cbacking, CHECKPOINT_BUF_SIZE));
+	std::string local_timestamp("all");
+	while (it->Valid())
+	{
+		region_timestamp rt;
+		e::slice key(it->key().data(), it->key().size());
+		returncode rc = decode_checkpoint(key, &rt.rid, &rt.checkpoint);
+		if (rc != datalayer::SUCCESS)
+		{
+			break;
+		}
+		if (rt.rid != ri || rt.checkpoint > checkpoint)
+		{
+			break;
+		}
+		local_timestamp.assign(it->value().data(), it->value().size());
+		it->Next();
+	}
+	assert(!m_wiper->region_will_be_wiped(ri));
+	*wipe = local_timestamp == "all";
+	leveldb::ReplayIterator *iter;
+	leveldb::Status st = m_db->GetReplayIterator(local_timestamp, &iter);
+	if (!st.ok())
+	{
+		LOG(ERROR) << "LevelDB corruption: invalid timestamp";
+		abort();
+	}
+	leveldb_replay_iterator_ptr ptr(m_db, iter);
+	const schema &sc(*m_daemon->m_config.get_schema(ri));
+	return new replay_iterator(ri, ptr, index_encoding::lookup(sc.attrs[0].type));
 }
 
 void
-datalayer :: create_index_marker(const region_id& ri, const index_id& ii)
+datalayer :: create_index_marker(const region_id &ri, const index_id &ii)
 {
-    char buf[sizeof(uint8_t) + 2 * VARINT_64_MAX_SIZE];
-    char* ptr = buf;
-    ptr = e::pack8be('I', ptr);
-    ptr = e::packvarint64(ri.get(), ptr);
-    ptr = e::packvarint64(ii.get(), ptr);
-    leveldb::Slice key(buf, ptr - buf);
-    leveldb::Slice val;
-    leveldb::Status st = m_db->Put(leveldb::WriteOptions(), key, val);
-
-    if (!st.ok())
-    {
-        LOG(ERROR) << "LevelDB corruption: could not put";
-        abort();
-    }
+	char buf[sizeof(uint8_t) + 2 * VARINT_64_MAX_SIZE];
+	char *ptr = buf;
+	ptr = e::pack8be('I', ptr);
+	ptr = e::packvarint64(ri.get(), ptr);
+	ptr = e::packvarint64(ii.get(), ptr);
+	leveldb::Slice key(buf, ptr - buf);
+	leveldb::Slice val;
+	leveldb::Status st = m_db->Put(leveldb::WriteOptions(), key, val);
+	if (!st.ok())
+	{
+		LOG(ERROR) << "LevelDB corruption: could not put";
+		abort();
+	}
 }
 
 bool
-datalayer :: has_index_marker(const region_id& ri, const index_id& ii)
+datalayer :: has_index_marker(const region_id &ri, const index_id &ii)
 {
-    char buf[sizeof(uint8_t) + 2 * VARINT_64_MAX_SIZE];
-    char* ptr = buf;
-    ptr = e::pack8be('I', ptr);
-    ptr = e::packvarint64(ri.get(), ptr);
-    ptr = e::packvarint64(ii.get(), ptr);
-    leveldb::Slice key(buf, ptr - buf);
-    std::string val;
-    leveldb::Status st = m_db->Get(leveldb::ReadOptions(), key, &val);
-
-    if (!st.ok() && !st.IsNotFound())
-    {
-        LOG(ERROR) << "LevelDB corruption: could not get";
-        abort();
-    }
-
-    return st.ok();
+	char buf[sizeof(uint8_t) + 2 * VARINT_64_MAX_SIZE];
+	char *ptr = buf;
+	ptr = e::pack8be('I', ptr);
+	ptr = e::packvarint64(ri.get(), ptr);
+	ptr = e::packvarint64(ii.get(), ptr);
+	leveldb::Slice key(buf, ptr - buf);
+	std::string val;
+	leveldb::Status st = m_db->Get(leveldb::ReadOptions(), key, &val);
+	if (!st.ok() && !st.IsNotFound())
+	{
+		LOG(ERROR) << "LevelDB corruption: could not get";
+		abort();
+	}
+	return st.ok();
 }
 
 bool
 datalayer :: only_key_is_hyperdex_key()
 {
-    leveldb::ReadOptions opts;
-    opts.fill_cache = false;
-    opts.verify_checksums = true;
-    opts.snapshot = NULL;
-    std::auto_ptr<leveldb::Iterator> it(m_db->NewIterator(opts));
-    it->SeekToFirst();
-    bool seen = false;
-
-    while (it->Valid())
-    {
-        if (it->key().compare(leveldb::Slice("hyperdex", 8)) != 0)
-        {
-            return false;
-        }
-
-        it->Next();
-        seen = true;
-    }
-
-    return seen;
+	leveldb::ReadOptions opts;
+	opts.fill_cache = false;
+	opts.verify_checksums = true;
+	opts.snapshot = NULL;
+	std::auto_ptr<leveldb::Iterator> it(m_db->NewIterator(opts));
+	it->SeekToFirst();
+	bool seen = false;
+	while (it->Valid())
+	{
+		if (it->key().compare(leveldb::Slice("hyperdex", 8)) != 0)
+		{
+			return false;
+		}
+		it->Next();
+		seen = true;
+	}
+	return seen;
 }
 
 bool
 datalayer :: upgrade_13x_to_14()
 {
-    leveldb::WriteOptions wopts;
-    wopts.sync = true;
-
-    // first scan every key that starts with "a", making a map from region id to max seqid.
-    std::map<region_id, uint64_t> seq_ids;
-    leveldb::ReadOptions ropts;
-    ropts.fill_cache = false;
-    ropts.verify_checksums = true;
-    ropts.snapshot = NULL;
-    std::auto_ptr<leveldb::Iterator> it(m_db->NewIterator(ropts));
-    it->Seek(leveldb::Slice("a", 1));
-
-    while (it->Valid())
-    {
-        if (it->key().size() != sizeof(uint64_t) * 3 + 1 ||
-            it->key().data()[0] != 'a')
-        {
-            break;
-        }
-
-        const char* ptr = it->key().data();
-        uint64_t reg_id;
-        uint64_t seq_id;
-        uint64_t ri;
-        e::unpack64be(ptr + 1, &reg_id);
-        e::unpack64be(ptr + 9, &seq_id);
-        e::unpack64be(ptr + 17, &ri);
-
-        if (reg_id == ri)
-        {
-            seq_id = std::max(seq_ids[region_id(ri)], UINT64_MAX - seq_id);
-            seq_ids[region_id(ri)] = seq_id;
-        }
-
-        it->Next();
-    }
-
-    if (!it->status().ok())
-    {
-        LOG(ERROR) << "could not upgrade to 1.4: " << it->status().ToString();
-        return false;
-    }
-
-    // now write out versions for the regions that we saw
-    for (std::map<region_id, uint64_t>::iterator s = seq_ids.begin();
-            s != seq_ids.end(); ++s)
-    {
-        char vbacking[VERSION_BUF_SIZE];
-        uint64_t v = std::max(s->second, disk_version(s->first));
-        encode_version(s->first, roundup_version(v), vbacking);
-        leveldb::Status st = m_db->Put(wopts, leveldb::Slice(vbacking, VERSION_BUF_SIZE), leveldb::Slice());
-
-        if (!st.ok())
-        {
-            LOG(ERROR) << "could not upgrade to 1.4: " << st.ToString();
-            return false;
-        }
-    }
-
-    // only after those are on disk should we delete the original keys
-    it->Seek(leveldb::Slice("a", 1));
-
-    while (it->Valid())
-    {
-        if (it->key().size() == sizeof(uint64_t) * 3 + 1 ||
-            it->key().data()[0] != 'a')
-        {
-            break;
-        }
-
-        leveldb::Status st = m_db->Delete(wopts, it->key());
-
-        if (!st.ok())
-        {
-            LOG(ERROR) << "could not upgrade to 1.4: " << it->status().ToString();
-            return false;
-        }
-
-        it->Next();
-    }
-
-    if (!it->status().ok())
-    {
-        LOG(ERROR) << "could not upgrade to 1.4: " << it->status().ToString();
-        return false;
-    }
-
-    // finally mark the new version
-    leveldb::Slice k("hyperdex", 8);
-    leveldb::Slice v(PACKAGE_VERSION, STRLENOF(PACKAGE_VERSION));
-    leveldb::Status st = m_db->Put(wopts, k, v);
-
-    if (!st.ok())
-    {
-        LOG(ERROR) << "could not upgrade to 1.4: " << st.ToString();
-        return false;
-    }
-
-    return true;
+	leveldb::WriteOptions wopts;
+	wopts.sync = true;
+	// first scan every key that starts with "a", making a map from region id to max seqid.
+	std::map<region_id, uint64_t> seq_ids;
+	leveldb::ReadOptions ropts;
+	ropts.fill_cache = false;
+	ropts.verify_checksums = true;
+	ropts.snapshot = NULL;
+	std::auto_ptr<leveldb::Iterator> it(m_db->NewIterator(ropts));
+	it->Seek(leveldb::Slice("a", 1));
+	while (it->Valid())
+	{
+		if (it->key().size() != sizeof(uint64_t) * 3 + 1 ||
+		    it->key().data()[0] != 'a')
+		{
+			break;
+		}
+		const char *ptr = it->key().data();
+		uint64_t reg_id;
+		uint64_t seq_id;
+		uint64_t ri;
+		e::unpack64be(ptr + 1, &reg_id);
+		e::unpack64be(ptr + 9, &seq_id);
+		e::unpack64be(ptr + 17, &ri);
+		if (reg_id == ri)
+		{
+			seq_id = std::max(seq_ids[region_id(ri)], UINT64_MAX - seq_id);
+			seq_ids[region_id(ri)] = seq_id;
+		}
+		it->Next();
+	}
+	if (!it->status().ok())
+	{
+		LOG(ERROR) << "could not upgrade to 1.4: " << it->status().ToString();
+		return false;
+	}
+	// now write out versions for the regions that we saw
+	for (std::map<region_id, uint64_t>::iterator s = seq_ids.begin();
+	     s != seq_ids.end(); ++s)
+	{
+		char vbacking[VERSION_BUF_SIZE];
+		uint64_t v = std::max(s->second, disk_version(s->first));
+		encode_version(s->first, roundup_version(v), vbacking);
+		leveldb::Status st = m_db->Put(wopts, leveldb::Slice(vbacking, VERSION_BUF_SIZE), leveldb::Slice());
+		if (!st.ok())
+		{
+			LOG(ERROR) << "could not upgrade to 1.4: " << st.ToString();
+			return false;
+		}
+	}
+	// only after those are on disk should we delete the original keys
+	it->Seek(leveldb::Slice("a", 1));
+	while (it->Valid())
+	{
+		if (it->key().size() == sizeof(uint64_t) * 3 + 1 ||
+		    it->key().data()[0] != 'a')
+		{
+			break;
+		}
+		leveldb::Status st = m_db->Delete(wopts, it->key());
+		if (!st.ok())
+		{
+			LOG(ERROR) << "could not upgrade to 1.4: " << it->status().ToString();
+			return false;
+		}
+		it->Next();
+	}
+	if (!it->status().ok())
+	{
+		LOG(ERROR) << "could not upgrade to 1.4: " << it->status().ToString();
+		return false;
+	}
+	// finally mark the new version
+	leveldb::Slice k("hyperdex", 8);
+	leveldb::Slice v(PACKAGE_VERSION, STRLENOF(PACKAGE_VERSION));
+	leveldb::Status st = m_db->Put(wopts, k, v);
+	if (!st.ok())
+	{
+		LOG(ERROR) << "could not upgrade to 1.4: " << st.ToString();
+		return false;
+	}
+	return true;
 }
 
 void
-datalayer :: find_indices(const region_id& rid, std::vector<const index*>* indices)
+datalayer :: find_indices(const region_id &rid, std::vector<const index *> *indices)
 {
-    std::vector<index_state>::iterator it;
-    it = std::lower_bound(m_indices.begin(), m_indices.end(), rid);
-
-    for (; it < m_indices.end() && it->ri == rid; ++it)
-    {
-        if (!it->is_usable())
-        {
-            continue;
-        }
-
-        const index* idx = m_daemon->m_config.get_index(it->ii);
-        assert(idx);
-        indices->push_back(idx);
-    }
+	std::vector<index_state>::iterator it;
+	it = std::lower_bound(m_indices.begin(), m_indices.end(), rid);
+	for (; it < m_indices.end() && it->ri == rid; ++it)
+	{
+		if (!it->is_usable())
+		{
+			continue;
+		}
+		const index *idx = m_daemon->m_config.get_index(it->ii);
+		assert(idx);
+		indices->push_back(idx);
+	}
 }
 
 void
-datalayer :: find_indices(const region_id& rid, uint16_t attr,
-                          std::vector<const index*>* indices)
+datalayer :: find_indices(const region_id &rid, uint16_t attr,
+                          std::vector<const index *> *indices)
 {
-    std::vector<index_state>::iterator it;
-    it = std::lower_bound(m_indices.begin(), m_indices.end(), rid);
-
-    for (; it < m_indices.end() && it->ri == rid; ++it)
-    {
-        if (!it->is_usable())
-        {
-            continue;
-        }
-
-        const index* idx = m_daemon->m_config.get_index(it->ii);
-        assert(idx);
-
-        if (idx->attr == attr)
-        {
-            indices->push_back(idx);
-        }
-    }
+	std::vector<index_state>::iterator it;
+	it = std::lower_bound(m_indices.begin(), m_indices.end(), rid);
+	for (; it < m_indices.end() && it->ri == rid; ++it)
+	{
+		if (!it->is_usable())
+		{
+			continue;
+		}
+		const index *idx = m_daemon->m_config.get_index(it->ii);
+		assert(idx);
+		if (idx->attr == attr)
+		{
+			indices->push_back(idx);
+		}
+	}
 }
 
 datalayer::returncode
 datalayer :: handle_error(leveldb::Status st)
 {
-    if (st.IsCorruption())
-    {
-        LOG(ERROR) << "corruption at the disk layer: " << st.ToString();
-        return CORRUPTION;
-    }
-    else if (st.IsIOError())
-    {
-        LOG(ERROR) << "IO error at the disk layer: " << st.ToString();
-        return IO_ERROR;
-    }
-    else
-    {
-        LOG(ERROR) << "LevelDB returned an unknown error that we don't know how to handle:";
-        LOG(ERROR) << st.ToString();
-        return LEVELDB_ERROR;
-    }
+	if (st.IsCorruption())
+	{
+		LOG(ERROR) << "corruption at the disk layer: " << st.ToString();
+		return CORRUPTION;
+	}
+	else if (st.IsIOError())
+	{
+		LOG(ERROR) << "IO error at the disk layer: " << st.ToString();
+		return IO_ERROR;
+	}
+	else
+	{
+		LOG(ERROR) << "LevelDB returned an unknown error that we don't know how to handle:";
+		LOG(ERROR) << st.ToString();
+		return LEVELDB_ERROR;
+	}
 }
 
 datalayer :: reference :: reference()
-    : m_backing()
+	: m_backing()
 {
 }
 
@@ -1424,25 +1274,24 @@ datalayer :: reference :: ~reference() throw ()
 }
 
 void
-datalayer :: reference :: swap(reference* ref)
+datalayer :: reference :: swap(reference *ref)
 {
-    m_backing.swap(ref->m_backing);
+	m_backing.swap(ref->m_backing);
 }
 
-std::ostream&
-hyperdex :: operator << (std::ostream& lhs, datalayer::returncode rhs)
+std::ostream &
+hyperdex :: operator << (std::ostream &lhs, datalayer::returncode rhs)
 {
-    switch (rhs)
-    {
-        STRINGIFY(datalayer::SUCCESS);
-        STRINGIFY(datalayer::NOT_FOUND);
-        STRINGIFY(datalayer::BAD_ENCODING);
-        STRINGIFY(datalayer::CORRUPTION);
-        STRINGIFY(datalayer::IO_ERROR);
-        STRINGIFY(datalayer::LEVELDB_ERROR);
-        default:
-            lhs << "unknown returncode";
-    }
-
-    return lhs;
+	switch (rhs)
+	{
+		STRINGIFY(datalayer::SUCCESS);
+		STRINGIFY(datalayer::NOT_FOUND);
+		STRINGIFY(datalayer::BAD_ENCODING);
+		STRINGIFY(datalayer::CORRUPTION);
+		STRINGIFY(datalayer::IO_ERROR);
+		STRINGIFY(datalayer::LEVELDB_ERROR);
+	default:
+		lhs << "unknown returncode";
+	}
+	return lhs;
 }
diff --git a/daemon/datalayer.h b/daemon/datalayer.h
index a84f7632c..6d1a8bbef 100644
--- a/daemon/datalayer.h
+++ b/daemon/datalayer.h
@@ -65,176 +65,176 @@ class daemon;
 
 class datalayer
 {
-    public:
-        enum returncode
-        {
-            SUCCESS,
-            NOT_FOUND,
-            BAD_ENCODING,
-            CORRUPTION,
-            IO_ERROR,
-            LEVELDB_ERROR
-        };
-        class reference;
-        class iterator;
-        class replay_iterator;
-        class dummy_iterator;
-        class region_iterator;
-        class search_iterator;
-        class index_iterator;
-        class range_index_iterator;
-        class intersect_iterator;
-        typedef leveldb_snapshot_ptr snapshot;
-        // must be pow2
-        const static uint64_t REGION_PERIODIC = 65536;
-
-    public:
-        datalayer(daemon*);
-        ~datalayer() throw ();
-
-    public:
-        bool initialize(const std::string& path,
-                        bool* saved,
-                        server_id* saved_us,
-                        po6::net::location* saved_bind_to,
-                        po6::net::hostname* saved_coordinator);
-        bool save_state(const server_id& m_us,
-                        const po6::net::location& bind_to,
-                        const po6::net::hostname& coordinator);
-        void teardown();
-        // reconfiguration
-        void pause();
-        void unpause();
-        void reconfigure(const configuration& old_config,
-                         const configuration& new_config,
-                         const server_id& us);
-        void debug_dump();
-        // stats
-        bool get_property(const e::slice& property,
-                          std::string* value);
-        std::string get_timestamp();
-        uint64_t approximate_size();
-
-    public:
-        // retrieve the current value of a key
-        returncode get(const region_id& ri,
-                       const e::slice& key,
-                       std::vector<e::slice>* value,
-                       uint64_t* version,
-                       reference* ref);
-        // put, overput, or delete a key where the existing value is known
-        returncode del(const region_id& ri,
-                       const e::slice& key,
-                       const std::vector<e::slice>& old_value);
-        returncode put(const region_id& ri,
-                       const e::slice& key,
-                       const std::vector<e::slice>& new_value,
-                       uint64_t version);
-        returncode overput(const region_id& ri,
-                           const e::slice& key,
-                           const std::vector<e::slice>& old_value,
-                           const std::vector<e::slice>& new_value,
-                           uint64_t version);
-        // put or delete where the previous value is unknown
-        returncode uncertain_del(const region_id& ri,
-                                 const e::slice& key);
-        returncode uncertain_put(const region_id& ri,
-                                 const e::slice& key,
-                                 const std::vector<e::slice>& new_value,
-                                 uint64_t version);
-        // leveldb provides no failure mechanism for this, neither do we
-        snapshot make_snapshot();
-        // create iterators from snapshots
-        iterator* make_search_iterator(snapshot snap,
-                                       const region_id& ri,
-                                       const std::vector<attribute_check>& checks,
-                                       std::ostringstream* ostr);
-        // backups
-        bool backup(const e::slice& name);
-        // get the object pointed to by the iterator
-        returncode get_from_iterator(const region_id& ri,
-                                     const schema& sc,
-                                     iterator* iter,
-                                     e::slice* key,
-                                     std::vector<e::slice>* value,
-                                     uint64_t* version,
-                                     reference* ref);
-        // track version counters
-        void bump_version(const region_id& ri, uint64_t version);
-        uint64_t max_version(const region_id& ri);
-        // checkpointing
-        returncode create_checkpoint(const region_timestamp& rt);
-        void set_checkpoint_gc(uint64_t checkpoint_gc);
-        void largest_checkpoint_for(const region_id& ri, uint64_t* checkpoint);
-        bool region_will_be_wiped(region_id rid);
-        void request_wipe(const transfer_id& xid,
-                          const region_id& ri);
-        void inhibit_wiping();
-        void permit_wiping();
-        replay_iterator* replay_region_from_checkpoint(const region_id& ri,
-                                                       uint64_t checkpoint, bool* wipe);
-        // indexing
-        void create_index_marker(const region_id& ri, const index_id& ii);
-        bool has_index_marker(const region_id& ri, const index_id& ii);
-        // used on startup
-        bool only_key_is_hyperdex_key();
-        bool upgrade_13x_to_14();
-
-    private:
-        class index_state;
-        class checkpointer_thread;
-        class indexer_thread;
-        class wiper_thread;
-        class wiper_indexer_mediator;
-        datalayer(const datalayer&);
-        datalayer& operator = (const datalayer&);
-
-    private:
-        bool write_version(const region_id& ri,
-                           uint64_t version,
-                           leveldb::WriteBatch* updates);
-        void update_memory_version(const region_id& ri, uint64_t version);
-        uint64_t disk_version(const region_id& ri);
-        void find_indices(const region_id& rid,
-                          std::vector<const index*>* indices);
-        void find_indices(const region_id& rid, uint16_t attr,
-                          std::vector<const index*>* indices);
-
-        returncode handle_error(leveldb::Status st);
-        void collect_lower_checkpoints(uint64_t checkpoint_gc);
-
-        const static region_id defaultri;
-        static uint64_t id(region_id ri) { return ri.get(); }
-
-    private:
-        daemon* m_daemon;
-        leveldb_db_ptr m_db;
-        std::vector<index_state> m_indices;
-        e::ao_hash_map<region_id, uint64_t, id, defaultri> m_versions;
-        const std::auto_ptr<checkpointer_thread> m_checkpointer;
-        const std::auto_ptr<wiper_indexer_mediator> m_mediator;
-        const std::auto_ptr<indexer_thread> m_indexer;
-        const std::auto_ptr<wiper_thread> m_wiper;
+public:
+	enum returncode
+	{
+		SUCCESS,
+		NOT_FOUND,
+		BAD_ENCODING,
+		CORRUPTION,
+		IO_ERROR,
+		LEVELDB_ERROR
+	};
+	class reference;
+	class iterator;
+	class replay_iterator;
+	class dummy_iterator;
+	class region_iterator;
+	class search_iterator;
+	class index_iterator;
+	class range_index_iterator;
+	class intersect_iterator;
+	typedef leveldb_snapshot_ptr snapshot;
+	// must be pow2
+	const static uint64_t REGION_PERIODIC = 65536;
+
+public:
+	datalayer(daemon *);
+	~datalayer() throw ();
+
+public:
+	bool initialize(const std::string &path,
+	                bool *saved,
+	                server_id *saved_us,
+	                po6::net::location *saved_bind_to,
+	                po6::net::hostname *saved_coordinator);
+	bool save_state(const server_id &m_us,
+	                const po6::net::location &bind_to,
+	                const po6::net::hostname &coordinator);
+	void teardown();
+	// reconfiguration
+	void pause();
+	void unpause();
+	void reconfigure(const configuration &old_config,
+	                 const configuration &new_config,
+	                 const server_id &us);
+	void debug_dump();
+	// stats
+	bool get_property(const e::slice &property,
+	                  std::string *value);
+	std::string get_timestamp();
+	uint64_t approximate_size();
+
+public:
+	// retrieve the current value of a key
+	returncode get(const region_id &ri,
+	               const e::slice &key,
+	               std::vector<e::slice> *value,
+	               uint64_t *version,
+	               reference *ref);
+	// put, overput, or delete a key where the existing value is known
+	returncode del(const region_id &ri,
+	               const e::slice &key,
+	               const std::vector<e::slice> &old_value);
+	returncode put(const region_id &ri,
+	               const e::slice &key,
+	               const std::vector<e::slice> &new_value,
+	               uint64_t version);
+	returncode overput(const region_id &ri,
+	                   const e::slice &key,
+	                   const std::vector<e::slice> &old_value,
+	                   const std::vector<e::slice> &new_value,
+	                   uint64_t version);
+	// put or delete where the previous value is unknown
+	returncode uncertain_del(const region_id &ri,
+	                         const e::slice &key);
+	returncode uncertain_put(const region_id &ri,
+	                         const e::slice &key,
+	                         const std::vector<e::slice> &new_value,
+	                         uint64_t version);
+	// leveldb provides no failure mechanism for this, neither do we
+	snapshot make_snapshot();
+	// create iterators from snapshots
+	iterator *make_search_iterator(snapshot snap,
+	                               const region_id &ri,
+	                               const std::vector<attribute_check> &checks,
+	                               std::ostringstream *ostr);
+	// backups
+	bool backup(const e::slice &name);
+	// get the object pointed to by the iterator
+	returncode get_from_iterator(const region_id &ri,
+	                             const schema &sc,
+	                             iterator *iter,
+	                             e::slice *key,
+	                             std::vector<e::slice> *value,
+	                             uint64_t *version,
+	                             reference *ref);
+	// track version counters
+	void bump_version(const region_id &ri, uint64_t version);
+	uint64_t max_version(const region_id &ri);
+	// checkpointing
+	returncode create_checkpoint(const region_timestamp &rt);
+	void set_checkpoint_gc(uint64_t checkpoint_gc);
+	void largest_checkpoint_for(const region_id &ri, uint64_t *checkpoint);
+	bool region_will_be_wiped(region_id rid);
+	void request_wipe(const transfer_id &xid,
+	                  const region_id &ri);
+	void inhibit_wiping();
+	void permit_wiping();
+	replay_iterator *replay_region_from_checkpoint(const region_id &ri,
+	                                               uint64_t checkpoint, bool *wipe);
+	// indexing
+	void create_index_marker(const region_id &ri, const index_id &ii);
+	bool has_index_marker(const region_id &ri, const index_id &ii);
+	// used on startup
+	bool only_key_is_hyperdex_key();
+	bool upgrade_13x_to_14();
+
+private:
+	class index_state;
+	class checkpointer_thread;
+	class indexer_thread;
+	class wiper_thread;
+	class wiper_indexer_mediator;
+	datalayer(const datalayer &);
+	datalayer &operator = (const datalayer &);
+
+private:
+	bool write_version(const region_id &ri,
+	                   uint64_t version,
+	                   leveldb::WriteBatch *updates);
+	void update_memory_version(const region_id &ri, uint64_t version);
+	uint64_t disk_version(const region_id &ri);
+	void find_indices(const region_id &rid,
+	                  std::vector<const index *> *indices);
+	void find_indices(const region_id &rid, uint16_t attr,
+	                  std::vector<const index *> *indices);
+
+	returncode handle_error(leveldb::Status st);
+	void collect_lower_checkpoints(uint64_t checkpoint_gc);
+
+	const static region_id defaultri;
+	static uint64_t id(region_id ri) { return ri.get(); }
+
+private:
+	daemon *m_daemon;
+	leveldb_db_ptr m_db;
+	std::vector<index_state> m_indices;
+	e::ao_hash_map<region_id, uint64_t, id, defaultri> m_versions;
+	const std::auto_ptr<checkpointer_thread> m_checkpointer;
+	const std::auto_ptr<wiper_indexer_mediator> m_mediator;
+	const std::auto_ptr<indexer_thread> m_indexer;
+	const std::auto_ptr<wiper_thread> m_wiper;
 };
 
 class datalayer::reference
 {
-    public:
-        reference();
-        ~reference() throw ();
+public:
+	reference();
+	~reference() throw ();
 
-    public:
-        void swap(reference* ref);
+public:
+	void swap(reference *ref);
 
-    private:
-        friend class datalayer;
+private:
+	friend class datalayer;
 
-    private:
-        std::string m_backing;
+private:
+	std::string m_backing;
 };
 
-std::ostream&
-operator << (std::ostream& lhs, datalayer::returncode rhs);
+std::ostream &
+operator << (std::ostream &lhs, datalayer::returncode rhs);
 
 END_HYPERDEX_NAMESPACE
 
diff --git a/daemon/datalayer_checkpointer_thread.cc b/daemon/datalayer_checkpointer_thread.cc
index 646bf0305..6c5f1eb65 100644
--- a/daemon/datalayer_checkpointer_thread.cc
+++ b/daemon/datalayer_checkpointer_thread.cc
@@ -38,13 +38,13 @@
 
 using hyperdex::datalayer;
 
-datalayer :: checkpointer_thread :: checkpointer_thread(daemon* d)
-    : background_thread(d)
-    , m_daemon(d)
-    , m_checkpoint_gc(0)
-    , m_checkpoint_gced(0)
-    , m_checkpoint_target(0)
-    , m_gc_inhibit_permit_diff(0)
+datalayer :: checkpointer_thread :: checkpointer_thread(daemon *d)
+	: background_thread(d)
+	, m_daemon(d)
+	, m_checkpoint_gc(0)
+	, m_checkpoint_gced(0)
+	, m_checkpoint_target(0)
+	, m_gc_inhibit_permit_diff(0)
 {
 }
 
@@ -52,129 +52,116 @@ datalayer :: checkpointer_thread :: ~checkpointer_thread() throw ()
 {
 }
 
-const char*
+const char *
 datalayer :: checkpointer_thread :: thread_name()
 {
-    return "checkpointer";
+	return "checkpointer";
 }
 
 bool
 datalayer :: checkpointer_thread :: have_work()
 {
-    return m_checkpoint_gced < m_checkpoint_gc &&
-           m_gc_inhibit_permit_diff == 0;
+	return m_checkpoint_gced < m_checkpoint_gc &&
+	       m_gc_inhibit_permit_diff == 0;
 }
 
 void
 datalayer :: checkpointer_thread :: copy_work()
 {
-    m_checkpoint_target = m_checkpoint_gc;
+	m_checkpoint_target = m_checkpoint_gc;
 }
 
 void
 datalayer :: checkpointer_thread :: do_work()
 {
-    collect_lower_checkpoints(m_checkpoint_target);
+	collect_lower_checkpoints(m_checkpoint_target);
 }
 
 void
 datalayer :: checkpointer_thread :: debug_dump()
 {
-    this->lock();
-    LOG(INFO) << "checkpointer thread ===========================================================";
-    LOG(INFO) << "checkpoint_gc=" << m_checkpoint_gc;
-    LOG(INFO) << "checkpoint_gced=" << m_checkpoint_gced;
-    LOG(INFO) << "checkpoint_target=" << m_checkpoint_target;
-    LOG(INFO) << "gc_inhibit_permit_diff=" << m_gc_inhibit_permit_diff;
-    this->unlock();
+	this->lock();
+	LOG(INFO) << "checkpointer thread ===========================================================";
+	LOG(INFO) << "checkpoint_gc=" << m_checkpoint_gc;
+	LOG(INFO) << "checkpoint_gced=" << m_checkpoint_gced;
+	LOG(INFO) << "checkpoint_target=" << m_checkpoint_target;
+	LOG(INFO) << "gc_inhibit_permit_diff=" << m_gc_inhibit_permit_diff;
+	this->unlock();
 }
 
 void
 datalayer :: checkpointer_thread :: inhibit_gc()
 {
-    this->lock();
-    ++m_gc_inhibit_permit_diff;
-    this->unlock();
+	this->lock();
+	++m_gc_inhibit_permit_diff;
+	this->unlock();
 }
 
 void
 datalayer :: checkpointer_thread :: permit_gc()
 {
-    this->lock();
-    assert(m_gc_inhibit_permit_diff > 0);
-    --m_gc_inhibit_permit_diff;
-
-    if (m_gc_inhibit_permit_diff == 0)
-    {
-        this->wakeup();
-    }
-
-    this->unlock();
+	this->lock();
+	assert(m_gc_inhibit_permit_diff > 0);
+	--m_gc_inhibit_permit_diff;
+	if (m_gc_inhibit_permit_diff == 0)
+	{
+		this->wakeup();
+	}
+	this->unlock();
 }
 
 void
 datalayer :: checkpointer_thread :: set_checkpoint_gc(uint64_t checkpoint_gc)
 {
-    this->lock();
-    m_checkpoint_gc = std::max(checkpoint_gc, m_checkpoint_gc);
-    this->wakeup();
-    this->unlock();
+	this->lock();
+	m_checkpoint_gc = std::max(checkpoint_gc, m_checkpoint_gc);
+	this->wakeup();
+	this->unlock();
 }
 
 void
 datalayer :: checkpointer_thread :: collect_lower_checkpoints(uint64_t checkpoint_gc)
 {
-    leveldb::ReadOptions opts;
-    opts.verify_checksums = true;
-    std::auto_ptr<leveldb::Iterator> it;
-    it.reset(m_daemon->m_data.m_db->NewIterator(opts));
-    it->Seek(leveldb::Slice("c", 1));
-    std::string lower_bound_timestamp("now");
-
-    while (it->Valid())
-    {
-        region_timestamp rt;
-        e::slice key(it->key().data(), it->key().size());
-        returncode rc = decode_checkpoint(key, &rt.rid, &rt.checkpoint);
-
-        if (rc != datalayer::SUCCESS)
-        {
-            break;
-        }
-
-        rt.local_timestamp = std::string(it->value().data(), it->value().size());
-
-        if (rt.checkpoint >= checkpoint_gc &&
-            m_daemon->m_data.m_db->ValidateTimestamp(rt.local_timestamp))
-        {
-            if (m_daemon->m_data.m_db->CompareTimestamps(rt.local_timestamp, lower_bound_timestamp) < 0)
-            {
-                lower_bound_timestamp = rt.local_timestamp;
-            }
-
-            it->Next();
-            continue;
-        }
-
-        leveldb::WriteOptions wopts;
-        wopts.sync = false;
-        leveldb::Status st = m_daemon->m_data.m_db->Delete(wopts, it->key());
-
-        if (!st.ok())
-        {
-            break;
-        }
-
-        it->Next();
-    }
-
-    this->lock();
-
-    if (m_gc_inhibit_permit_diff == 0)
-    {
-        m_daemon->m_data.m_db->AllowGarbageCollectBeforeTimestamp(lower_bound_timestamp);
-        m_checkpoint_gced = m_checkpoint_target;
-    }
-
-    this->unlock();
+	leveldb::ReadOptions opts;
+	opts.verify_checksums = true;
+	std::auto_ptr<leveldb::Iterator> it;
+	it.reset(m_daemon->m_data.m_db->NewIterator(opts));
+	it->Seek(leveldb::Slice("c", 1));
+	std::string lower_bound_timestamp("now");
+	while (it->Valid())
+	{
+		region_timestamp rt;
+		e::slice key(it->key().data(), it->key().size());
+		returncode rc = decode_checkpoint(key, &rt.rid, &rt.checkpoint);
+		if (rc != datalayer::SUCCESS)
+		{
+			break;
+		}
+		rt.local_timestamp = std::string(it->value().data(), it->value().size());
+		if (rt.checkpoint >= checkpoint_gc &&
+		    m_daemon->m_data.m_db->ValidateTimestamp(rt.local_timestamp))
+		{
+			if (m_daemon->m_data.m_db->CompareTimestamps(rt.local_timestamp, lower_bound_timestamp) < 0)
+			{
+				lower_bound_timestamp = rt.local_timestamp;
+			}
+			it->Next();
+			continue;
+		}
+		leveldb::WriteOptions wopts;
+		wopts.sync = false;
+		leveldb::Status st = m_daemon->m_data.m_db->Delete(wopts, it->key());
+		if (!st.ok())
+		{
+			break;
+		}
+		it->Next();
+	}
+	this->lock();
+	if (m_gc_inhibit_permit_diff == 0)
+	{
+		m_daemon->m_data.m_db->AllowGarbageCollectBeforeTimestamp(lower_bound_timestamp);
+		m_checkpoint_gced = m_checkpoint_target;
+	}
+	this->unlock();
 }
diff --git a/daemon/datalayer_checkpointer_thread.h b/daemon/datalayer_checkpointer_thread.h
index 563fb3020..dd5d60a5d 100644
--- a/daemon/datalayer_checkpointer_thread.h
+++ b/daemon/datalayer_checkpointer_thread.h
@@ -35,37 +35,37 @@
 
 class hyperdex::datalayer::checkpointer_thread : public hyperdex::background_thread
 {
-    public:
-        checkpointer_thread(daemon* d);
-        ~checkpointer_thread() throw ();
+public:
+	checkpointer_thread(daemon *d);
+	~checkpointer_thread() throw ();
 
-    public:
-        virtual const char* thread_name();
-        virtual bool have_work();
-        virtual void copy_work();
-        virtual void do_work();
+public:
+	virtual const char *thread_name();
+	virtual bool have_work();
+	virtual void copy_work();
+	virtual void do_work();
 
-    public:
-        void debug_dump();
-        // these are different than pause/unpause, which should only ever be
-        // called by the main thread.
-        void inhibit_gc();
-        void permit_gc();
-        void set_checkpoint_gc(uint64_t checkpoint_gc);
+public:
+	void debug_dump();
+	// these are different than pause/unpause, which should only ever be
+	// called by the main thread.
+	void inhibit_gc();
+	void permit_gc();
+	void set_checkpoint_gc(uint64_t checkpoint_gc);
 
-    private:
-        void collect_lower_checkpoints(uint64_t checkpoint_gc);
+private:
+	void collect_lower_checkpoints(uint64_t checkpoint_gc);
 
-    private:
-        daemon* m_daemon;
-        uint64_t m_checkpoint_gc; // under lock
-        uint64_t m_checkpoint_gced;
-        uint64_t m_checkpoint_target; // do_work; no lock; copy of _gc
-        uint64_t m_gc_inhibit_permit_diff;
+private:
+	daemon *m_daemon;
+	uint64_t m_checkpoint_gc; // under lock
+	uint64_t m_checkpoint_gced;
+	uint64_t m_checkpoint_target; // do_work; no lock; copy of _gc
+	uint64_t m_gc_inhibit_permit_diff;
 
-    private:
-        checkpointer_thread(const checkpointer_thread&);
-        checkpointer_thread& operator = (const checkpointer_thread&);
+private:
+	checkpointer_thread(const checkpointer_thread &);
+	checkpointer_thread &operator = (const checkpointer_thread &);
 };
 
 #endif // hyperdex_daemon_datalayer_checkpointer_h_
diff --git a/daemon/datalayer_encodings.cc b/daemon/datalayer_encodings.cc
index ff3cf43c5..6450897f3 100644
--- a/daemon/datalayer_encodings.cc
+++ b/daemon/datalayer_encodings.cc
@@ -43,300 +43,269 @@ using hyperdex::datalayer;
 size_t
 hyperdex :: object_prefix_sz(region_id ri)
 {
-    return e::varint_length(ri.get()) + 1;
+	return e::varint_length(ri.get()) + 1;
 }
 
-char*
-hyperdex :: encode_object_prefix(region_id ri, char* ptr)
+char *
+hyperdex :: encode_object_prefix(region_id ri, char *ptr)
 {
-    ptr = e::pack8be('o', ptr);
-    ptr = e::packvarint64(ri.get(), ptr);
-    return ptr;
+	ptr = e::pack8be('o', ptr);
+	ptr = e::packvarint64(ri.get(), ptr);
+	return ptr;
 }
 
 void
-hyperdex :: encode_object_region(const region_id& ri,
-                                 std::vector<char>* scratch,
-                                 leveldb::Slice* out)
+hyperdex :: encode_object_region(const region_id &ri,
+                                 std::vector<char> *scratch,
+                                 leveldb::Slice *out)
 {
-    size_t sz = object_prefix_sz(ri);
-
-    if (scratch->size() < sz)
-    {
-        scratch->resize(sz);
-    }
-
-    char* ptr = &scratch->front();
-    *out = leveldb::Slice(ptr, sz);
-    ptr = encode_object_prefix(ri, ptr);
+	size_t sz = object_prefix_sz(ri);
+	if (scratch->size() < sz)
+	{
+		scratch->resize(sz);
+	}
+	char *ptr = &scratch->front();
+	*out = leveldb::Slice(ptr, sz);
+	ptr = encode_object_prefix(ri, ptr);
 }
 
 void
-hyperdex :: encode_key(const region_id& ri,
-                       const e::slice& internal_key,
-                       std::vector<char>* scratch,
-                       leveldb::Slice* out)
+hyperdex :: encode_key(const region_id &ri,
+                       const e::slice &internal_key,
+                       std::vector<char> *scratch,
+                       leveldb::Slice *out)
 {
-    size_t sz = object_prefix_sz(ri) + internal_key.size();
-
-    if (scratch->size() < sz)
-    {
-        scratch->resize(sz);
-    }
-
-    char* ptr = &scratch->front();
-    *out = leveldb::Slice(ptr, sz);
-    ptr = encode_object_prefix(ri, ptr);
-    memmove(ptr, internal_key.data(), internal_key.size());
+	size_t sz = object_prefix_sz(ri) + internal_key.size();
+	if (scratch->size() < sz)
+	{
+		scratch->resize(sz);
+	}
+	char *ptr = &scratch->front();
+	*out = leveldb::Slice(ptr, sz);
+	ptr = encode_object_prefix(ri, ptr);
+	memmove(ptr, internal_key.data(), internal_key.size());
 }
 
 void
-hyperdex :: encode_key(const region_id& ri,
+hyperdex :: encode_key(const region_id &ri,
                        hyperdatatype key_type,
-                       const e::slice& key,
-                       std::vector<char>* scratch,
-                       leveldb::Slice* out)
+                       const e::slice &key,
+                       std::vector<char> *scratch,
+                       leveldb::Slice *out)
 {
-    const index_encoding* ie(index_encoding::lookup(key_type));
-    size_t sz = object_prefix_sz(ri) + ie->encoded_size(key);
-
-    if (scratch->size() < sz)
-    {
-        scratch->resize(sz);
-    }
-
-    char* ptr = &scratch->front();
-    *out = leveldb::Slice(ptr, sz);
-    ptr = encode_object_prefix(ri, ptr);
-    ie->encode(key, ptr);
+	const index_encoding *ie(index_encoding::lookup(key_type));
+	size_t sz = object_prefix_sz(ri) + ie->encoded_size(key);
+	if (scratch->size() < sz)
+	{
+		scratch->resize(sz);
+	}
+	char *ptr = &scratch->front();
+	*out = leveldb::Slice(ptr, sz);
+	ptr = encode_object_prefix(ri, ptr);
+	ie->encode(key, ptr);
 }
 
 bool
-hyperdex :: decode_key(const leveldb::Slice& in,
-                       region_id* ri,
-                       e::slice* internal_key)
+hyperdex :: decode_key(const leveldb::Slice &in,
+                       region_id *ri,
+                       e::slice *internal_key)
 {
-    if (in.size() < 2 || in.data()[0] != 'o')
-    {
-        return false;
-    }
-
-    uint64_t r;
-    const char* const end = in.data() + in.size();
-    const char* ptr = in.data() + sizeof(uint8_t);
-    ptr = e::varint64_decode(ptr, end, &r);
-
-    if (!ptr)
-    {
-        return false;
-    }
-
-    *ri = region_id(r);
-    *internal_key = e::slice(ptr, end - ptr);
-    return true;
+	if (in.size() < 2 || in.data()[0] != 'o')
+	{
+		return false;
+	}
+	uint64_t r;
+	const char *const end = in.data() + in.size();
+	const char *ptr = in.data() + sizeof(uint8_t);
+	ptr = e::varint64_decode(ptr, end, &r);
+	if (!ptr)
+	{
+		return false;
+	}
+	*ri = region_id(r);
+	*internal_key = e::slice(ptr, end - ptr);
+	return true;
 }
 
 void
-hyperdex :: encode_value(const std::vector<e::slice>& attrs,
+hyperdex :: encode_value(const std::vector<e::slice> &attrs,
                          uint64_t version,
-                         std::vector<char>* backing,
-                         leveldb::Slice* out)
+                         std::vector<char> *backing,
+                         leveldb::Slice *out)
 {
-    assert(attrs.size() < 65536);
-    size_t sz = sizeof(uint64_t) + sizeof(uint16_t);
-
-    for (size_t i = 0; i < attrs.size(); ++i)
-    {
-        sz += sizeof(uint32_t) + attrs[i].size();
-    }
-
-    backing->resize(sz);
-    char* ptr = &backing->front();
-    ptr = e::pack64be(version, ptr);
-    ptr = e::pack16be(attrs.size(), ptr);
-
-    for (size_t i = 0; i < attrs.size(); ++i)
-    {
-        ptr = e::pack32be(attrs[i].size(), ptr);
-        memmove(ptr, attrs[i].data(), attrs[i].size());
-        ptr += attrs[i].size();
-    }
-
-    *out = leveldb::Slice(&backing->front(), sz);
+	assert(attrs.size() < 65536);
+	size_t sz = sizeof(uint64_t) + sizeof(uint16_t);
+	for (size_t i = 0; i < attrs.size(); ++i)
+	{
+		sz += sizeof(uint32_t) + attrs[i].size();
+	}
+	backing->resize(sz);
+	char *ptr = &backing->front();
+	ptr = e::pack64be(version, ptr);
+	ptr = e::pack16be(attrs.size(), ptr);
+	for (size_t i = 0; i < attrs.size(); ++i)
+	{
+		ptr = e::pack32be(attrs[i].size(), ptr);
+		memmove(ptr, attrs[i].data(), attrs[i].size());
+		ptr += attrs[i].size();
+	}
+	*out = leveldb::Slice(&backing->front(), sz);
 }
 
 datalayer::returncode
-hyperdex :: decode_value(const e::slice& in,
-                         std::vector<e::slice>* attrs,
-                         uint64_t* version)
+hyperdex :: decode_value(const e::slice &in,
+                         std::vector<e::slice> *attrs,
+                         uint64_t *version)
 {
-    const uint8_t* ptr = in.data();
-    const uint8_t* end = ptr + in.size();
-
-    if (ptr + sizeof(uint64_t) <= end)
-    {
-        ptr = e::unpack64be(ptr, version);
-    }
-    else
-    {
-        return datalayer::BAD_ENCODING;
-    }
-
-    uint16_t num_attrs;
-
-    if (ptr + sizeof(uint16_t) <= end)
-    {
-        ptr = e::unpack16be(ptr, &num_attrs);
-    }
-    else
-    {
-        return datalayer::BAD_ENCODING;
-    }
-
-    attrs->clear();
-
-    for (size_t i = 0; i < num_attrs; ++i)
-    {
-        uint32_t sz = 0;
-
-        if (ptr + sizeof(uint32_t) <= end)
-        {
-            ptr = e::unpack32be(ptr, &sz);
-        }
-        else
-        {
-            return datalayer::BAD_ENCODING;
-        }
-
-        e::slice s(reinterpret_cast<const uint8_t*>(ptr), sz);
-        ptr += sz;
-        attrs->push_back(s);
-    }
-
-    return datalayer::SUCCESS;
+	const uint8_t *ptr = in.data();
+	const uint8_t *end = ptr + in.size();
+	if (ptr + sizeof(uint64_t) <= end)
+	{
+		ptr = e::unpack64be(ptr, version);
+	}
+	else
+	{
+		return datalayer::BAD_ENCODING;
+	}
+	uint16_t num_attrs;
+	if (ptr + sizeof(uint16_t) <= end)
+	{
+		ptr = e::unpack16be(ptr, &num_attrs);
+	}
+	else
+	{
+		return datalayer::BAD_ENCODING;
+	}
+	attrs->clear();
+	for (size_t i = 0; i < num_attrs; ++i)
+	{
+		uint32_t sz = 0;
+		if (ptr + sizeof(uint32_t) <= end)
+		{
+			ptr = e::unpack32be(ptr, &sz);
+		}
+		else
+		{
+			return datalayer::BAD_ENCODING;
+		}
+		e::slice s(reinterpret_cast<const uint8_t *>(ptr), sz);
+		ptr += sz;
+		attrs->push_back(s);
+	}
+	return datalayer::SUCCESS;
 }
 
 void
-hyperdex :: encode_version(const region_id& ri, /*region we wrote*/
+hyperdex :: encode_version(const region_id &ri, /*region we wrote*/
                            uint64_t version,
-                           char* out)
+                           char *out)
 {
-    char* ptr = out;
-    ptr = e::pack8be('v', ptr);
-    ptr = e::pack64be(ri.get(), ptr);
-    ptr = e::pack64be(UINT64_MAX - version, ptr);
+	char *ptr = out;
+	ptr = e::pack8be('v', ptr);
+	ptr = e::pack64be(ri.get(), ptr);
+	ptr = e::pack64be(UINT64_MAX - version, ptr);
 }
 
 datalayer::returncode
-hyperdex :: decode_version(const e::slice& in,
-                           region_id* ri, /*region we saw an ack for*/
-                           uint64_t* version)
+hyperdex :: decode_version(const e::slice &in,
+                           region_id *ri, /*region we saw an ack for*/
+                           uint64_t *version)
 {
-    if (in.size() != VERSION_BUF_SIZE)
-    {
-        return datalayer::BAD_ENCODING;
-    }
-
-    uint8_t _p;
-    uint64_t _ri;
-    const uint8_t* ptr = in.data();
-    ptr = e::unpack8be(ptr, &_p);
-    ptr = e::unpack64be(ptr, &_ri);
-    ptr = e::unpack64be(ptr, version);
-    *ri = region_id(_ri);
-    *version = UINT64_MAX - *version;
-    return _p == 'v' ? datalayer::SUCCESS : datalayer::BAD_ENCODING;
+	if (in.size() != VERSION_BUF_SIZE)
+	{
+		return datalayer::BAD_ENCODING;
+	}
+	uint8_t _p;
+	uint64_t _ri;
+	const uint8_t *ptr = in.data();
+	ptr = e::unpack8be(ptr, &_p);
+	ptr = e::unpack64be(ptr, &_ri);
+	ptr = e::unpack64be(ptr, version);
+	*ri = region_id(_ri);
+	*version = UINT64_MAX - *version;
+	return _p == 'v' ? datalayer::SUCCESS : datalayer::BAD_ENCODING;
 }
 
 void
-hyperdex :: encode_checkpoint(const region_id& ri,
+hyperdex :: encode_checkpoint(const region_id &ri,
                               uint64_t checkpoint,
-                              char* out)
+                              char *out)
 {
-    char* ptr = out;
-    ptr = e::pack8be('c', ptr);
-    ptr = e::pack64be(ri.get(), ptr);
-    ptr = e::pack64be(checkpoint, ptr);
+	char *ptr = out;
+	ptr = e::pack8be('c', ptr);
+	ptr = e::pack64be(ri.get(), ptr);
+	ptr = e::pack64be(checkpoint, ptr);
 }
 
 datalayer::returncode
-hyperdex :: decode_checkpoint(const e::slice& in,
-                              region_id* ri,
-                              uint64_t* checkpoint)
+hyperdex :: decode_checkpoint(const e::slice &in,
+                              region_id *ri,
+                              uint64_t *checkpoint)
 {
-    if (in.size() != CHECKPOINT_BUF_SIZE)
-    {
-        return datalayer::BAD_ENCODING;
-    }
-
-    const uint8_t* ptr = in.data();
-    uint8_t t;
-    uint64_t _ri;
-    ptr = e::unpack8be(ptr, &t);
-    ptr = e::unpack64be(ptr, &_ri);
-    ptr = e::unpack64be(ptr, checkpoint);
-    *ri = region_id(_ri);
-    return t == 'c' ? datalayer::SUCCESS : datalayer::BAD_ENCODING;
+	if (in.size() != CHECKPOINT_BUF_SIZE)
+	{
+		return datalayer::BAD_ENCODING;
+	}
+	const uint8_t *ptr = in.data();
+	uint8_t t;
+	uint64_t _ri;
+	ptr = e::unpack8be(ptr, &t);
+	ptr = e::unpack64be(ptr, &_ri);
+	ptr = e::unpack64be(ptr, checkpoint);
+	*ri = region_id(_ri);
+	return t == 'c' ? datalayer::SUCCESS : datalayer::BAD_ENCODING;
 }
 
 void
-hyperdex :: create_index_changes(const schema& sc,
-                                 const region_id& ri,
-                                 const std::vector<const index*>& indices,
-                                 const e::slice& key,
-                                 const std::vector<e::slice>* old_value,
-                                 const std::vector<e::slice>* new_value,
-                                 leveldb::WriteBatch* updates)
+hyperdex :: create_index_changes(const schema &sc,
+                                 const region_id &ri,
+                                 const std::vector<const index *> &indices,
+                                 const e::slice &key,
+                                 const std::vector<e::slice> *old_value,
+                                 const std::vector<e::slice> *new_value,
+                                 leveldb::WriteBatch *updates)
 {
-    assert(!old_value || !new_value || old_value->size() == new_value->size());
-    assert(!old_value || old_value->size() + 1 == sc.attrs_sz);
-    assert(!new_value || new_value->size() + 1 == sc.attrs_sz);
-    const index_encoding* key_ie = index_encoding::lookup(sc.attrs[0].type);
-
-    for (size_t i = 0; i < indices.size(); ++i)
-    {
-        const index* idx = indices[i];
-
-        assert(idx->attr > 0);
-        assert(idx->attr < sc.attrs_sz);
-
-        const index_info* ai = index_info::lookup(sc.attrs[idx->attr].type);
-        assert(ai);
-
-        const e::slice* old_attr = NULL;
-        const e::slice* new_attr = NULL;
-        old_attr = old_value ? &(*old_value)[idx->attr - 1] : NULL;
-        new_attr = new_value ? &(*new_value)[idx->attr - 1] : NULL;
-
-        if (!old_attr && !new_attr)
-        {
-            continue;
-        }
-
-        ai->index_changes(idx, ri, key_ie, key, old_attr, new_attr, updates);
-    }
+	assert(!old_value || !new_value || old_value->size() == new_value->size());
+	assert(!old_value || old_value->size() + 1 == sc.attrs_sz);
+	assert(!new_value || new_value->size() + 1 == sc.attrs_sz);
+	const index_encoding *key_ie = index_encoding::lookup(sc.attrs[0].type);
+	for (size_t i = 0; i < indices.size(); ++i)
+	{
+		const index *idx = indices[i];
+		assert(idx->attr > 0);
+		assert(idx->attr < sc.attrs_sz);
+		const index_info *ai = index_info::lookup(sc.attrs[idx->attr].type);
+		assert(ai);
+		const e::slice *old_attr = NULL;
+		const e::slice *new_attr = NULL;
+		old_attr = old_value ? &(*old_value)[idx->attr - 1] : NULL;
+		new_attr = new_value ? &(*new_value)[idx->attr - 1] : NULL;
+		if (!old_attr && !new_attr)
+		{
+			continue;
+		}
+		ai->index_changes(idx, ri, key_ie, key, old_attr, new_attr, updates);
+	}
 }
 
 void
-hyperdex :: encode_bump(char* _ptr, char* _end)
+hyperdex :: encode_bump(char *_ptr, char *_end)
 {
-    assert(_ptr);
-    assert(_ptr < _end);
-    uint8_t* ptr = reinterpret_cast<uint8_t*>(_end) - 1;
-    uint8_t* end = reinterpret_cast<uint8_t*>(_ptr);
-
-    for (; ptr >= end; --ptr)
-    {
-        if (*ptr < 255)
-        {
-            ++(*ptr);
-            return;
-        }
-        else
-        {
-            *ptr = 0;
-        }
-    }
-
-    abort();
+	assert(_ptr);
+	assert(_ptr < _end);
+	uint8_t *ptr = reinterpret_cast<uint8_t *>(_end) - 1;
+	uint8_t *end = reinterpret_cast<uint8_t *>(_ptr);
+	for (; ptr >= end; --ptr)
+	{
+		if (*ptr < 255)
+		{
+			++(*ptr);
+			return;
+		}
+		else
+		{
+			*ptr = 0;
+		}
+	}
+	abort();
 }
diff --git a/daemon/datalayer_encodings.h b/daemon/datalayer_encodings.h
index 50a69cb6f..e6405f71c 100644
--- a/daemon/datalayer_encodings.h
+++ b/daemon/datalayer_encodings.h
@@ -41,75 +41,75 @@ BEGIN_HYPERDEX_NAMESPACE
 size_t
 object_prefix_sz(region_id ri);
 
-char*
-encode_object_prefix(region_id ri, char* ptr);
+char *
+encode_object_prefix(region_id ri, char *ptr);
 
 void
-encode_object_region(const region_id& ri,
-                     std::vector<char>* scratch,
-                     leveldb::Slice* out);
+encode_object_region(const region_id &ri,
+                     std::vector<char> *scratch,
+                     leveldb::Slice *out);
 
 void
-encode_key(const region_id& ri,
-           const e::slice& internal_key,
-           std::vector<char>* scratch,
-           leveldb::Slice* out);
+encode_key(const region_id &ri,
+           const e::slice &internal_key,
+           std::vector<char> *scratch,
+           leveldb::Slice *out);
 
 void
-encode_key(const region_id& ri,
+encode_key(const region_id &ri,
            hyperdatatype key_type,
-           const e::slice& key,
-           std::vector<char>* scratch,
-           leveldb::Slice* out);
+           const e::slice &key,
+           std::vector<char> *scratch,
+           leveldb::Slice *out);
 
 bool
-decode_key(const leveldb::Slice& in,
-           region_id* ri,
-           e::slice* internal_key);
+decode_key(const leveldb::Slice &in,
+           region_id *ri,
+           e::slice *internal_key);
 
 void
-encode_value(const std::vector<e::slice>& attrs,
+encode_value(const std::vector<e::slice> &attrs,
              uint64_t version,
-             std::vector<char>* backing,
-             leveldb::Slice* out);
+             std::vector<char> *backing,
+             leveldb::Slice *out);
 datalayer::returncode
-decode_value(const e::slice& in,
-             std::vector<e::slice>* attrs,
-             uint64_t* version);
+decode_value(const e::slice &in,
+             std::vector<e::slice> *attrs,
+             uint64_t *version);
 
 // Encode the record of an operation for which we have sent an ACK
 #define VERSION_BUF_SIZE (sizeof(uint8_t) + 2 * sizeof(uint64_t))
 void
-encode_version(const region_id& ri, /*region we wrote*/
+encode_version(const region_id &ri, /*region we wrote*/
                uint64_t version,
-               char* out);
+               char *out);
 datalayer::returncode
-decode_version(const e::slice& in,
-               region_id* ri, /*region we saw an ack for*/
-               uint64_t* version);
+decode_version(const e::slice &in,
+               region_id *ri, /*region we saw an ack for*/
+               uint64_t *version);
 
 // checkpoints
 #define CHECKPOINT_BUF_SIZE (sizeof(uint8_t) + 2 * sizeof(uint64_t))
 void
-encode_checkpoint(const region_id& ri,
+encode_checkpoint(const region_id &ri,
                   uint64_t checkpoint,
-                  char* out);
+                  char *out);
 datalayer::returncode
-decode_checkpoint(const e::slice& in,
-                  region_id* ri,
-                  uint64_t* checkpoint);
+decode_checkpoint(const e::slice &in,
+                  region_id *ri,
+                  uint64_t *checkpoint);
 
 void
-create_index_changes(const schema& sc,
-                     const region_id& ri,
-                     const std::vector<const index*>& indices,
-                     const e::slice& key,
-                     const std::vector<e::slice>* old_value,
-                     const std::vector<e::slice>* new_value,
-                     leveldb::WriteBatch* updates);
+create_index_changes(const schema &sc,
+                     const region_id &ri,
+                     const std::vector<const index *> &indices,
+                     const e::slice &key,
+                     const std::vector<e::slice> *old_value,
+                     const std::vector<e::slice> *new_value,
+                     leveldb::WriteBatch *updates);
 
 void
-encode_bump(char* start, char* end);
+encode_bump(char *start, char *end);
 
 END_HYPERDEX_NAMESPACE
 
diff --git a/daemon/datalayer_index_state.h b/daemon/datalayer_index_state.h
index 639b2cff1..9c3cc5b9b 100644
--- a/daemon/datalayer_index_state.h
+++ b/daemon/datalayer_index_state.h
@@ -35,32 +35,31 @@ using hyperdex::datalayer;
 
 struct datalayer::index_state
 {
-    index_state() : ri(), ii(), m_usable(0) {}
-    index_state(region_id _ri, index_id _ii)
-        : ri(_ri), ii(_ii), m_usable(0) {}
-    index_state(const index_state& other)
-        : ri(other.ri), ii(other.ii)
-        , m_usable(other.m_usable) {}
-    bool is_usable() { e::atomic::memory_barrier(); return e::atomic::load_64_acquire(&m_usable) == 1; }
-    void set_usable() { e::atomic::store_64_release(&m_usable, 1); e::atomic::memory_barrier(); }
-    index_state& operator = (const index_state& rhs)
-    {
-        if (this != &rhs)
-        {
-            ri = rhs.ri;
-            ii = rhs.ii;
-            m_usable = rhs.m_usable;
-        }
+	index_state() : ri(), ii(), m_usable(0) {}
+	index_state(region_id _ri, index_id _ii)
+		: ri(_ri), ii(_ii), m_usable(0) {}
+	index_state(const index_state &other)
+		: ri(other.ri), ii(other.ii)
+		, m_usable(other.m_usable) {}
+	bool is_usable() { e::atomic::memory_barrier(); return e::atomic::load_64_acquire(&m_usable) == 1; }
+	void set_usable() { e::atomic::store_64_release(&m_usable, 1); e::atomic::memory_barrier(); }
+	index_state &operator = (const index_state &rhs)
+	{
+		if (this != &rhs)
+		{
+			ri = rhs.ri;
+			ii = rhs.ii;
+			m_usable = rhs.m_usable;
+		}
+		return *this;
+	}
+	bool operator < (const region_id &x) const { return ri < x; }
 
-        return *this;
-    }
-    bool operator < (const region_id& x) const { return ri < x; }
+	region_id ri;
+	index_id ii;
 
-    region_id ri;
-    index_id ii;
-
-    private:
-        uint64_t m_usable;
+private:
+	uint64_t m_usable;
 };
 
 #endif // hyperdex_daemon_datalayer_index_state_h_
diff --git a/daemon/datalayer_indexer_thread.cc b/daemon/datalayer_indexer_thread.cc
index 90d49a7b0..4a5a5fb91 100644
--- a/daemon/datalayer_indexer_thread.cc
+++ b/daemon/datalayer_indexer_thread.cc
@@ -44,16 +44,16 @@
 
 using hyperdex::datalayer;
 
-datalayer :: indexer_thread :: indexer_thread(daemon* d, wiper_indexer_mediator* m)
-    : background_thread(d)
-    , m_daemon(d)
-    , m_mediator(m)
-    , m_config()
-    , m_have_current(false)
-    , m_current_region()
-    , m_current_index()
-    , m_interrupted_count(0)
-    , m_interrupted(false)
+datalayer :: indexer_thread :: indexer_thread(daemon *d, wiper_indexer_mediator *m)
+	: background_thread(d)
+	, m_daemon(d)
+	, m_mediator(m)
+	, m_config()
+	, m_have_current(false)
+	, m_current_region()
+	, m_current_index()
+	, m_interrupted_count(0)
+	, m_interrupted(false)
 {
 }
 
@@ -61,434 +61,382 @@ datalayer :: indexer_thread :: ~indexer_thread() throw ()
 {
 }
 
-const char*
+const char *
 datalayer :: indexer_thread :: thread_name()
 {
-    return "indexing";
+	return "indexing";
 }
 
 bool
 datalayer :: indexer_thread :: have_work()
 {
-    m_interrupted = false;
-    m_mediator->clear_indexer_region();
-    m_have_current = false;
-    m_current_region = region_id();
-    m_current_index = index_id();
-
-    for (size_t i = 0; i < m_daemon->m_data.m_indices.size(); ++i)
-    {
-        index_state* is = &m_daemon->m_data.m_indices[i];
-
-        // if it's not usable (we have to index it first), and it's not
-        // currently being wiped, and it's something that we've been mapped to,
-        // then we have work to do
-        if (!is->is_usable() &&
-            !m_mediator->region_conflicts_with_wiper(is->ri) &&
-            m_daemon->m_config.get_virtual(is->ri, m_daemon->m_us) != virtual_server_id())
-        {
-            return true;
-        }
-    }
-
-    return false;
+	m_interrupted = false;
+	m_mediator->clear_indexer_region();
+	m_have_current = false;
+	m_current_region = region_id();
+	m_current_index = index_id();
+	for (size_t i = 0; i < m_daemon->m_data.m_indices.size(); ++i)
+	{
+		index_state *is = &m_daemon->m_data.m_indices[i];
+		// if it's not usable (we have to index it first), and it's not
+		// currently being wiped, and it's something that we've been mapped to,
+		// then we have work to do
+		if (!is->is_usable() &&
+		    !m_mediator->region_conflicts_with_wiper(is->ri) &&
+		    m_daemon->m_config.get_virtual(is->ri, m_daemon->m_us) != virtual_server_id())
+		{
+			return true;
+		}
+	}
+	return false;
 }
 
 void
 datalayer :: indexer_thread :: copy_work()
 {
-    for (size_t i = 0; i < m_daemon->m_data.m_indices.size(); ++i)
-    {
-        index_state* is = &m_daemon->m_data.m_indices[i];
-
-        // if it's not usable (we have to index it first), and it's not
-        // currently being wiped, and it's something that we've been mapped to,
-        // then we have work to do
-        if (!is->is_usable() &&
-            m_daemon->m_config.get_virtual(is->ri, m_daemon->m_us) != virtual_server_id() &&
-            m_mediator->set_indexer_region(is->ri))
-        {
-            m_config = m_daemon->m_config;
-            m_have_current   = true;
-            m_current_region = is->ri;
-            m_current_index  = is->ii;
-            return;
-        }
-    }
+	for (size_t i = 0; i < m_daemon->m_data.m_indices.size(); ++i)
+	{
+		index_state *is = &m_daemon->m_data.m_indices[i];
+		// if it's not usable (we have to index it first), and it's not
+		// currently being wiped, and it's something that we've been mapped to,
+		// then we have work to do
+		if (!is->is_usable() &&
+		    m_daemon->m_config.get_virtual(is->ri, m_daemon->m_us) != virtual_server_id() &&
+		    m_mediator->set_indexer_region(is->ri))
+		{
+			m_config = m_daemon->m_config;
+			m_have_current   = true;
+			m_current_region = is->ri;
+			m_current_index  = is->ii;
+			return;
+		}
+	}
 }
 
 void
 datalayer :: indexer_thread :: do_work()
 {
-    if (!m_have_current)
-    {
-        return;
-    }
-
-    if (!wipe(m_current_region, m_current_index))
-    {
-        return;
-    }
-
-    configuration config = m_config;
-    leveldb_db_ptr db = m_daemon->m_data.m_db;
-    const schema* sc = config.get_schema(m_current_region);
-    const index* idx = config.get_index(m_current_index);
-    assert(idx);
-    std::vector<const index*> idxs(1, idx);
-
-    // prohibit garbage collection during this section.
-    // this ensures that the timestamp we take will remain valid until the end
-    m_daemon->m_data.m_checkpointer->inhibit_gc();
-    e::guard g1 = e::makeobjguard(*m_daemon->m_data.m_checkpointer,
-                                  &checkpointer_thread::permit_gc);
-    g1.use_variable();
-
-    // Take a timestamp from the data layer.  We could just use a replay
-    // iterator for "all", but we wouldn't know which objects we indexed twice.
-    // By taking an iterator and then a replay iterator from the timestamp, we
-    // ensure that the majority of data gets indexed using "put" ops instead of
-    // the "get/put" pattern necessary to remove existing indices before adding.
-    std::string timestamp;
-    db->GetReplayTimestamp(&timestamp);
-
-    // Take this offline
-    this->offline();
-    e::guard g2 = e::makeobjguard(*this, &indexer_thread::online);
-    g2.use_variable();
-
-    // Now iterate over the data once.
-    std::auto_ptr<region_iterator> it(play(m_current_region, sc));
-
-    if (!it.get())
-    {
-        return;
-    }
-
-    while (it->valid())
-    {
-        if (!index_from_iterator(it.get(), sc, m_current_region, idxs))
-        {
-            return;
-        }
-
-        it->next();
-    }
-
-    // Now do it again from the checkpoint we took.
-    std::auto_ptr<replay_iterator> rit(replay(m_current_region, timestamp));
-
-    if (!rit.get())
-    {
-        return;
-    }
-
-    while (rit->valid())
-    {
-        if (!index_from_replay_iterator(rit.get(), sc, m_current_region, idxs))
-        {
-            return;
-        }
-
-        rit->next();
-    }
-
-    // Pause writes so we can hit the end of the iterator.
-    m_daemon->pause();
-    e::guard g3 = e::makeobjguard(*m_daemon, &daemon::unpause);
-    g3.use_variable();
-
-    // Keep iterating on the replay iterator
-    while (rit->valid())
-    {
-        if (!index_from_replay_iterator(rit.get(), sc, m_current_region, idxs))
-        {
-            return;
-        }
-
-        rit->next();
-    }
-
-    // make the index usable to all
-    if (!mark_usable(m_current_region, m_current_index))
-    {
-        return;
-    }
-
-    // Unpause writes
-    g3.dismiss();
-    m_daemon->unpause();
-
-    // Let the index possibly do its thing
-    m_daemon->m_data.m_wiper->kick();
+	if (!m_have_current)
+	{
+		return;
+	}
+	if (!wipe(m_current_region, m_current_index))
+	{
+		return;
+	}
+	configuration config = m_config;
+	leveldb_db_ptr db = m_daemon->m_data.m_db;
+	const schema *sc = config.get_schema(m_current_region);
+	const index *idx = config.get_index(m_current_index);
+	assert(idx);
+	std::vector<const index *> idxs(1, idx);
+	// prohibit garbage collection during this section.
+	// this ensures that the timestamp we take will remain valid until the end
+	m_daemon->m_data.m_checkpointer->inhibit_gc();
+	e::guard g1 = e::makeobjguard(*m_daemon->m_data.m_checkpointer,
+	                              &checkpointer_thread::permit_gc);
+	g1.use_variable();
+	// Take a timestamp from the data layer.  We could just use a replay
+	// iterator for "all", but we wouldn't know which objects we indexed twice.
+	// By taking an iterator and then a replay iterator from the timestamp, we
+	// ensure that the majority of data gets indexed using "put" ops instead of
+	// the "get/put" pattern necessary to remove existing indices before adding.
+	std::string timestamp;
+	db->GetReplayTimestamp(&timestamp);
+	// Take this offline
+	this->offline();
+	e::guard g2 = e::makeobjguard(*this, &indexer_thread::online);
+	g2.use_variable();
+	// Now iterate over the data once.
+	std::auto_ptr<region_iterator> it(play(m_current_region, sc));
+	if (!it.get())
+	{
+		return;
+	}
+	while (it->valid())
+	{
+		if (!index_from_iterator(it.get(), sc, m_current_region, idxs))
+		{
+			return;
+		}
+		it->next();
+	}
+	// Now do it again from the checkpoint we took.
+	std::auto_ptr<replay_iterator> rit(replay(m_current_region, timestamp));
+	if (!rit.get())
+	{
+		return;
+	}
+	while (rit->valid())
+	{
+		if (!index_from_replay_iterator(rit.get(), sc, m_current_region, idxs))
+		{
+			return;
+		}
+		rit->next();
+	}
+	// Pause writes so we can hit the end of the iterator.
+	m_daemon->pause();
+	e::guard g3 = e::makeobjguard(*m_daemon, &daemon::unpause);
+	g3.use_variable();
+	// Keep iterating on the replay iterator
+	while (rit->valid())
+	{
+		if (!index_from_replay_iterator(rit.get(), sc, m_current_region, idxs))
+		{
+			return;
+		}
+		rit->next();
+	}
+	// make the index usable to all
+	if (!mark_usable(m_current_region, m_current_index))
+	{
+		return;
+	}
+	// Unpause writes
+	g3.dismiss();
+	m_daemon->unpause();
+	// Let the index possibly do its thing
+	m_daemon->m_data.m_wiper->kick();
 }
 
 void
 datalayer :: indexer_thread :: debug_dump()
 {
-    this->lock();
-    LOG(INFO) << "indexer thread ================================================================";
-    LOG(INFO) << "have_current=" << (m_have_current ? "yes" : "no");
-    LOG(INFO) << "current_region=" << m_current_region;
-    LOG(INFO) << "current_index=" << m_current_index;
-    LOG(INFO) << "interrupted_count=" << m_interrupted_count;
-    this->unlock();
+	this->lock();
+	LOG(INFO) << "indexer thread ================================================================";
+	LOG(INFO) << "have_current=" << (m_have_current ? "yes" : "no");
+	LOG(INFO) << "current_region=" << m_current_region;
+	LOG(INFO) << "current_index=" << m_current_index;
+	LOG(INFO) << "interrupted_count=" << m_interrupted_count;
+	this->unlock();
 }
 
 void
 datalayer :: indexer_thread :: kick()
 {
-    this->lock();
-    this->wakeup();
-    this->unlock();
+	this->lock();
+	this->wakeup();
+	this->unlock();
 }
 
 bool
-datalayer :: indexer_thread :: mark_usable(const region_id& ri, const index_id& ii)
+datalayer :: indexer_thread :: mark_usable(const region_id &ri, const index_id &ii)
 {
-    // Publish the index
-    char buf[sizeof(uint8_t) + 2 * VARINT_64_MAX_SIZE];
-    char* ptr = buf;
-    ptr = e::pack8be('I', ptr);
-    ptr = e::packvarint64(ri.get(), ptr);
-    ptr = e::packvarint64(ii.get(), ptr);
-    leveldb::WriteOptions wo;
-    leveldb::Slice key(buf, ptr - buf);
-    leveldb::Slice val;
-    leveldb::Status st = m_daemon->m_data.m_db->Put(wo, key, val);
-
-    if (!st.ok())
-    {
-        LOG(ERROR) << "error indexing: write failed: " << st.ToString();
-        return false;
-    }
-
-    // Set the index to be usable
-    for (size_t i = 0; i < m_daemon->m_data.m_indices.size(); ++i)
-    {
-        index_state* is = &m_daemon->m_data.m_indices[i];
-
-        if (is->ri == ri &&
-            is->ii == ii)
-        {
-            is->set_usable();
-        }
-    }
-
-    return true;
+	// Publish the index
+	char buf[sizeof(uint8_t) + 2 * VARINT_64_MAX_SIZE];
+	char *ptr = buf;
+	ptr = e::pack8be('I', ptr);
+	ptr = e::packvarint64(ri.get(), ptr);
+	ptr = e::packvarint64(ii.get(), ptr);
+	leveldb::WriteOptions wo;
+	leveldb::Slice key(buf, ptr - buf);
+	leveldb::Slice val;
+	leveldb::Status st = m_daemon->m_data.m_db->Put(wo, key, val);
+	if (!st.ok())
+	{
+		LOG(ERROR) << "error indexing: write failed: " << st.ToString();
+		return false;
+	}
+	// Set the index to be usable
+	for (size_t i = 0; i < m_daemon->m_data.m_indices.size(); ++i)
+	{
+		index_state *is = &m_daemon->m_data.m_indices[i];
+		if (is->ri == ri &&
+		    is->ii == ii)
+		{
+			is->set_usable();
+		}
+	}
+	return true;
 }
 
 bool
 datalayer :: indexer_thread :: interrupted()
 {
-    ++m_interrupted_count;
-    bool ret = m_interrupted;
-
-    if (m_interrupted_count % 1000 == 0)
-    {
-        this->lock();
-        ret = this->is_shutdown();
-        m_interrupted = ret;
-        this->unlock();
-    }
-
-    return ret;
+	++m_interrupted_count;
+	bool ret = m_interrupted;
+	if (m_interrupted_count % 1000 == 0)
+	{
+		this->lock();
+		ret = this->is_shutdown();
+		m_interrupted = ret;
+		this->unlock();
+	}
+	return ret;
 }
 
-datalayer::region_iterator*
-datalayer :: indexer_thread :: play(const region_id& ri, const schema* sc)
+datalayer::region_iterator *
+datalayer :: indexer_thread :: play(const region_id &ri, const schema *sc)
 {
-    leveldb_db_ptr db = m_daemon->m_data.m_db;
-    leveldb_iterator_ptr iip;
-    leveldb::ReadOptions ro;
-    ro.fill_cache = false;
-    iip.reset(leveldb_snapshot_ptr(db, NULL), db->NewIterator(ro));
-    const index_encoding* ie = index_encoding::lookup(sc->attrs[0].type);
-    return new region_iterator(iip, ri, ie);
+	leveldb_db_ptr db = m_daemon->m_data.m_db;
+	leveldb_iterator_ptr iip;
+	leveldb::ReadOptions ro;
+	ro.fill_cache = false;
+	iip.reset(leveldb_snapshot_ptr(db, NULL), db->NewIterator(ro));
+	const index_encoding *ie = index_encoding::lookup(sc->attrs[0].type);
+	return new region_iterator(iip, ri, ie);
 }
 
-datalayer::replay_iterator*
-datalayer :: indexer_thread :: replay(const region_id& ri, const std::string& timestamp)
+datalayer::replay_iterator *
+datalayer :: indexer_thread :: replay(const region_id &ri, const std::string &timestamp)
 {
-    leveldb::ReplayIterator* riip;
-    leveldb::Status st = m_daemon->m_data.m_db->GetReplayIterator(timestamp, &riip);
-
-    if (!st.ok())
-    {
-        LOG(ERROR) << "error indexing: LevelDB corruption: invalid timestamp";
-        return NULL;
-    }
-
-    leveldb_replay_iterator_ptr ptr(m_daemon->m_data.m_db, riip);
-    const schema& sc(*m_daemon->m_config.get_schema(ri));
-    return new replay_iterator(ri, ptr, index_encoding::lookup(sc.attrs[0].type));
+	leveldb::ReplayIterator *riip;
+	leveldb::Status st = m_daemon->m_data.m_db->GetReplayIterator(timestamp, &riip);
+	if (!st.ok())
+	{
+		LOG(ERROR) << "error indexing: LevelDB corruption: invalid timestamp";
+		return NULL;
+	}
+	leveldb_replay_iterator_ptr ptr(m_daemon->m_data.m_db, riip);
+	const schema &sc(*m_daemon->m_config.get_schema(ri));
+	return new replay_iterator(ri, ptr, index_encoding::lookup(sc.attrs[0].type));
 }
 
 bool
-datalayer :: indexer_thread :: wipe(const region_id& ri, const index_id& ii)
+datalayer :: indexer_thread :: wipe(const region_id &ri, const index_id &ii)
 {
-    return wipe_common('I', ri, ii) && wipe_common('i', ri, ii);
+	return wipe_common('I', ri, ii) && wipe_common('i', ri, ii);
 }
 
 bool
-datalayer :: indexer_thread :: wipe_common(uint8_t c, const region_id& ri, const index_id& ii)
+datalayer :: indexer_thread :: wipe_common(uint8_t c, const region_id &ri, const index_id &ii)
 {
-    std::auto_ptr<leveldb::Iterator> it;
-    it.reset(m_daemon->m_data.m_db->NewIterator(leveldb::ReadOptions()));
-    char backing[sizeof(uint8_t) + 2 * VARINT_64_MAX_SIZE];
-    char* ptr = backing;
-    ptr = e::pack8be(c, ptr);
-    ptr = e::packvarint64(ri.get(), ptr);
-    ptr = e::packvarint64(ii.get(), ptr);
-    leveldb::Slice prefix(backing, ptr - backing);
-    it->Seek(prefix);
-
-    while (it->key().starts_with(prefix))
-    {
-        if (interrupted())
-        {
-            return false;
-        }
-
-        m_daemon->m_data.m_db->Delete(leveldb::WriteOptions(), it->key());
-        it->Next();
-    }
-
-    return true;
+	std::auto_ptr<leveldb::Iterator> it;
+	it.reset(m_daemon->m_data.m_db->NewIterator(leveldb::ReadOptions()));
+	char backing[sizeof(uint8_t) + 2 * VARINT_64_MAX_SIZE];
+	char *ptr = backing;
+	ptr = e::pack8be(c, ptr);
+	ptr = e::packvarint64(ri.get(), ptr);
+	ptr = e::packvarint64(ii.get(), ptr);
+	leveldb::Slice prefix(backing, ptr - backing);
+	it->Seek(prefix);
+	while (it->key().starts_with(prefix))
+	{
+		if (interrupted())
+		{
+			return false;
+		}
+		m_daemon->m_data.m_db->Delete(leveldb::WriteOptions(), it->key());
+		it->Next();
+	}
+	return true;
 }
 
 bool
-datalayer :: indexer_thread :: index_from_iterator(region_iterator* it,
-                                                   const schema* sc,
-                                                   const region_id& ri,
-                                                   const std::vector<const index*>& idxs)
+datalayer :: indexer_thread :: index_from_iterator(region_iterator *it,
+        const schema *sc,
+        const region_id &ri,
+        const std::vector<const index *> &idxs)
 {
-    if (interrupted())
-    {
-        return false;
-    }
-
-    e::slice key;
-    std::vector<e::slice> value;
-    uint64_t version;
-    datalayer::reference ref;
-    datalayer::returncode rc;
-    rc = m_daemon->m_data.get_from_iterator(ri, *sc, it,
-            &key, &value, &version, &ref);
-
-    if (rc != SUCCESS)
-    {
-        LOG(ERROR) << "error indexing: " << rc;
-        return false;
-    }
-
-    leveldb::WriteBatch batch;
-    create_index_changes(*sc, ri, idxs, key, NULL, &value, &batch);
-
-    leveldb::WriteOptions opts;
-    opts.sync = false;
-    leveldb::Status st = m_daemon->m_data.m_db->Write(opts, &batch);
-
-    if (!st.ok())
-    {
-        rc = m_daemon->m_data.handle_error(st);
-        LOG(ERROR) << "error indexing: " << rc;
-        return false;
-    }
-
-    return true;
+	if (interrupted())
+	{
+		return false;
+	}
+	e::slice key;
+	std::vector<e::slice> value;
+	uint64_t version;
+	datalayer::reference ref;
+	datalayer::returncode rc;
+	rc = m_daemon->m_data.get_from_iterator(ri, *sc, it,
+	                                        &key, &value, &version, &ref);
+	if (rc != SUCCESS)
+	{
+		LOG(ERROR) << "error indexing: " << rc;
+		return false;
+	}
+	leveldb::WriteBatch batch;
+	create_index_changes(*sc, ri, idxs, key, NULL, &value, &batch);
+	leveldb::WriteOptions opts;
+	opts.sync = false;
+	leveldb::Status st = m_daemon->m_data.m_db->Write(opts, &batch);
+	if (!st.ok())
+	{
+		rc = m_daemon->m_data.handle_error(st);
+		LOG(ERROR) << "error indexing: " << rc;
+		return false;
+	}
+	return true;
 }
 
 bool
-datalayer :: indexer_thread :: index_from_replay_iterator(replay_iterator* rit,
-                                                          const schema* sc,
-                                                          const region_id& ri,
-                                                          const std::vector<const index*>& idxs)
+datalayer :: indexer_thread :: index_from_replay_iterator(replay_iterator *rit,
+        const schema *sc,
+        const region_id &ri,
+        const std::vector<const index *> &idxs)
 {
-    if (interrupted())
-    {
-        return false;
-    }
-
-    e::slice key = rit->key();
-    std::vector<e::slice> _value;
-    uint64_t version;
-    datalayer::reference ref1;
-    datalayer::returncode rc;
-    std::vector<e::slice>* old_value = NULL;
-    std::vector<e::slice>* new_value = NULL;
-
-    if (rit->has_value())
-    {
-        rc = rit->unpack_value(&_value, &version, &ref1);
-
-        if (rc != SUCCESS)
-        {
-            LOG(ERROR) << "error indexing: " << rc;
-            return false;
-        }
-
-        new_value = &_value;
-    }
-    else
-    {
-        new_value = NULL;
-    }
-
-    // perform the read
-    std::vector<char> scratch;
-    leveldb::Slice lkey;
-    encode_key(ri, sc->attrs[0].type, key, &scratch, &lkey);
-    std::string ref2;
-    leveldb::ReadOptions opts;
-    opts.verify_checksums = true;
-    leveldb::Status st = m_daemon->m_data.m_db->Get(opts, lkey, &ref2);
-    std::vector<e::slice> _old_value;
-
-    if (st.ok())
-    {
-        uint64_t old_version;
-        rc = decode_value(e::slice(ref2.data(), ref2.size()),
-                          &_old_value, &old_version);
-
-        if (rc != SUCCESS)
-        {
-            rc = m_daemon->m_data.handle_error(st);
-            LOG(ERROR) << "error indexing: " << rc;
-            return false;
-        }
-
-        if (_old_value.size() + 1 != sc->attrs_sz)
-        {
-            LOG(ERROR) << "error indexing: " << BAD_ENCODING;
-            return false;
-        }
-
-        old_value = &_old_value;
-    }
-    else if (st.IsNotFound())
-    {
-        old_value = NULL;
-    }
-    else
-    {
-        rc = m_daemon->m_data.handle_error(st);
-        LOG(ERROR) << "error indexing: " << rc;
-        return false;
-    }
-
-    leveldb::WriteBatch batch;
-    create_index_changes(*sc, ri, idxs, key, old_value, new_value, &batch);
-    leveldb::WriteOptions wopts;
-    wopts.sync = false;
-    st = m_daemon->m_data.m_db->Write(wopts, &batch);
-
-    if (!st.ok())
-    {
-        rc = m_daemon->m_data.handle_error(st);
-        LOG(ERROR) << "error indexing: " << rc;
-        return false;
-    }
-
-    return true;
+	if (interrupted())
+	{
+		return false;
+	}
+	e::slice key = rit->key();
+	std::vector<e::slice> _value;
+	uint64_t version;
+	datalayer::reference ref1;
+	datalayer::returncode rc;
+	std::vector<e::slice> *old_value = NULL;
+	std::vector<e::slice> *new_value = NULL;
+	if (rit->has_value())
+	{
+		rc = rit->unpack_value(&_value, &version, &ref1);
+		if (rc != SUCCESS)
+		{
+			LOG(ERROR) << "error indexing: " << rc;
+			return false;
+		}
+		new_value = &_value;
+	}
+	else
+	{
+		new_value = NULL;
+	}
+	// perform the read
+	std::vector<char> scratch;
+	leveldb::Slice lkey;
+	encode_key(ri, sc->attrs[0].type, key, &scratch, &lkey);
+	std::string ref2;
+	leveldb::ReadOptions opts;
+	opts.verify_checksums = true;
+	leveldb::Status st = m_daemon->m_data.m_db->Get(opts, lkey, &ref2);
+	std::vector<e::slice> _old_value;
+	if (st.ok())
+	{
+		uint64_t old_version;
+		rc = decode_value(e::slice(ref2.data(), ref2.size()),
+		                  &_old_value, &old_version);
+		if (rc != SUCCESS)
+		{
+			rc = m_daemon->m_data.handle_error(st);
+			LOG(ERROR) << "error indexing: " << rc;
+			return false;
+		}
+		if (_old_value.size() + 1 != sc->attrs_sz)
+		{
+			LOG(ERROR) << "error indexing: " << BAD_ENCODING;
+			return false;
+		}
+		old_value = &_old_value;
+	}
+	else if (st.IsNotFound())
+	{
+		old_value = NULL;
+	}
+	else
+	{
+		rc = m_daemon->m_data.handle_error(st);
+		LOG(ERROR) << "error indexing: " << rc;
+		return false;
+	}
+	leveldb::WriteBatch batch;
+	create_index_changes(*sc, ri, idxs, key, old_value, new_value, &batch);
+	leveldb::WriteOptions wopts;
+	wopts.sync = false;
+	st = m_daemon->m_data.m_db->Write(wopts, &batch);
+	if (!st.ok())
+	{
+		rc = m_daemon->m_data.handle_error(st);
+		LOG(ERROR) << "error indexing: " << rc;
+		return false;
+	}
+	return true;
 }
diff --git a/daemon/datalayer_indexer_thread.h b/daemon/datalayer_indexer_thread.h
index 3e79f47ac..8e054801a 100644
--- a/daemon/datalayer_indexer_thread.h
+++ b/daemon/datalayer_indexer_thread.h
@@ -39,50 +39,50 @@
 
 class hyperdex::datalayer::indexer_thread : public hyperdex::background_thread
 {
-    public:
-        indexer_thread(daemon* d, wiper_indexer_mediator* m);
-        ~indexer_thread() throw ();
+public:
+	indexer_thread(daemon *d, wiper_indexer_mediator *m);
+	~indexer_thread() throw ();
 
-    public:
-        virtual const char* thread_name();
-        virtual bool have_work();
-        virtual void copy_work();
-        virtual void do_work();
+public:
+	virtual const char *thread_name();
+	virtual bool have_work();
+	virtual void copy_work();
+	virtual void do_work();
 
-    public:
-        void debug_dump();
-        void kick();
-        bool mark_usable(const region_id& ri, const index_id& ii);
+public:
+	void debug_dump();
+	void kick();
+	bool mark_usable(const region_id &ri, const index_id &ii);
 
-    private:
-        bool interrupted();
-        region_iterator* play(const region_id& ri, const schema* sc);
-        replay_iterator* replay(const region_id& ri,
-                                const std::string& timestamp);
-        bool wipe(const region_id& ri, const index_id& ii);
-        bool wipe_common(uint8_t c, const region_id& ri, const index_id& ii);
-        bool index_from_iterator(region_iterator* it,
-                                 const schema* sc,
-                                 const region_id& ri,
-                                 const std::vector<const index*>& idxs);
-        bool index_from_replay_iterator(replay_iterator* rit,
-                                        const schema* sc,
-                                        const region_id& ri,
-                                        const std::vector<const index*>& idxs);
+private:
+	bool interrupted();
+	region_iterator *play(const region_id &ri, const schema *sc);
+	replay_iterator *replay(const region_id &ri,
+	                        const std::string &timestamp);
+	bool wipe(const region_id &ri, const index_id &ii);
+	bool wipe_common(uint8_t c, const region_id &ri, const index_id &ii);
+	bool index_from_iterator(region_iterator *it,
+	                         const schema *sc,
+	                         const region_id &ri,
+	                         const std::vector<const index *> &idxs);
+	bool index_from_replay_iterator(replay_iterator *rit,
+	                                const schema *sc,
+	                                const region_id &ri,
+	                                const std::vector<const index *> &idxs);
 
-    private:
-        daemon* m_daemon;
-        wiper_indexer_mediator* m_mediator;
-        configuration m_config;
-        bool m_have_current;
-        region_id m_current_region;
-        index_id m_current_index;
-        uint64_t m_interrupted_count;
-        bool m_interrupted;
+private:
+	daemon *m_daemon;
+	wiper_indexer_mediator *m_mediator;
+	configuration m_config;
+	bool m_have_current;
+	region_id m_current_region;
+	index_id m_current_index;
+	uint64_t m_interrupted_count;
+	bool m_interrupted;
 
-    private:
-        indexer_thread(const indexer_thread&);
-        indexer_thread& operator = (const indexer_thread&);
+private:
+	indexer_thread(const indexer_thread &);
+	indexer_thread &operator = (const indexer_thread &);
 };
 
 #endif // hyperdex_daemon_datalayer_indexer_h_
diff --git a/daemon/datalayer_iterator.cc b/daemon/datalayer_iterator.cc
index 95ec0a3e4..e6867abc8 100644
--- a/daemon/datalayer_iterator.cc
+++ b/daemon/datalayer_iterator.cc
@@ -39,33 +39,29 @@
 using hyperdex::datalayer;
 using hyperdex::leveldb_snapshot_ptr;
 
-inline leveldb::Slice e2level(const e::slice& s) { return leveldb::Slice(reinterpret_cast<const char*>(s.data()), s.size()); }
-inline e::slice level2e(const leveldb::Slice& s) { return e::slice(s.data(), s.size()); }
+inline leveldb::Slice e2level(const e::slice &s) { return leveldb::Slice(reinterpret_cast<const char *>(s.data()), s.size()); }
+inline e::slice level2e(const leveldb::Slice &s) { return e::slice(s.data(), s.size()); }
 
 namespace
 {
 
 int
-internal_key_compare(const e::slice& lhs, const e::slice& rhs)
-{
-    int cmp = memcmp(lhs.data(), rhs.data(), std::min(lhs.size(), rhs.size()));
-
-    if (cmp == 0)
-    {
-        if (lhs.size() < rhs.size())
-        {
-            return -1;
-        }
-
-        if (lhs.size() > rhs.size())
-        {
-            return 1;
-        }
-
-        return 0;
-    }
-
-    return cmp;
+internal_key_compare(const e::slice &lhs, const e::slice &rhs)
+{
+	int cmp = memcmp(lhs.data(), rhs.data(), std::min(lhs.size(), rhs.size()));
+	if (cmp == 0)
+	{
+		if (lhs.size() < rhs.size())
+		{
+			return -1;
+		}
+		if (lhs.size() > rhs.size())
+		{
+			return 1;
+		}
+		return 0;
+	}
+	return cmp;
 }
 
 } // namespace
@@ -73,15 +69,15 @@ internal_key_compare(const e::slice& lhs, const e::slice& rhs)
 //////////////////////////////// class iterator ////////////////////////////////
 
 datalayer :: iterator :: iterator(leveldb_snapshot_ptr s)
-    : m_ref(0)
-    , m_snap(s)
+	: m_ref(0)
+	, m_snap(s)
 {
 }
 
 leveldb_snapshot_ptr
 datalayer :: iterator :: snap()
 {
-    return m_snap;
+	return m_snap;
 }
 
 datalayer :: iterator :: ~iterator() throw ()
@@ -90,101 +86,97 @@ datalayer :: iterator :: ~iterator() throw ()
 
 ///////////////////////////// class replay_iterator ////////////////////////////
 
-datalayer :: replay_iterator :: replay_iterator(const region_id& ri,
+datalayer :: replay_iterator :: replay_iterator(const region_id &ri,
                                                 leveldb_replay_iterator_ptr ptr,
-                                                const index_encoding* ie)
-    : m_ri(ri)
-    , m_iter(ptr.get())
-    , m_ptr(ptr)
-    , m_decoded()
-    , m_ie(ie)
+                                                const index_encoding *ie)
+	: m_ri(ri)
+	, m_iter(ptr.get())
+	, m_ptr(ptr)
+	, m_decoded()
+	, m_ie(ie)
 {
 }
 
 bool
 datalayer :: replay_iterator :: valid()
 {
-    char buf[sizeof(uint8_t) + VARINT_64_MAX_SIZE];
-    char* ptr = buf;
-    ptr = e::pack8be('o', ptr);
-    ptr = e::packvarint64(m_ri.get(), ptr);
-    leveldb::Slice prefix(buf, ptr - buf);
-
-    while (m_iter->Valid())
-    {
-        if (m_iter->key().starts_with(prefix))
-        {
-            return true;
-        }
-        else if (m_iter->key().compare(prefix) < 0)
-        {
-            m_iter->SkipTo(prefix);
-        }
-        else
-        {
-            m_iter->SkipToLast();
-        }
-    }
-
-    return false;
+	char buf[sizeof(uint8_t) + VARINT_64_MAX_SIZE];
+	char *ptr = buf;
+	ptr = e::pack8be('o', ptr);
+	ptr = e::packvarint64(m_ri.get(), ptr);
+	leveldb::Slice prefix(buf, ptr - buf);
+	while (m_iter->Valid())
+	{
+		if (m_iter->key().starts_with(prefix))
+		{
+			return true;
+		}
+		else if (m_iter->key().compare(prefix) < 0)
+		{
+			m_iter->SkipTo(prefix);
+		}
+		else
+		{
+			m_iter->SkipToLast();
+		}
+	}
+	return false;
 }
 
 void
 datalayer :: replay_iterator :: next()
 {
-    m_iter->Next();
+	m_iter->Next();
 }
 
 bool
 datalayer :: replay_iterator :: has_value()
 {
-    return m_iter->HasValue();
+	return m_iter->HasValue();
 }
 
 e::slice
 datalayer :: replay_iterator :: key()
 {
-    const size_t sz = object_prefix_sz(m_ri);
-    leveldb::Slice _k = m_iter->key();
-    e::slice k = e::slice(_k.data() + sz, _k.size() - sz);
-    size_t decoded_sz = m_ie->decoded_size(k);
-
-    if (m_decoded.size() < decoded_sz)
-    {
-        m_decoded.resize(decoded_sz);
-    }
-
-    m_ie->decode(k, &m_decoded.front());
-    return e::slice(&m_decoded.front(), decoded_sz);
+	const size_t sz = object_prefix_sz(m_ri);
+	leveldb::Slice _k = m_iter->key();
+	e::slice k = e::slice(_k.data() + sz, _k.size() - sz);
+	size_t decoded_sz = m_ie->decoded_size(k);
+	if (m_decoded.size() < decoded_sz)
+	{
+		m_decoded.resize(decoded_sz);
+	}
+	m_ie->decode(k, &m_decoded.front());
+	return e::slice(&m_decoded.front(), decoded_sz);
 }
 
 datalayer::returncode
-datalayer :: replay_iterator :: unpack_value(std::vector<e::slice>* value,
-                                             uint64_t* version,
-                                             reference* ref)
+datalayer :: replay_iterator :: unpack_value(std::vector<e::slice> *value,
+                                             uint64_t *version,
+                                             reference *ref)
 {
-    ref->m_backing.assign(m_iter->value().data(), m_iter->value().size());
-    e::slice v(ref->m_backing.data(), ref->m_backing.size());
-    return decode_value(v, value, version);
+	ref->m_backing.assign(m_iter->value().data(), m_iter->value().size());
+	e::slice v(ref->m_backing.data(), ref->m_backing.size());
+	return decode_value(v, value, version);
 }
 
 leveldb::Status
 datalayer :: replay_iterator :: status()
 {
-    return m_iter->status();
+	return m_iter->status();
 }
 
 ///////////////////////////// class dummy_iterator /////////////////////////////
 
 datalayer :: dummy_iterator :: dummy_iterator()
-    : iterator(leveldb_snapshot_ptr())
+	: iterator(leveldb_snapshot_ptr())
 {
 }
 
 bool
 datalayer :: dummy_iterator :: valid()
 {
-    return false;
+	return false;
 }
 
 void
@@ -193,21 +185,21 @@ datalayer :: dummy_iterator :: next()
 }
 
 uint64_t
-datalayer :: dummy_iterator :: cost(leveldb::DB*)
+datalayer :: dummy_iterator :: cost(leveldb::DB *)
 {
-    return 0;
+	return 0;
 }
 
 e::slice
 datalayer :: dummy_iterator :: key()
 {
-    return e::slice();
+	return e::slice();
 }
 
-std::ostream&
-datalayer :: dummy_iterator :: describe(std::ostream& out) const
+std::ostream &
+datalayer :: dummy_iterator :: describe(std::ostream &out) const
 {
-    return out << "dummy_iterator()";
+	return out << "dummy_iterator()";
 }
 
 datalayer :: dummy_iterator :: ~dummy_iterator() throw ()
@@ -217,111 +209,103 @@ datalayer :: dummy_iterator :: ~dummy_iterator() throw ()
 ///////////////////////////// class region_iterator ////////////////////////////
 
 datalayer :: region_iterator :: region_iterator(leveldb_iterator_ptr iter,
-                                                const region_id& ri,
-                                                const index_encoding* ie)
-    : iterator(iter.snap())
-    , m_iter(iter)
-    , m_ri(ri)
-    , m_decoded()
-    , m_ie(ie)
+                                                const region_id &ri,
+                                                const index_encoding *ie)
+	: iterator(iter.snap())
+	, m_iter(iter)
+	, m_ri(ri)
+	, m_decoded()
+	, m_ie(ie)
 {
-    char buf[sizeof(uint8_t) + VARINT_64_MAX_SIZE];
-    char* ptr = buf;
-    ptr = e::pack8be('o', ptr);
-    ptr = e::packvarint64(ri.get(), ptr);
-    m_iter->Seek(leveldb::Slice(buf, ptr - buf));
+	char buf[sizeof(uint8_t) + VARINT_64_MAX_SIZE];
+	char *ptr = buf;
+	ptr = e::pack8be('o', ptr);
+	ptr = e::packvarint64(ri.get(), ptr);
+	m_iter->Seek(leveldb::Slice(buf, ptr - buf));
 }
 
 datalayer :: region_iterator :: ~region_iterator() throw ()
 {
 }
 
-std::ostream&
-datalayer :: region_iterator :: describe(std::ostream& out) const
+std::ostream &
+datalayer :: region_iterator :: describe(std::ostream &out) const
 {
-    return out << "region_iterator(" << m_ri << ")";
+	return out << "region_iterator(" << m_ri << ")";
 }
 
 bool
 datalayer :: region_iterator :: valid()
 {
-    if (!m_iter->Valid())
-    {
-        return false;
-    }
-
-    leveldb::Slice k = m_iter->key();
-
-    if (k.size() < 2 || k.data()[0] != 'o')
-    {
-        return false;
-    }
-
-    uint64_t ri;
-
-    if (!e::varint64_decode(k.data() + sizeof(uint8_t), k.data() + k.size(), &ri))
-    {
-        return false;
-    }
-
-    return region_id(ri) == m_ri;
+	if (!m_iter->Valid())
+	{
+		return false;
+	}
+	leveldb::Slice k = m_iter->key();
+	if (k.size() < 2 || k.data()[0] != 'o')
+	{
+		return false;
+	}
+	uint64_t ri;
+	if (!e::varint64_decode(k.data() + sizeof(uint8_t), k.data() + k.size(), &ri))
+	{
+		return false;
+	}
+	return region_id(ri) == m_ri;
 }
 
 void
 datalayer :: region_iterator :: next()
 {
-    m_iter->Next();
+	m_iter->Next();
 }
 
 uint64_t
-datalayer :: region_iterator :: cost(leveldb::DB* db)
-{
-    const size_t sz = object_prefix_sz(m_ri);
-    char buf[2 * (sizeof(uint8_t) + VARINT_64_MAX_SIZE)];
-    char* ptr = buf;
-    ptr = encode_object_prefix(m_ri, ptr);
-    assert(ptr == buf + sz);
-    ptr = encode_object_prefix(m_ri, ptr);
-    assert(ptr == buf + sz + sz);
-    encode_bump(buf + sz, buf + 2 * sz);
-    // create the range
-    leveldb::Range r;
-    r.start = leveldb::Slice(buf, sz);
-    r.limit = leveldb::Slice(buf + sz, sz);
-    // ask leveldb for the size of the range
-    uint64_t ret;
-    db->GetApproximateSizes(&r, 1, &ret);
-    return ret;
+datalayer :: region_iterator :: cost(leveldb::DB *db)
+{
+	const size_t sz = object_prefix_sz(m_ri);
+	char buf[2 * (sizeof(uint8_t) + VARINT_64_MAX_SIZE)];
+	char *ptr = buf;
+	ptr = encode_object_prefix(m_ri, ptr);
+	assert(ptr == buf + sz);
+	ptr = encode_object_prefix(m_ri, ptr);
+	assert(ptr == buf + sz + sz);
+	encode_bump(buf + sz, buf + 2 * sz);
+	// create the range
+	leveldb::Range r;
+	r.start = leveldb::Slice(buf, sz);
+	r.limit = leveldb::Slice(buf + sz, sz);
+	// ask leveldb for the size of the range
+	uint64_t ret;
+	db->GetApproximateSizes(&r, 1, &ret);
+	return ret;
 }
 
 e::slice
 datalayer :: region_iterator :: key()
 {
-    // first pull out the internal key
-    leveldb::Slice _k = m_iter->key();
-    const char* end = _k.data() + _k.size();
-    const char* ptr = _k.data() + sizeof(uint8_t);
-    uint64_t region;
-    ptr = e::varint64_decode(ptr, end, &region);
-    assert(ptr);
-
-    // now convert that into its decoded form
-    e::slice k = e::slice(ptr, end - ptr);
-    size_t decoded_sz = m_ie->decoded_size(k);
-
-    if (m_decoded.size() < decoded_sz)
-    {
-        m_decoded.resize(decoded_sz);
-    }
-
-    m_ie->decode(k, &m_decoded.front());
-    return e::slice(&m_decoded.front(), decoded_sz);
+	// first pull out the internal key
+	leveldb::Slice _k = m_iter->key();
+	const char *end = _k.data() + _k.size();
+	const char *ptr = _k.data() + sizeof(uint8_t);
+	uint64_t region;
+	ptr = e::varint64_decode(ptr, end, &region);
+	assert(ptr);
+	// now convert that into its decoded form
+	e::slice k = e::slice(ptr, end - ptr);
+	size_t decoded_sz = m_ie->decoded_size(k);
+	if (m_decoded.size() < decoded_sz)
+	{
+		m_decoded.resize(decoded_sz);
+	}
+	m_ie->decode(k, &m_decoded.front());
+	return e::slice(&m_decoded.front(), decoded_sz);
 }
 
 ///////////////////////////// class index_iterator /////////////////////////////
 
 datalayer :: index_iterator :: index_iterator(leveldb_snapshot_ptr s)
-    : iterator(s)
+	: iterator(s)
 {
 }
 
@@ -332,58 +316,54 @@ datalayer :: index_iterator :: ~index_iterator() throw ()
 ////////////////////////// class range_index_iterator //////////////////////////
 
 datalayer :: range_index_iterator :: range_index_iterator(leveldb_snapshot_ptr s,
-                                                          size_t prefix_sz,
-                                                          const e::slice& range_lower,
-                                                          const e::slice& range_upper,
-                                                          bool has_lower,
-                                                          bool has_upper,
-                                                          const index_encoding* val_ie,
-                                                          const index_encoding* key_ie)
-    : index_iterator(s)
-    , m_iter()
-    , m_val_ie(val_ie)
-    , m_key_ie(key_ie)
-    , m_prefix()
-    , m_range_lower()
-    , m_range_upper()
-    , m_value_lower()
-    , m_value_upper()
-    , m_range_buf(range_lower.size() + range_upper.size())
-    , m_scratch()
-    , m_has_lower(has_lower)
-    , m_has_upper(has_upper)
-    , m_invalid(false)
-{
-    // setup the iterator
-    leveldb::ReadOptions opts;
-    opts.fill_cache = true;
-    opts.verify_checksums = true;
-    opts.snapshot = s.get();
-    m_iter.reset(s, s.db()->NewIterator(opts));
-
-    // copy the lower/upper into our buffer
-    memmove(&m_range_buf[0], range_lower.data(), range_lower.size());
-    memmove(&m_range_buf[0] + range_lower.size(), range_upper.data(), range_upper.size());
-    m_range_lower = e::slice(&m_range_buf[0], range_lower.size());
-    m_range_upper = e::slice(&m_range_buf[0] + range_lower.size(), range_upper.size());
-    assert(m_range_lower.size() >= prefix_sz);
-    assert(m_range_upper.size() >= prefix_sz);
-    assert(memcmp(m_range_lower.data(), m_range_upper.data(), prefix_sz) == 0);
-    m_prefix = e::slice(m_range_lower.data(), prefix_sz);
-
-    // pull the value lower/upper
-    if (m_has_lower)
-    {
-        m_invalid = !decode_entry_keyless(m_range_lower, &m_value_lower) || m_invalid;
-    }
-
-    // pull the value lower/upper
-    if (m_has_upper)
-    {
-        m_invalid = !decode_entry_keyless(m_range_upper, &m_value_upper) || m_invalid;
-    }
-
-    m_iter->Seek(e2level(m_range_lower));
+        size_t prefix_sz,
+        const e::slice &range_lower,
+        const e::slice &range_upper,
+        bool has_lower,
+        bool has_upper,
+        const index_encoding *val_ie,
+        const index_encoding *key_ie)
+	: index_iterator(s)
+	, m_iter()
+	, m_val_ie(val_ie)
+	, m_key_ie(key_ie)
+	, m_prefix()
+	, m_range_lower()
+	, m_range_upper()
+	, m_value_lower()
+	, m_value_upper()
+	, m_range_buf(range_lower.size() + range_upper.size())
+	, m_scratch()
+	, m_has_lower(has_lower)
+	, m_has_upper(has_upper)
+	, m_invalid(false)
+{
+	// setup the iterator
+	leveldb::ReadOptions opts;
+	opts.fill_cache = true;
+	opts.verify_checksums = true;
+	opts.snapshot = s.get();
+	m_iter.reset(s, s.db()->NewIterator(opts));
+	// copy the lower/upper into our buffer
+	memmove(&m_range_buf[0], range_lower.data(), range_lower.size());
+	memmove(&m_range_buf[0] + range_lower.size(), range_upper.data(), range_upper.size());
+	m_range_lower = e::slice(&m_range_buf[0], range_lower.size());
+	m_range_upper = e::slice(&m_range_buf[0] + range_lower.size(), range_upper.size());
+	assert(m_range_lower.size() >= prefix_sz);
+	assert(m_range_upper.size() >= prefix_sz);
+	assert(memcmp(m_range_lower.data(), m_range_upper.data(), prefix_sz) == 0);
+	m_prefix = e::slice(m_range_lower.data(), prefix_sz);
+	// pull the value lower/upper
+	if (m_has_lower)
+	{
+		m_invalid = !decode_entry_keyless(m_range_lower, &m_value_lower) || m_invalid;
+	}
+	// pull the value lower/upper
+	if (m_has_upper)
+	{
+		m_invalid = !decode_entry_keyless(m_range_upper, &m_value_upper) || m_invalid;
+	}
+	m_iter->Seek(e2level(m_range_lower));
 }
 
 datalayer :: range_index_iterator :: ~range_index_iterator() throw ()
@@ -393,274 +373,244 @@ datalayer :: range_index_iterator :: ~range_index_iterator() throw ()
 bool
 datalayer :: range_index_iterator :: valid()
 {
-    while (!m_invalid && m_iter->Valid())
-    {
-        if (!m_iter->key().starts_with(e2level(m_prefix)))
-        {
-            m_invalid = true;
-            return false;
-        }
-
-        e::slice current = level2e(m_iter->key());
-        e::slice iv;
-        e::slice ik;
-
-        if (!decode_entry(current, &iv, &ik))
-        {
-            m_invalid = true;
-            return false;
-        }
-
-        size_t sz = std::min(m_range_upper.size(), current.size());
-
-        if (m_has_upper && memcmp(m_range_upper.data(), current.data(), sz) < 0)
-        {
-            m_invalid = true;
-            return false;
-        }
-
-        if (m_has_lower && internal_key_compare(m_value_lower, iv) > 0)
-        {
-            m_iter->Next();
-            continue;
-        }
-
-        if (m_has_upper && internal_key_compare(m_value_upper, iv) < 0)
-        {
-            m_iter->Next();
-            continue;
-        }
-
-        return true;
-    }
-
-    return false;
+	while (!m_invalid && m_iter->Valid())
+	{
+		if (!m_iter->key().starts_with(e2level(m_prefix)))
+		{
+			m_invalid = true;
+			return false;
+		}
+		e::slice current = level2e(m_iter->key());
+		e::slice iv;
+		e::slice ik;
+		if (!decode_entry(current, &iv, &ik))
+		{
+			m_invalid = true;
+			return false;
+		}
+		size_t sz = std::min(m_range_upper.size(), current.size());
+		if (m_has_upper && memcmp(m_range_upper.data(), current.data(), sz) < 0)
+		{
+			m_invalid = true;
+			return false;
+		}
+		if (m_has_lower && internal_key_compare(m_value_lower, iv) > 0)
+		{
+			m_iter->Next();
+			continue;
+		}
+		if (m_has_upper && internal_key_compare(m_value_upper, iv) < 0)
+		{
+			m_iter->Next();
+			continue;
+		}
+		return true;
+	}
+	return false;
 }
 
 void
 datalayer :: range_index_iterator :: next()
 {
-    m_iter->Next();
+	m_iter->Next();
 }
 
 uint64_t
-datalayer :: range_index_iterator :: cost(leveldb::DB* db)
-{
-    if (m_scratch.size() < m_range_upper.size())
-    {
-        m_scratch.resize(m_range_upper.size());
-    }
-
-    memmove(&m_scratch[0], m_range_upper.data(), m_range_upper.size());
-    hyperdex::encode_bump(&m_scratch[0], &m_scratch[0] + m_range_upper.size());
-    // create the range
-    leveldb::Range r;
-    r.start = m_iter->key();
-    r.limit = leveldb::Slice(&m_scratch[0], m_range_upper.size());
-    // ask leveldb for the size of the range
-    uint64_t ret;
-    db->GetApproximateSizes(&r, 1, &ret);
-    return ret;
+datalayer :: range_index_iterator :: cost(leveldb::DB *db)
+{
+	if (m_scratch.size() < m_range_upper.size())
+	{
+		m_scratch.resize(m_range_upper.size());
+	}
+	memmove(&m_scratch[0], m_range_upper.data(), m_range_upper.size());
+	hyperdex::encode_bump(&m_scratch[0], &m_scratch[0] + m_range_upper.size());
+	// create the range
+	leveldb::Range r;
+	r.start = m_iter->key();
+	r.limit = leveldb::Slice(&m_scratch[0], m_range_upper.size());
+	// ask leveldb for the size of the range
+	uint64_t ret;
+	db->GetApproximateSizes(&r, 1, &ret);
+	return ret;
 }
 
 e::slice
 datalayer :: range_index_iterator :: key()
 {
-    e::slice ik = this->internal_key();
-    size_t decoded_sz = m_key_ie->decoded_size(ik);
-
-    if (m_scratch.size() < decoded_sz)
-    {
-        m_scratch.resize(decoded_sz);
-    }
-
-    m_key_ie->decode(ik, &m_scratch.front());
-    return e::slice(&m_scratch.front(), decoded_sz);
+	e::slice ik = this->internal_key();
+	size_t decoded_sz = m_key_ie->decoded_size(ik);
+	if (m_scratch.size() < decoded_sz)
+	{
+		m_scratch.resize(decoded_sz);
+	}
+	m_key_ie->decode(ik, &m_scratch.front());
+	return e::slice(&m_scratch.front(), decoded_sz);
 }
 
-std::ostream&
-datalayer :: range_index_iterator :: describe(std::ostream& out) const
+std::ostream &
+datalayer :: range_index_iterator :: describe(std::ostream &out) const
 {
-    return out << "range_iterator()";
+	return out << "range_iterator()";
 }
 
 e::slice
 datalayer :: range_index_iterator :: internal_key()
 {
-    leveldb::Slice in = m_iter->key();
-    e::slice v;
-    e::slice k;
-    decode_entry(level2e(in), &v, &k);
-    return k;
+	leveldb::Slice in = m_iter->key();
+	e::slice v;
+	e::slice k;
+	decode_entry(level2e(in), &v, &k);
+	return k;
 }
 
 bool
 datalayer :: range_index_iterator :: sorted()
 {
-    return m_has_lower && m_has_upper && m_value_lower == m_value_upper;
+	return m_has_lower && m_has_upper && m_value_lower == m_value_upper;
 }
 
 void
-datalayer :: range_index_iterator :: seek(const e::slice& ik)
+datalayer :: range_index_iterator :: seek(const e::slice &ik)
 {
-    leveldb::Slice in = m_iter->key();
-    e::slice v;
-    e::slice k;
-    decode_entry(level2e(in), &v, &k);
-    encode_entry(v, ik, &m_scratch, &k);
-    m_iter->Seek(e2level(k));
+	leveldb::Slice in = m_iter->key();
+	e::slice v;
+	e::slice k;
+	decode_entry(level2e(in), &v, &k);
+	encode_entry(v, ik, &m_scratch, &k);
+	m_iter->Seek(e2level(k));
 }
 
 bool
-datalayer :: range_index_iterator :: decode_entry(const e::slice& in, e::slice* v, e::slice* k)
-{
-    assert(in.starts_with(m_prefix));
-    const char* ptr = reinterpret_cast<const char*>(in.data());
-    const char* const end = ptr + in.size();
-    ptr += m_prefix.size();
-    size_t rem = end - ptr;
-
-    if (!m_val_ie)
-    {
-        *k = e::slice(ptr, rem);
-        *v = *k;
-    }
-    else if (m_val_ie->encoding_fixed())
-    {
-        size_t sz = m_val_ie->encoded_size(e::slice());
-
-        if (sz > rem)
-        {
-            return false;
-        }
-
-        *v = e::slice(ptr, sz);
-        *k = e::slice(ptr + sz, rem - sz);
-    }
-    else if (m_key_ie->encoding_fixed())
-    {
-        size_t sz = m_key_ie->encoded_size(e::slice());
-
-        if (sz > rem)
-        {
-            return false;
-        }
-
-        *v = e::slice(ptr, rem - sz);
-        *k = e::slice(ptr + rem - sz, sz);
-    }
-    else
-    {
-        if (rem < sizeof(uint32_t))
-        {
-            return false;
-        }
-
-        uint32_t k_sz;
-        e::unpack32be(end - sizeof(uint32_t), &k_sz);
-
-        if (k_sz + sizeof(uint32_t) > rem)
-        {
-            return false;
-        }
-
-        *v = e::slice(ptr, rem - sizeof(uint32_t) - k_sz);
-        *k = e::slice(ptr + v->size(), k_sz);
-    }
-
-    return true;
+datalayer :: range_index_iterator :: decode_entry(const e::slice &in, e::slice *v, e::slice *k)
+{
+	assert(in.starts_with(m_prefix));
+	const char *ptr = reinterpret_cast<const char *>(in.data());
+	const char *const end = ptr + in.size();
+	ptr += m_prefix.size();
+	size_t rem = end - ptr;
+	if (!m_val_ie)
+	{
+		*k = e::slice(ptr, rem);
+		*v = *k;
+	}
+	else if (m_val_ie->encoding_fixed())
+	{
+		size_t sz = m_val_ie->encoded_size(e::slice());
+		if (sz > rem)
+		{
+			return false;
+		}
+		*v = e::slice(ptr, sz);
+		*k = e::slice(ptr + sz, rem - sz);
+	}
+	else if (m_key_ie->encoding_fixed())
+	{
+		size_t sz = m_key_ie->encoded_size(e::slice());
+		if (sz > rem)
+		{
+			return false;
+		}
+		*v = e::slice(ptr, rem - sz);
+		*k = e::slice(ptr + rem - sz, sz);
+	}
+	else
+	{
+		if (rem < sizeof(uint32_t))
+		{
+			return false;
+		}
+		uint32_t k_sz;
+		e::unpack32be(end - sizeof(uint32_t), &k_sz);
+		if (k_sz + sizeof(uint32_t) > rem)
+		{
+			return false;
+		}
+		*v = e::slice(ptr, rem - sizeof(uint32_t) - k_sz);
+		*k = e::slice(ptr + v->size(), k_sz);
+	}
+	return true;
 }
 
 bool
-datalayer :: range_index_iterator :: decode_entry_keyless(const e::slice& in, e::slice* val)
+datalayer :: range_index_iterator :: decode_entry_keyless(const e::slice &in, e::slice *val)
 {
-    assert(in.starts_with(m_prefix));
-    *val = e::slice(in.data() + m_prefix.size(), in.size() - m_prefix.size());
-    return true;
+	assert(in.starts_with(m_prefix));
+	*val = e::slice(in.data() + m_prefix.size(), in.size() - m_prefix.size());
+	return true;
 }
 
 void
-datalayer :: range_index_iterator :: encode_entry(const e::slice& v,
-                                                  const e::slice& k,
-                                                  std::vector<char>* scratch,
-                                                  e::slice* slice)
-{
-    if (!m_val_ie)
-    {
-        size_t sz = m_prefix.size() + k.size();
-
-        if (scratch->size() < sz)
-        {
-            scratch->resize(sz);
-        }
-
-        char* ptr = &(*scratch)[0];
-        memmove(ptr, m_prefix.data(), m_prefix.size());
-        ptr += m_prefix.size();
-        memmove(ptr, k.data(), k.size());
-        ptr += k.size();
-        *slice = e::slice(&(*scratch)[0], ptr - &(*scratch)[0]);
-    }
-    else
-    {
-        size_t sz = m_prefix.size() + v.size() + k.size() + sizeof(uint32_t);
-
-        if (scratch->size() < sz)
-        {
-            scratch->resize(sz);
-        }
-
-        char* ptr = &(*scratch)[0];
-        memmove(ptr, m_prefix.data(), m_prefix.size());
-        ptr += m_prefix.size();
-        memmove(ptr, v.data(), v.size());
-        ptr += v.size();
-        memmove(ptr, k.data(), k.size());
-        ptr += k.size();
-
-        if (!m_val_ie->encoding_fixed() && !m_key_ie->encoding_fixed())
-        {
-            ptr = e::pack32be(k.size(), ptr);
-        }
-
-        *slice = e::slice(&(*scratch)[0], ptr - &(*scratch)[0]);
-    }
+datalayer :: range_index_iterator :: encode_entry(const e::slice &v,
+                                                  const e::slice &k,
+                                                  std::vector<char> *scratch,
+                                                  e::slice *slice)
+{
+	if (!m_val_ie)
+	{
+		size_t sz = m_prefix.size() + k.size();
+		if (scratch->size() < sz)
+		{
+			scratch->resize(sz);
+		}
+		char *ptr = &(*scratch)[0];
+		memmove(ptr, m_prefix.data(), m_prefix.size());
+		ptr += m_prefix.size();
+		memmove(ptr, k.data(), k.size());
+		ptr += k.size();
+		*slice = e::slice(&(*scratch)[0], ptr - & (*scratch)[0]);
+	}
+	else
+	{
+		size_t sz = m_prefix.size() + v.size() + k.size() + sizeof(uint32_t);
+		if (scratch->size() < sz)
+		{
+			scratch->resize(sz);
+		}
+		char *ptr = &(*scratch)[0];
+		memmove(ptr, m_prefix.data(), m_prefix.size());
+		ptr += m_prefix.size();
+		memmove(ptr, v.data(), v.size());
+		ptr += v.size();
+		memmove(ptr, k.data(), k.size());
+		ptr += k.size();
+		if (!m_val_ie->encoding_fixed() && !m_key_ie->encoding_fixed())
+		{
+			ptr = e::pack32be(k.size(), ptr);
+		}
+		*slice = e::slice(&(*scratch)[0], ptr - & (*scratch)[0]);
+	}
 }
 
 //////////////////////////// class intersect_iterator ////////////////////////////
 
 datalayer :: intersect_iterator :: intersect_iterator(leveldb_snapshot_ptr s,
-                                                      const std::vector<e::intrusive_ptr<index_iterator> >& iterators)
-    : index_iterator(s)
-    , m_iters()
-    , m_cost(0)
-    , m_invalid(false)
-{
-    assert(!iterators.empty());
-    std::vector<std::pair<uint64_t, e::intrusive_ptr<index_iterator> > > iters;
-
-    for (size_t i = 0; i < iterators.size(); ++i)
-    {
-        assert(iterators[i]->sorted());
-        iters.push_back(std::make_pair(iterators[i]->cost(s.db()), iterators[i]));
-    }
-
-    std::sort(iters.begin(), iters.end());
-    m_iters.resize(iters.size());
-
-    for (size_t i = 0; i < iters.size(); ++i)
-    {
-        m_cost += iters[i].first;
-        m_iters[i] = iters[i].second;
-    }
-
-    for (size_t i = 0; i < m_iters.size(); ++i)
-    {
-        if (!m_iters[i]->valid())
-        {
-            m_invalid = true;
-        }
-    }
+        const std::vector<e::intrusive_ptr<index_iterator> > &iterators)
+	: index_iterator(s)
+	, m_iters()
+	, m_cost(0)
+	, m_invalid(false)
+{
+	assert(!iterators.empty());
+	std::vector<std::pair<uint64_t, e::intrusive_ptr<index_iterator> > > iters;
+	for (size_t i = 0; i < iterators.size(); ++i)
+	{
+		assert(iterators[i]->sorted());
+		iters.push_back(std::make_pair(iterators[i]->cost(s.db()), iterators[i]));
+	}
+	std::sort(iters.begin(), iters.end());
+	m_iters.resize(iters.size());
+	for (size_t i = 0; i < iters.size(); ++i)
+	{
+		m_cost += iters[i].first;
+		m_iters[i] = iters[i].second;
+	}
+	for (size_t i = 0; i < m_iters.size(); ++i)
+	{
+		if (!m_iters[i]->valid())
+		{
+			m_invalid = true;
+		}
+	}
 }
 
 datalayer :: intersect_iterator :: ~intersect_iterator() throw ()
@@ -670,112 +620,102 @@ datalayer :: intersect_iterator :: ~intersect_iterator() throw ()
 bool
 datalayer :: intersect_iterator :: valid()
 {
-    while (!m_invalid && m_iters[0]->valid())
-    {
-        bool retry = false;
-
-        for (size_t i = 1; i < m_iters.size(); ++i)
-        {
-            m_iters[i]->seek(m_iters[0]->internal_key());
-
-            if (!m_iters[i]->valid())
-            {
-                m_invalid = true;
-                return false;
-            }
-
-            int cmp = internal_key_compare(m_iters[0]->internal_key(),
-                                           m_iters[i]->internal_key());
-
-            if (cmp < 0)
-            {
-                m_iters[0]->seek(m_iters[i]->internal_key());
-                retry = true;
-                break;
-            }
-
-            assert(cmp == 0);
-        }
-
-        if (!retry)
-        {
-            return true;
-        }
-    }
-
-    m_invalid = true;
-    return false;
+	while (!m_invalid && m_iters[0]->valid())
+	{
+		bool retry = false;
+		for (size_t i = 1; i < m_iters.size(); ++i)
+		{
+			m_iters[i]->seek(m_iters[0]->internal_key());
+			if (!m_iters[i]->valid())
+			{
+				m_invalid = true;
+				return false;
+			}
+			int cmp = internal_key_compare(m_iters[0]->internal_key(),
+			                               m_iters[i]->internal_key());
+			if (cmp < 0)
+			{
+				m_iters[0]->seek(m_iters[i]->internal_key());
+				retry = true;
+				break;
+			}
+			assert(cmp == 0);
+		}
+		if (!retry)
+		{
+			return true;
+		}
+	}
+	m_invalid = true;
+	return false;
 }
 
 void
 datalayer :: intersect_iterator :: next()
 {
-    m_iters[0]->next();
+	m_iters[0]->next();
 }
 
 uint64_t
-datalayer :: intersect_iterator :: cost(leveldb::DB*)
+datalayer :: intersect_iterator :: cost(leveldb::DB *)
 {
-    return m_cost;
+	return m_cost;
 }
 
 e::slice
 datalayer :: intersect_iterator :: key()
 {
-    return m_iters[0]->key();
+	return m_iters[0]->key();
 }
 
-std::ostream&
-datalayer :: intersect_iterator :: describe(std::ostream& out) const
+std::ostream &
+datalayer :: intersect_iterator :: describe(std::ostream &out) const
 {
-    out << "intersect_iterator(";
-
-    for (size_t i = 0; i < m_iters.size(); ++i)
-    {
-        if (i > 0)
-        {
-            out << ", ";
-        }
-
-        out << *m_iters[i];
-    }
-
-    return out << ")";
+	out << "intersect_iterator(";
+	for (size_t i = 0; i < m_iters.size(); ++i)
+	{
+		if (i > 0)
+		{
+			out << ", ";
+		}
+		out << *m_iters[i];
+	}
+	return out << ")";
 }
 
 e::slice
 datalayer :: intersect_iterator :: internal_key()
 {
-    return m_iters[0]->internal_key();
+	return m_iters[0]->internal_key();
 }
 
 bool
 datalayer :: intersect_iterator :: sorted()
 {
-    return true;
+	return true;
 }
 
 void
-datalayer :: intersect_iterator :: seek(const e::slice& k)
+datalayer :: intersect_iterator :: seek(const e::slice &k)
 {
-    return m_iters[0]->seek(k);
+	return m_iters[0]->seek(k);
 }
 
 ///////////////////////////// class search_iterator ////////////////////////////
 
-datalayer :: search_iterator :: search_iterator(datalayer* dl,
-                                                const region_id& ri,
+datalayer :: search_iterator :: search_iterator(datalayer *dl,
+                                                const region_id &ri,
                                                 e::intrusive_ptr<index_iterator> iter,
-                                                std::ostringstream* ostr,
-                                                const std::vector<attribute_check>* checks)
-    : iterator(iter->snap())
-    , m_dl(dl)
-    , m_ri(ri)
-    , m_iter(iter)
-    , m_error(SUCCESS)
-    , m_ostr(ostr)
-    , m_num_gets(0)
-    , m_checks(checks)
+                                                std::ostringstream *ostr,
+                                                const std::vector<attribute_check> *checks)
+	: iterator(iter->snap())
+	, m_dl(dl)
+	, m_ri(ri)
+	, m_iter(iter)
+	, m_error(SUCCESS)
+	, m_ostr(ostr)
+	, m_num_gets(0)
+	, m_checks(checks)
 {
 }
 
@@ -783,86 +723,78 @@ datalayer :: search_iterator :: ~search_iterator() throw ()
 {
 }
 
-std::ostream&
-datalayer :: search_iterator :: describe(std::ostream& out) const
+std::ostream &
+datalayer :: search_iterator :: describe(std::ostream &out) const
 {
-    return out << "search_iterator(" << *m_iter << ")";
+	return out << "search_iterator(" << *m_iter << ")";
 }
 
 bool
 datalayer :: search_iterator :: valid()
 {
-    if (m_error != SUCCESS)
-    {
-        return false;
-    }
-
-    // Don't try to optimize by replacing m_ri with a const schema* because it
-    // won't persist across reconfigurations
-    const schema& sc(*m_dl->m_daemon->m_config.get_schema(m_ri));
-
-    uint64_t version;
-    std::vector<e::slice> value;
-    reference ref;
-
-    // while the most selective iterator is valid and not past the end
-    while (m_iter->valid())
-    {
-        leveldb::ReadOptions opts;
-        opts.fill_cache = true;
-        opts.verify_checksums = true;
-        std::vector<char> kbacking;
-        leveldb::Slice lkey;
-        encode_key(m_ri, sc.attrs[0].type, m_iter->key(), &kbacking, &lkey);
-        leveldb::Status st = m_dl->m_db->Get(opts, lkey, &ref.m_backing);
-
-        if (st.ok())
-        {
-            e::slice v(ref.m_backing.data(), ref.m_backing.size());
-            datalayer::returncode rc = decode_value(v, &value, &version);
-
-            if (rc != SUCCESS)
-            {
-                m_error = rc;
-                return false;
-            }
-
-            ++m_num_gets;
-        }
-        else
-        {
-            m_error = m_dl->handle_error(st);
-            return false;
-        }
-
-        if (passes_attribute_checks(sc, *m_checks, m_iter->key(), value) == m_checks->size())
-        {
-            return true;
-        }
-        else
-        {
-            m_iter->next();
-        }
-    }
-
-    if (m_ostr) *m_ostr << " iterator retrieved " << m_num_gets << " objects from disk\n";
-    return false;
+	if (m_error != SUCCESS)
+	{
+		return false;
+	}
+	// Don't try to optimize by replacing m_ri with a const schema* because it
+	// won't persist across reconfigurations
+	const schema &sc(*m_dl->m_daemon->m_config.get_schema(m_ri));
+	uint64_t version;
+	std::vector<e::slice> value;
+	reference ref;
+	// while the most selective iterator is valid and not past the end
+	while (m_iter->valid())
+	{
+		leveldb::ReadOptions opts;
+		opts.fill_cache = true;
+		opts.verify_checksums = true;
+		std::vector<char> kbacking;
+		leveldb::Slice lkey;
+		encode_key(m_ri, sc.attrs[0].type, m_iter->key(), &kbacking, &lkey);
+		leveldb::Status st = m_dl->m_db->Get(opts, lkey, &ref.m_backing);
+		if (st.ok())
+		{
+			e::slice v(ref.m_backing.data(), ref.m_backing.size());
+			datalayer::returncode rc = decode_value(v, &value, &version);
+			if (rc != SUCCESS)
+			{
+				m_error = rc;
+				return false;
+			}
+			++m_num_gets;
+		}
+		else
+		{
+			m_error = m_dl->handle_error(st);
+			return false;
+		}
+		if (passes_attribute_checks(sc, *m_checks, m_iter->key(), value) == m_checks->size())
+		{
+			return true;
+		}
+		else
+		{
+			m_iter->next();
+		}
+	}
+	if (m_ostr) *m_ostr << " iterator retrieved " << m_num_gets << " objects from disk\n";
+	return false;
 }
 
 void
 datalayer :: search_iterator :: next()
 {
-    m_iter->next();
+	m_iter->next();
 }
 
 uint64_t
-datalayer :: search_iterator :: cost(leveldb::DB* db)
+datalayer :: search_iterator :: cost(leveldb::DB *db)
 {
-    return m_iter->cost(db);
+	return m_iter->cost(db);
 }
 
 e::slice
 datalayer :: search_iterator :: key()
 {
-    return m_iter->key();
+	return m_iter->key();
 }
diff --git a/daemon/datalayer_iterator.h b/daemon/datalayer_iterator.h
index 16a887004..22afa525d 100644
--- a/daemon/datalayer_iterator.h
+++ b/daemon/datalayer_iterator.h
@@ -40,225 +40,225 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class datalayer::iterator
 {
-    public:
-        iterator(leveldb_snapshot_ptr snap);
-
-    public:
-        virtual bool valid() = 0;
-        // REQUIRES: valid
-        virtual void next() = 0;
-        virtual uint64_t cost(leveldb::DB*) = 0;
-        // REQUIRES: valid
-        virtual e::slice key() = 0;
-        virtual std::ostream& describe(std::ostream&) const = 0;
-
-    public:
-        leveldb_snapshot_ptr snap();
-
-    protected:
-        friend class e::intrusive_ptr<iterator>;
-        virtual ~iterator() throw ();
-        void inc() { ++m_ref; }
-        void dec() { --m_ref; if (m_ref == 0) delete this; }
-        size_t m_ref;
-
-    private:
-        leveldb_snapshot_ptr m_snap;
+public:
+	iterator(leveldb_snapshot_ptr snap);
+
+public:
+	virtual bool valid() = 0;
+	// REQUIRES: valid
+	virtual void next() = 0;
+	virtual uint64_t cost(leveldb::DB *) = 0;
+	// REQUIRES: valid
+	virtual e::slice key() = 0;
+	virtual std::ostream &describe(std::ostream &) const = 0;
+
+public:
+	leveldb_snapshot_ptr snap();
+
+protected:
+	friend class e::intrusive_ptr<iterator>;
+	virtual ~iterator() throw ();
+	void inc() { ++m_ref; }
+	void dec() { --m_ref; if (m_ref == 0) delete this; }
+	size_t m_ref;
+
+private:
+	leveldb_snapshot_ptr m_snap;
 };
 
 class datalayer::replay_iterator
 {
-    public:
-        replay_iterator(const region_id& ri, leveldb_replay_iterator_ptr ptr, const index_encoding* ie);
-
-    public:
-        bool valid();
-        void next();
-        bool has_value();
-        e::slice key();
-        returncode unpack_value(std::vector<e::slice>* value,
-                                uint64_t* version,
-                                reference* ref);
-        leveldb::Status status();
-
-    private:
-        region_id m_ri;
-        leveldb::ReplayIterator* m_iter;
-        leveldb_replay_iterator_ptr m_ptr;
-        std::vector<char> m_decoded;
-        const index_encoding *const m_ie;
-
-    private:
-        replay_iterator(const replay_iterator&);
-        replay_iterator& operator = (const replay_iterator&);
+public:
+	replay_iterator(const region_id &ri, leveldb_replay_iterator_ptr ptr, const index_encoding *ie);
+
+public:
+	bool valid();
+	void next();
+	bool has_value();
+	e::slice key();
+	returncode unpack_value(std::vector<e::slice> *value,
+	                        uint64_t *version,
+	                        reference *ref);
+	leveldb::Status status();
+
+private:
+	region_id m_ri;
+	leveldb::ReplayIterator *m_iter;
+	leveldb_replay_iterator_ptr m_ptr;
+	std::vector<char> m_decoded;
+	const index_encoding *const m_ie;
+
+private:
+	replay_iterator(const replay_iterator &);
+	replay_iterator &operator = (const replay_iterator &);
 };
 
 class datalayer::dummy_iterator : public iterator
 {
-    public:
-        dummy_iterator();
-
-    public:
-        virtual bool valid();
-        virtual void next();
-        virtual uint64_t cost(leveldb::DB*);
-        virtual e::slice key();
-        virtual std::ostream& describe(std::ostream&) const;
-
-    protected:
-        virtual ~dummy_iterator() throw ();
+public:
+	dummy_iterator();
+
+public:
+	virtual bool valid();
+	virtual void next();
+	virtual uint64_t cost(leveldb::DB *);
+	virtual e::slice key();
+	virtual std::ostream &describe(std::ostream &) const;
+
+protected:
+	virtual ~dummy_iterator() throw ();
 };
 
 class datalayer::region_iterator : public iterator
 {
-    public:
-        region_iterator(leveldb_iterator_ptr iter,
-                        const region_id& ri,
-                        const index_encoding* ie);
-        virtual ~region_iterator() throw ();
-
-    public:
-        virtual bool valid();
-        virtual void next();
-        virtual uint64_t cost(leveldb::DB*);
-        virtual e::slice key();
-        virtual std::ostream& describe(std::ostream&) const;
-
-    private:
-        region_iterator(const region_iterator&);
-        region_iterator& operator = (const region_iterator&);
-
-    private:
-        leveldb_iterator_ptr m_iter;
-        region_id m_ri;
-        std::vector<char> m_decoded;
-        const index_encoding *const m_ie;
+public:
+	region_iterator(leveldb_iterator_ptr iter,
+	                const region_id &ri,
+	                const index_encoding *ie);
+	virtual ~region_iterator() throw ();
+
+public:
+	virtual bool valid();
+	virtual void next();
+	virtual uint64_t cost(leveldb::DB *);
+	virtual e::slice key();
+	virtual std::ostream &describe(std::ostream &) const;
+
+private:
+	region_iterator(const region_iterator &);
+	region_iterator &operator = (const region_iterator &);
+
+private:
+	leveldb_iterator_ptr m_iter;
+	region_id m_ri;
+	std::vector<char> m_decoded;
+	const index_encoding *const m_ie;
 };
 
 class datalayer::index_iterator : public iterator
 {
-    public:
-        index_iterator(leveldb_snapshot_ptr snap);
-        virtual ~index_iterator() throw ();
+public:
+	index_iterator(leveldb_snapshot_ptr snap);
+	virtual ~index_iterator() throw ();
 
-    public:
-        virtual e::slice internal_key() = 0;
-        virtual bool sorted() = 0;
-        virtual void seek(const e::slice& internal_key) = 0;
+public:
+	virtual e::slice internal_key() = 0;
+	virtual bool sorted() = 0;
+	virtual void seek(const e::slice &internal_key) = 0;
 
-    protected:
-        friend class e::intrusive_ptr<index_iterator>;
+protected:
+	friend class e::intrusive_ptr<index_iterator>;
 };
 
 class datalayer::range_index_iterator : public index_iterator
 {
-    public:
-        range_index_iterator(leveldb_snapshot_ptr snap,
-                             size_t range_prefix_sz,
-                             const e::slice& range_lower,
-                             const e::slice& range_upper,
-                             bool has_value_lower,
-                             bool has_value_upper,
-                             const index_encoding* val_ie,
-                             const index_encoding* key_ie);
-        virtual ~range_index_iterator() throw ();
-
-    public:
-        virtual bool valid();
-        virtual void next();
-        virtual uint64_t cost(leveldb::DB*);
-        virtual e::slice key();
-        virtual std::ostream& describe(std::ostream&) const;
-        virtual e::slice internal_key();
-        virtual bool sorted();
-        virtual void seek(const e::slice& internal_key);
-
-    private:
-        bool decode_entry(const e::slice& in, e::slice* val, e::slice* key);
-        bool decode_entry_keyless(const e::slice& in, e::slice* val);
-        void encode_entry(const e::slice& val,
-                          const e::slice& key,
-                          std::vector<char>* scratch,
-                          e::slice* slice);
-
-    private:
-        range_index_iterator(const range_index_iterator&);
-        range_index_iterator& operator = (const range_index_iterator&);
-
-    private:
-        leveldb_iterator_ptr m_iter;
-        const index_encoding *const m_val_ie;
-        const index_encoding *const m_key_ie;
-        e::slice m_prefix;
-        e::slice m_range_lower;
-        e::slice m_range_upper;
-        e::slice m_value_lower;
-        e::slice m_value_upper;
-        std::vector<char> m_range_buf;
-        std::vector<char> m_scratch;
-        bool m_has_lower;
-        bool m_has_upper;
-        bool m_invalid;
+public:
+	range_index_iterator(leveldb_snapshot_ptr snap,
+	                     size_t range_prefix_sz,
+	                     const e::slice &range_lower,
+	                     const e::slice &range_upper,
+	                     bool has_value_lower,
+	                     bool has_value_upper,
+	                     const index_encoding *val_ie,
+	                     const index_encoding *key_ie);
+	virtual ~range_index_iterator() throw ();
+
+public:
+	virtual bool valid();
+	virtual void next();
+	virtual uint64_t cost(leveldb::DB *);
+	virtual e::slice key();
+	virtual std::ostream &describe(std::ostream &) const;
+	virtual e::slice internal_key();
+	virtual bool sorted();
+	virtual void seek(const e::slice &internal_key);
+
+private:
+	bool decode_entry(const e::slice &in, e::slice *val, e::slice *key);
+	bool decode_entry_keyless(const e::slice &in, e::slice *val);
+	void encode_entry(const e::slice &val,
+	                  const e::slice &key,
+	                  std::vector<char> *scratch,
+	                  e::slice *slice);
+
+private:
+	range_index_iterator(const range_index_iterator &);
+	range_index_iterator &operator = (const range_index_iterator &);
+
+private:
+	leveldb_iterator_ptr m_iter;
+	const index_encoding *const m_val_ie;
+	const index_encoding *const m_key_ie;
+	e::slice m_prefix;
+	e::slice m_range_lower;
+	e::slice m_range_upper;
+	e::slice m_value_lower;
+	e::slice m_value_upper;
+	std::vector<char> m_range_buf;
+	std::vector<char> m_scratch;
+	bool m_has_lower;
+	bool m_has_upper;
+	bool m_invalid;
 };
 
 class datalayer::intersect_iterator : public index_iterator
 {
-    public:
-        intersect_iterator(leveldb_snapshot_ptr snap,
-                           const std::vector<e::intrusive_ptr<index_iterator> >& iterators);
-        virtual ~intersect_iterator() throw ();
-
-    public:
-        virtual bool valid();
-        virtual void next();
-        virtual uint64_t cost(leveldb::DB*);
-        virtual e::slice key();
-        virtual std::ostream& describe(std::ostream&) const;
-        virtual e::slice internal_key();
-        virtual bool sorted();
-        virtual void seek(const e::slice& internal_key);
-
-    private:
-        std::vector<e::intrusive_ptr<index_iterator> > m_iters;
-        uint64_t m_cost;
-        bool m_invalid;
+public:
+	intersect_iterator(leveldb_snapshot_ptr snap,
+	                   const std::vector<e::intrusive_ptr<index_iterator> > &iterators);
+	virtual ~intersect_iterator() throw ();
+
+public:
+	virtual bool valid();
+	virtual void next();
+	virtual uint64_t cost(leveldb::DB *);
+	virtual e::slice key();
+	virtual std::ostream &describe(std::ostream &) const;
+	virtual e::slice internal_key();
+	virtual bool sorted();
+	virtual void seek(const e::slice &internal_key);
+
+private:
+	std::vector<e::intrusive_ptr<index_iterator> > m_iters;
+	uint64_t m_cost;
+	bool m_invalid;
 };
 
 class datalayer::search_iterator : public iterator
 {
-    public:
-        search_iterator(datalayer* dl,
-                        const region_id& ri,
-                        e::intrusive_ptr<index_iterator> iter,
-                        std::ostringstream* ostr,
-                        const std::vector<attribute_check>* checks);
-        virtual ~search_iterator() throw ();
-
-    public:
-        virtual bool valid();
-        virtual void next();
-        virtual uint64_t cost(leveldb::DB*);
-        virtual e::slice key();
-        virtual std::ostream& describe(std::ostream&) const;
-
-    private:
-        search_iterator(const search_iterator&);
-        search_iterator& operator = (const search_iterator&);
-
-    private:
-        datalayer* m_dl;
-        region_id m_ri;
-        e::intrusive_ptr<index_iterator> m_iter;
-        returncode m_error;
-        std::ostringstream* m_ostr;
-        uint64_t m_num_gets;
-        const std::vector<attribute_check>* m_checks;
+public:
+	search_iterator(datalayer *dl,
+	                const region_id &ri,
+	                e::intrusive_ptr<index_iterator> iter,
+	                std::ostringstream *ostr,
+	                const std::vector<attribute_check> *checks);
+	virtual ~search_iterator() throw ();
+
+public:
+	virtual bool valid();
+	virtual void next();
+	virtual uint64_t cost(leveldb::DB *);
+	virtual e::slice key();
+	virtual std::ostream &describe(std::ostream &) const;
+
+private:
+	search_iterator(const search_iterator &);
+	search_iterator &operator = (const search_iterator &);
+
+private:
+	datalayer *m_dl;
+	region_id m_ri;
+	e::intrusive_ptr<index_iterator> m_iter;
+	returncode m_error;
+	std::ostringstream *m_ostr;
+	uint64_t m_num_gets;
+	const std::vector<attribute_check> *m_checks;
 };
 
-inline std::ostream&
-operator << (std::ostream& lhs, const datalayer::iterator& rhs)
+inline std::ostream &
+operator << (std::ostream &lhs, const datalayer::iterator &rhs)
 {
-    return rhs.describe(lhs);
+	return rhs.describe(lhs);
 }
 
 END_HYPERDEX_NAMESPACE
diff --git a/daemon/datalayer_wiper_indexer_mediator.h b/daemon/datalayer_wiper_indexer_mediator.h
index 0a7e1bcb8..e0999789b 100644
--- a/daemon/datalayer_wiper_indexer_mediator.h
+++ b/daemon/datalayer_wiper_indexer_mediator.h
@@ -32,34 +32,34 @@ using hyperdex::datalayer;
 
 class datalayer::wiper_indexer_mediator
 {
-    public:
-        wiper_indexer_mediator();
-        ~wiper_indexer_mediator() throw ();
-
-    public:
-        void debug_dump();
-        bool region_conflicts_with_wiper(const region_id& ri);
-        bool region_conflicts_with_indexer(const region_id& ri);
-        bool set_wiper_region(const region_id& ri);
-        bool set_indexer_region(const region_id& ri);
-        void clear_wiper_region();
-        void clear_indexer_region();
-
-    private:
-        wiper_indexer_mediator(const wiper_indexer_mediator&);
-        wiper_indexer_mediator& operator = (const wiper_indexer_mediator&);
-
-    private:
-        po6::threads::mutex m_protect;
-        region_id m_wiper;
-        region_id m_indexer;
+public:
+	wiper_indexer_mediator();
+	~wiper_indexer_mediator() throw ();
+
+public:
+	void debug_dump();
+	bool region_conflicts_with_wiper(const region_id &ri);
+	bool region_conflicts_with_indexer(const region_id &ri);
+	bool set_wiper_region(const region_id &ri);
+	bool set_indexer_region(const region_id &ri);
+	void clear_wiper_region();
+	void clear_indexer_region();
+
+private:
+	wiper_indexer_mediator(const wiper_indexer_mediator &);
+	wiper_indexer_mediator &operator = (const wiper_indexer_mediator &);
+
+private:
+	po6::threads::mutex m_protect;
+	region_id m_wiper;
+	region_id m_indexer;
 };
 
 inline
 datalayer :: wiper_indexer_mediator :: wiper_indexer_mediator()
-    : m_protect()
-    , m_wiper()
-    , m_indexer()
+	: m_protect()
+	, m_wiper()
+	, m_indexer()
 {
 }
 
@@ -71,66 +71,62 @@ datalayer :: wiper_indexer_mediator :: ~wiper_indexer_mediator() throw ()
 inline void
 datalayer :: wiper_indexer_mediator :: debug_dump()
 {
-    po6::threads::mutex::hold hold(&m_protect);
-    LOG(INFO) << "wiper-indexer mediator ========================================================";
-    LOG(INFO) << "wiper=" << m_wiper;
-    LOG(INFO) << "indexer=" << m_indexer;
+	po6::threads::mutex::hold hold(&m_protect);
+	LOG(INFO) << "wiper-indexer mediator ========================================================";
+	LOG(INFO) << "wiper=" << m_wiper;
+	LOG(INFO) << "indexer=" << m_indexer;
 }
 
 inline bool
-datalayer :: wiper_indexer_mediator :: region_conflicts_with_wiper(const region_id& ri)
+datalayer :: wiper_indexer_mediator :: region_conflicts_with_wiper(const region_id &ri)
 {
-    po6::threads::mutex::hold hold(&m_protect);
-    return m_wiper == ri;
+	po6::threads::mutex::hold hold(&m_protect);
+	return m_wiper == ri;
 }
 
 inline bool
-datalayer :: wiper_indexer_mediator :: region_conflicts_with_indexer(const region_id& ri)
+datalayer :: wiper_indexer_mediator :: region_conflicts_with_indexer(const region_id &ri)
 {
-    po6::threads::mutex::hold hold(&m_protect);
-    return m_indexer == ri;
+	po6::threads::mutex::hold hold(&m_protect);
+	return m_indexer == ri;
 }
 
 inline bool
-datalayer :: wiper_indexer_mediator :: set_wiper_region(const region_id& ri)
+datalayer :: wiper_indexer_mediator :: set_wiper_region(const region_id &ri)
 {
-    po6::threads::mutex::hold hold(&m_protect);
-
-    if (m_indexer != ri)
-    {
-        m_wiper = ri;
-        return true;
-    }
-
-    return false;
+	po6::threads::mutex::hold hold(&m_protect);
+	if (m_indexer != ri)
+	{
+		m_wiper = ri;
+		return true;
+	}
+	return false;
 }
 
 inline bool
-datalayer :: wiper_indexer_mediator :: set_indexer_region(const region_id& ri)
+datalayer :: wiper_indexer_mediator :: set_indexer_region(const region_id &ri)
 {
-    po6::threads::mutex::hold hold(&m_protect);
-
-    if (m_wiper != ri)
-    {
-        m_indexer = ri;
-        return true;
-    }
-
-    return false;
+	po6::threads::mutex::hold hold(&m_protect);
+	if (m_wiper != ri)
+	{
+		m_indexer = ri;
+		return true;
+	}
+	return false;
 }
 
 inline void
 datalayer :: wiper_indexer_mediator :: clear_wiper_region()
 {
-    po6::threads::mutex::hold hold(&m_protect);
-    m_wiper = region_id();
+	po6::threads::mutex::hold hold(&m_protect);
+	m_wiper = region_id();
 }
 
 inline void
 datalayer :: wiper_indexer_mediator :: clear_indexer_region()
 {
-    po6::threads::mutex::hold hold(&m_protect);
-    m_indexer = region_id();
+	po6::threads::mutex::hold hold(&m_protect);
+	m_indexer = region_id();
 }
 
 #endif // hyperdex_daemon_datalayer_wiper_indexer_mediator_h_
diff --git a/daemon/datalayer_wiper_thread.cc b/daemon/datalayer_wiper_thread.cc
index b7c0f7cb8..323b28f58 100644
--- a/daemon/datalayer_wiper_thread.cc
+++ b/daemon/datalayer_wiper_thread.cc
@@ -42,17 +42,17 @@
 
 using hyperdex::datalayer;
 
-datalayer :: wiper_thread :: wiper_thread(daemon* d, wiper_indexer_mediator* m)
-    : background_thread(d)
-    , m_daemon(d)
-    , m_mediator(m)
-    , m_wiping()
-    , m_have_current(false)
-    , m_wipe_current_xid()
-    , m_wipe_current_rid()
-    , m_wiping_inhibit_permit_diff(0)
-    , m_interrupted_count(0)
-    , m_interrupted(false)
+datalayer :: wiper_thread :: wiper_thread(daemon *d, wiper_indexer_mediator *m)
+	: background_thread(d)
+	, m_daemon(d)
+	, m_mediator(m)
+	, m_wiping()
+	, m_have_current(false)
+	, m_wipe_current_xid()
+	, m_wipe_current_rid()
+	, m_wiping_inhibit_permit_diff(0)
+	, m_interrupted_count(0)
+	, m_interrupted(false)
 {
 }
 
@@ -60,245 +60,223 @@ datalayer :: wiper_thread :: ~wiper_thread() throw ()
 {
 }
 
-const char*
+const char *
 datalayer :: wiper_thread :: thread_name()
 {
-    return "wiping";
+	return "wiping";
 }
 
 bool
 datalayer :: wiper_thread :: have_work()
 {
-    m_interrupted = false;
-    m_mediator->clear_wiper_region();
-    m_have_current = false;
-    m_wipe_current_xid = transfer_id();
-    m_wipe_current_rid = region_id();
-    return !m_wiping.empty() && m_wiping_inhibit_permit_diff == 0 &&
-           !m_mediator->region_conflicts_with_indexer(m_wiping.front().second);
+	m_interrupted = false;
+	m_mediator->clear_wiper_region();
+	m_have_current = false;
+	m_wipe_current_xid = transfer_id();
+	m_wipe_current_rid = region_id();
+	return !m_wiping.empty() && m_wiping_inhibit_permit_diff == 0 &&
+	       !m_mediator->region_conflicts_with_indexer(m_wiping.front().second);
 }
 
 void
 datalayer :: wiper_thread :: copy_work()
 {
-    m_wipe_current_xid = m_wiping.front().first;
-    m_wipe_current_rid = m_wiping.front().second;
-    m_have_current = m_mediator->set_wiper_region(m_wipe_current_rid);
+	m_wipe_current_xid = m_wiping.front().first;
+	m_wipe_current_rid = m_wiping.front().second;
+	m_have_current = m_mediator->set_wiper_region(m_wipe_current_rid);
 }
 
 void
 datalayer :: wiper_thread :: do_work()
 {
-    if (!m_have_current)
-    {
-        return;
-    }
-
-    wipe(m_wipe_current_xid, m_wipe_current_rid);
+	if (!m_have_current)
+	{
+		return;
+	}
+	wipe(m_wipe_current_xid, m_wipe_current_rid);
 }
 
 void
 datalayer :: wiper_thread :: debug_dump()
 {
-    this->lock();
-    LOG(INFO) << "wiper thread ==================================================================";
-    LOG(INFO) << "wiping:";
-
-    for (wipe_list_t::iterator it = m_wiping.begin(); it != m_wiping.end(); ++it)
-    {
-        LOG(INFO) << "  " << it->first << " " << it->second;
-    }
-
-    LOG(INFO) << "have_current=" << (m_have_current ? "yes" : "no");
-    LOG(INFO) << "wipe_current_xid=" << m_wipe_current_xid;
-    LOG(INFO) << "wipe_current_rid=" << m_wipe_current_rid;
-    LOG(INFO) << "wiping_inhibit_permit_diff=" << m_wiping_inhibit_permit_diff;
-    LOG(INFO) << "interrupted_count=" << m_interrupted_count;
-    this->unlock();
+	this->lock();
+	LOG(INFO) << "wiper thread ==================================================================";
+	LOG(INFO) << "wiping:";
+	for (wipe_list_t::iterator it = m_wiping.begin(); it != m_wiping.end(); ++it)
+	{
+		LOG(INFO) << "  " << it->first << " " << it->second;
+	}
+	LOG(INFO) << "have_current=" << (m_have_current ? "yes" : "no");
+	LOG(INFO) << "wipe_current_xid=" << m_wipe_current_xid;
+	LOG(INFO) << "wipe_current_rid=" << m_wipe_current_rid;
+	LOG(INFO) << "wiping_inhibit_permit_diff=" << m_wiping_inhibit_permit_diff;
+	LOG(INFO) << "interrupted_count=" << m_interrupted_count;
+	this->unlock();
 }
 
 void
 datalayer :: wiper_thread :: inhibit_wiping()
 {
-    this->lock();
-    ++m_wiping_inhibit_permit_diff;
-    this->unlock();
+	this->lock();
+	++m_wiping_inhibit_permit_diff;
+	this->unlock();
 }
 
 void
 datalayer :: wiper_thread :: permit_wiping()
 {
-    this->lock();
-    assert(m_wiping_inhibit_permit_diff > 0);
-    --m_wiping_inhibit_permit_diff;
-
-    if (m_wiping_inhibit_permit_diff == 0)
-    {
-        this->wakeup();
-    }
-
-    this->unlock();
+	this->lock();
+	assert(m_wiping_inhibit_permit_diff > 0);
+	--m_wiping_inhibit_permit_diff;
+	if (m_wiping_inhibit_permit_diff == 0)
+	{
+		this->wakeup();
+	}
+	this->unlock();
 }
 
 bool
 datalayer :: wiper_thread :: region_will_be_wiped(region_id rid)
 {
-    bool found = false;
-    this->lock();
-
-    for (wipe_list_t::iterator it = m_wiping.begin();
-            !found && it != m_wiping.end(); ++it)
-    {
-        found = it->second == rid;
-    }
-
-    this->unlock();
-    return found;
+	bool found = false;
+	this->lock();
+	for (wipe_list_t::iterator it = m_wiping.begin();
+	     !found && it != m_wiping.end(); ++it)
+	{
+		found = it->second == rid;
+	}
+	this->unlock();
+	return found;
 }
 
 void
 datalayer :: wiper_thread :: request_wipe(transfer_id xid,
-                                                  region_id ri)
+                                          region_id ri)
 {
-    this->lock();
-    m_wiping.push_back(std::make_pair(xid, ri));
-    this->wakeup();
-    this->unlock();
+	this->lock();
+	m_wiping.push_back(std::make_pair(xid, ri));
+	this->wakeup();
+	this->unlock();
 }
 
 void
 datalayer :: wiper_thread :: kick()
 {
-    this->lock();
-    this->wakeup();
-    this->unlock();
+	this->lock();
+	this->wakeup();
+	this->unlock();
 }
 
 bool
 datalayer :: wiper_thread :: interrupted()
 {
-    ++m_interrupted_count;
-    bool ret = m_interrupted;
-
-    if (m_interrupted_count % 1000 == 0)
-    {
-        this->lock();
-        ret = this->is_shutdown();
-        m_interrupted = ret;
-        this->unlock();
-    }
-
-    return ret;
+	++m_interrupted_count;
+	bool ret = m_interrupted;
+	if (m_interrupted_count % 1000 == 0)
+	{
+		this->lock();
+		ret = this->is_shutdown();
+		m_interrupted = ret;
+		this->unlock();
+	}
+	return ret;
 }
 
 void
 datalayer :: wiper_thread :: wipe(transfer_id xid, region_id rid)
 {
-    this->offline();
-    wipe_checkpoints(rid);
-    wipe_indices(rid);
-    wipe_objects(rid);
-    this->online();
-
-    if (interrupted())
-    {
-        return;
-    }
-
-    // now mark it as usable
-    for (size_t i = 0; i < m_daemon->m_data.m_indices.size(); ++i)
-    {
-        index_state* is = &m_daemon->m_data.m_indices[i];
-
-        if (is->ri == rid)
-        {
-            if (!m_daemon->m_data.m_indexer->mark_usable(is->ri, is->ii))
-            {
-                return;
-            }
-        }
-    }
-
-    this->lock();
-    assert(!m_wiping.empty());
-    assert(m_wiping.front().first == xid);
-    assert(m_wiping.front().second == rid);
-
-    if (m_wiping_inhibit_permit_diff == 0)
-    {
-        m_wiping.pop_front();
-    }
-
-    this->unlock();
-    m_daemon->m_data.m_indexer->kick();
-
-    // now report that it was wiped
-    m_daemon->m_stm.report_wiped(xid);
+	this->offline();
+	wipe_checkpoints(rid);
+	wipe_indices(rid);
+	wipe_objects(rid);
+	this->online();
+	if (interrupted())
+	{
+		return;
+	}
+	// now mark it as usable
+	for (size_t i = 0; i < m_daemon->m_data.m_indices.size(); ++i)
+	{
+		index_state *is = &m_daemon->m_data.m_indices[i];
+		if (is->ri == rid)
+		{
+			if (!m_daemon->m_data.m_indexer->mark_usable(is->ri, is->ii))
+			{
+				return;
+			}
+		}
+	}
+	this->lock();
+	assert(!m_wiping.empty());
+	assert(m_wiping.front().first == xid);
+	assert(m_wiping.front().second == rid);
+	if (m_wiping_inhibit_permit_diff == 0)
+	{
+		m_wiping.pop_front();
+	}
+	this->unlock();
+	m_daemon->m_data.m_indexer->kick();
+	// now report that it was wiped
+	m_daemon->m_stm.report_wiped(xid);
 }
 
 void
 datalayer :: wiper_thread :: wipe_checkpoints(region_id rid)
 {
-    std::auto_ptr<leveldb::Iterator> it;
-    it.reset(m_daemon->m_data.m_db->NewIterator(leveldb::ReadOptions()));
-    char cbacking[CHECKPOINT_BUF_SIZE];
-    encode_checkpoint(rid, 0, cbacking);
-    it->Seek(leveldb::Slice(cbacking, CHECKPOINT_BUF_SIZE));
-
-    while (it->Valid())
-    {
-        if (interrupted())
-        {
-            return;
-        }
-
-        region_timestamp rt;
-        e::slice key(it->key().data(), it->key().size());
-        returncode rc = decode_checkpoint(key, &rt.rid, &rt.checkpoint);
-
-        if (rc != datalayer::SUCCESS || rt.rid != rid)
-        {
-            break;
-        }
-
-        m_daemon->m_data.m_db->Delete(leveldb::WriteOptions(), it->key());
-        it->Next();
-    }
+	std::auto_ptr<leveldb::Iterator> it;
+	it.reset(m_daemon->m_data.m_db->NewIterator(leveldb::ReadOptions()));
+	char cbacking[CHECKPOINT_BUF_SIZE];
+	encode_checkpoint(rid, 0, cbacking);
+	it->Seek(leveldb::Slice(cbacking, CHECKPOINT_BUF_SIZE));
+	while (it->Valid())
+	{
+		if (interrupted())
+		{
+			return;
+		}
+		region_timestamp rt;
+		e::slice key(it->key().data(), it->key().size());
+		returncode rc = decode_checkpoint(key, &rt.rid, &rt.checkpoint);
+		if (rc != datalayer::SUCCESS || rt.rid != rid)
+		{
+			break;
+		}
+		m_daemon->m_data.m_db->Delete(leveldb::WriteOptions(), it->key());
+		it->Next();
+	}
 }
 
 void
 datalayer :: wiper_thread :: wipe_indices(region_id rid)
 {
-    wipe_common('I', rid);
-    wipe_common('i', rid);
+	wipe_common('I', rid);
+	wipe_common('i', rid);
 }
 
 void
 datalayer :: wiper_thread :: wipe_objects(region_id rid)
 {
-    wipe_common('o', rid);
+	wipe_common('o', rid);
 }
 
 void
 datalayer :: wiper_thread :: wipe_common(uint8_t c, region_id rid)
 {
-    std::auto_ptr<leveldb::Iterator> it;
-    it.reset(m_daemon->m_data.m_db->NewIterator(leveldb::ReadOptions()));
-    char backing[sizeof(uint8_t) + VARINT_64_MAX_SIZE];
-    char* ptr = backing;
-    ptr = e::pack8be(c, ptr);
-    ptr = e::packvarint64(rid.get(), ptr);
-    leveldb::Slice prefix(backing, ptr - backing);
-    it->Seek(prefix);
-
-    while (it->key().starts_with(prefix))
-    {
-        if (interrupted())
-        {
-            return;
-        }
-
-        m_daemon->m_data.m_db->Delete(leveldb::WriteOptions(), it->key());
-        it->Next();
-    }
+	std::auto_ptr<leveldb::Iterator> it;
+	it.reset(m_daemon->m_data.m_db->NewIterator(leveldb::ReadOptions()));
+	char backing[sizeof(uint8_t) + VARINT_64_MAX_SIZE];
+	char *ptr = backing;
+	ptr = e::pack8be(c, ptr);
+	ptr = e::packvarint64(rid.get(), ptr);
+	leveldb::Slice prefix(backing, ptr - backing);
+	it->Seek(prefix);
+	while (it->key().starts_with(prefix))
+	{
+		if (interrupted())
+		{
+			return;
+		}
+		m_daemon->m_data.m_db->Delete(leveldb::WriteOptions(), it->key());
+		it->Next();
+	}
 }
diff --git a/daemon/datalayer_wiper_thread.h b/daemon/datalayer_wiper_thread.h
index 4b16c8b4b..e441de380 100644
--- a/daemon/datalayer_wiper_thread.h
+++ b/daemon/datalayer_wiper_thread.h
@@ -35,53 +35,53 @@
 
 class hyperdex::datalayer::wiper_thread : public hyperdex::background_thread
 {
-    public:
-        wiper_thread(daemon* d, wiper_indexer_mediator* m);
-        ~wiper_thread() throw ();
+public:
+	wiper_thread(daemon *d, wiper_indexer_mediator *m);
+	~wiper_thread() throw ();
 
-    public:
-        virtual const char* thread_name();
-        virtual bool have_work();
-        virtual void copy_work();
-        virtual void do_work();
+public:
+	virtual const char *thread_name();
+	virtual bool have_work();
+	virtual void copy_work();
+	virtual void do_work();
 
-    public:
-        void debug_dump();
-        // These are different than pause/unpause, which should only ever be
-        // called by the main thread.  They guarantee that after the wiper is
-        // done with the current region, it will not make progress to the next
-        // region.  Thus, between pairs of inhibit/permit,
-        // "region_will_be_wiped" is guaranteed not to go from true->false.
-        void inhibit_wiping();
-        void permit_wiping();
-        bool region_will_be_wiped(region_id rid);
-        void request_wipe(transfer_id xid,
-                          region_id ri);
-        void kick();
+public:
+	void debug_dump();
+	// These are different than pause/unpause, which should only ever be
+	// called by the main thread.  They guarantee that after the wiper is
+	// done with the current region, it will not make progress to the next
+	// region.  Thus, between pairs of inhibit/permit,
+	// "region_will_be_wiped" is guaranteed not to go from true->false.
+	void inhibit_wiping();
+	void permit_wiping();
+	bool region_will_be_wiped(region_id rid);
+	void request_wipe(transfer_id xid,
+	                  region_id ri);
+	void kick();
 
-    private:
-        bool interrupted();
-        void wipe(transfer_id xid, region_id rid);
-        void wipe_checkpoints(region_id rid);
-        void wipe_indices(region_id rid);
-        void wipe_objects(region_id rid);
-        void wipe_common(uint8_t c, region_id rid);
+private:
+	bool interrupted();
+	void wipe(transfer_id xid, region_id rid);
+	void wipe_checkpoints(region_id rid);
+	void wipe_indices(region_id rid);
+	void wipe_objects(region_id rid);
+	void wipe_common(uint8_t c, region_id rid);
 
-    private:
-        daemon* m_daemon;
-        wiper_indexer_mediator* m_mediator;
-        typedef std::list<std::pair<transfer_id, region_id> > wipe_list_t;
-        wipe_list_t m_wiping;
-        bool m_have_current;
-        transfer_id m_wipe_current_xid;
-        region_id m_wipe_current_rid;
-        uint64_t m_wiping_inhibit_permit_diff;
-        uint64_t m_interrupted_count;
-        bool m_interrupted;
+private:
+	daemon *m_daemon;
+	wiper_indexer_mediator *m_mediator;
+	typedef std::list<std::pair<transfer_id, region_id> > wipe_list_t;
+	wipe_list_t m_wiping;
+	bool m_have_current;
+	transfer_id m_wipe_current_xid;
+	region_id m_wipe_current_rid;
+	uint64_t m_wiping_inhibit_permit_diff;
+	uint64_t m_interrupted_count;
+	bool m_interrupted;
 
-    private:
-        wiper_thread(const wiper_thread&);
-        wiper_thread& operator = (const wiper_thread&);
+private:
+	wiper_thread(const wiper_thread &);
+	wiper_thread &operator = (const wiper_thread &);
 };
 
 #endif // hyperdex_daemon_datalayer_wiper_thread_h_
diff --git a/daemon/identifier_collector.cc b/daemon/identifier_collector.cc
index 477305ef7..55c8fe21b 100644
--- a/daemon/identifier_collector.cc
+++ b/daemon/identifier_collector.cc
@@ -39,9 +39,9 @@ using hyperdex::region_id;
 
 const region_id identifier_collector::defaultri;
 
-identifier_collector :: identifier_collector(e::garbage_collector* gc)
-    : m_gc(gc)
-    , m_collectors()
+identifier_collector :: identifier_collector(e::garbage_collector *gc)
+	: m_gc(gc)
+	, m_collectors()
 {
 }
 
@@ -50,64 +50,54 @@ identifier_collector :: ~identifier_collector() throw ()
 }
 
 void
-identifier_collector :: bump(const region_id& ri, uint64_t lb)
+identifier_collector :: bump(const region_id &ri, uint64_t lb)
 {
-    e::compat::shared_ptr<e::seqno_collector> sc;
-
-    if (!m_collectors.get(ri, &sc))
-    {
-        abort();
-    }
-
-    sc->collect_up_to(lb);
+	e::compat::shared_ptr<e::seqno_collector> sc;
+	if (!m_collectors.get(ri, &sc))
+	{
+		abort();
+	}
+	sc->collect_up_to(lb);
 }
 
 void
-identifier_collector :: collect(const region_id& ri, uint64_t seqno)
+identifier_collector :: collect(const region_id &ri, uint64_t seqno)
 {
-    e::compat::shared_ptr<e::seqno_collector> sc;
-
-    if (!m_collectors.get(ri, &sc))
-    {
-        abort();
-    }
-
-    sc->collect(seqno);
+	e::compat::shared_ptr<e::seqno_collector> sc;
+	if (!m_collectors.get(ri, &sc))
+	{
+		abort();
+	}
+	sc->collect(seqno);
 }
 
 uint64_t
-identifier_collector :: lower_bound(const region_id& ri)
+identifier_collector :: lower_bound(const region_id &ri)
 {
-    e::compat::shared_ptr<e::seqno_collector> sc;
-
-    if (!m_collectors.get(ri, &sc))
-    {
-        abort();
-    }
-
-    uint64_t lb;
-    sc->lower_bound(&lb);
-    return lb;
+	e::compat::shared_ptr<e::seqno_collector> sc;
+	if (!m_collectors.get(ri, &sc))
+	{
+		abort();
+	}
+	uint64_t lb;
+	sc->lower_bound(&lb);
+	return lb;
 }
 
 void
-identifier_collector :: adopt(region_id* ris, size_t ris_sz)
+identifier_collector :: adopt(region_id *ris, size_t ris_sz)
 {
-    collector_map_t new_collectors;
-
-    for (size_t i = 0; i < ris_sz; ++i)
-    {
-        e::compat::shared_ptr<e::seqno_collector> sc;
-
-        if (!m_collectors.get(ris[i], &sc))
-        {
-            sc = e::compat::shared_ptr<e::seqno_collector>(new e::seqno_collector(m_gc));
-            sc->collect(0);
-        }
-
-        assert(sc);
-        new_collectors.put(ris[i], sc);
-    }
-
-    m_collectors.swap(&new_collectors);
+	collector_map_t new_collectors;
+	for (size_t i = 0; i < ris_sz; ++i)
+	{
+		e::compat::shared_ptr<e::seqno_collector> sc;
+		if (!m_collectors.get(ris[i], &sc))
+		{
+			sc = e::compat::shared_ptr<e::seqno_collector>(new e::seqno_collector(m_gc));
+			sc->collect(0);
+		}
+		assert(sc);
+		new_collectors.put(ris[i], sc);
+	}
+	m_collectors.swap(&new_collectors);
 }
diff --git a/daemon/identifier_collector.h b/daemon/identifier_collector.h
index 4fb775ec8..4b31a19fd 100644
--- a/daemon/identifier_collector.h
+++ b/daemon/identifier_collector.h
@@ -41,35 +41,35 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class identifier_collector
 {
-    public:
-        identifier_collector(e::garbage_collector* gc);
-        ~identifier_collector() throw ();
+public:
+	identifier_collector(e::garbage_collector *gc);
+	~identifier_collector() throw ();
 
-    // concurrent methods
-    // these methods return "true" if ri is a managed region_id, else "false"
-    public:
-        // force the lower bound for "ri" to be "lb" or more
-        // equivalent to calling collect on 0 through lb - 1
-        void bump(const region_id& ri, uint64_t lb);
-        // mark the identifier as collected
-        void collect(const region_id& ri, uint64_t id);
-        // store a value in "*lb" such that ids "< *lb" have been collected
-        uint64_t lower_bound(const region_id& ri);
+	// concurrent methods
+	// these methods return "true" if ri is a managed region_id, else "false"
+public:
+	// force the lower bound for "ri" to be "lb" or more
+	// equivalent to calling collect on 0 through lb - 1
+	void bump(const region_id &ri, uint64_t lb);
+	// mark the identifier as collected
+	void collect(const region_id &ri, uint64_t id);
+	// store a value in "*lb" such that ids "< *lb" have been collected
+	uint64_t lower_bound(const region_id &ri);
 
-    // external synchronization required; nothing can call other methods
-    public:
-        void adopt(region_id* ris, size_t ris_sz);
+	// external synchronization required; nothing can call other methods
+public:
+	void adopt(region_id *ris, size_t ris_sz);
 
-    private:
-        identifier_collector(const identifier_collector&);
-        identifier_collector& operator = (const identifier_collector&);
-        static uint64_t id(region_id ri) { return ri.get(); }
+private:
+	identifier_collector(const identifier_collector &);
+	identifier_collector &operator = (const identifier_collector &);
+	static uint64_t id(region_id ri) { return ri.get(); }
 
-    private:
-        const static region_id defaultri;
-        typedef e::ao_hash_map<region_id, e::compat::shared_ptr<e::seqno_collector>, id, defaultri> collector_map_t;
-        e::garbage_collector* m_gc;
-        collector_map_t m_collectors;
+private:
+	const static region_id defaultri;
+	typedef e::ao_hash_map<region_id, e::compat::shared_ptr<e::seqno_collector>, id, defaultri> collector_map_t;
+	e::garbage_collector *m_gc;
+	collector_map_t m_collectors;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/daemon/identifier_generator.cc b/daemon/identifier_generator.cc
index 29db60fad..706be5f3f 100644
--- a/daemon/identifier_generator.cc
+++ b/daemon/identifier_generator.cc
@@ -41,7 +41,7 @@ using hyperdex::region_id;
 const region_id identifier_generator::defaultri;
 
 identifier_generator :: identifier_generator()
-    : m_generators()
+	: m_generators()
 {
 }
 
@@ -50,74 +50,62 @@ identifier_generator :: ~identifier_generator() throw ()
 }
 
 bool
-identifier_generator :: bump(const region_id& ri, uint64_t id)
+identifier_generator :: bump(const region_id &ri, uint64_t id)
 {
-    uint64_t* val = NULL;
-
-    if (!m_generators.mod(ri, &val))
-    {
-        return false;
-    }
-
-    uint64_t count = load_64_nobarrier(val);
-
-    while (count <= id)
-    {
-        count = e::atomic::compare_and_swap_64_nobarrier(val, count, id + 1);
-    }
-
-    return true;
+	uint64_t *val = NULL;
+	if (!m_generators.mod(ri, &val))
+	{
+		return false;
+	}
+	uint64_t count = load_64_nobarrier(val);
+	while (count <= id)
+	{
+		count = e::atomic::compare_and_swap_64_nobarrier(val, count, id + 1);
+	}
+	return true;
 }
 
 uint64_t
-identifier_generator :: peek(const region_id& ri) const
+identifier_generator :: peek(const region_id &ri) const
 {
-    e::atomic::memory_barrier();
-    uint64_t val = 0;
-
-    if (!m_generators.get(ri, &val))
-    {
-        abort();
-    }
-
-    return val;
+	e::atomic::memory_barrier();
+	uint64_t val = 0;
+	if (!m_generators.get(ri, &val))
+	{
+		abort();
+	}
+	return val;
 }
 
 uint64_t
-identifier_generator :: generate_id(const region_id& ri)
+identifier_generator :: generate_id(const region_id &ri)
 {
-    uint64_t* val = NULL;
-
-    if (!m_generators.mod(ri, &val))
-    {
-        abort();
-    }
-
-    return e::atomic::increment_64_nobarrier(val, 1) - 1;
+	uint64_t *val = NULL;
+	if (!m_generators.mod(ri, &val))
+	{
+		abort();
+	}
+	return e::atomic::increment_64_nobarrier(val, 1) - 1;
 }
 
 void
-identifier_generator :: adopt(region_id* ris, size_t ris_sz)
+identifier_generator :: adopt(region_id *ris, size_t ris_sz)
 {
-    generator_map_t new_generators;
-
-    for (size_t i = 0; i < ris_sz; ++i)
-    {
-        uint64_t count = 0;
-
-        if (!m_generators.get(ris[i], &count))
-        {
-            count = 1;
-        }
-
-        new_generators.put(ris[i], count);
-    }
-
-    m_generators.swap(&new_generators);
+	generator_map_t new_generators;
+	for (size_t i = 0; i < ris_sz; ++i)
+	{
+		uint64_t count = 0;
+		if (!m_generators.get(ris[i], &count))
+		{
+			count = 1;
+		}
+		new_generators.put(ris[i], count);
+	}
+	m_generators.swap(&new_generators);
 }
 
 void
-identifier_generator :: copy_from(const identifier_generator& ig)
+identifier_generator :: copy_from(const identifier_generator &ig)
 {
-    m_generators.copy_from(ig.m_generators);
+	m_generators.copy_from(ig.m_generators);
 }
diff --git a/daemon/identifier_generator.h b/daemon/identifier_generator.h
index 7643c42d9..0153e6769 100644
--- a/daemon/identifier_generator.h
+++ b/daemon/identifier_generator.h
@@ -39,36 +39,36 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class identifier_generator
 {
-    public:
-        identifier_generator();
-        ~identifier_generator() throw ();
+public:
+	identifier_generator();
+	~identifier_generator() throw ();
 
-    // concurrent methods
-    // these methods return "true" if ri is a managed region_id, else "false"
-    public:
-        // ensure that new identifiers are strictly greater than "id"
-        bool bump(const region_id& ri, uint64_t id);
-        // look at the next identifier, and store it in "id"
-        uint64_t peek(const region_id& ri) const;
-        // generate one unique identifier, and store it in "id"
-        uint64_t generate_id(const region_id& ri);
+	// concurrent methods
+	// these methods return "true" if ri is a managed region_id, else "false"
+public:
+	// ensure that new identifiers are strictly greater than "id"
+	bool bump(const region_id &ri, uint64_t id);
+	// look at the next identifier, and store it in "id"
+	uint64_t peek(const region_id &ri) const;
+	// generate one unique identifier, and store it in "id"
+	uint64_t generate_id(const region_id &ri);
 
-    // external synchronization required; nothing can call other methods during
-    // adopt; copy_from must be mutually exclusive with adopt on either
-    // generator, and mutually exclusive with all on this generator
-    public:
-        void adopt(region_id* ris, size_t ris_sz);
-        void copy_from(const identifier_generator&);
+	// external synchronization required; nothing can call other methods during
+	// adopt; copy_from must be mutually exclusive with adopt on either
+	// generator, and mutually exclusive with all on this generator
+public:
+	void adopt(region_id *ris, size_t ris_sz);
+	void copy_from(const identifier_generator &);
 
-    private:
-        identifier_generator(const identifier_generator&);
-        identifier_generator& operator = (const identifier_generator&);
-        static uint64_t hashid(region_id ri) { return ri.get(); }
+private:
+	identifier_generator(const identifier_generator &);
+	identifier_generator &operator = (const identifier_generator &);
+	static uint64_t hashid(region_id ri) { return ri.get(); }
 
-    private:
-        const static region_id defaultri;
-        typedef e::ao_hash_map<region_id, uint64_t, hashid, defaultri> generator_map_t;
-        generator_map_t m_generators;
+private:
+	const static region_id defaultri;
+	typedef e::ao_hash_map<region_id, uint64_t, hashid, defaultri> generator_map_t;
+	generator_map_t m_generators;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/daemon/index_container.cc b/daemon/index_container.cc
index 0e2715e8a..310197d88 100644
--- a/daemon/index_container.cc
+++ b/daemon/index_container.cc
@@ -47,98 +47,91 @@ index_container :: ~index_container() throw ()
 }
 
 void
-index_container :: index_changes(const index* idx,
-                                 const region_id& ri,
-                                 const index_encoding* key_ie,
-                                 const e::slice& key,
-                                 const e::slice* old_value,
-                                 const e::slice* new_value,
-                                 leveldb::WriteBatch* updates) const
+index_container :: index_changes(const index *idx,
+                                 const region_id &ri,
+                                 const index_encoding *key_ie,
+                                 const e::slice &key,
+                                 const e::slice *old_value,
+                                 const e::slice *new_value,
+                                 leveldb::WriteBatch *updates) const
 {
-    std::vector<e::slice> old_elems;
-    std::vector<e::slice> new_elems;
-
-    if (old_value)
-    {
-        this->extract_elements(*old_value, &old_elems);
-    }
-
-    if (new_value)
-    {
-        this->extract_elements(*new_value, &new_elems);
-    }
-
-    std::sort(old_elems.begin(), old_elems.end());
-    std::sort(new_elems.begin(), new_elems.end());
-    std::vector<e::slice>::iterator it;
-    it = std::unique(old_elems.begin(), old_elems.end());
-    old_elems.resize(it - old_elems.begin());
-    it = std::unique(new_elems.begin(), new_elems.end());
-    new_elems.resize(it - new_elems.begin());
-    size_t old_idx = 0;
-    size_t new_idx = 0;
-    const index_info* ii = this->element_index_info();
-
-    while (old_idx < old_elems.size() &&
-           new_idx < new_elems.size())
-    {
-        if (old_elems[old_idx] == new_elems[new_idx])
-        {
-            ii->index_changes(idx, ri, key_ie, key,
-                              &old_elems[old_idx], &new_elems[new_idx],
-                              updates);
-            ++old_idx;
-            ++new_idx;
-        }
-        else if (old_elems[old_idx] < new_elems[new_idx])
-        {
-            ii->index_changes(idx, ri, key_ie, key,
-                              &old_elems[old_idx], NULL, updates);
-            ++old_idx;
-        }
-        else if (old_elems[old_idx] > new_elems[new_idx])
-        {
-            ii->index_changes(idx, ri, key_ie, key,
-                              NULL, &new_elems[new_idx], updates);
-            ++new_idx;
-        }
-    }
-
-    while (old_idx < old_elems.size())
-    {
-        ii->index_changes(idx, ri, key_ie, key,
-                          &old_elems[old_idx], NULL, updates);
-        ++old_idx;
-    }
-
-    while (new_idx < new_elems.size())
-    {
-        ii->index_changes(idx, ri, key_ie, key,
-                          NULL, &new_elems[new_idx], updates);
-        ++new_idx;
-    }
+	std::vector<e::slice> old_elems;
+	std::vector<e::slice> new_elems;
+	if (old_value)
+	{
+		this->extract_elements(*old_value, &old_elems);
+	}
+	if (new_value)
+	{
+		this->extract_elements(*new_value, &new_elems);
+	}
+	std::sort(old_elems.begin(), old_elems.end());
+	std::sort(new_elems.begin(), new_elems.end());
+	std::vector<e::slice>::iterator it;
+	it = std::unique(old_elems.begin(), old_elems.end());
+	old_elems.resize(it - old_elems.begin());
+	it = std::unique(new_elems.begin(), new_elems.end());
+	new_elems.resize(it - new_elems.begin());
+	size_t old_idx = 0;
+	size_t new_idx = 0;
+	const index_info *ii = this->element_index_info();
+	while (old_idx < old_elems.size() &&
+	       new_idx < new_elems.size())
+	{
+		if (old_elems[old_idx] == new_elems[new_idx])
+		{
+			ii->index_changes(idx, ri, key_ie, key,
+			                  &old_elems[old_idx], &new_elems[new_idx],
+			                  updates);
+			++old_idx;
+			++new_idx;
+		}
+		else if (old_elems[old_idx] < new_elems[new_idx])
+		{
+			ii->index_changes(idx, ri, key_ie, key,
+			                  &old_elems[old_idx], NULL, updates);
+			++old_idx;
+		}
+		else if (old_elems[old_idx] > new_elems[new_idx])
+		{
+			ii->index_changes(idx, ri, key_ie, key,
+			                  NULL, &new_elems[new_idx], updates);
+			++new_idx;
+		}
+	}
+	while (old_idx < old_elems.size())
+	{
+		ii->index_changes(idx, ri, key_ie, key,
+		                  &old_elems[old_idx], NULL, updates);
+		++old_idx;
+	}
+	while (new_idx < new_elems.size())
+	{
+		ii->index_changes(idx, ri, key_ie, key,
+		                  NULL, &new_elems[new_idx], updates);
+		++new_idx;
+	}
 }
 
-datalayer::index_iterator*
+datalayer::index_iterator *
 index_container :: iterator_from_check(leveldb_snapshot_ptr snap,
-                                       const region_id& ri,
-                                       const index_id& ii,
-                                       const attribute_check& c,
-                                       const index_encoding* key_ie) const
+                                       const region_id &ri,
+                                       const index_id &ii,
+                                       const attribute_check &c,
+                                       const index_encoding *key_ie) const
 {
-    if (c.predicate == HYPERPREDICATE_CONTAINS &&
-        c.datatype == this->element_datatype_info()->datatype())
-    {
-        range r;
-        r.attr = c.attr;
-        r.type = c.datatype;
-        r.start = c.value;
-        r.end = c.value;
-        r.has_start = true;
-        r.has_end = true;
-        r.invalid = false;
-        return this->element_index_info()->iterator_from_range(snap, ri, ii, r, key_ie);
-    }
-
-    return NULL;
+	if (c.predicate == HYPERPREDICATE_CONTAINS &&
+	    c.datatype == this->element_datatype_info()->datatype())
+	{
+		range r;
+		r.attr = c.attr;
+		r.type = c.datatype;
+		r.start = c.value;
+		r.end = c.value;
+		r.has_start = true;
+		r.has_end = true;
+		r.invalid = false;
+		return this->element_index_info()->iterator_from_range(snap, ri, ii, r, key_ie);
+	}
+	return NULL;
 }
diff --git a/daemon/index_container.h b/daemon/index_container.h
index d789b770b..e22d42475 100644
--- a/daemon/index_container.h
+++ b/daemon/index_container.h
@@ -36,29 +36,29 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class index_container : public index_info
 {
-    protected:
-        index_container();
-        virtual ~index_container() throw ();
+protected:
+	index_container();
+	virtual ~index_container() throw ();
 
-    public:
-        virtual void index_changes(const index* idx,
-                                   const region_id& ri,
-                                   const index_encoding* key_ie,
-                                   const e::slice& key,
-                                   const e::slice* old_value,
-                                   const e::slice* new_value,
-                                   leveldb::WriteBatch* updates) const;
-        virtual datalayer::index_iterator* iterator_from_check(leveldb_snapshot_ptr snap,
-                                                               const region_id& ri,
-                                                               const index_id& ii,
-                                                               const attribute_check& c,
-                                                               const index_encoding* key_ie) const;
+public:
+	virtual void index_changes(const index *idx,
+	                           const region_id &ri,
+	                           const index_encoding *key_ie,
+	                           const e::slice &key,
+	                           const e::slice *old_value,
+	                           const e::slice *new_value,
+	                           leveldb::WriteBatch *updates) const;
+	virtual datalayer::index_iterator *iterator_from_check(leveldb_snapshot_ptr snap,
+	        const region_id &ri,
+	        const index_id &ii,
+	        const attribute_check &c,
+	        const index_encoding *key_ie) const;
 
-    private:
-        virtual void extract_elements(const e::slice& container,
-                                      std::vector<e::slice>* elems) const = 0;
-        virtual const datatype_info* element_datatype_info() const = 0;
-        virtual const index_info* element_index_info() const = 0;
+private:
+	virtual void extract_elements(const e::slice &container,
+	                              std::vector<e::slice> *elems) const = 0;
+	virtual const datatype_info *element_datatype_info() const = 0;
+	virtual const index_info *element_index_info() const = 0;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/daemon/index_document.cc b/daemon/index_document.cc
index 886455afe..2b88c4b90 100644
--- a/daemon/index_document.cc
+++ b/daemon/index_document.cc
@@ -42,11 +42,11 @@
 using hyperdex::index_document;
 using hyperdex::index_encoding_document;
 
-inline leveldb::Slice e2level(const e::slice& s) { return leveldb::Slice(reinterpret_cast<const char*>(s.data()), s.size()); }
-inline e::slice level2e(const leveldb::Slice& s) { return e::slice(s.data(), s.size()); }
+inline leveldb::Slice e2level(const e::slice &s) { return leveldb::Slice(reinterpret_cast<const char *>(s.data()), s.size()); }
+inline e::slice level2e(const leveldb::Slice &s) { return e::slice(s.data(), s.size()); }
 
 index_document :: index_document()
-    : m_di()
+	: m_di()
 {
 }
 
@@ -57,409 +57,374 @@ index_document :: ~index_document() throw ()
 hyperdatatype
 index_document :: datatype() const
 {
-    return HYPERDATATYPE_DOCUMENT;
+	return HYPERDATATYPE_DOCUMENT;
 }
 
 void
-index_document :: index_changes(const index* idx,
-                                const region_id& ri,
-                                const index_encoding* key_ie,
-                                const e::slice& key,
-                                const e::slice* old_document,
-                                const e::slice* new_document,
-                                leveldb::WriteBatch* updates) const
+index_document :: index_changes(const index *idx,
+                                const region_id &ri,
+                                const index_encoding *key_ie,
+                                const e::slice &key,
+                                const e::slice *old_document,
+                                const e::slice *new_document,
+                                leveldb::WriteBatch *updates) const
 {
-    type_t t;
-    std::vector<char> scratch_value;
-    e::slice value;
-    std::vector<char> scratch_entry;
-    e::slice entry;
-
-    if (old_document && new_document && *old_document == *new_document)
-    {
-        return;
-    }
-
-    if (old_document && parse_path(idx, *old_document, &t, &scratch_value, &value))
-    {
-        index_entry(ri, idx->id, t, key_ie, key, value, &scratch_entry, &entry);
-        updates->Delete(leveldb::Slice(reinterpret_cast<const char*>(entry.data()), entry.size()));
-    }
-
-    if (new_document && parse_path(idx, *new_document, &t, &scratch_value, &value))
-    {
-        index_entry(ri, idx->id, t, key_ie, key, value, &scratch_entry, &entry);
-        updates->Put(leveldb::Slice(reinterpret_cast<const char*>(entry.data()), entry.size()), leveldb::Slice());
-    }
+	type_t t;
+	std::vector<char> scratch_value;
+	e::slice value;
+	std::vector<char> scratch_entry;
+	e::slice entry;
+	if (old_document && new_document && *old_document == *new_document)
+	{
+		return;
+	}
+	if (old_document && parse_path(idx, *old_document, &t, &scratch_value, &value))
+	{
+		index_entry(ri, idx->id, t, key_ie, key, value, &scratch_entry, &entry);
+		updates->Delete(leveldb::Slice(reinterpret_cast<const char *>(entry.data()), entry.size()));
+	}
+	if (new_document && parse_path(idx, *new_document, &t, &scratch_value, &value))
+	{
+		index_entry(ri, idx->id, t, key_ie, key, value, &scratch_entry, &entry);
+		updates->Put(leveldb::Slice(reinterpret_cast<const char *>(entry.data()), entry.size()), leveldb::Slice());
+	}
 }
 
-hyperdex::datalayer::index_iterator*
+hyperdex::datalayer::index_iterator *
 index_document :: iterator_from_check(leveldb_snapshot_ptr snap,
-                                      const region_id& ri,
-                                      const index_id& ii,
-                                      const attribute_check& check,
-                                      const index_encoding* key_ie) const
+                                      const region_id &ri,
+                                      const index_id &ii,
+                                      const attribute_check &check,
+                                      const index_encoding *key_ie) const
 {
-    const char* path = reinterpret_cast<const char*>(check.value.data());
-    size_t path_sz = strnlen(path, check.value.size());
-
-    if (path_sz >= check.value.size())
-    {
-        return NULL;
-    }
-
-    if (check.datatype != HYPERDATATYPE_STRING &&
-        check.datatype != HYPERDATATYPE_INT64 &&
-        check.datatype != HYPERDATATYPE_FLOAT &&
-        check.datatype != HYPERDATATYPE_DOCUMENT)
-    {
-        return NULL;
-    }
-
-    char scratch_v[sizeof(int64_t) + sizeof(double)];
-    e::slice value(path + path_sz + 1, check.value.size() - path_sz - 1);
-
-    if (check.datatype == HYPERDATATYPE_INT64)
-    {
-        memset(scratch_v, 0, sizeof(int64_t));
-        memmove(scratch_v, value.data(), std::min(value.size(), sizeof(int64_t)));
-        int64_t val_i;
-        e::unpack64le(scratch_v, &val_i);
-        double val_d = val_i;
-        e::pack64le(val_d, scratch_v);
-        value = e::slice(scratch_v, sizeof(double));
-    }
-
-    size_t range_prefix_sz = index_entry_prefix_size(ri, ii);
-    std::vector<char> scratch_a;
-    std::vector<char> scratch_b;
-    e::slice a;
-    e::slice b;
-    e::slice start;
-    e::slice limit;
-    bool has_start;
-    bool has_limit;
-
-    type_t t;
-
-    if(check.datatype == HYPERDATATYPE_STRING)
-    {
-        t = STRING;
-    }
-    else if(check.datatype == HYPERDATATYPE_DOCUMENT)
-    {
-        if(check.predicate != HYPERPREDICATE_EQUALS)
-        {
-            return NULL;
-        }
-
-        t = DOCUMENT;
-    }
-    else
-    {
-        t = NUMBER;
-    }
-
-    index_entry(ri, ii, t, value, &scratch_a, &a);
-    index_entry(ri, ii, t, &scratch_b, &b);
-
-    switch (check.predicate)
-    {
-        case HYPERPREDICATE_EQUALS:
-            start = a;
-            limit = a;
-            break;
-        case HYPERPREDICATE_LESS_THAN:
-        case HYPERPREDICATE_LESS_EQUAL:
-            start = b;
-            limit = a;
-            break;
-        case HYPERPREDICATE_GREATER_EQUAL:
-        case HYPERPREDICATE_GREATER_THAN:
-            start = a;
-            limit = b;
-            break;
-        case HYPERPREDICATE_FAIL:
-        case HYPERPREDICATE_CONTAINS_LESS_THAN:
-        case HYPERPREDICATE_REGEX:
-        case HYPERPREDICATE_LENGTH_EQUALS:
-        case HYPERPREDICATE_LENGTH_LESS_EQUAL:
-        case HYPERPREDICATE_LENGTH_GREATER_EQUAL:
-        case HYPERPREDICATE_CONTAINS:
-        default:
-            return NULL;
-    }
-
-    const index_encoding* ie = lookup_encoding(t);
-
-    has_start = a.data() == start.data();
-    has_limit = a.data() == limit.data();
-    return new datalayer::range_index_iterator(snap, range_prefix_sz,
-                                               start, limit,
-                                               has_start, has_limit,
-                                               ie, key_ie);
+	const char *path = reinterpret_cast<const char *>(check.value.data());
+	size_t path_sz = strnlen(path, check.value.size());
+	if (path_sz >= check.value.size())
+	{
+		return NULL;
+	}
+	if (check.datatype != HYPERDATATYPE_STRING &&
+	    check.datatype != HYPERDATATYPE_INT64 &&
+	    check.datatype != HYPERDATATYPE_FLOAT &&
+	    check.datatype != HYPERDATATYPE_DOCUMENT)
+	{
+		return NULL;
+	}
+	char scratch_v[sizeof(int64_t) + sizeof(double)];
+	e::slice value(path + path_sz + 1, check.value.size() - path_sz - 1);
+	if (check.datatype == HYPERDATATYPE_INT64)
+	{
+		memset(scratch_v, 0, sizeof(int64_t));
+		memmove(scratch_v, value.data(), std::min(value.size(), sizeof(int64_t)));
+		int64_t val_i;
+		e::unpack64le(scratch_v, &val_i);
+		double val_d = val_i;
+		e::pack64le(val_d, scratch_v);
+		value = e::slice(scratch_v, sizeof(double));
+	}
+	size_t range_prefix_sz = index_entry_prefix_size(ri, ii);
+	std::vector<char> scratch_a;
+	std::vector<char> scratch_b;
+	e::slice a;
+	e::slice b;
+	e::slice start;
+	e::slice limit;
+	bool has_start;
+	bool has_limit;
+	type_t t;
+	if (check.datatype == HYPERDATATYPE_STRING)
+	{
+		t = STRING;
+	}
+	else if (check.datatype == HYPERDATATYPE_DOCUMENT)
+	{
+		if (check.predicate != HYPERPREDICATE_EQUALS)
+		{
+			return NULL;
+		}
+		t = DOCUMENT;
+	}
+	else
+	{
+		t = NUMBER;
+	}
+	index_entry(ri, ii, t, value, &scratch_a, &a);
+	index_entry(ri, ii, t, &scratch_b, &b);
+	switch (check.predicate)
+	{
+	case HYPERPREDICATE_EQUALS:
+		start = a;
+		limit = a;
+		break;
+	case HYPERPREDICATE_LESS_THAN:
+	case HYPERPREDICATE_LESS_EQUAL:
+		start = b;
+		limit = a;
+		break;
+	case HYPERPREDICATE_GREATER_EQUAL:
+	case HYPERPREDICATE_GREATER_THAN:
+		start = a;
+		limit = b;
+		break;
+	case HYPERPREDICATE_FAIL:
+	case HYPERPREDICATE_CONTAINS_LESS_THAN:
+	case HYPERPREDICATE_REGEX:
+	case HYPERPREDICATE_LENGTH_EQUALS:
+	case HYPERPREDICATE_LENGTH_LESS_EQUAL:
+	case HYPERPREDICATE_LENGTH_GREATER_EQUAL:
+	case HYPERPREDICATE_CONTAINS:
+	default:
+		return NULL;
+	}
+	const index_encoding *ie = lookup_encoding(t);
+	has_start = a.data() == start.data();
+	has_limit = a.data() == limit.data();
+	return new datalayer::range_index_iterator(snap, range_prefix_sz,
+	                                           start, limit,
+	                                           has_start, has_limit,
+	                                           ie, key_ie);
 }
 
-const hyperdex::index_encoding*
+const hyperdex::index_encoding *
 index_document :: lookup_encoding(type_t t) const
 {
-    switch (t)
-    {
-        case STRING:
-            return index_encoding::lookup(HYPERDATATYPE_STRING);
-        case NUMBER:
-            return index_encoding::lookup(HYPERDATATYPE_FLOAT);
-        case DOCUMENT:
-            return index_encoding::lookup(HYPERDATATYPE_DOCUMENT);
-        default:
-            abort();
-    }
-
-    return NULL;
+	switch (t)
+	{
+	case STRING:
+		return index_encoding::lookup(HYPERDATATYPE_STRING);
+	case NUMBER:
+		return index_encoding::lookup(HYPERDATATYPE_FLOAT);
+	case DOCUMENT:
+		return index_encoding::lookup(HYPERDATATYPE_DOCUMENT);
+	default:
+		abort();
+	}
+	return NULL;
 }
 
 bool
-index_document :: parse_path(const index* idx,
-                             const e::slice& document,
-                             type_t* t,
-                             std::vector<char>* scratch,
-                             e::slice* value) const
+index_document :: parse_path(const index *idx,
+                             const e::slice &document,
+                             type_t *t,
+                             std::vector<char> *scratch,
+                             e::slice *value) const
 {
-    hyperdatatype type;
-
-    if (m_di.extract_value(idx->extra.cdata(), document, &type, scratch, value))
-    {
-        if (type == HYPERDATATYPE_STRING)
-        {
-            *t = STRING;
-            return true;
-        }
-        else if (type == HYPERDATATYPE_INT64 || type == HYPERDATATYPE_FLOAT)
-        {
-            *t = NUMBER;
-            return true;
-        }
-        else if (type == HYPERDATATYPE_DOCUMENT)
-        {
-            *t = DOCUMENT;
-            return true;
-        }
-    }
-
-    return false;
+	hyperdatatype type;
+	if (m_di.extract_value(idx->extra.cdata(), document, &type, scratch, value))
+	{
+		if (type == HYPERDATATYPE_STRING)
+		{
+			*t = STRING;
+			return true;
+		}
+		else if (type == HYPERDATATYPE_INT64 || type == HYPERDATATYPE_FLOAT)
+		{
+			*t = NUMBER;
+			return true;
+		}
+		else if (type == HYPERDATATYPE_DOCUMENT)
+		{
+			*t = DOCUMENT;
+			return true;
+		}
+	}
+	return false;
 }
 
 size_t
-index_document :: index_entry_prefix_size(const region_id& ri, const index_id& ii) const
+index_document :: index_entry_prefix_size(const region_id &ri, const index_id &ii) const
 {
-    return sizeof(uint8_t)
-         + e::varint_length(ri.get())
-         + e::varint_length(ii.get())
-         + sizeof(uint8_t);
+	return sizeof(uint8_t)
+	       + e::varint_length(ri.get())
+	       + e::varint_length(ii.get())
+	       + sizeof(uint8_t);
 }
 
 void
-index_document :: index_entry(const region_id& ri,
-                              const index_id& ii,
+index_document :: index_entry(const region_id &ri,
+                              const index_id &ii,
                               type_t t,
-                              std::vector<char>* scratch,
-                              e::slice* slice) const
+                              std::vector<char> *scratch,
+                              e::slice *slice) const
 {
-    size_t sz = sizeof(uint8_t)
-              + e::varint_length(ri.get())
-              + e::varint_length(ii.get())
-              + sizeof(uint8_t);
-
-    if (scratch->size() < sz)
-    {
-        scratch->resize(sz);
-    }
-
-    uint8_t t8;
-    if(t == STRING)
-    {
-        t8 = 's';
-    }
-    else if(t == NUMBER)
-    {
-        t8 = 'i';
-    }
-    else
-    {
-        t8 = 'd';
-    }
-
-    char* ptr = &scratch->front();
-    ptr = e::pack8be('i', ptr);
-    ptr = e::packvarint64(ri.get(), ptr);
-    ptr = e::packvarint64(ii.get(), ptr);
-    ptr = e::pack8be(t8, ptr);
-    assert(ptr == &scratch->front() + sz);
-    *slice = e::slice(&scratch->front(), sz);
+	size_t sz = sizeof(uint8_t)
+	            + e::varint_length(ri.get())
+	            + e::varint_length(ii.get())
+	            + sizeof(uint8_t);
+	if (scratch->size() < sz)
+	{
+		scratch->resize(sz);
+	}
+	uint8_t t8;
+	if (t == STRING)
+	{
+		t8 = 's';
+	}
+	else if (t == NUMBER)
+	{
+		t8 = 'i';
+	}
+	else
+	{
+		t8 = 'd';
+	}
+	char *ptr = &scratch->front();
+	ptr = e::pack8be('i', ptr);
+	ptr = e::packvarint64(ri.get(), ptr);
+	ptr = e::packvarint64(ii.get(), ptr);
+	ptr = e::pack8be(t8, ptr);
+	assert(ptr == &scratch->front() + sz);
+	*slice = e::slice(&scratch->front(), sz);
 }
 
 void
-index_document :: index_entry(const region_id& ri,
-                              const index_id& ii,
+index_document :: index_entry(const region_id &ri,
+                              const index_id &ii,
                               type_t t,
-                              const e::slice& value,
-                              std::vector<char>* scratch,
-                              e::slice* slice) const
+                              const e::slice &value,
+                              std::vector<char> *scratch,
+                              e::slice *slice) const
 {
-    const index_encoding* val_ie = lookup_encoding(t);
-
-    size_t val_sz = val_ie->encoded_size(value);
-    size_t sz = sizeof(uint8_t)
-              + e::varint_length(ri.get())
-              + e::varint_length(ii.get())
-              + sizeof(uint8_t)
-              + val_sz;
-
-    if (scratch->size() < sz)
-    {
-        scratch->resize(sz);
-    }
-
-    uint8_t t8;
-    if(t == STRING)
-    {
-        t8 = 's';
-    }
-    else if(t == NUMBER)
-    {
-        t8 = 'i';
-    }
-    else
-    {
-        t8 = 'd';
-    }
-
-    char* ptr = &scratch->front();
-    ptr = e::pack8be('i', ptr);
-    ptr = e::packvarint64(ri.get(), ptr);
-    ptr = e::packvarint64(ii.get(), ptr);
-    ptr = e::pack8be(t8, ptr);
-    ptr = val_ie->encode(value, ptr);
-    assert(ptr == &scratch->front() + sz);
-    *slice = e::slice(&scratch->front(), sz);
+	const index_encoding *val_ie = lookup_encoding(t);
+	size_t val_sz = val_ie->encoded_size(value);
+	size_t sz = sizeof(uint8_t)
+	            + e::varint_length(ri.get())
+	            + e::varint_length(ii.get())
+	            + sizeof(uint8_t)
+	            + val_sz;
+	if (scratch->size() < sz)
+	{
+		scratch->resize(sz);
+	}
+	uint8_t t8;
+	if (t == STRING)
+	{
+		t8 = 's';
+	}
+	else if (t == NUMBER)
+	{
+		t8 = 'i';
+	}
+	else
+	{
+		t8 = 'd';
+	}
+	char *ptr = &scratch->front();
+	ptr = e::pack8be('i', ptr);
+	ptr = e::packvarint64(ri.get(), ptr);
+	ptr = e::packvarint64(ii.get(), ptr);
+	ptr = e::pack8be(t8, ptr);
+	ptr = val_ie->encode(value, ptr);
+	assert(ptr == &scratch->front() + sz);
+	*slice = e::slice(&scratch->front(), sz);
 }
 
-hyperdex::datalayer::index_iterator*
+hyperdex::datalayer::index_iterator *
 index_document :: iterator_for_keys(leveldb_snapshot_ptr snap,
-                                     const region_id& ri) const
+                                    const region_id &ri) const
 {
-    range scan;
-    scan.attr = 0;
-    scan.type = HYPERDATATYPE_DOCUMENT;
-    scan.has_start = false;
-    scan.has_end = false;
-    scan.invalid = false;
-    const index_encoding* ie = index_encoding::lookup(scan.type);
-    return iterator_key(snap, ri, scan, ie);
+	range scan;
+	scan.attr = 0;
+	scan.type = HYPERDATATYPE_DOCUMENT;
+	scan.has_start = false;
+	scan.has_end = false;
+	scan.invalid = false;
+	const index_encoding *ie = index_encoding::lookup(scan.type);
+	return iterator_key(snap, ri, scan, ie);
 }
 
-hyperdex::datalayer::index_iterator*
+hyperdex::datalayer::index_iterator *
 index_document :: iterator_key(leveldb_snapshot_ptr snap,
-                                const region_id& ri,
-                                const range& r,
-                                const index_encoding* key_ie) const
+                               const region_id &ri,
+                               const range &r,
+                               const index_encoding *key_ie) const
 {
-    std::vector<char> scratch_start;
-    std::vector<char> scratch_limit;
-    e::slice start;
-    e::slice limit;
-
-    size_t range_prefix_sz = object_prefix_sz(ri);
-
-    if (r.has_start)
-    {
-        leveldb::Slice _start;
-        encode_key(ri, r.type, r.start, &scratch_start, &_start);
-        start = level2e(_start);
-    }
-    else
-    {
-        leveldb::Slice _start;
-        encode_object_region(ri, &scratch_start, &_start);
-        start = level2e(_start);
-    }
-
-    if (r.has_end)
-    {
-        leveldb::Slice _limit;
-        encode_key(ri, r.type, r.end, &scratch_limit, &_limit);
-        limit = level2e(_limit);
-    }
-    else
-    {
-        leveldb::Slice _limit;
-        encode_object_region(ri, &scratch_limit, &_limit);
-        limit = level2e(_limit);
-    }
-
-    return new hyperdex::datalayer::range_index_iterator(snap, range_prefix_sz,
-                                               start, limit,
-                                               r.has_start, r.has_end,
-                                               NULL, key_ie);
+	std::vector<char> scratch_start;
+	std::vector<char> scratch_limit;
+	e::slice start;
+	e::slice limit;
+	size_t range_prefix_sz = object_prefix_sz(ri);
+	if (r.has_start)
+	{
+		leveldb::Slice _start;
+		encode_key(ri, r.type, r.start, &scratch_start, &_start);
+		start = level2e(_start);
+	}
+	else
+	{
+		leveldb::Slice _start;
+		encode_object_region(ri, &scratch_start, &_start);
+		start = level2e(_start);
+	}
+	if (r.has_end)
+	{
+		leveldb::Slice _limit;
+		encode_key(ri, r.type, r.end, &scratch_limit, &_limit);
+		limit = level2e(_limit);
+	}
+	else
+	{
+		leveldb::Slice _limit;
+		encode_object_region(ri, &scratch_limit, &_limit);
+		limit = level2e(_limit);
+	}
+	return new hyperdex::datalayer::range_index_iterator(snap, range_prefix_sz,
+	        start, limit,
+	        r.has_start, r.has_end,
+	        NULL, key_ie);
 }
 
 void
-index_document :: index_entry(const region_id& ri,
-                              const index_id& ii,
+index_document :: index_entry(const region_id &ri,
+                              const index_id &ii,
                               type_t t,
-                              const index_encoding* key_ie,
-                              const e::slice& key,
-                              const e::slice& value,
-                              std::vector<char>* scratch,
-                              e::slice* slice) const
+                              const index_encoding *key_ie,
+                              const e::slice &key,
+                              const e::slice &value,
+                              std::vector<char> *scratch,
+                              e::slice *slice) const
 {
-    const index_encoding* val_ie = lookup_encoding(t);
-
-    size_t key_sz = key_ie->encoded_size(key);
-    size_t val_sz = val_ie->encoded_size(value);
-    bool variable = !key_ie->encoding_fixed() && !val_ie->encoding_fixed();
-    size_t sz = sizeof(uint8_t)
-              + e::varint_length(ri.get())
-              + e::varint_length(ii.get())
-              + sizeof(uint8_t)
-              + val_sz
-              + key_sz
-              + (variable ? sizeof(uint32_t) : 0);
-
-    if (scratch->size() < sz)
-    {
-        scratch->resize(sz);
-    }
-
-    uint8_t t8;
-    if(t == STRING)
-    {
-        t8 = 's';
-    }
-    else if(t == NUMBER)
-    {
-        t8 = 'i';
-    }
-    else
-    {
-        t8 = 'd';
-    }
-
-    char* ptr = &scratch->front();
-    ptr = e::pack8be('i', ptr);
-    ptr = e::packvarint64(ri.get(), ptr);
-    ptr = e::packvarint64(ii.get(), ptr);
-    ptr = e::pack8be(t8, ptr);
-    ptr = val_ie->encode(value, ptr);
-    ptr = key_ie->encode(key, ptr);
-
-    if (variable)
-    {
-        ptr = e::pack32be(key_sz, ptr);
-    }
-
-    assert(ptr == &scratch->front() + sz);
-    *slice = e::slice(&scratch->front(), sz);
+	const index_encoding *val_ie = lookup_encoding(t);
+	size_t key_sz = key_ie->encoded_size(key);
+	size_t val_sz = val_ie->encoded_size(value);
+	bool variable = !key_ie->encoding_fixed() && !val_ie->encoding_fixed();
+	size_t sz = sizeof(uint8_t)
+	            + e::varint_length(ri.get())
+	            + e::varint_length(ii.get())
+	            + sizeof(uint8_t)
+	            + val_sz
+	            + key_sz
+	            + (variable ? sizeof(uint32_t) : 0);
+	if (scratch->size() < sz)
+	{
+		scratch->resize(sz);
+	}
+	uint8_t t8;
+	if (t == STRING)
+	{
+		t8 = 's';
+	}
+	else if (t == NUMBER)
+	{
+		t8 = 'i';
+	}
+	else
+	{
+		t8 = 'd';
+	}
+	char *ptr = &scratch->front();
+	ptr = e::pack8be('i', ptr);
+	ptr = e::packvarint64(ri.get(), ptr);
+	ptr = e::packvarint64(ii.get(), ptr);
+	ptr = e::pack8be(t8, ptr);
+	ptr = val_ie->encode(value, ptr);
+	ptr = key_ie->encode(key, ptr);
+	if (variable)
+	{
+		ptr = e::pack32be(key_sz, ptr);
+	}
+	assert(ptr == &scratch->front() + sz);
+	*slice = e::slice(&scratch->front(), sz);
 }
 
 index_encoding_document :: index_encoding_document()
@@ -473,31 +438,31 @@ index_encoding_document :: ~index_encoding_document() throw ()
 bool
 index_encoding_document :: encoding_fixed() const
 {
-    return false;
+	return false;
 }
 
 size_t
-index_encoding_document :: encoded_size(const e::slice& decoded) const
+index_encoding_document :: encoded_size(const e::slice &decoded) const
 {
-    return decoded.size();
+	return decoded.size();
 }
 
-char*
-index_encoding_document :: encode(const e::slice& decoded, char* encoded) const
+char *
+index_encoding_document :: encode(const e::slice &decoded, char *encoded) const
 {
-    memmove(encoded, decoded.data(), decoded.size());
-    return encoded + decoded.size();
+	memmove(encoded, decoded.data(), decoded.size());
+	return encoded + decoded.size();
 }
 
 size_t
-index_encoding_document :: decoded_size(const e::slice& encoded) const
+index_encoding_document :: decoded_size(const e::slice &encoded) const
 {
-    return encoded.size();
+	return encoded.size();
 }
 
-char*
-index_encoding_document :: decode(const e::slice& encoded, char* decoded) const
+char *
+index_encoding_document :: decode(const e::slice &encoded, char *decoded) const
 {
-    memmove(decoded, encoded.data(), encoded.size());
-    return decoded + encoded.size();
+	memmove(decoded, encoded.data(), encoded.size());
+	return decoded + encoded.size();
 }
diff --git a/daemon/index_document.h b/daemon/index_document.h
index a09264261..4c5c1b6c2 100644
--- a/daemon/index_document.h
+++ b/daemon/index_document.h
@@ -37,78 +37,78 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class index_document : public index_info
 {
-    public:
-        index_document();
-        virtual ~index_document() throw ();
+public:
+	index_document();
+	virtual ~index_document() throw ();
 
-    public:
-        virtual hyperdatatype datatype() const;
-        virtual void index_changes(const index* idx,
-                                   const region_id& ri,
-                                   const index_encoding* key_ie,
-                                   const e::slice& key,
-                                   const e::slice* old_document,
-                                   const e::slice* new_document,
-                                   leveldb::WriteBatch* updates) const;
-        virtual datalayer::index_iterator* iterator_from_check(leveldb_snapshot_ptr snap,
-                                                               const region_id& ri,
-                                                               const index_id& ii,
-                                                               const attribute_check& c,
-                                                               const index_encoding* key_ie) const;
-        virtual datalayer::index_iterator* iterator_for_keys(leveldb_snapshot_ptr snap,
-                                             const region_id& ri) const;
+public:
+	virtual hyperdatatype datatype() const;
+	virtual void index_changes(const index *idx,
+	                           const region_id &ri,
+	                           const index_encoding *key_ie,
+	                           const e::slice &key,
+	                           const e::slice *old_document,
+	                           const e::slice *new_document,
+	                           leveldb::WriteBatch *updates) const;
+	virtual datalayer::index_iterator *iterator_from_check(leveldb_snapshot_ptr snap,
+	        const region_id &ri,
+	        const index_id &ii,
+	        const attribute_check &c,
+	        const index_encoding *key_ie) const;
+	virtual datalayer::index_iterator *iterator_for_keys(leveldb_snapshot_ptr snap,
+	        const region_id &ri) const;
 
-    private:
-        enum type_t { STRING, NUMBER, DOCUMENT };
-        bool parse_path(const index* idx,
-                        const e::slice& document,
-                        type_t* t,
-                        std::vector<char>* scratch,
-                        e::slice* value) const;
-        size_t index_entry_prefix_size(const region_id& ri, const index_id& ii) const;
-        void index_entry(const region_id& ri,
-                         const index_id& ii,
-                         type_t t,
-                         std::vector<char>* scratch,
-                         e::slice* slice) const;
-        void index_entry(const region_id& ri,
-                         const index_id& ii,
-                         type_t t,
-                         const e::slice& value,
-                         std::vector<char>* scratch,
-                         e::slice* slice) const;
-        void index_entry(const region_id& ri,
-                         const index_id& ii,
-                         type_t t,
-                         const index_encoding* key_ie,
-                         const e::slice& key,
-                         const e::slice& value,
-                         std::vector<char>* scratch,
-                         e::slice* slice) const;
+private:
+	enum type_t { STRING, NUMBER, DOCUMENT };
+	bool parse_path(const index *idx,
+	                const e::slice &document,
+	                type_t *t,
+	                std::vector<char> *scratch,
+	                e::slice *value) const;
+	size_t index_entry_prefix_size(const region_id &ri, const index_id &ii) const;
+	void index_entry(const region_id &ri,
+	                 const index_id &ii,
+	                 type_t t,
+	                 std::vector<char> *scratch,
+	                 e::slice *slice) const;
+	void index_entry(const region_id &ri,
+	                 const index_id &ii,
+	                 type_t t,
+	                 const e::slice &value,
+	                 std::vector<char> *scratch,
+	                 e::slice *slice) const;
+	void index_entry(const region_id &ri,
+	                 const index_id &ii,
+	                 type_t t,
+	                 const index_encoding *key_ie,
+	                 const e::slice &key,
+	                 const e::slice &value,
+	                 std::vector<char> *scratch,
+	                 e::slice *slice) const;
 
-        datalayer::index_iterator* iterator_key(leveldb_snapshot_ptr snap,
-                                        const region_id& ri,
-                                        const range& r,
-                                        const index_encoding* key_ie) const;
+	datalayer::index_iterator *iterator_key(leveldb_snapshot_ptr snap,
+	                                        const region_id &ri,
+	                                        const range &r,
+	                                        const index_encoding *key_ie) const;
 
-        const index_encoding* lookup_encoding(type_t t) const;
+	const index_encoding *lookup_encoding(type_t t) const;
 
-    private:
-        const datatype_document m_di;
+private:
+	const datatype_document m_di;
 };
 
 class index_encoding_document : public index_encoding
 {
-    public:
-        index_encoding_document();
-        virtual ~index_encoding_document() throw ();
+public:
+	index_encoding_document();
+	virtual ~index_encoding_document() throw ();
 
-    public:
-        virtual bool encoding_fixed() const;
-        virtual size_t encoded_size(const e::slice& decoded) const;
-        virtual char* encode(const e::slice& decoded, char* encoded) const;
-        virtual size_t decoded_size(const e::slice& encoded) const;
-        virtual char* decode(const e::slice& encoded, char* decoded) const;
+public:
+	virtual bool encoding_fixed() const;
+	virtual size_t encoded_size(const e::slice &decoded) const;
+	virtual char *encode(const e::slice &decoded, char *encoded) const;
+	virtual size_t decoded_size(const e::slice &encoded) const;
+	virtual char *decode(const e::slice &encoded, char *decoded) const;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/daemon/index_float.cc b/daemon/index_float.cc
index 2aad97e6d..9dffccd44 100644
--- a/daemon/index_float.cc
+++ b/daemon/index_float.cc
@@ -38,7 +38,7 @@ using hyperdex::index_float;
 using hyperdex::index_encoding_float;
 
 index_float :: index_float()
-    : index_primitive(index_encoding::lookup(HYPERDATATYPE_FLOAT))
+	: index_primitive(index_encoding::lookup(HYPERDATATYPE_FLOAT))
 {
 }
 
@@ -49,7 +49,7 @@ index_float :: ~index_float() throw ()
 hyperdatatype
 index_float :: datatype() const
 {
-    return HYPERDATATYPE_FLOAT;
+	return HYPERDATATYPE_FLOAT;
 }
 
 index_encoding_float :: index_encoding_float()
@@ -63,48 +63,44 @@ index_encoding_float :: ~index_encoding_float() throw ()
 bool
 index_encoding_float :: encoding_fixed() const
 {
-    return true;
+	return true;
 }
 
 size_t
-index_encoding_float :: encoded_size(const e::slice&) const
+index_encoding_float :: encoded_size(const e::slice &) const
 {
-    // why?
-    return 2 * sizeof(double);
+	// why?
+	return 2 * sizeof(double);
 }
 
-char*
-index_encoding_float :: encode(const e::slice& decoded, char* encoded) const
+char *
+index_encoding_float :: encode(const e::slice &decoded, char *encoded) const
 {
-    datatype_info* di = datatype_info::lookup(HYPERDATATYPE_FLOAT);
-    double number = 0;
-
-    if (di->validate(decoded) && decoded.size() == sizeof(double))
-    {
-        e::unpackdoublele(decoded.data(), &number);
-    }
-
-    char* ptr = encoded;
-    ptr = e::pack64be(di->hash(decoded), ptr);
-    ptr = e::packdoublele(number, ptr);
-    return ptr;
+	datatype_info *di = datatype_info::lookup(HYPERDATATYPE_FLOAT);
+	double number = 0;
+	if (di->validate(decoded) && decoded.size() == sizeof(double))
+	{
+		e::unpackdoublele(decoded.data(), &number);
+	}
+	char *ptr = encoded;
+	ptr = e::pack64be(di->hash(decoded), ptr);
+	ptr = e::packdoublele(number, ptr);
+	return ptr;
 }
 
 size_t
-index_encoding_float :: decoded_size(const e::slice&) const
+index_encoding_float :: decoded_size(const e::slice &) const
 {
-    return sizeof(double);
+	return sizeof(double);
 }
 
-char*
-index_encoding_float :: decode(const e::slice& encoded, char* decoded) const
+char *
+index_encoding_float :: decode(const e::slice &encoded, char *decoded) const
 {
-    double number = 0;
-
-    if (encoded.size() == 2 * sizeof(double))
-    {
-        e::unpackdoublele(decoded + sizeof(double), &number);
-    }
-
-    return e::packdoublele(number, decoded);
+	double number = 0;
+	if (encoded.size() == 2 * sizeof(double))
+	{
+		e::unpackdoublele(decoded + sizeof(double), &number);
+	}
+	return e::packdoublele(number, decoded);
 }
diff --git a/daemon/index_float.h b/daemon/index_float.h
index 7d63e9885..9a5914473 100644
--- a/daemon/index_float.h
+++ b/daemon/index_float.h
@@ -36,26 +36,26 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class index_float : public index_primitive
 {
-    public:
-        index_float();
-        virtual ~index_float() throw ();
+public:
+	index_float();
+	virtual ~index_float() throw ();
 
-    public:
-        virtual hyperdatatype datatype() const;
+public:
+	virtual hyperdatatype datatype() const;
 };
 
 class index_encoding_float : public index_encoding
 {
-    public:
-        index_encoding_float();
-        virtual ~index_encoding_float() throw ();
-
-    public:
-        virtual bool encoding_fixed() const;
-        virtual size_t encoded_size(const e::slice& decoded) const;
-        virtual char* encode(const e::slice& decoded, char* encoded) const;
-        virtual size_t decoded_size(const e::slice& encoded) const;
-        virtual char* decode(const e::slice& encoded, char* decoded) const;
+public:
+	index_encoding_float();
+	virtual ~index_encoding_float() throw ();
+
+public:
+	virtual bool encoding_fixed() const;
+	virtual size_t encoded_size(const e::slice &decoded) const;
+	virtual char *encode(const e::slice &decoded, char *encoded) const;
+	virtual size_t decoded_size(const e::slice &encoded) const;
+	virtual char *decode(const e::slice &encoded, char *decoded) const;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/daemon/index_info.cc b/daemon/index_info.cc
index 44852f2dd..c9901b328 100644
--- a/daemon/index_info.cc
+++ b/daemon/index_info.cc
@@ -73,54 +73,54 @@ static const hyperdex::index_timestamp i_timestamp_day(HYPERDATATYPE_TIMESTAMP_D
 static const hyperdex::index_timestamp i_timestamp_week(HYPERDATATYPE_TIMESTAMP_WEEK);
 static const hyperdex::index_timestamp i_timestamp_month(HYPERDATATYPE_TIMESTAMP_MONTH);
 
-const index_encoding*
+const index_encoding *
 index_encoding :: lookup(hyperdatatype datatype)
 {
-    switch (datatype)
-    {
-        case HYPERDATATYPE_STRING:
-            return &e_string;
-        case HYPERDATATYPE_INT64:
-            return &e_int64;
-        case HYPERDATATYPE_FLOAT:
-            return &e_float;
-        case HYPERDATATYPE_TIMESTAMP_SECOND:
-        case HYPERDATATYPE_TIMESTAMP_MINUTE:
-        case HYPERDATATYPE_TIMESTAMP_HOUR:
-        case HYPERDATATYPE_TIMESTAMP_DAY:
-        case HYPERDATATYPE_TIMESTAMP_WEEK:
-        case HYPERDATATYPE_TIMESTAMP_MONTH:
-            return &e_timestamp;
-        case HYPERDATATYPE_DOCUMENT:
-            return &e_document;
-        case HYPERDATATYPE_GENERIC:
-        case HYPERDATATYPE_LIST_GENERIC:
-        case HYPERDATATYPE_LIST_STRING:
-        case HYPERDATATYPE_LIST_INT64:
-        case HYPERDATATYPE_LIST_FLOAT:
-        case HYPERDATATYPE_SET_GENERIC:
-        case HYPERDATATYPE_SET_STRING:
-        case HYPERDATATYPE_SET_INT64:
-        case HYPERDATATYPE_SET_FLOAT:
-        case HYPERDATATYPE_MAP_GENERIC:
-        case HYPERDATATYPE_TIMESTAMP_GENERIC:
-        case HYPERDATATYPE_MAP_STRING_KEYONLY:
-        case HYPERDATATYPE_MAP_STRING_STRING:
-        case HYPERDATATYPE_MAP_STRING_INT64:
-        case HYPERDATATYPE_MAP_STRING_FLOAT:
-        case HYPERDATATYPE_MAP_INT64_KEYONLY:
-        case HYPERDATATYPE_MAP_INT64_STRING:
-        case HYPERDATATYPE_MAP_INT64_INT64:
-        case HYPERDATATYPE_MAP_INT64_FLOAT:
-        case HYPERDATATYPE_MAP_FLOAT_KEYONLY:
-        case HYPERDATATYPE_MAP_FLOAT_STRING:
-        case HYPERDATATYPE_MAP_FLOAT_INT64:
-        case HYPERDATATYPE_MAP_FLOAT_FLOAT:
-        case HYPERDATATYPE_MACAROON_SECRET:
-        case HYPERDATATYPE_GARBAGE:
-        default:
-            abort();
-    }
+	switch (datatype)
+	{
+	case HYPERDATATYPE_STRING:
+		return &e_string;
+	case HYPERDATATYPE_INT64:
+		return &e_int64;
+	case HYPERDATATYPE_FLOAT:
+		return &e_float;
+	case HYPERDATATYPE_TIMESTAMP_SECOND:
+	case HYPERDATATYPE_TIMESTAMP_MINUTE:
+	case HYPERDATATYPE_TIMESTAMP_HOUR:
+	case HYPERDATATYPE_TIMESTAMP_DAY:
+	case HYPERDATATYPE_TIMESTAMP_WEEK:
+	case HYPERDATATYPE_TIMESTAMP_MONTH:
+		return &e_timestamp;
+	case HYPERDATATYPE_DOCUMENT:
+		return &e_document;
+	case HYPERDATATYPE_GENERIC:
+	case HYPERDATATYPE_LIST_GENERIC:
+	case HYPERDATATYPE_LIST_STRING:
+	case HYPERDATATYPE_LIST_INT64:
+	case HYPERDATATYPE_LIST_FLOAT:
+	case HYPERDATATYPE_SET_GENERIC:
+	case HYPERDATATYPE_SET_STRING:
+	case HYPERDATATYPE_SET_INT64:
+	case HYPERDATATYPE_SET_FLOAT:
+	case HYPERDATATYPE_MAP_GENERIC:
+	case HYPERDATATYPE_TIMESTAMP_GENERIC:
+	case HYPERDATATYPE_MAP_STRING_KEYONLY:
+	case HYPERDATATYPE_MAP_STRING_STRING:
+	case HYPERDATATYPE_MAP_STRING_INT64:
+	case HYPERDATATYPE_MAP_STRING_FLOAT:
+	case HYPERDATATYPE_MAP_INT64_KEYONLY:
+	case HYPERDATATYPE_MAP_INT64_STRING:
+	case HYPERDATATYPE_MAP_INT64_INT64:
+	case HYPERDATATYPE_MAP_INT64_FLOAT:
+	case HYPERDATATYPE_MAP_FLOAT_KEYONLY:
+	case HYPERDATATYPE_MAP_FLOAT_STRING:
+	case HYPERDATATYPE_MAP_FLOAT_INT64:
+	case HYPERDATATYPE_MAP_FLOAT_FLOAT:
+	case HYPERDATATYPE_MACAROON_SECRET:
+	case HYPERDATATYPE_GARBAGE:
+	default:
+		abort();
+	}
 }
 
 index_encoding :: index_encoding()
@@ -131,74 +131,74 @@ index_encoding :: ~index_encoding() throw ()
 {
 }
 
-const index_info*
+const index_info *
 index_info :: lookup(hyperdatatype datatype)
 {
-    switch (datatype)
-    {
-        case HYPERDATATYPE_STRING:
-            return &i_string;
-        case HYPERDATATYPE_INT64:
-            return &i_int64;
-        case HYPERDATATYPE_FLOAT:
-            return &i_float;
-        case HYPERDATATYPE_TIMESTAMP_SECOND:
-            return &i_timestamp_second;
-        case HYPERDATATYPE_TIMESTAMP_MINUTE:
-            return &i_timestamp_minute;
-        case HYPERDATATYPE_TIMESTAMP_HOUR:
-            return &i_timestamp_hour;
-        case HYPERDATATYPE_TIMESTAMP_DAY:
-            return &i_timestamp_day;
-        case HYPERDATATYPE_TIMESTAMP_WEEK:
-            return &i_timestamp_week;
-        case HYPERDATATYPE_TIMESTAMP_MONTH:
-            return &i_timestamp_month;
-        case HYPERDATATYPE_DOCUMENT:
-            return &i_document;
-        case HYPERDATATYPE_LIST_STRING:
-            return &i_list_string;
-        case HYPERDATATYPE_LIST_INT64:
-            return &i_list_int64;
-        case HYPERDATATYPE_LIST_FLOAT:
-            return &i_list_float;
-        case HYPERDATATYPE_SET_STRING:
-            return &i_set_string;
-        case HYPERDATATYPE_SET_INT64:
-            return &i_set_int64;
-        case HYPERDATATYPE_SET_FLOAT:
-            return &i_set_float;
-        case HYPERDATATYPE_MAP_STRING_STRING:
-            return &i_map_string_string;
-        case HYPERDATATYPE_MAP_STRING_INT64:
-            return &i_map_string_int64;
-        case HYPERDATATYPE_MAP_STRING_FLOAT:
-            return &i_map_string_float;
-        case HYPERDATATYPE_MAP_INT64_STRING:
-            return &i_map_int64_string;
-        case HYPERDATATYPE_MAP_INT64_INT64:
-            return &i_map_int64_int64;
-        case HYPERDATATYPE_MAP_INT64_FLOAT:
-            return &i_map_int64_float;
-        case HYPERDATATYPE_MAP_FLOAT_STRING:
-            return &i_map_float_string;
-        case HYPERDATATYPE_MAP_FLOAT_INT64:
-            return &i_map_float_int64;
-        case HYPERDATATYPE_MAP_FLOAT_FLOAT:
-            return &i_map_float_float;
-        case HYPERDATATYPE_GENERIC:
-        case HYPERDATATYPE_LIST_GENERIC:
-        case HYPERDATATYPE_SET_GENERIC:
-        case HYPERDATATYPE_MAP_GENERIC:
-        case HYPERDATATYPE_MAP_STRING_KEYONLY:
-        case HYPERDATATYPE_MAP_INT64_KEYONLY:
-        case HYPERDATATYPE_MAP_FLOAT_KEYONLY:
-        case HYPERDATATYPE_TIMESTAMP_GENERIC:
-        case HYPERDATATYPE_MACAROON_SECRET:
-        case HYPERDATATYPE_GARBAGE:
-        default:
-            abort();
-    }
+	switch (datatype)
+	{
+	case HYPERDATATYPE_STRING:
+		return &i_string;
+	case HYPERDATATYPE_INT64:
+		return &i_int64;
+	case HYPERDATATYPE_FLOAT:
+		return &i_float;
+	case HYPERDATATYPE_TIMESTAMP_SECOND:
+		return &i_timestamp_second;
+	case HYPERDATATYPE_TIMESTAMP_MINUTE:
+		return &i_timestamp_minute;
+	case HYPERDATATYPE_TIMESTAMP_HOUR:
+		return &i_timestamp_hour;
+	case HYPERDATATYPE_TIMESTAMP_DAY:
+		return &i_timestamp_day;
+	case HYPERDATATYPE_TIMESTAMP_WEEK:
+		return &i_timestamp_week;
+	case HYPERDATATYPE_TIMESTAMP_MONTH:
+		return &i_timestamp_month;
+	case HYPERDATATYPE_DOCUMENT:
+		return &i_document;
+	case HYPERDATATYPE_LIST_STRING:
+		return &i_list_string;
+	case HYPERDATATYPE_LIST_INT64:
+		return &i_list_int64;
+	case HYPERDATATYPE_LIST_FLOAT:
+		return &i_list_float;
+	case HYPERDATATYPE_SET_STRING:
+		return &i_set_string;
+	case HYPERDATATYPE_SET_INT64:
+		return &i_set_int64;
+	case HYPERDATATYPE_SET_FLOAT:
+		return &i_set_float;
+	case HYPERDATATYPE_MAP_STRING_STRING:
+		return &i_map_string_string;
+	case HYPERDATATYPE_MAP_STRING_INT64:
+		return &i_map_string_int64;
+	case HYPERDATATYPE_MAP_STRING_FLOAT:
+		return &i_map_string_float;
+	case HYPERDATATYPE_MAP_INT64_STRING:
+		return &i_map_int64_string;
+	case HYPERDATATYPE_MAP_INT64_INT64:
+		return &i_map_int64_int64;
+	case HYPERDATATYPE_MAP_INT64_FLOAT:
+		return &i_map_int64_float;
+	case HYPERDATATYPE_MAP_FLOAT_STRING:
+		return &i_map_float_string;
+	case HYPERDATATYPE_MAP_FLOAT_INT64:
+		return &i_map_float_int64;
+	case HYPERDATATYPE_MAP_FLOAT_FLOAT:
+		return &i_map_float_float;
+	case HYPERDATATYPE_GENERIC:
+	case HYPERDATATYPE_LIST_GENERIC:
+	case HYPERDATATYPE_SET_GENERIC:
+	case HYPERDATATYPE_MAP_GENERIC:
+	case HYPERDATATYPE_MAP_STRING_KEYONLY:
+	case HYPERDATATYPE_MAP_INT64_KEYONLY:
+	case HYPERDATATYPE_MAP_FLOAT_KEYONLY:
+	case HYPERDATATYPE_TIMESTAMP_GENERIC:
+	case HYPERDATATYPE_MACAROON_SECRET:
+	case HYPERDATATYPE_GARBAGE:
+	default:
+		abort();
+	}
 }
 
 index_info :: index_info()
@@ -209,29 +209,29 @@ index_info :: ~index_info() throw ()
 {
 }
 
-datalayer::index_iterator*
+datalayer::index_iterator *
 index_info :: iterator_for_keys(leveldb_snapshot_ptr,
-                                const region_id&) const
+                                const region_id &) const
 {
-    return NULL;
+	return NULL;
 }
 
-datalayer::index_iterator*
+datalayer::index_iterator *
 index_info :: iterator_from_range(leveldb_snapshot_ptr,
-                                  const region_id&,
-                                  const index_id&,
-                                  const range&,
-                                  const index_encoding*) const
+                                  const region_id &,
+                                  const index_id &,
+                                  const range &,
+                                  const index_encoding *) const
 {
-    return NULL;
+	return NULL;
 }
 
-datalayer::index_iterator*
+datalayer::index_iterator *
 index_info :: iterator_from_check(leveldb_snapshot_ptr,
-                                  const region_id&,
-                                  const index_id&,
-                                  const attribute_check&,
-                                  const index_encoding*) const
+                                  const region_id &,
+                                  const index_id &,
+                                  const attribute_check &,
+                                  const index_encoding *) const
 {
-    return NULL;
+	return NULL;
 }
diff --git a/daemon/index_info.h b/daemon/index_info.h
index 12453c093..e7ca3af34 100644
--- a/daemon/index_info.h
+++ b/daemon/index_info.h
@@ -46,70 +46,70 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class index_encoding
 {
-    public:
-        // return NULL for unencodable type
-        static const index_encoding* lookup(hyperdatatype datatype);
+public:
+	// return NULL for unencodable type
+	static const index_encoding *lookup(hyperdatatype datatype);
 
-    public:
-        index_encoding();
-        virtual ~index_encoding() throw ();
+public:
+	index_encoding();
+	virtual ~index_encoding() throw ();
 
-    public:
-        // is this encoding fixed in size?  are encoded_size() and
-        // decoded_size() invariant of the passed slice?
-        virtual bool encoding_fixed() const = 0;
-        // the number of bytes necessary to encode "decoded"
-        virtual size_t encoded_size(const e::slice& decoded) const = 0;
-        // write the encoded form of "decoded" to "encoded" which points to at
-        // least "encoded_size" bytes of memory
-        virtual char* encode(const e::slice& decoded, char* encoded) const = 0;
-        // the number of bytes necessary to decode "encoded"
-        virtual size_t decoded_size(const e::slice& encoded) const = 0;
-        // write the decoded form of "encoded" to "decoded" which points to at
-        // least "decoded_size" bytes of memory
-        virtual char* decode(const e::slice& encoded, char* decoded) const = 0;
+public:
+	// is this encoding fixed in size?  are encoded_size() and
+	// decoded_size() invariant of the passed slice?
+	virtual bool encoding_fixed() const = 0;
+	// the number of bytes necessary to encode "decoded"
+	virtual size_t encoded_size(const e::slice &decoded) const = 0;
+	// write the encoded form of "decoded" to "encoded" which points to at
+	// least "encoded_size" bytes of memory
+	virtual char *encode(const e::slice &decoded, char *encoded) const = 0;
+	// the number of bytes necessary to decode "encoded"
+	virtual size_t decoded_size(const e::slice &encoded) const = 0;
+	// write the decoded form of "encoded" to "decoded" which points to at
+	// least "decoded_size" bytes of memory
+	virtual char *decode(const e::slice &encoded, char *decoded) const = 0;
 };
 
 class index_info
 {
-    public:
-        // return NULL for unindexable type
-        static const index_info* lookup(hyperdatatype datatype);
+public:
+	// return NULL for unindexable type
+	static const index_info *lookup(hyperdatatype datatype);
 
-    public:
-        index_info();
-        virtual ~index_info() throw ();
+public:
+	index_info();
+	virtual ~index_info() throw ();
 
-    public:
-        // what datatype is this index for?
-        virtual hyperdatatype datatype() const = 0;
-        // apply to updates all the writes necessary to transform the index from
-        // old_value to new_value
-        virtual void index_changes(const index* idx,
-                                   const region_id& ri,
-                                   const index_encoding* key_ie,
-                                   const e::slice& key,
-                                   const e::slice* old_value,
-                                   const e::slice* new_value,
-                                   leveldb::WriteBatch* updates) const = 0;
-        // return an iterator across all keys
-        // if not indexable (full scan), return NULL
-        virtual datalayer::index_iterator* iterator_for_keys(leveldb_snapshot_ptr snap,
-                                                             const region_id& ri) const;
-        // return an iterator that retrieves at least the keys matching r
-        // if not indexable (full scan), return NULL
-        virtual datalayer::index_iterator* iterator_from_range(leveldb_snapshot_ptr snap,
-                                                               const region_id& ri,
-                                                               const index_id& ii,
-                                                               const range& r,
-                                                               const index_encoding* key_ie) const;
-        // return an iterator that retrieves at least the keys that pass c
-        // if not indexable (full scan), return NULL
-        virtual datalayer::index_iterator* iterator_from_check(leveldb_snapshot_ptr snap,
-                                                               const region_id& ri,
-                                                               const index_id& ii,
-                                                               const attribute_check& c,
-                                                               const index_encoding* key_ie) const;
+public:
+	// what datatype is this index for?
+	virtual hyperdatatype datatype() const = 0;
+	// apply to updates all the writes necessary to transform the index from
+	// old_value to new_value
+	virtual void index_changes(const index *idx,
+	                           const region_id &ri,
+	                           const index_encoding *key_ie,
+	                           const e::slice &key,
+	                           const e::slice *old_value,
+	                           const e::slice *new_value,
+	                           leveldb::WriteBatch *updates) const = 0;
+	// return an iterator across all keys
+	// if not indexable (full scan), return NULL
+	virtual datalayer::index_iterator *iterator_for_keys(leveldb_snapshot_ptr snap,
+	        const region_id &ri) const;
+	// return an iterator that retrieves at least the keys matching r
+	// if not indexable (full scan), return NULL
+	virtual datalayer::index_iterator *iterator_from_range(leveldb_snapshot_ptr snap,
+	        const region_id &ri,
+	        const index_id &ii,
+	        const range &r,
+	        const index_encoding *key_ie) const;
+	// return an iterator that retrieves at least the keys that pass c
+	// if not indexable (full scan), return NULL
+	virtual datalayer::index_iterator *iterator_from_check(leveldb_snapshot_ptr snap,
+	        const region_id &ri,
+	        const index_id &ii,
+	        const attribute_check &c,
+	        const index_encoding *key_ie) const;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/daemon/index_int64.cc b/daemon/index_int64.cc
index b09d2ddf3..162b19294 100644
--- a/daemon/index_int64.cc
+++ b/daemon/index_int64.cc
@@ -38,7 +38,7 @@ using hyperdex::index_int64;
 using hyperdex::index_encoding_int64;
 
 index_int64 :: index_int64()
-    : index_primitive(index_encoding::lookup(HYPERDATATYPE_INT64))
+	: index_primitive(index_encoding::lookup(HYPERDATATYPE_INT64))
 {
 }
 
@@ -49,7 +49,7 @@ index_int64 :: ~index_int64() throw ()
 hyperdatatype
 index_int64 :: datatype() const
 {
-    return HYPERDATATYPE_INT64;
+	return HYPERDATATYPE_INT64;
 }
 
 index_encoding_int64 :: index_encoding_int64()
@@ -63,37 +63,35 @@ index_encoding_int64 :: ~index_encoding_int64() throw ()
 bool
 index_encoding_int64 :: encoding_fixed() const
 {
-    return true;
+	return true;
 }
 
 size_t
-index_encoding_int64 :: encoded_size(const e::slice&) const
+index_encoding_int64 :: encoded_size(const e::slice &) const
 {
-    return sizeof(int64_t);
+	return sizeof(int64_t);
 }
 
-char*
-index_encoding_int64 :: encode(const e::slice& decoded, char* encoded) const
+char *
+index_encoding_int64 :: encode(const e::slice &decoded, char *encoded) const
 {
-    return e::pack64be(datatype_info::lookup(HYPERDATATYPE_INT64)->hash(decoded), encoded);
+	return e::pack64be(datatype_info::lookup(HYPERDATATYPE_INT64)->hash(decoded), encoded);
 }
 
 size_t
-index_encoding_int64 :: decoded_size(const e::slice&) const
+index_encoding_int64 :: decoded_size(const e::slice &) const
 {
-    return sizeof(int64_t);
+	return sizeof(int64_t);
 }
 
-char*
-index_encoding_int64 :: decode(const e::slice& encoded, char* decoded) const
+char *
+index_encoding_int64 :: decode(const e::slice &encoded, char *decoded) const
 {
-    uint64_t x = 0;
-
-    if (encoded.size() == sizeof(int64_t))
-    {
-        e::unpack64be(encoded.data(), &x);
-    }
-
-    int64_t number = ordered_decode_int64(x);
-    return e::pack64le(number, decoded);
+	uint64_t x = 0;
+	if (encoded.size() == sizeof(int64_t))
+	{
+		e::unpack64be(encoded.data(), &x);
+	}
+	int64_t number = ordered_decode_int64(x);
+	return e::pack64le(number, decoded);
 }
diff --git a/daemon/index_int64.h b/daemon/index_int64.h
index 7cb903cba..69c1450c7 100644
--- a/daemon/index_int64.h
+++ b/daemon/index_int64.h
@@ -36,26 +36,26 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class index_int64 : public index_primitive
 {
-    public:
-        index_int64();
-        virtual ~index_int64() throw ();
+public:
+	index_int64();
+	virtual ~index_int64() throw ();
 
-    public:
-        virtual hyperdatatype datatype() const;
+public:
+	virtual hyperdatatype datatype() const;
 };
 
 class index_encoding_int64 : public index_encoding
 {
-    public:
-        index_encoding_int64();
-        virtual ~index_encoding_int64() throw ();
-
-    public:
-        virtual bool encoding_fixed() const;
-        virtual size_t encoded_size(const e::slice& decoded) const;
-        virtual char* encode(const e::slice& decoded, char* encoded) const;
-        virtual size_t decoded_size(const e::slice& encoded) const;
-        virtual char* decode(const e::slice& encoded, char* decoded) const;
+public:
+	index_encoding_int64();
+	virtual ~index_encoding_int64() throw ();
+
+public:
+	virtual bool encoding_fixed() const;
+	virtual size_t encoded_size(const e::slice &decoded) const;
+	virtual char *encode(const e::slice &decoded, char *encoded) const;
+	virtual size_t decoded_size(const e::slice &encoded) const;
+	virtual char *decode(const e::slice &encoded, char *decoded) const;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/daemon/index_list.cc b/daemon/index_list.cc
index 0711263c1..d4242f7ab 100644
--- a/daemon/index_list.cc
+++ b/daemon/index_list.cc
@@ -36,7 +36,7 @@ using hyperdex::index_info;
 using hyperdex::index_list;
 
 index_list :: index_list(hyperdatatype dt)
-    : m_datatype(dt)
+	: m_datatype(dt)
 {
 }
 
@@ -47,36 +47,34 @@ index_list :: ~index_list() throw ()
 hyperdatatype
 index_list :: datatype() const
 {
-    return CREATE_CONTAINER(HYPERDATATYPE_LIST_GENERIC, m_datatype);
+	return CREATE_CONTAINER(HYPERDATATYPE_LIST_GENERIC, m_datatype);
 }
 
 void
-index_list :: extract_elements(const e::slice& list,
-                              std::vector<e::slice>* elems) const
+index_list :: extract_elements(const e::slice &list,
+                               std::vector<e::slice> *elems) const
 {
-    datatype_info* elem = datatype_info::lookup(m_datatype);
-    const uint8_t* ptr = list.data();
-    const uint8_t* end = list.data() + list.size();
-    e::slice e;
-
-    while (ptr < end)
-    {
-        bool stepped = elem->step(&ptr, end, &e);
-        assert(stepped);
-        elems->push_back(e);
-    }
-
-    assert(ptr == end);
+	datatype_info *elem = datatype_info::lookup(m_datatype);
+	const uint8_t *ptr = list.data();
+	const uint8_t *end = list.data() + list.size();
+	e::slice e;
+	while (ptr < end)
+	{
+		bool stepped = elem->step(&ptr, end, &e);
+		assert(stepped);
+		elems->push_back(e);
+	}
+	assert(ptr == end);
 }
 
-const datatype_info*
+const datatype_info *
 index_list :: element_datatype_info() const
 {
-    return datatype_info::lookup(m_datatype);
+	return datatype_info::lookup(m_datatype);
 }
 
-const index_info*
+const index_info *
 index_list :: element_index_info() const
 {
-    return index_info::lookup(m_datatype);
+	return index_info::lookup(m_datatype);
 }
diff --git a/daemon/index_list.h b/daemon/index_list.h
index 44219cb78..7a06d44fc 100644
--- a/daemon/index_list.h
+++ b/daemon/index_list.h
@@ -37,19 +37,19 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class index_list : public index_container
 {
-    public:
-        index_list(hyperdatatype datatype);
-        virtual ~index_list() throw ();
-
-    private:
-        virtual hyperdatatype datatype() const;
-        virtual void extract_elements(const e::slice& container,
-                                      std::vector<e::slice>* elems) const;
-        virtual const datatype_info* element_datatype_info() const;
-        virtual const index_info* element_index_info() const;
-
-    private:
-        hyperdatatype m_datatype;
+public:
+	index_list(hyperdatatype datatype);
+	virtual ~index_list() throw ();
+
+private:
+	virtual hyperdatatype datatype() const;
+	virtual void extract_elements(const e::slice &container,
+	                              std::vector<e::slice> *elems) const;
+	virtual const datatype_info *element_datatype_info() const;
+	virtual const index_info *element_index_info() const;
+
+private:
+	hyperdatatype m_datatype;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/daemon/index_map.cc b/daemon/index_map.cc
index e1a2a83b2..5a5b40d33 100644
--- a/daemon/index_map.cc
+++ b/daemon/index_map.cc
@@ -37,8 +37,8 @@ using hyperdex::index_map;
 
 index_map :: index_map(hyperdatatype key_datatype,
                        hyperdatatype val_datatype)
-    : m_key_datatype(key_datatype)
-    , m_val_datatype(val_datatype)
+	: m_key_datatype(key_datatype)
+	, m_val_datatype(val_datatype)
 {
 }
 
@@ -49,43 +49,41 @@ index_map :: ~index_map() throw ()
 hyperdatatype
 index_map :: datatype() const
 {
-    return CREATE_CONTAINER2(HYPERDATATYPE_MAP_GENERIC,
-                             m_key_datatype,
-                             m_val_datatype);
+	return CREATE_CONTAINER2(HYPERDATATYPE_MAP_GENERIC,
+	                         m_key_datatype,
+	                         m_val_datatype);
 }
 
 void
-index_map :: extract_elements(const e::slice& map,
-                              std::vector<e::slice>* elems) const
+index_map :: extract_elements(const e::slice &map,
+                              std::vector<e::slice> *elems) const
 {
-    datatype_info* elem_k = datatype_info::lookup(m_key_datatype);
-    datatype_info* elem_v = datatype_info::lookup(m_val_datatype);
-    const uint8_t* ptr = map.data();
-    const uint8_t* end = map.data() + map.size();
-    e::slice key;
-    e::slice val;
-
-    while (ptr < end)
-    {
-        bool stepped;
-        stepped = elem_k->step(&ptr, end, &key);
-        assert(stepped);
-        stepped = elem_v->step(&ptr, end, &val);
-        assert(stepped);
-        elems->push_back(key);
-    }
-
-    assert(ptr == end);
+	datatype_info *elem_k = datatype_info::lookup(m_key_datatype);
+	datatype_info *elem_v = datatype_info::lookup(m_val_datatype);
+	const uint8_t *ptr = map.data();
+	const uint8_t *end = map.data() + map.size();
+	e::slice key;
+	e::slice val;
+	while (ptr < end)
+	{
+		bool stepped;
+		stepped = elem_k->step(&ptr, end, &key);
+		assert(stepped);
+		stepped = elem_v->step(&ptr, end, &val);
+		assert(stepped);
+		elems->push_back(key);
+	}
+	assert(ptr == end);
 }
 
-const datatype_info*
+const datatype_info *
 index_map :: element_datatype_info() const
 {
-    return datatype_info::lookup(m_key_datatype);
+	return datatype_info::lookup(m_key_datatype);
 }
 
-const index_info*
+const index_info *
 index_map :: element_index_info() const
 {
-    return index_info::lookup(m_key_datatype);
+	return index_info::lookup(m_key_datatype);
 }
diff --git a/daemon/index_map.h b/daemon/index_map.h
index 0a0bdf3fd..df86d6749 100644
--- a/daemon/index_map.h
+++ b/daemon/index_map.h
@@ -37,21 +37,21 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class index_map : public index_container
 {
-    public:
-        index_map(hyperdatatype key_datatype,
-                  hyperdatatype val_datatype);
-        virtual ~index_map() throw ();
-
-    private:
-        virtual hyperdatatype datatype() const;
-        virtual void extract_elements(const e::slice& container,
-                                      std::vector<e::slice>* elems) const;
-        virtual const datatype_info* element_datatype_info() const;
-        virtual const index_info* element_index_info() const;
-
-    private:
-        hyperdatatype m_key_datatype;
-        hyperdatatype m_val_datatype;
+public:
+	index_map(hyperdatatype key_datatype,
+	          hyperdatatype val_datatype);
+	virtual ~index_map() throw ();
+
+private:
+	virtual hyperdatatype datatype() const;
+	virtual void extract_elements(const e::slice &container,
+	                              std::vector<e::slice> *elems) const;
+	virtual const datatype_info *element_datatype_info() const;
+	virtual const index_info *element_index_info() const;
+
+private:
+	hyperdatatype m_key_datatype;
+	hyperdatatype m_val_datatype;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/daemon/index_primitive.cc b/daemon/index_primitive.cc
index 04bef5df4..06f95e3a4 100644
--- a/daemon/index_primitive.cc
+++ b/daemon/index_primitive.cc
@@ -37,11 +37,11 @@
 using hyperdex::datalayer;
 using hyperdex::index_primitive;
 
-inline leveldb::Slice e2level(const e::slice& s) { return leveldb::Slice(reinterpret_cast<const char*>(s.data()), s.size()); }
-inline e::slice level2e(const leveldb::Slice& s) { return e::slice(s.data(), s.size()); }
+inline leveldb::Slice e2level(const e::slice &s) { return leveldb::Slice(reinterpret_cast<const char *>(s.data()), s.size()); }
+inline e::slice level2e(const leveldb::Slice &s) { return e::slice(s.data(), s.size()); }
 
-index_primitive :: index_primitive(const index_encoding* ie)
-    : m_ie(ie)
+index_primitive :: index_primitive(const index_encoding *ie)
+	: m_ie(ie)
 {
 }
 
@@ -50,280 +50,258 @@ index_primitive :: ~index_primitive() throw ()
 }
 
 void
-index_primitive :: index_changes(const index* idx,
-                                 const region_id& ri,
-                                 const index_encoding* key_ie,
-                                 const e::slice& key,
-                                 const e::slice* old_value,
-                                 const e::slice* new_value,
-                                 leveldb::WriteBatch* updates) const
+index_primitive :: index_changes(const index *idx,
+                                 const region_id &ri,
+                                 const index_encoding *key_ie,
+                                 const e::slice &key,
+                                 const e::slice *old_value,
+                                 const e::slice *new_value,
+                                 leveldb::WriteBatch *updates) const
 {
-    std::vector<char> scratch;
-    e::slice slice;
-
-    if (old_value && new_value && *old_value == *new_value)
-    {
-        return;
-    }
-
-    if (old_value)
-    {
-        index_entry(ri, idx->id, key_ie, key, *old_value, &scratch, &slice);
-        updates->Delete(e2level(slice));
-    }
-
-    if (new_value)
-    {
-        index_entry(ri, idx->id, key_ie, key, *new_value, &scratch, &slice);
-        updates->Put(e2level(slice), leveldb::Slice());
-    }
+	std::vector<char> scratch;
+	e::slice slice;
+	if (old_value && new_value && *old_value == *new_value)
+	{
+		return;
+	}
+	if (old_value)
+	{
+		index_entry(ri, idx->id, key_ie, key, *old_value, &scratch, &slice);
+		updates->Delete(e2level(slice));
+	}
+	if (new_value)
+	{
+		index_entry(ri, idx->id, key_ie, key, *new_value, &scratch, &slice);
+		updates->Put(e2level(slice), leveldb::Slice());
+	}
 }
 
-datalayer::index_iterator*
+datalayer::index_iterator *
 index_primitive :: iterator_for_keys(leveldb_snapshot_ptr snap,
-                                     const region_id& ri) const
+                                     const region_id &ri) const
 {
-    range scan;
-    scan.attr = 0;
-    scan.type = this->datatype();
-    scan.has_start = false;
-    scan.has_end = false;
-    scan.invalid = false;
-    const index_encoding* ie = index_encoding::lookup(scan.type);
-    return iterator_key(snap, ri, scan, ie);
+	range scan;
+	scan.attr = 0;
+	scan.type = this->datatype();
+	scan.has_start = false;
+	scan.has_end = false;
+	scan.invalid = false;
+	const index_encoding *ie = index_encoding::lookup(scan.type);
+	return iterator_key(snap, ri, scan, ie);
 }
 
-datalayer::index_iterator*
+datalayer::index_iterator *
 index_primitive :: iterator_from_range(leveldb_snapshot_ptr snap,
-                                       const region_id& ri,
-                                       const index_id& ii,
-                                       const range& r,
-                                       const index_encoding* key_ie) const
+                                       const region_id &ri,
+                                       const index_id &ii,
+                                       const range &r,
+                                       const index_encoding *key_ie) const
 {
-    if (r.invalid)
-    {
-        return NULL;
-    }
-
-    if (r.attr != 0)
-    {
-        return iterator_attr(snap, ri, ii, r, key_ie);
-    }
-    else
-    {
-        return iterator_key(snap, ri, r, key_ie);
-    }
+	if (r.invalid)
+	{
+		return NULL;
+	}
+	if (r.attr != 0)
+	{
+		return iterator_attr(snap, ri, ii, r, key_ie);
+	}
+	else
+	{
+		return iterator_key(snap, ri, r, key_ie);
+	}
 }
 
-datalayer::index_iterator*
+datalayer::index_iterator *
 index_primitive :: iterator_key(leveldb_snapshot_ptr snap,
-                                const region_id& ri,
-                                const range& r,
-                                const index_encoding* key_ie) const
+                                const region_id &ri,
+                                const range &r,
+                                const index_encoding *key_ie) const
 {
-    std::vector<char> scratch_start;
-    std::vector<char> scratch_limit;
-    e::slice start;
-    e::slice limit;
-
-    size_t range_prefix_sz = object_prefix_sz(ri);
-
-    if (r.has_start)
-    {
-        leveldb::Slice _start;
-        encode_key(ri, r.type, r.start, &scratch_start, &_start);
-        start = level2e(_start);
-    }
-    else
-    {
-        leveldb::Slice _start;
-        encode_object_region(ri, &scratch_start, &_start);
-        start = level2e(_start);
-    }
-
-    if (r.has_end)
-    {
-        leveldb::Slice _limit;
-        encode_key(ri, r.type, r.end, &scratch_limit, &_limit);
-        limit = level2e(_limit);
-    }
-    else
-    {
-        leveldb::Slice _limit;
-        encode_object_region(ri, &scratch_limit, &_limit);
-        limit = level2e(_limit);
-    }
-
-    return new datalayer::range_index_iterator(snap, range_prefix_sz,
-                                               start, limit,
-                                               r.has_start, r.has_end,
-                                               NULL, key_ie);
+	std::vector<char> scratch_start;
+	std::vector<char> scratch_limit;
+	e::slice start;
+	e::slice limit;
+	size_t range_prefix_sz = object_prefix_sz(ri);
+	if (r.has_start)
+	{
+		leveldb::Slice _start;
+		encode_key(ri, r.type, r.start, &scratch_start, &_start);
+		start = level2e(_start);
+	}
+	else
+	{
+		leveldb::Slice _start;
+		encode_object_region(ri, &scratch_start, &_start);
+		start = level2e(_start);
+	}
+	if (r.has_end)
+	{
+		leveldb::Slice _limit;
+		encode_key(ri, r.type, r.end, &scratch_limit, &_limit);
+		limit = level2e(_limit);
+	}
+	else
+	{
+		leveldb::Slice _limit;
+		encode_object_region(ri, &scratch_limit, &_limit);
+		limit = level2e(_limit);
+	}
+	return new datalayer::range_index_iterator(snap, range_prefix_sz,
+	                                           start, limit,
+	                                           r.has_start, r.has_end,
+	                                           NULL, key_ie);
 }
 
-datalayer::index_iterator*
+datalayer::index_iterator *
 index_primitive :: iterator_attr(leveldb_snapshot_ptr snap,
-                                 const region_id& ri,
-                                 const index_id& ii,
-                                 const range& r,
-                                 const index_encoding* key_ie) const
+                                 const region_id &ri,
+                                 const index_id &ii,
+                                 const range &r,
+                                 const index_encoding *key_ie) const
 {
-    std::vector<char> scratch_start;
-    std::vector<char> scratch_limit;
-    e::slice start;
-    e::slice limit;
-
-    size_t range_prefix_sz = index_entry_prefix_size(ri, ii);
-
-    if (r.has_start)
-    {
-        index_entry(ri, ii, r.start, &scratch_start, &start);
-    }
-    else
-    {
-        index_entry(ri, ii, &scratch_start, &start);
-    }
-
-    if (r.has_end)
-    {
-        index_entry(ri, ii, r.end, &scratch_limit, &limit);
-    }
-    else
-    {
-        index_entry(ri, ii, &scratch_limit, &limit);
-    }
-
-    return new datalayer::range_index_iterator(snap, range_prefix_sz,
-                                               start, limit,
-                                               r.has_start, r.has_end,
-                                               m_ie, key_ie);
+	std::vector<char> scratch_start;
+	std::vector<char> scratch_limit;
+	e::slice start;
+	e::slice limit;
+	size_t range_prefix_sz = index_entry_prefix_size(ri, ii);
+	if (r.has_start)
+	{
+		index_entry(ri, ii, r.start, &scratch_start, &start);
+	}
+	else
+	{
+		index_entry(ri, ii, &scratch_start, &start);
+	}
+	if (r.has_end)
+	{
+		index_entry(ri, ii, r.end, &scratch_limit, &limit);
+	}
+	else
+	{
+		index_entry(ri, ii, &scratch_limit, &limit);
+	}
+	return new datalayer::range_index_iterator(snap, range_prefix_sz,
+	                                           start, limit,
+	                                           r.has_start, r.has_end,
+	                                           m_ie, key_ie);
 }
 
 size_t
-index_primitive :: index_entry_prefix_size(const region_id& ri, const index_id& ii) const
+index_primitive :: index_entry_prefix_size(const region_id &ri, const index_id &ii) const
 {
-    return sizeof(uint8_t)
-         + e::varint_length(ri.get())
-         + e::varint_length(ii.get());
+	return sizeof(uint8_t)
+	       + e::varint_length(ri.get())
+	       + e::varint_length(ii.get());
 }
 
 void
-index_primitive :: index_entry(const region_id& ri,
-                               const index_id& ii,
-                               std::vector<char>* scratch,
-                               e::slice* slice) const
+index_primitive :: index_entry(const region_id &ri,
+                               const index_id &ii,
+                               std::vector<char> *scratch,
+                               e::slice *slice) const
 {
-    size_t sz = sizeof(uint8_t)
-              + e::varint_length(ri.get())
-              + e::varint_length(ii.get());
-
-    if (scratch->size() < sz)
-    {
-        scratch->resize(sz);
-    }
-
-    char* ptr = &scratch->front();
-    ptr = e::pack8be('i', ptr);
-    ptr = e::packvarint64(ri.get(), ptr);
-    ptr = e::packvarint64(ii.get(), ptr);
-    assert(ptr == &scratch->front() + sz);
-    *slice = e::slice(&scratch->front(), sz);
+	size_t sz = sizeof(uint8_t)
+	            + e::varint_length(ri.get())
+	            + e::varint_length(ii.get());
+	if (scratch->size() < sz)
+	{
+		scratch->resize(sz);
+	}
+	char *ptr = &scratch->front();
+	ptr = e::pack8be('i', ptr);
+	ptr = e::packvarint64(ri.get(), ptr);
+	ptr = e::packvarint64(ii.get(), ptr);
+	assert(ptr == &scratch->front() + sz);
+	*slice = e::slice(&scratch->front(), sz);
 }
 
 void
-index_primitive :: index_entry(const region_id& ri,
-                               const index_id& ii,
-                               const e::slice& value,
-                               std::vector<char>* scratch,
-                               e::slice* slice) const
+index_primitive :: index_entry(const region_id &ri,
+                               const index_id &ii,
+                               const e::slice &value,
+                               std::vector<char> *scratch,
+                               e::slice *slice) const
 {
-    size_t val_sz = m_ie->encoded_size(value);
-    size_t sz = sizeof(uint8_t)
-              + e::varint_length(ri.get())
-              + e::varint_length(ii.get())
-              + val_sz;
-
-    if (scratch->size() < sz)
-    {
-        scratch->resize(sz);
-    }
-
-    char* ptr = &scratch->front();
-    ptr = e::pack8be('i', ptr);
-    ptr = e::packvarint64(ri.get(), ptr);
-    ptr = e::packvarint64(ii.get(), ptr);
-    ptr = m_ie->encode(value, ptr);
-    assert(ptr == &scratch->front() + sz);
-    *slice = e::slice(&scratch->front(), sz);
+	size_t val_sz = m_ie->encoded_size(value);
+	size_t sz = sizeof(uint8_t)
+	            + e::varint_length(ri.get())
+	            + e::varint_length(ii.get())
+	            + val_sz;
+	if (scratch->size() < sz)
+	{
+		scratch->resize(sz);
+	}
+	char *ptr = &scratch->front();
+	ptr = e::pack8be('i', ptr);
+	ptr = e::packvarint64(ri.get(), ptr);
+	ptr = e::packvarint64(ii.get(), ptr);
+	ptr = m_ie->encode(value, ptr);
+	assert(ptr == &scratch->front() + sz);
+	*slice = e::slice(&scratch->front(), sz);
 }
 
 void
-index_primitive :: index_entry(const region_id& ri,
-                               const index_id& ii,
-                               const e::slice& internal_key,
-                               const e::slice& value,
-                               std::vector<char>* scratch,
-                               e::slice* slice) const
+index_primitive :: index_entry(const region_id &ri,
+                               const index_id &ii,
+                               const e::slice &internal_key,
+                               const e::slice &value,
+                               std::vector<char> *scratch,
+                               e::slice *slice) const
 {
-    size_t key_sz = internal_key.size();
-    size_t val_sz = m_ie->encoded_size(value);
-    size_t sz = sizeof(uint8_t)
-              + e::varint_length(ri.get())
-              + e::varint_length(ii.get())
-              + val_sz
-              + key_sz;
-
-    if (scratch->size() < sz)
-    {
-        scratch->resize(sz);
-    }
-
-    char* ptr = &scratch->front();
-    ptr = e::pack8be('i', ptr);
-    ptr = e::packvarint64(ri.get(), ptr);
-    ptr = e::packvarint64(ii.get(), ptr);
-    ptr = m_ie->encode(value, ptr);
-    memmove(ptr, internal_key.data(), key_sz);
-    ptr += key_sz;
-    assert(ptr == &scratch->front() + sz);
-    *slice = e::slice(&scratch->front(), sz);
+	size_t key_sz = internal_key.size();
+	size_t val_sz = m_ie->encoded_size(value);
+	size_t sz = sizeof(uint8_t)
+	            + e::varint_length(ri.get())
+	            + e::varint_length(ii.get())
+	            + val_sz
+	            + key_sz;
+	if (scratch->size() < sz)
+	{
+		scratch->resize(sz);
+	}
+	char *ptr = &scratch->front();
+	ptr = e::pack8be('i', ptr);
+	ptr = e::packvarint64(ri.get(), ptr);
+	ptr = e::packvarint64(ii.get(), ptr);
+	ptr = m_ie->encode(value, ptr);
+	memmove(ptr, internal_key.data(), key_sz);
+	ptr += key_sz;
+	assert(ptr == &scratch->front() + sz);
+	*slice = e::slice(&scratch->front(), sz);
 }
 
 void
-index_primitive :: index_entry(const region_id& ri,
-                               const index_id& ii,
-                               const index_encoding* key_ie,
-                               const e::slice& key,
-                               const e::slice& value,
-                               std::vector<char>* scratch,
-                               e::slice* slice) const
+index_primitive :: index_entry(const region_id &ri,
+                               const index_id &ii,
+                               const index_encoding *key_ie,
+                               const e::slice &key,
+                               const e::slice &value,
+                               std::vector<char> *scratch,
+                               e::slice *slice) const
 {
-    size_t key_sz = key_ie->encoded_size(key);
-    size_t val_sz = m_ie->encoded_size(value);
-    bool variable = !key_ie->encoding_fixed() && !m_ie->encoding_fixed();
-    size_t sz = sizeof(uint8_t)
-              + e::varint_length(ri.get())
-              + e::varint_length(ii.get())
-              + val_sz
-              + key_sz
-              + (variable ? sizeof(uint32_t) : 0);
-
-    if (scratch->size() < sz)
-    {
-        scratch->resize(sz);
-    }
-
-    char* ptr = &scratch->front();
-    ptr = e::pack8be('i', ptr);
-    ptr = e::packvarint64(ri.get(), ptr);
-    ptr = e::packvarint64(ii.get(), ptr);
-    ptr = m_ie->encode(value, ptr);
-    ptr = key_ie->encode(key, ptr);
-
-    if (variable)
-    {
-        ptr = e::pack32be(key_sz, ptr);
-    }
-
-    assert(ptr == &scratch->front() + sz);
-    *slice = e::slice(&scratch->front(), sz);
+	size_t key_sz = key_ie->encoded_size(key);
+	size_t val_sz = m_ie->encoded_size(value);
+	bool variable = !key_ie->encoding_fixed() && !m_ie->encoding_fixed();
+	size_t sz = sizeof(uint8_t)
+	            + e::varint_length(ri.get())
+	            + e::varint_length(ii.get())
+	            + val_sz
+	            + key_sz
+	            + (variable ? sizeof(uint32_t) : 0);
+	if (scratch->size() < sz)
+	{
+		scratch->resize(sz);
+	}
+	char *ptr = &scratch->front();
+	ptr = e::pack8be('i', ptr);
+	ptr = e::packvarint64(ri.get(), ptr);
+	ptr = e::packvarint64(ii.get(), ptr);
+	ptr = m_ie->encode(value, ptr);
+	ptr = key_ie->encode(key, ptr);
+	if (variable)
+	{
+		ptr = e::pack32be(key_sz, ptr);
+	}
+	assert(ptr == &scratch->front() + sz);
+	*slice = e::slice(&scratch->front(), sz);
 }
diff --git a/daemon/index_primitive.h b/daemon/index_primitive.h
index de60a187e..265c7a9a8 100644
--- a/daemon/index_primitive.h
+++ b/daemon/index_primitive.h
@@ -36,70 +36,70 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class index_primitive : public index_info
 {
-    protected:
-        index_primitive(const index_encoding* ie);
-        virtual ~index_primitive() throw ();
+protected:
+	index_primitive(const index_encoding *ie);
+	virtual ~index_primitive() throw ();
 
-    public:
-        virtual void index_changes(const index* idx,
-                                   const region_id& ri,
-                                   const index_encoding* key_ie,
-                                   const e::slice& key,
-                                   const e::slice* old_value,
-                                   const e::slice* new_value,
-                                   leveldb::WriteBatch* updates) const;
-        virtual datalayer::index_iterator* iterator_for_keys(leveldb_snapshot_ptr snap,
-                                                             const region_id& ri) const;
-        virtual datalayer::index_iterator* iterator_from_range(leveldb_snapshot_ptr snap,
-                                                               const region_id& ri,
-                                                               const index_id& ii,
-                                                               const range& r,
-                                                               const index_encoding* key_ie) const;
+public:
+	virtual void index_changes(const index *idx,
+	                           const region_id &ri,
+	                           const index_encoding *key_ie,
+	                           const e::slice &key,
+	                           const e::slice *old_value,
+	                           const e::slice *new_value,
+	                           leveldb::WriteBatch *updates) const;
+	virtual datalayer::index_iterator *iterator_for_keys(leveldb_snapshot_ptr snap,
+	        const region_id &ri) const;
+	virtual datalayer::index_iterator *iterator_from_range(leveldb_snapshot_ptr snap,
+	        const region_id &ri,
+	        const index_id &ii,
+	        const range &r,
+	        const index_encoding *key_ie) const;
 
-    private:
-        class range_iterator;
-        class key_iterator;
+private:
+	class range_iterator;
+	class key_iterator;
 
-    private:
-        datalayer::index_iterator* iterator_key(leveldb_snapshot_ptr snap,
-                                                const region_id& ri,
-                                                const range& r,
-                                                const index_encoding* key_ie) const;
-        datalayer::index_iterator* iterator_attr(leveldb_snapshot_ptr snap,
-                                                 const region_id& ri,
-                                                 const index_id& ii,
-                                                 const range& r,
-                                                 const index_encoding* key_ie) const;
-        size_t index_entry_prefix_size(const region_id& ri, const index_id& ii) const;
-        void index_entry(const region_id& ri,
-                         const index_id& ii,
-                         std::vector<char>* scratch,
-                         e::slice* slice) const;
-        void index_entry(const region_id& ri,
-                         const index_id& ii,
-                         const e::slice& value,
-                         std::vector<char>* scratch,
-                         e::slice* slice) const;
-        void index_entry(const region_id& ri,
-                         const index_id& ii,
-                         const e::slice& internal_key,
-                         const e::slice& value,
-                         std::vector<char>* scratch,
-                         e::slice* slice) const;
-        void index_entry(const region_id& ri,
-                         const index_id& ii,
-                         const index_encoding* key_ie,
-                         const e::slice& key,
-                         const e::slice& value,
-                         std::vector<char>* scratch,
-                         e::slice* slice) const;
+private:
+	datalayer::index_iterator *iterator_key(leveldb_snapshot_ptr snap,
+	                                        const region_id &ri,
+	                                        const range &r,
+	                                        const index_encoding *key_ie) const;
+	datalayer::index_iterator *iterator_attr(leveldb_snapshot_ptr snap,
+	                                         const region_id &ri,
+	                                         const index_id &ii,
+	                                         const range &r,
+	                                         const index_encoding *key_ie) const;
+	size_t index_entry_prefix_size(const region_id &ri, const index_id &ii) const;
+	void index_entry(const region_id &ri,
+	                 const index_id &ii,
+	                 std::vector<char> *scratch,
+	                 e::slice *slice) const;
+	void index_entry(const region_id &ri,
+	                 const index_id &ii,
+	                 const e::slice &value,
+	                 std::vector<char> *scratch,
+	                 e::slice *slice) const;
+	void index_entry(const region_id &ri,
+	                 const index_id &ii,
+	                 const e::slice &internal_key,
+	                 const e::slice &value,
+	                 std::vector<char> *scratch,
+	                 e::slice *slice) const;
+	void index_entry(const region_id &ri,
+	                 const index_id &ii,
+	                 const index_encoding *key_ie,
+	                 const e::slice &key,
+	                 const e::slice &value,
+	                 std::vector<char> *scratch,
+	                 e::slice *slice) const;
 
-    private:
-        index_primitive(const index_primitive&);
-        index_primitive& operator = (const index_primitive&);
+private:
+	index_primitive(const index_primitive &);
+	index_primitive &operator = (const index_primitive &);
 
-    private:
-        const index_encoding *const m_ie;
+private:
+	const index_encoding *const m_ie;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/daemon/index_set.cc b/daemon/index_set.cc
index b122d7e35..01f7bb1af 100644
--- a/daemon/index_set.cc
+++ b/daemon/index_set.cc
@@ -36,7 +36,7 @@ using hyperdex::index_info;
 using hyperdex::index_set;
 
 index_set :: index_set(hyperdatatype dt)
-    : m_datatype(dt)
+	: m_datatype(dt)
 {
 }
 
@@ -47,36 +47,34 @@ index_set :: ~index_set() throw ()
 hyperdatatype
 index_set :: datatype() const
 {
-    return CREATE_CONTAINER(HYPERDATATYPE_SET_GENERIC, m_datatype);
+	return CREATE_CONTAINER(HYPERDATATYPE_SET_GENERIC, m_datatype);
 }
 
 void
-index_set :: extract_elements(const e::slice& set,
-                              std::vector<e::slice>* elems) const
+index_set :: extract_elements(const e::slice &set,
+                              std::vector<e::slice> *elems) const
 {
-    datatype_info* elem = datatype_info::lookup(m_datatype);
-    const uint8_t* ptr = set.data();
-    const uint8_t* end = set.data() + set.size();
-    e::slice e;
-
-    while (ptr < end)
-    {
-        bool stepped = elem->step(&ptr, end, &e);
-        assert(stepped);
-        elems->push_back(e);
-    }
-
-    assert(ptr == end);
+	datatype_info *elem = datatype_info::lookup(m_datatype);
+	const uint8_t *ptr = set.data();
+	const uint8_t *end = set.data() + set.size();
+	e::slice e;
+	while (ptr < end)
+	{
+		bool stepped = elem->step(&ptr, end, &e);
+		assert(stepped);
+		elems->push_back(e);
+	}
+	assert(ptr == end);
 }
 
-const datatype_info*
+const datatype_info *
 index_set :: element_datatype_info() const
 {
-    return datatype_info::lookup(m_datatype);
+	return datatype_info::lookup(m_datatype);
 }
 
-const index_info*
+const index_info *
 index_set :: element_index_info() const
 {
-    return index_info::lookup(m_datatype);
+	return index_info::lookup(m_datatype);
 }
diff --git a/daemon/index_set.h b/daemon/index_set.h
index 5e71b7b5a..b04828d78 100644
--- a/daemon/index_set.h
+++ b/daemon/index_set.h
@@ -37,19 +37,19 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class index_set : public index_container
 {
-    public:
-        index_set(hyperdatatype datatype);
-        virtual ~index_set() throw ();
-
-    private:
-        virtual hyperdatatype datatype() const;
-        virtual void extract_elements(const e::slice& container,
-                                      std::vector<e::slice>* elems) const;
-        virtual const datatype_info* element_datatype_info() const;
-        virtual const index_info* element_index_info() const;
-
-    private:
-        hyperdatatype m_datatype;
+public:
+	index_set(hyperdatatype datatype);
+	virtual ~index_set() throw ();
+
+private:
+	virtual hyperdatatype datatype() const;
+	virtual void extract_elements(const e::slice &container,
+	                              std::vector<e::slice> *elems) const;
+	virtual const datatype_info *element_datatype_info() const;
+	virtual const index_info *element_index_info() const;
+
+private:
+	hyperdatatype m_datatype;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/daemon/index_string.cc b/daemon/index_string.cc
index 295ac8f62..c20ce5406 100644
--- a/daemon/index_string.cc
+++ b/daemon/index_string.cc
@@ -37,7 +37,7 @@ using hyperdex::index_string;
 using hyperdex::index_encoding_string;
 
 index_string :: index_string()
-    : index_primitive(index_encoding::lookup(HYPERDATATYPE_STRING))
+	: index_primitive(index_encoding::lookup(HYPERDATATYPE_STRING))
 {
 }
 
@@ -48,7 +48,7 @@ index_string :: ~index_string() throw ()
 hyperdatatype
 index_string :: datatype() const
 {
-    return HYPERDATATYPE_STRING;
+	return HYPERDATATYPE_STRING;
 }
 
 index_encoding_string :: index_encoding_string()
@@ -62,31 +62,31 @@ index_encoding_string :: ~index_encoding_string() throw ()
 bool
 index_encoding_string :: encoding_fixed() const
 {
-    return false;
+	return false;
 }
 
 size_t
-index_encoding_string :: encoded_size(const e::slice& decoded) const
+index_encoding_string :: encoded_size(const e::slice &decoded) const
 {
-    return decoded.size();
+	return decoded.size();
 }
 
-char*
-index_encoding_string :: encode(const e::slice& decoded, char* encoded) const
+char *
+index_encoding_string :: encode(const e::slice &decoded, char *encoded) const
 {
-    memmove(encoded, decoded.data(), decoded.size());
-    return encoded + decoded.size();
+	memmove(encoded, decoded.data(), decoded.size());
+	return encoded + decoded.size();
 }
 
 size_t
-index_encoding_string :: decoded_size(const e::slice& encoded) const
+index_encoding_string :: decoded_size(const e::slice &encoded) const
 {
-    return encoded.size();
+	return encoded.size();
 }
 
-char*
-index_encoding_string :: decode(const e::slice& encoded, char* decoded) const
+char *
+index_encoding_string :: decode(const e::slice &encoded, char *decoded) const
 {
-    memmove(decoded, encoded.data(), encoded.size());
-    return decoded + encoded.size();
+	memmove(decoded, encoded.data(), encoded.size());
+	return decoded + encoded.size();
 }
diff --git a/daemon/index_string.h b/daemon/index_string.h
index 0c8694661..8a64393da 100644
--- a/daemon/index_string.h
+++ b/daemon/index_string.h
@@ -36,26 +36,26 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class index_string : public index_primitive
 {
-    public:
-        index_string();
-        virtual ~index_string() throw ();
+public:
+	index_string();
+	virtual ~index_string() throw ();
 
-    public:
-        virtual hyperdatatype datatype() const;
+public:
+	virtual hyperdatatype datatype() const;
 };
 
 class index_encoding_string : public index_encoding
 {
-    public:
-        index_encoding_string();
-        virtual ~index_encoding_string() throw ();
-
-    public:
-        virtual bool encoding_fixed() const;
-        virtual size_t encoded_size(const e::slice& decoded) const;
-        virtual char* encode(const e::slice& decoded, char* encoded) const;
-        virtual size_t decoded_size(const e::slice& encoded) const;
-        virtual char* decode(const e::slice& encoded, char* decoded) const;
+public:
+	index_encoding_string();
+	virtual ~index_encoding_string() throw ();
+
+public:
+	virtual bool encoding_fixed() const;
+	virtual size_t encoded_size(const e::slice &decoded) const;
+	virtual char *encode(const e::slice &decoded, char *encoded) const;
+	virtual size_t decoded_size(const e::slice &encoded) const;
+	virtual char *decode(const e::slice &encoded, char *decoded) const;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/daemon/index_timestamp.cc b/daemon/index_timestamp.cc
index 28b51ac3a..cd1e37b44 100644
--- a/daemon/index_timestamp.cc
+++ b/daemon/index_timestamp.cc
@@ -38,10 +38,10 @@ using hyperdex::index_timestamp;
 using hyperdex::index_encoding_timestamp;
 
 index_timestamp :: index_timestamp(hyperdatatype t)
-    : index_primitive(index_encoding::lookup(t))
-    , m_type(t)
+	: index_primitive(index_encoding::lookup(t))
+	, m_type(t)
 {
-    assert(CONTAINER_TYPE(m_type) == HYPERDATATYPE_TIMESTAMP_GENERIC);
+	assert(CONTAINER_TYPE(m_type) == HYPERDATATYPE_TIMESTAMP_GENERIC);
 }
 
 index_timestamp :: ~index_timestamp() throw ()
@@ -51,11 +51,11 @@ index_timestamp :: ~index_timestamp() throw ()
 hyperdatatype
 index_timestamp :: datatype() const
 {
-    return m_type;
+	return m_type;
 }
 
 index_encoding_timestamp :: index_encoding_timestamp()
-    : m_iei()
+	: m_iei()
 {
 }
 
@@ -66,29 +66,29 @@ index_encoding_timestamp :: ~index_encoding_timestamp() throw ()
 bool
 index_encoding_timestamp :: encoding_fixed() const
 {
-    return m_iei.encoding_fixed();
+	return m_iei.encoding_fixed();
 }
 
 size_t
-index_encoding_timestamp :: encoded_size(const e::slice& x) const
+index_encoding_timestamp :: encoded_size(const e::slice &x) const
 {
-    return m_iei.encoded_size(x);
+	return m_iei.encoded_size(x);
 }
 
-char*
-index_encoding_timestamp :: encode(const e::slice& decoded, char* encoded) const
+char *
+index_encoding_timestamp :: encode(const e::slice &decoded, char *encoded) const
 {
-    return m_iei.encode(decoded, encoded);
+	return m_iei.encode(decoded, encoded);
 }
 
 size_t
-index_encoding_timestamp :: decoded_size(const e::slice& x) const
+index_encoding_timestamp :: decoded_size(const e::slice &x) const
 {
-    return m_iei.decoded_size(x);
+	return m_iei.decoded_size(x);
 }
 
-char*
-index_encoding_timestamp :: decode(const e::slice& encoded, char* decoded) const
+char *
+index_encoding_timestamp :: decode(const e::slice &encoded, char *decoded) const
 {
-    return m_iei.decode(encoded, decoded);
+	return m_iei.decode(encoded, decoded);
 }
diff --git a/daemon/index_timestamp.h b/daemon/index_timestamp.h
index 02f2e695e..25b010d07 100644
--- a/daemon/index_timestamp.h
+++ b/daemon/index_timestamp.h
@@ -38,32 +38,32 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class index_timestamp : public index_primitive
 {
-    public:
-        index_timestamp(hyperdatatype t);
-        virtual ~index_timestamp() throw ();
+public:
+	index_timestamp(hyperdatatype t);
+	virtual ~index_timestamp() throw ();
 
-    public:
-        virtual hyperdatatype datatype() const;
+public:
+	virtual hyperdatatype datatype() const;
 
-    private:
-        hyperdatatype m_type;
+private:
+	hyperdatatype m_type;
 };
 
 class index_encoding_timestamp : public index_encoding
 {
-    public:
-        index_encoding_timestamp();
-        virtual ~index_encoding_timestamp() throw ();
+public:
+	index_encoding_timestamp();
+	virtual ~index_encoding_timestamp() throw ();
 
-    public:
-        virtual bool encoding_fixed() const;
-        virtual size_t encoded_size(const e::slice& decoded) const;
-        virtual char* encode(const e::slice& decoded, char* encoded) const;
-        virtual size_t decoded_size(const e::slice& encoded) const;
-        virtual char* decode(const e::slice& encoded, char* decoded) const;
+public:
+	virtual bool encoding_fixed() const;
+	virtual size_t encoded_size(const e::slice &decoded) const;
+	virtual char *encode(const e::slice &decoded, char *encoded) const;
+	virtual size_t decoded_size(const e::slice &encoded) const;
+	virtual char *decode(const e::slice &encoded, char *decoded) const;
 
-    private:
-        index_encoding_int64 m_iei;
+private:
+	index_encoding_int64 m_iei;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/daemon/key_operation.cc b/daemon/key_operation.cc
index 5087ecc4d..043a47a85 100644
--- a/daemon/key_operation.cc
+++ b/daemon/key_operation.cc
@@ -39,25 +39,25 @@ key_operation :: key_operation(uint64_t old_version,
                                uint64_t new_version,
                                bool _fresh,
                                bool _has_value,
-                               const std::vector<e::slice>& _value,
+                               const std::vector<e::slice> &_value,
                                std::auto_ptr<e::arena> memory)
-    : m_ref(0)
-    , m_prev_version(old_version)
-    , m_this_version(new_version)
-    , m_acked(false)
-    , m_fresh(_fresh)
-    , m_has_value(_has_value)
-    , m_recv_config_version()
-    , m_recv()
-    , m_sent_config_version()
-    , m_sent()
-    , m_value(_value)
-    , m_memory(memory)
-    , m_type(UNKNOWN)
-    , m_this_old_region()
-    , m_this_new_region()
-    , m_prev_region()
-    , m_next_region()
+	: m_ref(0)
+	, m_prev_version(old_version)
+	, m_this_version(new_version)
+	, m_acked(false)
+	, m_fresh(_fresh)
+	, m_has_value(_has_value)
+	, m_recv_config_version()
+	, m_recv()
+	, m_sent_config_version()
+	, m_sent()
+	, m_value(_value)
+	, m_memory(memory)
+	, m_type(UNKNOWN)
+	, m_this_old_region()
+	, m_this_new_region()
+	, m_prev_region()
+	, m_next_region()
 {
 }
 
@@ -68,58 +68,56 @@ key_operation :: ~key_operation() throw ()
 void
 key_operation :: set_continuous()
 {
-    assert(m_type == UNKNOWN);
-    m_type = CONTINUOUS;
+	assert(m_type == UNKNOWN);
+	m_type = CONTINUOUS;
 }
 
 void
-key_operation :: set_continuous_hashes(const region_id& pr,
-                                       const region_id& tor,
-                                       const region_id& tnr,
-                                       const region_id& nr)
+key_operation :: set_continuous_hashes(const region_id &pr,
+                                       const region_id &tor,
+                                       const region_id &tnr,
+                                       const region_id &nr)
 {
-    assert(m_type == CONTINUOUS);
-    assert(m_prev_region == region_id());
-    assert(m_this_old_region == region_id());
-    assert(m_this_new_region == region_id());
-    assert(m_next_region == region_id());
-
-    m_prev_region = pr;
-    m_this_old_region = tor;
-    m_this_new_region = tnr;
-    m_next_region = nr;
+	assert(m_type == CONTINUOUS);
+	assert(m_prev_region == region_id());
+	assert(m_this_old_region == region_id());
+	assert(m_this_new_region == region_id());
+	assert(m_next_region == region_id());
+	m_prev_region = pr;
+	m_this_old_region = tor;
+	m_this_new_region = tnr;
+	m_next_region = nr;
 }
 
 void
-key_operation :: set_discontinuous(const region_id& pr,
-                                   const region_id& tor,
-                                   const region_id& tnr,
-                                   const region_id& nr)
+key_operation :: set_discontinuous(const region_id &pr,
+                                   const region_id &tor,
+                                   const region_id &tnr,
+                                   const region_id &nr)
 {
-    assert(m_type == UNKNOWN);
-    assert(m_prev_region == region_id());
-    assert(m_this_old_region == region_id());
-    assert(m_this_new_region == region_id());
-    assert(m_next_region == region_id());
-    m_type = DISCONTINUOUS;
-
-    m_prev_region = pr;
-    m_this_old_region = tor;
-    m_this_new_region = tnr;
-    m_next_region = nr;
+	assert(m_type == UNKNOWN);
+	assert(m_prev_region == region_id());
+	assert(m_this_old_region == region_id());
+	assert(m_this_new_region == region_id());
+	assert(m_next_region == region_id());
+	m_type = DISCONTINUOUS;
+	m_prev_region = pr;
+	m_this_old_region = tor;
+	m_this_new_region = tnr;
+	m_next_region = nr;
 }
 
 void
 key_operation :: debug_dump()
 {
-    LOG(INFO) << "    unique op id: prev=" << m_prev_version << " this=" << m_this_version;
-    LOG(INFO) << "    has value: " << (m_has_value ? "yes" : "no");
-    LOG(INFO) << "    recv: version=" << m_recv_config_version << " from=" << m_recv;
-    LOG(INFO) << "    sent: version=" << m_sent_config_version << " to=" << m_sent;
-    LOG(INFO) << "    fresh: " << (m_fresh ? "yes" : "no");
-    LOG(INFO) << "    acked: " << (m_acked ? "yes" : "no");
-    LOG(INFO) << "    prev: " << m_prev_region;
-    LOG(INFO) << "    this_old: " << m_this_old_region;
-    LOG(INFO) << "    this_new: " << m_this_new_region;
-    LOG(INFO) << "    next: " << m_next_region;
+	LOG(INFO) << "    unique op id: prev=" << m_prev_version << " this=" << m_this_version;
+	LOG(INFO) << "    has value: " << (m_has_value ? "yes" : "no");
+	LOG(INFO) << "    recv: version=" << m_recv_config_version << " from=" << m_recv;
+	LOG(INFO) << "    sent: version=" << m_sent_config_version << " to=" << m_sent;
+	LOG(INFO) << "    fresh: " << (m_fresh ? "yes" : "no");
+	LOG(INFO) << "    acked: " << (m_acked ? "yes" : "no");
+	LOG(INFO) << "    prev: " << m_prev_region;
+	LOG(INFO) << "    this_old: " << m_this_old_region;
+	LOG(INFO) << "    this_new: " << m_this_new_region;
+	LOG(INFO) << "    next: " << m_next_region;
 }
diff --git a/daemon/key_operation.h b/daemon/key_operation.h
index 07a2b04ad..db56085b4 100644
--- a/daemon/key_operation.h
+++ b/daemon/key_operation.h
@@ -43,92 +43,92 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class key_operation
 {
-    public:
-        key_operation(uint64_t old_version,
-                      uint64_t new_version,
-                      bool fresh,
-                      bool has_value,
-                      const std::vector<e::slice>& value,
-                      std::auto_ptr<e::arena> memory);
-        ~key_operation() throw ();
-
-    public:
-        uint64_t prev_version() const { return m_prev_version; }
-        uint64_t this_version() const { return m_this_version; }
-
-        // the state of this op
-        void mark_acked() { m_acked = true; }
-        // can we ack this op AND remove it from local state?
-        bool ackable() const { return m_acked; }
-
-        // who we recv/sent from/to along the chain
-        void set_recv(uint64_t version, const virtual_server_id& vsi)
-        { m_recv_config_version = version; m_recv = vsi; }
-        bool recv_from(uint64_t version) const { return version == m_recv_config_version; }
-        virtual_server_id recv_from() const { return m_recv; }
-        void set_sent(uint64_t version, const virtual_server_id& vsi)
-        { m_sent_config_version = version; m_sent = vsi; }
-        virtual_server_id sent_to() const { return m_sent; }
-        uint64_t sent_version() const { return m_sent_config_version; }
-        bool sent_to(uint64_t version, const virtual_server_id& vsi) const
-        { return m_sent_config_version == version && m_sent == vsi; }
-
-        // the path of the op through the value-dependent chain
-        bool is_continuous() { return m_type == CONTINUOUS; }
-        bool is_discontinuous() { return m_type == DISCONTINUOUS; }
-        // call before hashing
-        void set_continuous();
-        // call after hashing; must call above first
-        void set_continuous_hashes(const region_id& prev_region,
-                                   const region_id& this_old_region,
-                                   const region_id& this_new_region,
-                                   const region_id& next_region);
-        void set_discontinuous(const region_id& prev_region,
-                               const region_id& this_old_region,
-                               const region_id& this_new_region,
-                               const region_id& next_region);
-        region_id prev_region() const { return m_prev_region; }
-        region_id this_old_region() const { return m_this_old_region; }
-        region_id this_new_region() const { return m_this_new_region; }
-        region_id next_region() const { return m_next_region; }
-
-        // the value set by this op
-        bool is_fresh() { return m_fresh; }
-        bool has_value() { return m_has_value; }
-        const std::vector<e::slice>& value() { return m_value; }
-
-        void debug_dump();
-
-    private:
-        friend class e::intrusive_ptr<key_operation>;
-        void inc() { ++m_ref; }
-        void dec() { if (--m_ref == 0) delete this; }
-
-    private:
-        size_t m_ref;
-        const uint64_t m_prev_version;
-        const uint64_t m_this_version;
-        bool m_acked;
-        bool m_fresh;
-        const bool m_has_value;
-
-        uint64_t m_recv_config_version;
-        virtual_server_id m_recv; // we recv from here
-        uint64_t m_sent_config_version;
-        virtual_server_id m_sent; // we sent to here
-
-        const std::vector<e::slice> m_value;
-        const std::auto_ptr<e::arena> m_memory;
-
-        enum { UNKNOWN, CONTINUOUS, DISCONTINUOUS } m_type;
-        region_id m_this_old_region;
-        region_id m_this_new_region;
-        region_id m_prev_region;
-        region_id m_next_region;
-
-    private:
-        key_operation(const key_operation&);
-        key_operation& operator = (const key_operation&);
+public:
+	key_operation(uint64_t old_version,
+	              uint64_t new_version,
+	              bool fresh,
+	              bool has_value,
+	              const std::vector<e::slice> &value,
+	              std::auto_ptr<e::arena> memory);
+	~key_operation() throw ();
+
+public:
+	uint64_t prev_version() const { return m_prev_version; }
+	uint64_t this_version() const { return m_this_version; }
+
+	// the state of this op
+	void mark_acked() { m_acked = true; }
+	// can we ack this op AND remove it from local state?
+	bool ackable() const { return m_acked; }
+
+	// who we recv/sent from/to along the chain
+	void set_recv(uint64_t version, const virtual_server_id &vsi)
+	{ m_recv_config_version = version; m_recv = vsi; }
+	bool recv_from(uint64_t version) const { return version == m_recv_config_version; }
+	virtual_server_id recv_from() const { return m_recv; }
+	void set_sent(uint64_t version, const virtual_server_id &vsi)
+	{ m_sent_config_version = version; m_sent = vsi; }
+	virtual_server_id sent_to() const { return m_sent; }
+	uint64_t sent_version() const { return m_sent_config_version; }
+	bool sent_to(uint64_t version, const virtual_server_id &vsi) const
+	{ return m_sent_config_version == version && m_sent == vsi; }
+
+	// the path of the op through the value-dependent chain
+	bool is_continuous() { return m_type == CONTINUOUS; }
+	bool is_discontinuous() { return m_type == DISCONTINUOUS; }
+	// call before hashing
+	void set_continuous();
+	// call after hashing; must call above first
+	void set_continuous_hashes(const region_id &prev_region,
+	                           const region_id &this_old_region,
+	                           const region_id &this_new_region,
+	                           const region_id &next_region);
+	void set_discontinuous(const region_id &prev_region,
+	                       const region_id &this_old_region,
+	                       const region_id &this_new_region,
+	                       const region_id &next_region);
+	region_id prev_region() const { return m_prev_region; }
+	region_id this_old_region() const { return m_this_old_region; }
+	region_id this_new_region() const { return m_this_new_region; }
+	region_id next_region() const { return m_next_region; }
+
+	// the value set by this op
+	bool is_fresh() { return m_fresh; }
+	bool has_value() { return m_has_value; }
+	const std::vector<e::slice> &value() { return m_value; }
+
+	void debug_dump();
+
+private:
+	friend class e::intrusive_ptr<key_operation>;
+	void inc() { ++m_ref; }
+	void dec() { if (--m_ref == 0) delete this; }
+
+private:
+	size_t m_ref;
+	const uint64_t m_prev_version;
+	const uint64_t m_this_version;
+	bool m_acked;
+	bool m_fresh;
+	const bool m_has_value;
+
+	uint64_t m_recv_config_version;
+	virtual_server_id m_recv; // we recv from here
+	uint64_t m_sent_config_version;
+	virtual_server_id m_sent; // we sent to here
+
+	const std::vector<e::slice> m_value;
+	const std::auto_ptr<e::arena> m_memory;
+
+	enum { UNKNOWN, CONTINUOUS, DISCONTINUOUS } m_type;
+	region_id m_this_old_region;
+	region_id m_this_new_region;
+	region_id m_prev_region;
+	region_id m_next_region;
+
+private:
+	key_operation(const key_operation &);
+	key_operation &operator = (const key_operation &);
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/daemon/key_region.cc b/daemon/key_region.cc
index 7d09e6597..e8f2f3d4e 100644
--- a/daemon/key_region.cc
+++ b/daemon/key_region.cc
@@ -31,48 +31,46 @@
 using hyperdex::key_region;
 
 key_region :: key_region()
-    : region()
-    , key()
+	: region()
+	, key()
 {
 }
 
-key_region :: key_region(const region_id& r, const e::slice& k)
-    : region(r)
-    , key(reinterpret_cast<const char*>(k.data()), k.size())
+key_region :: key_region(const region_id &r, const e::slice &k)
+	: region(r)
+	, key(reinterpret_cast<const char *>(k.data()), k.size())
 {
 }
 
-key_region :: key_region(const key_region& other)
-    : region(other.region)
-    , key(other.key)
+key_region :: key_region(const key_region &other)
+	: region(other.region)
+	, key(other.key)
 {
 }
 
 bool
-key_region :: operator < (const key_region& rhs) const
+key_region :: operator < (const key_region &rhs) const
 {
-    if (region == rhs.region)
-    {
-        return key < rhs.key;
-    }
-
-    return region < rhs.region;
+	if (region == rhs.region)
+	{
+		return key < rhs.key;
+	}
+	return region < rhs.region;
 }
 
 bool
-key_region :: operator == (const key_region& rhs) const
+key_region :: operator == (const key_region &rhs) const
 {
-    return region == rhs.region && key == rhs.key;
+	return region == rhs.region && key == rhs.key;
 }
 
-key_region&
-key_region :: operator = (const key_region& rhs)
+key_region &
+key_region :: operator = (const key_region &rhs)
 {
-    if (this != &rhs)
-    {
-        region = rhs.region;
-        key = rhs.key;
-    }
-
-    return *this;
+	if (this != &rhs)
+	{
+		region = rhs.region;
+		key = rhs.key;
+	}
+	return *this;
 }
diff --git a/daemon/key_region.h b/daemon/key_region.h
index f26b3d2fb..dce1660a4 100644
--- a/daemon/key_region.h
+++ b/daemon/key_region.h
@@ -39,22 +39,22 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class key_region
 {
-    public:
-        key_region();
-        key_region(const region_id& r, const e::slice& k);
-        key_region(const key_region& other);
+public:
+	key_region();
+	key_region(const region_id &r, const e::slice &k);
+	key_region(const key_region &other);
 
-    public:
-        bool operator < (const key_region& rhs) const;
-        bool operator == (const key_region& rhs) const;
-        key_region& operator = (const key_region& rhs);
+public:
+	bool operator < (const key_region &rhs) const;
+	bool operator == (const key_region &rhs) const;
+	key_region &operator = (const key_region &rhs);
 
-    public:
-        region_id region;
-        std::string key;
+public:
+	region_id region;
+	std::string key;
 
-    private:
-        friend class e::compat::hash<key_region>;
+private:
+	friend class e::compat::hash<key_region>;
 };
 
 END_HYPERDEX_NAMESPACE
@@ -64,12 +64,12 @@ BEGIN_E_COMPAT_NAMESPACE
 template <>
 struct hash<hyperdex::key_region>
 {
-    size_t operator()(const hyperdex::key_region& kr) const
-    {
-        return CityHash64WithSeed(reinterpret_cast<const char*>(kr.key.data()),
-                                  kr.key.size(),
-                                  e::compat::hash<uint64_t>()(kr.region.get()));
-    }
+	size_t operator()(const hyperdex::key_region &kr) const
+	{
+		return CityHash64WithSeed(reinterpret_cast<const char *>(kr.key.data()),
+		                          kr.key.size(),
+		                          e::compat::hash<uint64_t>()(kr.region.get()));
+	}
 };
 
 END_E_COMPAT_NAMESPACE
diff --git a/daemon/key_state.cc b/daemon/key_state.cc
index d0383f46a..e946da732 100644
--- a/daemon/key_state.cc
+++ b/daemon/key_state.cc
@@ -51,975 +51,886 @@ using hyperdex::key_state;
 
 struct key_state::deferred_key_change
 {
-    deferred_key_change(const server_id& _from,
-                        uint64_t _nonce, uint64_t _version,
-                        std::auto_ptr<key_change> _kc,
-                        std::auto_ptr<e::buffer> _backing)
-        : from(_from)
-        , nonce(_nonce)
-        , version(_version)
-        , kc(_kc)
-        , backing(_backing)
-        , m_ref(0)
-    {
-    }
-
-    void inc() { ++m_ref; }
-    void dec() { if (--m_ref == 0) delete this; }
-
-    const server_id from;
-    const uint64_t nonce;
-    const uint64_t version;
-    const std::auto_ptr<key_change> kc;
-    const std::auto_ptr<e::buffer> backing;
-
-    private:
-        size_t m_ref;
-
-    private:
-        deferred_key_change(const deferred_key_change&);
-        deferred_key_change& operator = (const deferred_key_change&);
+	deferred_key_change(const server_id &_from,
+	                    uint64_t _nonce, uint64_t _version,
+	                    std::auto_ptr<key_change> _kc,
+	                    std::auto_ptr<e::buffer> _backing)
+		: from(_from)
+		, nonce(_nonce)
+		, version(_version)
+		, kc(_kc)
+		, backing(_backing)
+		, m_ref(0)
+	{
+	}
+
+	void inc() { ++m_ref; }
+	void dec() { if (--m_ref == 0) delete this; }
+
+	const server_id from;
+	const uint64_t nonce;
+	const uint64_t version;
+	const std::auto_ptr<key_change> kc;
+	const std::auto_ptr<e::buffer> backing;
+
+private:
+	size_t m_ref;
+
+private:
+	deferred_key_change(const deferred_key_change &);
+	deferred_key_change &operator = (const deferred_key_change &);
 };
 
 struct key_state::client_response
 {
-    client_response() : respond_after(0), client(), nonce(), ret() {}
-    client_response(uint64_t _respond_after,
-                    server_id _client,
-                    uint64_t _nonce,
-                    network_returncode _ret)
-        : respond_after(_respond_after)
-        , client(_client)
-        , nonce(_nonce)
-        , ret(_ret)
-    {
-    }
-    ~client_response() throw () {}
-
-    // intentionally backwards so the max heap becomes min heap.
-    bool operator < (const client_response& rhs)
-    {
-        return respond_after > rhs.respond_after;
-    }
-
-    uint64_t respond_after;
-    server_id client;
-    uint64_t nonce;
-    network_returncode ret;
+	client_response() : respond_after(0), client(), nonce(), ret() {}
+	client_response(uint64_t _respond_after,
+	                server_id _client,
+	                uint64_t _nonce,
+	                network_returncode _ret)
+		: respond_after(_respond_after)
+		, client(_client)
+		, nonce(_nonce)
+		, ret(_ret)
+	{
+	}
+	~client_response() throw () {}
+
+	// intentionally backwards so the max heap becomes min heap.
+	bool operator < (const client_response &rhs)
+	{
+		return respond_after > rhs.respond_after;
+	}
+
+	uint64_t respond_after;
+	server_id client;
+	uint64_t nonce;
+	network_returncode ret;
 };
 
-key_state :: key_state(const key_region& kr)
-    : m_ri(kr.region)
-    , m_key_backing(reinterpret_cast<const char*>(kr.key.data()), kr.key.size())
-    , m_key(m_key_backing.data(), m_key_backing.size())
-    , m_client_atomics()
-    , m_chain_ops()
-    , m_chain_subspaces()
-    , m_chain_acks()
-    , m_lock()
-    , m_avail(&m_lock)
-    , m_someone_is_working_the_state_machine(false)
-    , m_someone_needs_to_work_the_state_machine(false)
-    , m_initialized(false)
-    , m_has_old_value(false)
-    , m_old_version(0)
-    , m_old_value()
-    , m_old_disk_ref()
-    , m_old_op()
-    , m_client_responses_heap()
-    , m_committable()
-    , m_committable_empty(true)
-    , m_blocked()
-    , m_blocked_empty(true)
-    , m_deferred()
-    , m_deferred_empty(true)
-    , m_changes()
-    , m_changes_empty(true)
+key_state :: key_state(const key_region &kr)
+	: m_ri(kr.region)
+	, m_key_backing(reinterpret_cast<const char *>(kr.key.data()), kr.key.size())
+	, m_key(m_key_backing.data(), m_key_backing.size())
+	, m_client_atomics()
+	, m_chain_ops()
+	, m_chain_subspaces()
+	, m_chain_acks()
+	, m_lock()
+	, m_avail(&m_lock)
+	, m_someone_is_working_the_state_machine(false)
+	, m_someone_needs_to_work_the_state_machine(false)
+	, m_initialized(false)
+	, m_has_old_value(false)
+	, m_old_version(0)
+	, m_old_value()
+	, m_old_disk_ref()
+	, m_old_op()
+	, m_client_responses_heap()
+	, m_committable()
+	, m_committable_empty(true)
+	, m_blocked()
+	, m_blocked_empty(true)
+	, m_deferred()
+	, m_deferred_empty(true)
+	, m_changes()
+	, m_changes_empty(true)
 {
 }
 
 key_state :: ~key_state() throw ()
 {
-    m_lock.lock();
-    m_lock.unlock();
+	m_lock.lock();
+	m_lock.unlock();
 }
 
 key_region
 key_state :: state_key() const
 {
-    return key_region(m_ri, m_key);
+	return key_region(m_ri, m_key);
 }
 
 bool
 key_state :: finished()
 {
-    po6::threads::mutex::hold hold(&m_lock);
-    return !m_someone_is_working_the_state_machine &&
-           !m_someone_needs_to_work_the_state_machine &&
-           m_committable_empty &&
-           m_blocked_empty &&
-           m_deferred_empty &&
-           m_changes_empty;
+	po6::threads::mutex::hold hold(&m_lock);
+	return !m_someone_is_working_the_state_machine &&
+	       !m_someone_needs_to_work_the_state_machine &&
+	       m_committable_empty &&
+	       m_blocked_empty &&
+	       m_deferred_empty &&
+	       m_changes_empty;
 }
 
 bool
 key_state :: initialized()
 {
-    po6::threads::mutex::hold hold(&m_lock);
-    return m_initialized;
+	po6::threads::mutex::hold hold(&m_lock);
+	return m_initialized;
 }
 
 hyperdex::datalayer::returncode
-key_state :: initialize(datalayer* data,
-                        const schema&,
-                        const region_id& ri)
+key_state :: initialize(datalayer *data,
+                        const schema &,
+                        const region_id &ri)
 {
-    po6::threads::mutex::hold hold(&m_lock);
-
-    // maybe we get lucky
-    if (m_initialized)
-    {
-        return datalayer::SUCCESS;
-    }
-
-    while (m_someone_is_working_the_state_machine)
-    {
-        m_avail.wait();
-    }
-
-    // make sure someone else didn't initialize while we waited
-    if (m_initialized)
-    {
-        return datalayer::SUCCESS;
-    }
-
-    datalayer::returncode rc = data->get(ri, m_key, &m_old_value, &m_old_version, &m_old_disk_ref);
-
-    switch (rc)
-    {
-        case datalayer::SUCCESS:
-            m_has_old_value = true;
-            break;
-        case datalayer::NOT_FOUND:
-        case datalayer::BAD_ENCODING:
-        case datalayer::CORRUPTION:
-        case datalayer::IO_ERROR:
-        case datalayer::LEVELDB_ERROR:
-        default:
-            m_has_old_value = false;
-            m_old_version = 0;
-            break;
-    }
-
-    m_initialized = true;
-    CHECK_INVARIANTS();
-    return rc;
+	po6::threads::mutex::hold hold(&m_lock);
+	// maybe we get lucky
+	if (m_initialized)
+	{
+		return datalayer::SUCCESS;
+	}
+	while (m_someone_is_working_the_state_machine)
+	{
+		m_avail.wait();
+	}
+	// make sure someone else didn't initialize while we waited
+	if (m_initialized)
+	{
+		return datalayer::SUCCESS;
+	}
+	datalayer::returncode rc = data->get(ri, m_key, &m_old_value, &m_old_version, &m_old_disk_ref);
+	switch (rc)
+	{
+	case datalayer::SUCCESS:
+		m_has_old_value = true;
+		break;
+	case datalayer::NOT_FOUND:
+	case datalayer::BAD_ENCODING:
+	case datalayer::CORRUPTION:
+	case datalayer::IO_ERROR:
+	case datalayer::LEVELDB_ERROR:
+	default:
+		m_has_old_value = false;
+		m_old_version = 0;
+		break;
+	}
+	m_initialized = true;
+	CHECK_INVARIANTS();
+	return rc;
 }
 
 struct key_state::stub_client_atomic
 {
-    stub_client_atomic(const server_id& f,
-                       uint64_t n,
-                       std::auto_ptr<key_change> k,
-                       std::auto_ptr<e::buffer> b)
-        : from(f), nonce(n), kc(k), backing(b) {}
-    ~stub_client_atomic() throw () {}
-
-    server_id from;
-    uint64_t nonce;
-    std::auto_ptr<key_change> kc;
-    std::auto_ptr<e::buffer> backing;
+	stub_client_atomic(const server_id &f,
+	                   uint64_t n,
+	                   std::auto_ptr<key_change> k,
+	                   std::auto_ptr<e::buffer> b)
+		: from(f), nonce(n), kc(k), backing(b) {}
+	~stub_client_atomic() throw () {}
+
+	server_id from;
+	uint64_t nonce;
+	std::auto_ptr<key_change> kc;
+	std::auto_ptr<e::buffer> backing;
 };
 
 void
-key_state :: enqueue_client_atomic(replication_manager* rm,
-                                   const virtual_server_id& us,
-                                   const schema& sc,
-                                   const server_id& from,
+key_state :: enqueue_client_atomic(replication_manager *rm,
+                                   const virtual_server_id &us,
+                                   const schema &sc,
+                                   const server_id &from,
                                    uint64_t nonce,
                                    std::auto_ptr<key_change> kc,
                                    std::auto_ptr<e::buffer> backing)
 {
-    bool have_it = possibly_takeover_state_machine();
-
-    if (have_it)
-    {
-        do_client_atomic(rm, us, sc, from, nonce, kc, backing);
-        work_state_machine_with_work_bit(rm, us, sc);
-    }
-    else
-    {
-        m_client_atomics.push(new stub_client_atomic(from, nonce, kc, backing));
-        someone_needs_to_work_the_state_machine();
-        work_state_machine_or_pass_the_buck(rm, us, sc);
-    }
+	bool have_it = possibly_takeover_state_machine();
+	if (have_it)
+	{
+		do_client_atomic(rm, us, sc, from, nonce, kc, backing);
+		work_state_machine_with_work_bit(rm, us, sc);
+	}
+	else
+	{
+		m_client_atomics.push(new stub_client_atomic(from, nonce, kc, backing));
+		someone_needs_to_work_the_state_machine();
+		work_state_machine_or_pass_the_buck(rm, us, sc);
+	}
 }
 
 struct key_state::stub_chain_op
 {
-    stub_chain_op(const virtual_server_id& _from,
-                  uint64_t _old_version,
-                  uint64_t _new_version,
-                  bool _fresh,
-                  bool _has_value,
-                  const std::vector<e::slice>& _value,
-                  std::auto_ptr<e::buffer> _backing)
-        : from(_from)
-        , old_version(_old_version)
-        , new_version(_new_version)
-        , fresh(_fresh)
-        , has_value(_has_value)
-        , value(_value)
-        , backing(_backing)
-    {
-    }
-    ~stub_chain_op() throw () {}
-
-    virtual_server_id from;
-    uint64_t old_version;
-    uint64_t new_version;
-    bool fresh;
-    bool has_value;
-    std::vector<e::slice> value;
-    std::auto_ptr<e::buffer> backing;
+	stub_chain_op(const virtual_server_id &_from,
+	              uint64_t _old_version,
+	              uint64_t _new_version,
+	              bool _fresh,
+	              bool _has_value,
+	              const std::vector<e::slice> &_value,
+	              std::auto_ptr<e::buffer> _backing)
+		: from(_from)
+		, old_version(_old_version)
+		, new_version(_new_version)
+		, fresh(_fresh)
+		, has_value(_has_value)
+		, value(_value)
+		, backing(_backing)
+	{
+	}
+	~stub_chain_op() throw () {}
+
+	virtual_server_id from;
+	uint64_t old_version;
+	uint64_t new_version;
+	bool fresh;
+	bool has_value;
+	std::vector<e::slice> value;
+	std::auto_ptr<e::buffer> backing;
 };
 
 void
-key_state :: enqueue_chain_op(replication_manager* rm,
-                              const virtual_server_id& us,
-                              const schema& sc,
-                              const virtual_server_id& from,
+key_state :: enqueue_chain_op(replication_manager *rm,
+                              const virtual_server_id &us,
+                              const schema &sc,
+                              const virtual_server_id &from,
                               uint64_t old_version,
                               uint64_t new_version,
                               bool fresh,
                               bool has_value,
-                              const std::vector<e::slice>& value,
+                              const std::vector<e::slice> &value,
                               std::auto_ptr<e::buffer> backing)
 {
-    bool have_it = possibly_takeover_state_machine();
-
-    if (have_it)
-    {
-        do_chain_op(rm, us, sc, from, old_version, new_version, fresh, has_value, value, backing);
-        work_state_machine_with_work_bit(rm, us, sc);
-    }
-    else
-    {
-        m_chain_ops.push(new stub_chain_op(from, old_version, new_version, fresh, has_value, value, backing));
-        someone_needs_to_work_the_state_machine();
-        work_state_machine_or_pass_the_buck(rm, us, sc);
-    }
+	bool have_it = possibly_takeover_state_machine();
+	if (have_it)
+	{
+		do_chain_op(rm, us, sc, from, old_version, new_version, fresh, has_value, value, backing);
+		work_state_machine_with_work_bit(rm, us, sc);
+	}
+	else
+	{
+		m_chain_ops.push(new stub_chain_op(from, old_version, new_version, fresh, has_value, value, backing));
+		someone_needs_to_work_the_state_machine();
+		work_state_machine_or_pass_the_buck(rm, us, sc);
+	}
 }
 
 struct key_state::stub_chain_subspace
 {
-    stub_chain_subspace(const virtual_server_id& _from,
-                        uint64_t _old_version,
-                        uint64_t _new_version,
-                        const std::vector<e::slice>& _value,
-                        std::auto_ptr<e::buffer> _backing,
-                        const region_id& _prev_region,
-                        const region_id& _this_old_region,
-                        const region_id& _this_new_region,
-                        const region_id& _next_region)
-        : from(_from)
-        , old_version(_old_version)
-        , new_version(_new_version)
-        , value(_value)
-        , backing(_backing)
-        , prev_region(_prev_region)
-        , this_old_region(_this_old_region)
-        , this_new_region(_this_new_region)
-        , next_region(_next_region)
-    {
-    }
-    ~stub_chain_subspace() throw () {}
-
-    virtual_server_id from;
-    uint64_t old_version;
-    uint64_t new_version;
-    std::vector<e::slice> value;
-    std::auto_ptr<e::buffer> backing;
-    region_id prev_region;
-    region_id this_old_region;
-    region_id this_new_region;
-    region_id next_region;
+	stub_chain_subspace(const virtual_server_id &_from,
+	                    uint64_t _old_version,
+	                    uint64_t _new_version,
+	                    const std::vector<e::slice> &_value,
+	                    std::auto_ptr<e::buffer> _backing,
+	                    const region_id &_prev_region,
+	                    const region_id &_this_old_region,
+	                    const region_id &_this_new_region,
+	                    const region_id &_next_region)
+		: from(_from)
+		, old_version(_old_version)
+		, new_version(_new_version)
+		, value(_value)
+		, backing(_backing)
+		, prev_region(_prev_region)
+		, this_old_region(_this_old_region)
+		, this_new_region(_this_new_region)
+		, next_region(_next_region)
+	{
+	}
+	~stub_chain_subspace() throw () {}
+
+	virtual_server_id from;
+	uint64_t old_version;
+	uint64_t new_version;
+	std::vector<e::slice> value;
+	std::auto_ptr<e::buffer> backing;
+	region_id prev_region;
+	region_id this_old_region;
+	region_id this_new_region;
+	region_id next_region;
 };
 
 void
-key_state :: enqueue_chain_subspace(replication_manager* rm,
-                                    const virtual_server_id& us,
-                                    const schema& sc,
-                                    const virtual_server_id& from,
+key_state :: enqueue_chain_subspace(replication_manager *rm,
+                                    const virtual_server_id &us,
+                                    const schema &sc,
+                                    const virtual_server_id &from,
                                     uint64_t old_version,
                                     uint64_t new_version,
-                                    const std::vector<e::slice>& value,
+                                    const std::vector<e::slice> &value,
                                     std::auto_ptr<e::buffer> backing,
-                                    const region_id& prev_region,
-                                    const region_id& this_old_region,
-                                    const region_id& this_new_region,
-                                    const region_id& next_region)
+                                    const region_id &prev_region,
+                                    const region_id &this_old_region,
+                                    const region_id &this_new_region,
+                                    const region_id &next_region)
 {
-    bool have_it = possibly_takeover_state_machine();
-
-    if (have_it)
-    {
-        do_chain_subspace(rm, us, sc, from, old_version, new_version, value, backing, prev_region, this_old_region, this_new_region, next_region);
-        work_state_machine_with_work_bit(rm, us, sc);
-    }
-    else
-    {
-        m_chain_subspaces.push(new stub_chain_subspace(from, old_version, new_version, value, backing, prev_region, this_old_region, this_new_region, next_region));
-        someone_needs_to_work_the_state_machine();
-        work_state_machine_or_pass_the_buck(rm, us, sc);
-    }
+	bool have_it = possibly_takeover_state_machine();
+	if (have_it)
+	{
+		do_chain_subspace(rm, us, sc, from, old_version, new_version, value, backing, prev_region, this_old_region, this_new_region, next_region);
+		work_state_machine_with_work_bit(rm, us, sc);
+	}
+	else
+	{
+		m_chain_subspaces.push(new stub_chain_subspace(from, old_version, new_version, value, backing, prev_region, this_old_region, this_new_region, next_region));
+		someone_needs_to_work_the_state_machine();
+		work_state_machine_or_pass_the_buck(rm, us, sc);
+	}
 }
 
 struct key_state::stub_chain_ack
 {
-    stub_chain_ack(const virtual_server_id& _from,
-                   uint64_t _version)
-        : from(_from)
-        , version(_version)
-    {
-    }
-    ~stub_chain_ack() throw () {}
-
-    virtual_server_id from;
-    uint64_t version;
+	stub_chain_ack(const virtual_server_id &_from,
+	               uint64_t _version)
+		: from(_from)
+		, version(_version)
+	{
+	}
+	~stub_chain_ack() throw () {}
+
+	virtual_server_id from;
+	uint64_t version;
 };
 
 void
-key_state :: enqueue_chain_ack(replication_manager* rm,
-                               const virtual_server_id& us,
-                               const schema& sc,
-                               const virtual_server_id& from,
+key_state :: enqueue_chain_ack(replication_manager *rm,
+                               const virtual_server_id &us,
+                               const schema &sc,
+                               const virtual_server_id &from,
                                uint64_t version)
 {
-    bool have_it = possibly_takeover_state_machine();
-
-    if (have_it)
-    {
-        do_chain_ack(rm, us, sc, from, version);
-        work_state_machine_with_work_bit(rm, us, sc);
-    }
-    else
-    {
-        m_chain_acks.push(new stub_chain_ack(from, version));
-        someone_needs_to_work_the_state_machine();
-        work_state_machine_or_pass_the_buck(rm, us, sc);
-    }
+	bool have_it = possibly_takeover_state_machine();
+	if (have_it)
+	{
+		do_chain_ack(rm, us, sc, from, version);
+		work_state_machine_with_work_bit(rm, us, sc);
+	}
+	else
+	{
+		m_chain_acks.push(new stub_chain_ack(from, version));
+		someone_needs_to_work_the_state_machine();
+		work_state_machine_or_pass_the_buck(rm, us, sc);
+	}
 }
 
 void
-key_state :: work_state_machine(replication_manager* rm,
-                                const virtual_server_id& us,
-                                const schema& sc)
+key_state :: work_state_machine(replication_manager *rm,
+                                const virtual_server_id &us,
+                                const schema &sc)
 {
-    work_state_machine_or_pass_the_buck(rm, us, sc);
+	work_state_machine_or_pass_the_buck(rm, us, sc);
 }
 
 uint64_t
 key_state :: max_version()
 {
-    po6::threads::mutex::hold hold(&m_lock);
-
-    while (m_someone_is_working_the_state_machine)
-    {
-        m_avail.wait();
-    }
-
-    uint64_t ret = 0;
-
-    for (key_operation_list_t::const_iterator it = m_committable.begin();
-            it != m_committable.end(); ++it)
-    {
-        ret = std::max(ret, (*it)->this_version());
-    }
-
-    for (key_operation_list_t::const_iterator it = m_blocked.begin();
-            it != m_blocked.end(); ++it)
-    {
-        ret = std::max(ret, (*it)->this_version());
-    }
-
-    for (key_operation_list_t::const_iterator it = m_deferred.begin();
-            it != m_deferred.end(); ++it)
-    {
-        ret = std::max(ret, (*it)->this_version());
-    }
-
-    for (key_change_list_t::const_iterator it = m_changes.begin();
-            it != m_changes.end(); ++it)
-    {
-        ret = std::max(ret, (*it)->version);
-    }
-
-    return ret;
+	po6::threads::mutex::hold hold(&m_lock);
+	while (m_someone_is_working_the_state_machine)
+	{
+		m_avail.wait();
+	}
+	uint64_t ret = 0;
+	for (key_operation_list_t::const_iterator it = m_committable.begin();
+	     it != m_committable.end(); ++it)
+	{
+		ret = std::max(ret, (*it)->this_version());
+	}
+	for (key_operation_list_t::const_iterator it = m_blocked.begin();
+	     it != m_blocked.end(); ++it)
+	{
+		ret = std::max(ret, (*it)->this_version());
+	}
+	for (key_operation_list_t::const_iterator it = m_deferred.begin();
+	     it != m_deferred.end(); ++it)
+	{
+		ret = std::max(ret, (*it)->this_version());
+	}
+	for (key_change_list_t::const_iterator it = m_changes.begin();
+	     it != m_changes.end(); ++it)
+	{
+		ret = std::max(ret, (*it)->version);
+	}
+	return ret;
 }
 
 void
-key_state :: reconfigure(e::garbage_collector* gc)
+key_state :: reconfigure(e::garbage_collector *gc)
 {
-    po6::threads::mutex::hold hold(&m_lock);
-
-    while (m_someone_is_working_the_state_machine)
-    {
-        m_avail.wait();
-    }
-
-    stub_client_atomic* sca;
-    stub_chain_op* sco;
-    stub_chain_subspace* scs;
-    stub_chain_ack* scack;
-
-    while (m_client_atomics.pop(gc, &sca))
-    {
-        delete sca;
-    }
-
-    while (m_chain_ops.pop(gc, &sco))
-    {
-        delete sco;
-    }
-
-    while (m_chain_subspaces.pop(gc, &scs))
-    {
-        delete scs;
-    }
-
-    while (m_chain_acks.pop(gc, &scack))
-    {
-        delete scack;
-    }
-
-    m_deferred.clear();
-    CHECK_INVARIANTS();
+	po6::threads::mutex::hold hold(&m_lock);
+	while (m_someone_is_working_the_state_machine)
+	{
+		m_avail.wait();
+	}
+	stub_client_atomic *sca;
+	stub_chain_op *sco;
+	stub_chain_subspace *scs;
+	stub_chain_ack *scack;
+	while (m_client_atomics.pop(gc, &sca))
+	{
+		delete sca;
+	}
+	while (m_chain_ops.pop(gc, &sco))
+	{
+		delete sco;
+	}
+	while (m_chain_subspaces.pop(gc, &scs))
+	{
+		delete scs;
+	}
+	while (m_chain_acks.pop(gc, &scack))
+	{
+		delete scack;
+	}
+	m_deferred.clear();
+	CHECK_INVARIANTS();
 }
 
 void
-key_state :: reset(e::garbage_collector* gc)
+key_state :: reset(e::garbage_collector *gc)
 {
-    po6::threads::mutex::hold hold(&m_lock);
-
-    while (m_someone_is_working_the_state_machine)
-    {
-        m_avail.wait();
-    }
-
-    stub_client_atomic* sca;
-    stub_chain_op* sco;
-    stub_chain_subspace* scs;
-    stub_chain_ack* scack;
-
-    while (m_client_atomics.pop(gc, &sca))
-    {
-        delete sca;
-    }
-
-    while (m_chain_ops.pop(gc, &sco))
-    {
-        delete sco;
-    }
-
-    while (m_chain_subspaces.pop(gc, &scs))
-    {
-        delete scs;
-    }
-
-    while (m_chain_acks.pop(gc, &scack))
-    {
-        delete scack;
-    }
-
-    m_someone_is_working_the_state_machine = false;
-    m_someone_needs_to_work_the_state_machine = false;
-    m_avail.broadcast();
-
-    m_committable.clear();
-    m_blocked.clear();
-    m_deferred.clear();
-    m_changes.clear();
-    CHECK_INVARIANTS();
+	po6::threads::mutex::hold hold(&m_lock);
+	while (m_someone_is_working_the_state_machine)
+	{
+		m_avail.wait();
+	}
+	stub_client_atomic *sca;
+	stub_chain_op *sco;
+	stub_chain_subspace *scs;
+	stub_chain_ack *scack;
+	while (m_client_atomics.pop(gc, &sca))
+	{
+		delete sca;
+	}
+	while (m_chain_ops.pop(gc, &sco))
+	{
+		delete sco;
+	}
+	while (m_chain_subspaces.pop(gc, &scs))
+	{
+		delete scs;
+	}
+	while (m_chain_acks.pop(gc, &scack))
+	{
+		delete scack;
+	}
+	m_someone_is_working_the_state_machine = false;
+	m_someone_needs_to_work_the_state_machine = false;
+	m_avail.broadcast();
+	m_committable.clear();
+	m_blocked.clear();
+	m_deferred.clear();
+	m_changes.clear();
+	CHECK_INVARIANTS();
 }
 
 void
-key_state :: resend_committable(replication_manager* rm,
-                                const virtual_server_id& us)
+key_state :: resend_committable(replication_manager *rm,
+                                const virtual_server_id &us)
 {
-    po6::threads::mutex::hold hold(&m_lock);
-
-    while (m_someone_is_working_the_state_machine)
-    {
-        m_avail.wait();
-    }
-
-    CHECK_INVARIANTS();
-
-    for (key_operation_list_t::iterator it = m_committable.begin();
-            it != m_committable.end(); ++it)
-    {
-        // skip those messages already sent in this version
-        if ((*it)->sent_version() >= rm->m_daemon->m_config.version())
-        {
-            continue;
-        }
-
-        (*it)->set_sent(0, virtual_server_id());
-        rm->send_message(us, m_key, *it);
-    }
-
-    CHECK_INVARIANTS();
+	po6::threads::mutex::hold hold(&m_lock);
+	while (m_someone_is_working_the_state_machine)
+	{
+		m_avail.wait();
+	}
+	CHECK_INVARIANTS();
+	for (key_operation_list_t::iterator it = m_committable.begin();
+	     it != m_committable.end(); ++it)
+	{
+		// skip those messages already sent in this version
+		if ((*it)->sent_version() >= rm->m_daemon->m_config.version())
+		{
+			continue;
+		}
+		(*it)->set_sent(0, virtual_server_id());
+		rm->send_message(us, m_key, *it);
+	}
+	CHECK_INVARIANTS();
 }
 
 void
-key_state :: append_all_versions(std::vector<std::pair<region_id, uint64_t> >* versions)
+key_state :: append_all_versions(std::vector<std::pair<region_id, uint64_t> > *versions)
 {
-    po6::threads::mutex::hold hold(&m_lock);
-
-    while (m_someone_is_working_the_state_machine)
-    {
-        m_avail.wait();
-    }
-
-    size_t sz = versions->size() + m_committable.size() + m_blocked.size() + m_deferred.size();
-
-    if (versions->capacity() < sz)
-    {
-        versions->reserve(std::max(sz, versions->capacity() + (versions->capacity() >> 1ULL)));
-    }
-
-    for (key_operation_list_t::iterator it = m_committable.begin();
-            it != m_committable.end(); ++it)
-    {
-        versions->push_back(std::make_pair(m_ri, (*it)->this_version()));
-    }
-
-    for (key_operation_list_t::iterator it = m_blocked.begin();
-            it != m_blocked.end(); ++it)
-    {
-        versions->push_back(std::make_pair(m_ri, (*it)->this_version()));
-    }
-
-    for (key_operation_list_t::iterator it = m_deferred.begin();
-            it != m_deferred.end(); ++it)
-    {
-        versions->push_back(std::make_pair(m_ri, (*it)->this_version()));
-    }
-
-    // XXX
+	po6::threads::mutex::hold hold(&m_lock);
+	while (m_someone_is_working_the_state_machine)
+	{
+		m_avail.wait();
+	}
+	size_t sz = versions->size() + m_committable.size() + m_blocked.size() + m_deferred.size();
+	if (versions->capacity() < sz)
+	{
+		versions->reserve(std::max(sz, versions->capacity() + (versions->capacity() >> 1ULL)));
+	}
+	for (key_operation_list_t::iterator it = m_committable.begin();
+	     it != m_committable.end(); ++it)
+	{
+		versions->push_back(std::make_pair(m_ri, (*it)->this_version()));
+	}
+	for (key_operation_list_t::iterator it = m_blocked.begin();
+	     it != m_blocked.end(); ++it)
+	{
+		versions->push_back(std::make_pair(m_ri, (*it)->this_version()));
+	}
+	for (key_operation_list_t::iterator it = m_deferred.begin();
+	     it != m_deferred.end(); ++it)
+	{
+		versions->push_back(std::make_pair(m_ri, (*it)->this_version()));
+	}
+	// XXX
 }
 
 void
 key_state :: debug_dump()
 {
-    po6::threads::mutex::hold hold(&m_lock);
-
-    while (m_someone_is_working_the_state_machine)
-    {
-        m_avail.wait();
-    }
-
-    LOG(INFO) << " old " << m_old_version;
-
-    for (key_operation_list_t::const_iterator it = m_committable.begin();
-            it != m_committable.end(); ++it)
-    {
-        LOG(INFO) << " committable " << (*it)->this_version();
-        (*it)->debug_dump();
-    }
-
-    for (key_operation_list_t::const_iterator it = m_blocked.begin();
-            it != m_blocked.end(); ++it)
-    {
-        LOG(INFO) << " blocked " << (*it)->this_version();
-        (*it)->debug_dump();
-    }
-
-    for (key_operation_list_t::const_iterator it = m_deferred.begin();
-            it != m_deferred.end(); ++it)
-    {
-        LOG(INFO) << " deferred " << (*it)->this_version();
-        (*it)->debug_dump();
-    }
+	po6::threads::mutex::hold hold(&m_lock);
+	while (m_someone_is_working_the_state_machine)
+	{
+		m_avail.wait();
+	}
+	LOG(INFO) << " old " << m_old_version;
+	for (key_operation_list_t::const_iterator it = m_committable.begin();
+	     it != m_committable.end(); ++it)
+	{
+		LOG(INFO) << " committable " << (*it)->this_version();
+		(*it)->debug_dump();
+	}
+	for (key_operation_list_t::const_iterator it = m_blocked.begin();
+	     it != m_blocked.end(); ++it)
+	{
+		LOG(INFO) << " blocked " << (*it)->this_version();
+		(*it)->debug_dump();
+	}
+	for (key_operation_list_t::const_iterator it = m_deferred.begin();
+	     it != m_deferred.end(); ++it)
+	{
+		LOG(INFO) << " deferred " << (*it)->this_version();
+		(*it)->debug_dump();
+	}
 }
 
 void
 key_state :: check_invariants() const
 {
-    assert(m_initialized);
-    uint64_t version = 0;
-
-    for (key_operation_list_t::const_iterator it = m_committable.begin();
-            it != m_committable.end(); ++it)
-    {
-        key_operation* op = it->get();
-        assert(op);
-        assert(op->prev_version() < op->this_version());
-        assert(version == 0 || version == op->prev_version());
-        version = op->this_version();
-        assert(op->is_continuous() || op->is_discontinuous());
-    }
-
-    for (key_operation_list_t::const_iterator it = m_blocked.begin();
-            it != m_blocked.end(); ++it)
-    {
-        key_operation* op = it->get();
-        assert(op);
-        assert(op->prev_version() < op->this_version());
-        assert(version == 0 || version == op->prev_version());
-        version = op->this_version();
-        assert(op->is_continuous() || op->is_discontinuous());
-    }
-
-    uint64_t deferred_max_version = version;
-
-    for (key_operation_list_t::const_iterator it = m_deferred.begin();
-            it != m_deferred.end(); ++it)
-    {
-        key_operation* op = it->get();
-        assert(op);
-        assert(op->prev_version() < op->this_version());
-        assert(version == 0 || version <= op->prev_version());
-        assert(version == 0 || version < op->this_version());
-        deferred_max_version = std::max(op->this_version(), deferred_max_version);
-        assert(op->is_continuous() || op->is_discontinuous());
-    }
-
-    version = deferred_max_version;
-
-    for (key_change_list_t::const_iterator it = m_changes.begin();
-            it != m_changes.end(); ++it)
-    {
-        deferred_key_change* dkc = it->get();
-        assert(dkc);
-        assert(version == 0 || version < dkc->version);
-        version = dkc->version;
-    }
-
-    assert(m_committable.empty() || m_old_version <= m_committable.back()->this_version());
-    assert(m_blocked.empty() || m_old_version < m_blocked.front()->this_version());
-    assert(m_deferred.empty() || m_old_version < m_deferred.front()->this_version());
-    assert(m_changes.empty() || m_old_version < m_changes.front()->version);
-
-    assert(m_committable_empty == m_committable.empty());
-    assert(m_blocked_empty == m_blocked.empty());
-    assert(m_deferred_empty == m_deferred.empty());
-    assert(m_changes_empty == m_changes.empty());
+	assert(m_initialized);
+	uint64_t version = 0;
+	for (key_operation_list_t::const_iterator it = m_committable.begin();
+	     it != m_committable.end(); ++it)
+	{
+		key_operation *op = it->get();
+		assert(op);
+		assert(op->prev_version() < op->this_version());
+		assert(version == 0 || version == op->prev_version());
+		version = op->this_version();
+		assert(op->is_continuous() || op->is_discontinuous());
+	}
+	for (key_operation_list_t::const_iterator it = m_blocked.begin();
+	     it != m_blocked.end(); ++it)
+	{
+		key_operation *op = it->get();
+		assert(op);
+		assert(op->prev_version() < op->this_version());
+		assert(version == 0 || version == op->prev_version());
+		version = op->this_version();
+		assert(op->is_continuous() || op->is_discontinuous());
+	}
+	uint64_t deferred_max_version = version;
+	for (key_operation_list_t::const_iterator it = m_deferred.begin();
+	     it != m_deferred.end(); ++it)
+	{
+		key_operation *op = it->get();
+		assert(op);
+		assert(op->prev_version() < op->this_version());
+		assert(version == 0 || version <= op->prev_version());
+		assert(version == 0 || version < op->this_version());
+		deferred_max_version = std::max(op->this_version(), deferred_max_version);
+		assert(op->is_continuous() || op->is_discontinuous());
+	}
+	version = deferred_max_version;
+	for (key_change_list_t::const_iterator it = m_changes.begin();
+	     it != m_changes.end(); ++it)
+	{
+		deferred_key_change *dkc = it->get();
+		assert(dkc);
+		assert(version == 0 || version < dkc->version);
+		version = dkc->version;
+	}
+	assert(m_committable.empty() || m_old_version <= m_committable.back()->this_version());
+	assert(m_blocked.empty() || m_old_version < m_blocked.front()->this_version());
+	assert(m_deferred.empty() || m_old_version < m_deferred.front()->this_version());
+	assert(m_changes.empty() || m_old_version < m_changes.front()->version);
+	assert(m_committable_empty == m_committable.empty());
+	assert(m_blocked_empty == m_blocked.empty());
+	assert(m_deferred_empty == m_deferred.empty());
+	assert(m_changes_empty == m_changes.empty());
 }
 
 void
 key_state :: someone_needs_to_work_the_state_machine()
 {
-    po6::threads::mutex::hold hold(&m_lock);
-    m_someone_needs_to_work_the_state_machine = true;
+	po6::threads::mutex::hold hold(&m_lock);
+	m_someone_needs_to_work_the_state_machine = true;
 }
 
 void
-key_state :: work_state_machine_or_pass_the_buck(replication_manager* rm,
-                                                 const virtual_server_id& us,
-                                                 const schema& sc)
+key_state :: work_state_machine_or_pass_the_buck(replication_manager *rm,
+                                                 const virtual_server_id &us,
+                                                 const schema &sc)
 {
-    if (possibly_takeover_state_machine())
-    {
-        work_state_machine_with_work_bit(rm, us, sc);
-    }
+	if (possibly_takeover_state_machine())
+	{
+		work_state_machine_with_work_bit(rm, us, sc);
+	}
 }
 
 void
 key_state :: takeover_state_machine()
 {
-    po6::threads::mutex::hold hold(&m_lock);
-
-    while (m_someone_is_working_the_state_machine)
-    {
-        m_avail.wait();
-    }
-
-    m_someone_is_working_the_state_machine = true;
+	po6::threads::mutex::hold hold(&m_lock);
+	while (m_someone_is_working_the_state_machine)
+	{
+		m_avail.wait();
+	}
+	m_someone_is_working_the_state_machine = true;
 }
 
 bool
 key_state :: possibly_takeover_state_machine()
 {
-    po6::threads::mutex::hold hold(&m_lock);
-    bool have_it = !m_someone_is_working_the_state_machine;
-    m_someone_is_working_the_state_machine = true;
-    return have_it;
+	po6::threads::mutex::hold hold(&m_lock);
+	bool have_it = !m_someone_is_working_the_state_machine;
+	m_someone_is_working_the_state_machine = true;
+	return have_it;
 }
 
 void
-key_state :: work_state_machine_with_work_bit(replication_manager* rm,
-                                              const virtual_server_id& us,
-                                              const schema& sc)
+key_state :: work_state_machine_with_work_bit(replication_manager *rm,
+                                              const virtual_server_id &us,
+                                              const schema &sc)
 {
-    while (true)
-    {
-        m_lock.lock();
-        m_someone_needs_to_work_the_state_machine = false;
-        m_lock.unlock();
-        e::garbage_collector* gc = &rm->m_daemon->m_gc;
-        stub_client_atomic* sca;
-        stub_chain_op* sco;
-        stub_chain_subspace* scs;
-        stub_chain_ack* scack;
-
-        while (m_client_atomics.pop(gc, &sca))
-        {
-            do_client_atomic(rm, us, sc, sca->from, sca->nonce, sca->kc, sca->backing);
-            delete sca;
-        }
-
-        while (m_chain_ops.pop(gc, &sco))
-        {
-            do_chain_op(rm, us, sc, sco->from, sco->old_version, sco->new_version, sco->fresh, sco->has_value, sco->value, sco->backing);
-            delete sco;
-        }
-
-        while (m_chain_subspaces.pop(gc, &scs))
-        {
-            do_chain_subspace(rm, us, sc, scs->from, scs->old_version, scs->new_version, scs->value, scs->backing,
-                              scs->prev_region, scs->this_old_region, scs->this_new_region, scs->next_region);
-            delete scs;
-        }
-
-        while (m_chain_acks.pop(gc, &scack))
-        {
-            do_chain_ack(rm, us, sc, scack->from, scack->version);
-            delete scack;
-        }
-
-        bool did_work = false;
-        CHECK_INVARIANTS();
-
-        // Drain the blocked and deferred items first, because order does not
-        // matter.
-        //
-        // Then drain the changes queue as it relies upon the deferred queue to
-        // be empty.
-        //
-        // Finally drain the committable queue to batch-write as many items as
-        // possible to the disk.
-
-        if (drain_queue(rm, us, sc, &m_blocked, &key_state::drain_blocked))
-        {
-            did_work = true;
-        }
-
-        if (drain_queue(rm, us, sc, &m_deferred, &key_state::drain_deferred))
-        {
-            did_work = true;
-        }
-
-        if (drain_queue(rm, us, sc, &m_changes, &key_state::drain_changes))
-        {
-            did_work = true;
-        }
-
-        if (did_work && m_committable.size() < 64)
-        {
-            // continue here because it will not hurt, and the more we can build
-            // up the "committable" queue, the more progress we can make
-            continue;
-        }
-
-        if (drain_queue(rm, us, sc, &m_committable, &key_state::drain_committable))
-        {
-            did_work = true;
-        }
-
-        CHECK_INVARIANTS();
-        send_responses(rm, us);
-
-        if (did_work)
-        {
-            continue;
-        }
-
-        bool done = false;
-        po6::threads::mutex::hold hold(&m_lock);
-        done = !m_someone_needs_to_work_the_state_machine;
-        m_someone_is_working_the_state_machine = !done;
-
-        if (done)
-        {
-            m_committable_empty = m_committable.empty();
-            m_blocked_empty = m_blocked.empty();
-            m_deferred_empty = m_deferred.empty();
-            m_changes_empty = m_changes.empty();
-            m_avail.broadcast();
-            break;
-        }
-    }
+	while (true)
+	{
+		m_lock.lock();
+		m_someone_needs_to_work_the_state_machine = false;
+		m_lock.unlock();
+		e::garbage_collector *gc = &rm->m_daemon->m_gc;
+		stub_client_atomic *sca;
+		stub_chain_op *sco;
+		stub_chain_subspace *scs;
+		stub_chain_ack *scack;
+		while (m_client_atomics.pop(gc, &sca))
+		{
+			do_client_atomic(rm, us, sc, sca->from, sca->nonce, sca->kc, sca->backing);
+			delete sca;
+		}
+		while (m_chain_ops.pop(gc, &sco))
+		{
+			do_chain_op(rm, us, sc, sco->from, sco->old_version, sco->new_version, sco->fresh, sco->has_value, sco->value, sco->backing);
+			delete sco;
+		}
+		while (m_chain_subspaces.pop(gc, &scs))
+		{
+			do_chain_subspace(rm, us, sc, scs->from, scs->old_version, scs->new_version, scs->value, scs->backing,
+			                  scs->prev_region, scs->this_old_region, scs->this_new_region, scs->next_region);
+			delete scs;
+		}
+		while (m_chain_acks.pop(gc, &scack))
+		{
+			do_chain_ack(rm, us, sc, scack->from, scack->version);
+			delete scack;
+		}
+		bool did_work = false;
+		CHECK_INVARIANTS();
+		// Drain the blocked and deferred items first, because order does not
+		// matter.
+		//
+		// Then drain the changes queue as it relies upon the deferred queue to
+		// be empty.
+		//
+		// Finally drain the committable queue to batch-write as many items as
+		// possible to the disk.
+		if (drain_queue(rm, us, sc, &m_blocked, &key_state::drain_blocked))
+		{
+			did_work = true;
+		}
+		if (drain_queue(rm, us, sc, &m_deferred, &key_state::drain_deferred))
+		{
+			did_work = true;
+		}
+		if (drain_queue(rm, us, sc, &m_changes, &key_state::drain_changes))
+		{
+			did_work = true;
+		}
+		if (did_work && m_committable.size() < 64)
+		{
+			// continue here because it will not hurt, and the more we can build
+			// up the "committable" queue, the more progress we can make
+			continue;
+		}
+		if (drain_queue(rm, us, sc, &m_committable, &key_state::drain_committable))
+		{
+			did_work = true;
+		}
+		CHECK_INVARIANTS();
+		send_responses(rm, us);
+		if (did_work)
+		{
+			continue;
+		}
+		bool done = false;
+		po6::threads::mutex::hold hold(&m_lock);
+		done = !m_someone_needs_to_work_the_state_machine;
+		m_someone_is_working_the_state_machine = !done;
+		if (done)
+		{
+			m_committable_empty = m_committable.empty();
+			m_blocked_empty = m_blocked.empty();
+			m_deferred_empty = m_deferred.empty();
+			m_changes_empty = m_changes.empty();
+			m_avail.broadcast();
+			break;
+		}
+	}
 }
 
 void
-key_state :: do_client_atomic(replication_manager* rm,
-                              const virtual_server_id&,
-                              const schema&,
-                              const server_id& from,
+key_state :: do_client_atomic(replication_manager *rm,
+                              const virtual_server_id &,
+                              const schema &,
+                              const server_id &from,
                               uint64_t nonce,
                               std::auto_ptr<key_change> kc,
                               std::auto_ptr<e::buffer> backing)
 {
-    uint64_t version = rm->m_idgen.generate_id(m_ri);
-
-    if (version % datalayer::REGION_PERIODIC == 0)
-    {
-        rm->m_daemon->m_data.bump_version(m_ri, version);
-    }
-
-    e::intrusive_ptr<deferred_key_change> dkc;
-    dkc = new deferred_key_change(from, nonce, version, kc, backing);
-    m_changes.push_back(dkc);
+	uint64_t version = rm->m_idgen.generate_id(m_ri);
+	if (version % datalayer::REGION_PERIODIC == 0)
+	{
+		rm->m_daemon->m_data.bump_version(m_ri, version);
+	}
+	e::intrusive_ptr<deferred_key_change> dkc;
+	dkc = new deferred_key_change(from, nonce, version, kc, backing);
+	m_changes.push_back(dkc);
 }
 
 void
-key_state :: do_chain_op(replication_manager* rm,
-                         const virtual_server_id& us,
-                         const schema&,
-                         const virtual_server_id& from,
+key_state :: do_chain_op(replication_manager *rm,
+                         const virtual_server_id &us,
+                         const schema &,
+                         const virtual_server_id &from,
                          uint64_t old_version,
                          uint64_t new_version,
                          bool fresh,
                          bool has_value,
-                         const std::vector<e::slice>& value,
+                         const std::vector<e::slice> &value,
                          std::auto_ptr<e::buffer> backing)
 {
-    e::intrusive_ptr<key_operation> op = get(new_version);
-    std::auto_ptr<e::arena> memory(new e::arena());
-    memory->takeover(backing.release());
-
-    if (!op)
-    {
-        op = enqueue_continuous_key_op(old_version, new_version, fresh,
-                                       has_value, value, memory);
-    }
-
-    assert(op);
-    op->set_recv(rm->m_daemon->m_config.version(), from);
-
-    if (op->ackable())
-    {
-        rm->send_ack(us, m_key, op);
-    }
+	e::intrusive_ptr<key_operation> op = get(new_version);
+	std::auto_ptr<e::arena> memory(new e::arena());
+	memory->takeover(backing.release());
+	if (!op)
+	{
+		op = enqueue_continuous_key_op(old_version, new_version, fresh,
+		                               has_value, value, memory);
+	}
+	assert(op);
+	op->set_recv(rm->m_daemon->m_config.version(), from);
+	if (op->ackable())
+	{
+		rm->send_ack(us, m_key, op);
+	}
 }
 
 void
-key_state :: do_chain_subspace(replication_manager* rm,
-                               const virtual_server_id& us,
-                               const schema&,
-                               const virtual_server_id& from,
+key_state :: do_chain_subspace(replication_manager *rm,
+                               const virtual_server_id &us,
+                               const schema &,
+                               const virtual_server_id &from,
                                uint64_t old_version,
                                uint64_t new_version,
-                               const std::vector<e::slice>& value,
+                               const std::vector<e::slice> &value,
                                std::auto_ptr<e::buffer> backing,
-                               const region_id& prev_region,
-                               const region_id& this_old_region,
-                               const region_id& this_new_region,
-                               const region_id& next_region)
+                               const region_id &prev_region,
+                               const region_id &this_old_region,
+                               const region_id &this_new_region,
+                               const region_id &next_region)
 {
-    e::intrusive_ptr<key_operation> op = get(new_version);
-    std::auto_ptr<e::arena> memory(new e::arena());
-    memory->takeover(backing.release());
-
-    if (!op)
-    {
-        op = enqueue_discontinuous_key_op(old_version, new_version,
-                                          value, memory,
-                                          prev_region, this_old_region,
-                                          this_new_region, next_region);
-    }
-
-    assert(op);
-    op->set_recv(rm->m_daemon->m_config.version(), from);
-
-    if (op->ackable())
-    {
-        rm->send_ack(us, m_key, op);
-    }
+	e::intrusive_ptr<key_operation> op = get(new_version);
+	std::auto_ptr<e::arena> memory(new e::arena());
+	memory->takeover(backing.release());
+	if (!op)
+	{
+		op = enqueue_discontinuous_key_op(old_version, new_version,
+		                                  value, memory,
+		                                  prev_region, this_old_region,
+		                                  this_new_region, next_region);
+	}
+	assert(op);
+	op->set_recv(rm->m_daemon->m_config.version(), from);
+	if (op->ackable())
+	{
+		rm->send_ack(us, m_key, op);
+	}
 }
 
 void
-key_state :: do_chain_ack(replication_manager* rm,
-                          const virtual_server_id& us,
-                          const schema&,
-                          const virtual_server_id& from,
+key_state :: do_chain_ack(replication_manager *rm,
+                          const virtual_server_id &us,
+                          const schema &,
+                          const virtual_server_id &from,
                           uint64_t version)
 {
-    e::intrusive_ptr<key_operation> op = get(version);
-
-    if (!op)
-    {
-        LOG(ERROR) << "dropping CHAIN_ACK for update we haven't seen";
-        LOG(ERROR) << "troubleshoot info: from=" << from << " to=" << us
-                   << " version=" << version << " key=" << m_key.hex();
-        return;
-    }
-
-    if (!op->sent_to(rm->m_daemon->m_config.version(), from))
-    {
-        return;
-    }
-
-    op->mark_acked();
-    rm->send_ack(us, m_key, op);
-    rm->collect(m_ri, op);
+	e::intrusive_ptr<key_operation> op = get(version);
+	if (!op)
+	{
+		LOG(ERROR) << "dropping CHAIN_ACK for update we haven't seen";
+		LOG(ERROR) << "troubleshoot info: from=" << from << " to=" << us
+		           << " version=" << version << " key=" << m_key.hex();
+		return;
+	}
+	if (!op->sent_to(rm->m_daemon->m_config.version(), from))
+	{
+		return;
+	}
+	op->mark_acked();
+	rm->send_ack(us, m_key, op);
+	rm->collect(m_ri, op);
 }
 
 void
-key_state :: add_response(const client_response& cr)
+key_state :: add_response(const client_response &cr)
 {
-    m_client_responses_heap.push_back(cr);
-    std::push_heap(m_client_responses_heap.begin(),
-                   m_client_responses_heap.end());
+	m_client_responses_heap.push_back(cr);
+	std::push_heap(m_client_responses_heap.begin(),
+	               m_client_responses_heap.end());
 }
 
 void
-key_state :: send_responses(replication_manager* rm,
-                            const virtual_server_id& us)
+key_state :: send_responses(replication_manager *rm,
+                            const virtual_server_id &us)
 {
-    while (!m_client_responses_heap.empty() &&
-           m_client_responses_heap[0].respond_after <= m_old_version)
-    {
-        const client_response& cr(m_client_responses_heap[0]);
-        rm->respond_to_client(us, cr.client, cr.nonce, cr.ret);
-
-        std::pop_heap(m_client_responses_heap.begin(),
-                      m_client_responses_heap.end());
-        m_client_responses_heap.pop_back();
-    }
+	while (!m_client_responses_heap.empty() &&
+	       m_client_responses_heap[0].respond_after <= m_old_version)
+	{
+		const client_response &cr(m_client_responses_heap[0]);
+		rm->respond_to_client(us, cr.client, cr.nonce, cr.ret);
+		std::pop_heap(m_client_responses_heap.begin(),
+		              m_client_responses_heap.end());
+		m_client_responses_heap.pop_back();
+	}
 }
 
 namespace
 {
 
 bool
-get_by_version(const std::list<e::intrusive_ptr<key_operation> >& list,
-               uint64_t version, e::intrusive_ptr<key_operation>* op)
+get_by_version(const std::list<e::intrusive_ptr<key_operation> > &list,
+               uint64_t version, e::intrusive_ptr<key_operation> *op)
 {
-    if (list.empty() || list.back()->this_version() < version)
-    {
-        return false;
-    }
-
-    for (std::list<e::intrusive_ptr<key_operation> >::const_iterator it = list.begin();
-            it != list.end(); ++it)
-    {
-        uint64_t v = (*it)->this_version();
-
-        if (v == version)
-        {
-            *op = *it;
-            return true;
-        }
-        else if (v > version)
-        {
-            return false;
-        }
-    }
-
-    return false;
+	if (list.empty() || list.back()->this_version() < version)
+	{
+		return false;
+	}
+	for (std::list<e::intrusive_ptr<key_operation> >::const_iterator it = list.begin();
+	     it != list.end(); ++it)
+	{
+		uint64_t v = (*it)->this_version();
+		if (v == version)
+		{
+			*op = *it;
+			return true;
+		}
+		else if (v > version)
+		{
+			return false;
+		}
+	}
+	return false;
 }
 
 } // namespace
@@ -1027,18 +938,16 @@ get_by_version(const std::list<e::intrusive_ptr<key_operation> >& list,
 e::intrusive_ptr<key_operation>
 key_state :: get(uint64_t new_version)
 {
-    CHECK_INVARIANTS();
-    e::intrusive_ptr<key_operation> op;
-
-    if (get_by_version(m_committable, new_version, &op) ||
-        get_by_version(m_blocked, new_version, &op) ||
-        get_by_version(m_deferred, new_version, &op))
-    {
-        assert(op);
-        return op;
-    }
-
-    return NULL;
+	CHECK_INVARIANTS();
+	e::intrusive_ptr<key_operation> op;
+	if (get_by_version(m_committable, new_version, &op) ||
+	    get_by_version(m_blocked, new_version, &op) ||
+	    get_by_version(m_deferred, new_version, &op))
+	{
+		assert(op);
+		return op;
+	}
+	return NULL;
 }
 
 e::intrusive_ptr<key_operation>
@@ -1046,498 +955,445 @@ key_state :: enqueue_continuous_key_op(uint64_t old_version,
                                        uint64_t new_version,
                                        bool fresh,
                                        bool has_value,
-                                       const std::vector<e::slice>& value,
+                                       const std::vector<e::slice> &value,
                                        std::auto_ptr<e::arena> memory)
 {
-    e::intrusive_ptr<key_operation> op;
-    op = new key_operation(old_version, new_version, fresh,
-                           has_value, value, memory);
-    op->set_continuous();
-
-    if ((!has_value && !m_has_old_value) ||
-        (new_version <= m_old_version))
-    {
-        op->mark_acked();
-        return op;
-    }
-
-    m_deferred.push_back(op);
-    return op;
+	e::intrusive_ptr<key_operation> op;
+	op = new key_operation(old_version, new_version, fresh,
+	                       has_value, value, memory);
+	op->set_continuous();
+	if ((!has_value && !m_has_old_value) ||
+	    (new_version <= m_old_version))
+	{
+		op->mark_acked();
+		return op;
+	}
+	m_deferred.push_back(op);
+	return op;
 }
 
 e::intrusive_ptr<key_operation>
 key_state :: enqueue_discontinuous_key_op(uint64_t old_version,
                                           uint64_t new_version,
-                                          const std::vector<e::slice>& value,
+                                          const std::vector<e::slice> &value,
                                           std::auto_ptr<e::arena> memory,
-                                          const region_id& prev_region,
-                                          const region_id& this_old_region,
-                                          const region_id& this_new_region,
-                                          const region_id& next_region)
+                                          const region_id &prev_region,
+                                          const region_id &this_old_region,
+                                          const region_id &this_new_region,
+                                          const region_id &next_region)
 {
-    e::intrusive_ptr<key_operation> op;
-    op = new key_operation(old_version, new_version, false,
-                           true, value, memory);
-    op->set_discontinuous(prev_region, this_old_region, this_new_region, next_region);
-    m_deferred.push_back(op);
-    return op;
+	e::intrusive_ptr<key_operation> op;
+	op = new key_operation(old_version, new_version, false,
+	                       true, value, memory);
+	op->set_discontinuous(prev_region, this_old_region, this_new_region, next_region);
+	m_deferred.push_back(op);
+	return op;
 }
 
 void
-key_state :: get_latest(bool* has_old_value,
-                        uint64_t* old_version,
-                        const std::vector<e::slice>** old_value)
+key_state :: get_latest(bool *has_old_value,
+                        uint64_t *old_version,
+                        const std::vector<e::slice> **old_value)
 {
-    CHECK_INVARIANTS();
-    *old_version = 0;
-
-    // We try to pick the highest version of the key we know of here
-    // We know that the pending and commitable operations are sorted so we only look at their back
-
-    if (!m_blocked.empty() && m_blocked.back()->this_version() > *old_version)
-    {
-        *has_old_value = m_blocked.back()->has_value();
-        *old_version = m_blocked.back()->this_version();
-        *old_value = &m_blocked.back()->value();
-    }
-
-    if (!m_committable.empty() && m_committable.back()->this_version() > *old_version)
-    {
-        *has_old_value = m_committable.back()->has_value();
-        *old_version = m_committable.back()->this_version();
-        *old_value = &m_committable.back()->value();
-    }
-
-    if (m_old_version > *old_version)
-    {
-        *has_old_value = m_has_old_value;
-        *old_version = m_old_version;
-        *old_value = &m_old_value;
-    }
+	CHECK_INVARIANTS();
+	*old_version = 0;
+	// We try to pick the highest version of the key we know of here
+	// We know that the pending and commitable operations are sorted so we only look at their back
+	if (!m_blocked.empty() && m_blocked.back()->this_version() > *old_version)
+	{
+		*has_old_value = m_blocked.back()->has_value();
+		*old_version = m_blocked.back()->this_version();
+		*old_value = &m_blocked.back()->value();
+	}
+	if (!m_committable.empty() && m_committable.back()->this_version() > *old_version)
+	{
+		*has_old_value = m_committable.back()->has_value();
+		*old_version = m_committable.back()->this_version();
+		*old_value = &m_committable.back()->value();
+	}
+	if (m_old_version > *old_version)
+	{
+		*has_old_value = m_has_old_value;
+		*old_version = m_old_version;
+		*old_value = &m_old_value;
+	}
 }
 
 bool
-key_state :: drain_queue(replication_manager* rm,
-                         const virtual_server_id& us,
-                         const schema& sc,
-                         key_operation_list_t* q,
-                         void (key_state::*f)(replication_manager* rm,
-                                              const virtual_server_id& us,
-                                              const schema& sc))
+key_state :: drain_queue(replication_manager *rm,
+                         const virtual_server_id &us,
+                         const schema &sc,
+                         key_operation_list_t *q,
+                         void (key_state::*f)(replication_manager *rm,
+                                              const virtual_server_id &us,
+                                              const schema &sc))
 {
-    bool did_work = false;
-
-    while (!q->empty())
-    {
-        CHECK_INVARIANTS();
-        size_t before = q->size();
-        (this->*f)(rm, us, sc);
-        size_t after = q->size();
-
-        if (before > after)
-        {
-            did_work = true;
-        }
-        else
-        {
-            break;
-        }
-    }
-
-    return did_work;
+	bool did_work = false;
+	while (!q->empty())
+	{
+		CHECK_INVARIANTS();
+		size_t before = q->size();
+		(this->*f)(rm, us, sc);
+		size_t after = q->size();
+		if (before > after)
+		{
+			did_work = true;
+		}
+		else
+		{
+			break;
+		}
+	}
+	return did_work;
 }
 
 bool
-key_state :: drain_queue(replication_manager* rm,
-                         const virtual_server_id& us,
-                         const schema& sc,
-                         key_change_list_t* q,
-                         void (key_state::*f)(replication_manager* rm,
-                                              const virtual_server_id& us,
-                                              const schema& sc))
+key_state :: drain_queue(replication_manager *rm,
+                         const virtual_server_id &us,
+                         const schema &sc,
+                         key_change_list_t *q,
+                         void (key_state::*f)(replication_manager *rm,
+                                              const virtual_server_id &us,
+                                              const schema &sc))
 {
-    bool did_work = false;
-
-    while (!q->empty())
-    {
-        CHECK_INVARIANTS();
-        size_t before = q->size();
-        (this->*f)(rm, us, sc);
-        size_t after = q->size();
-
-        if (before > after)
-        {
-            did_work = true;
-        }
-        else
-        {
-            break;
-        }
-    }
-
-    return did_work;
+	bool did_work = false;
+	while (!q->empty())
+	{
+		CHECK_INVARIANTS();
+		size_t before = q->size();
+		(this->*f)(rm, us, sc);
+		size_t after = q->size();
+		if (before > after)
+		{
+			did_work = true;
+		}
+		else
+		{
+			break;
+		}
+	}
+	return did_work;
 }
 
 void
-key_state :: drain_changes(replication_manager*,
-                           const virtual_server_id&,
-                           const schema& sc)
+key_state :: drain_changes(replication_manager *,
+                           const virtual_server_id &,
+                           const schema &sc)
 {
-    assert(!m_changes.empty());
-
-    if (!m_deferred.empty())
-    {
-        return;
-    }
-
-    assert(sc.attrs_sz > 0);
-    bool has_old_value = false;
-    uint64_t old_version = 0;
-    const std::vector<e::slice>* old_value = NULL;
-    get_latest(&has_old_value, &old_version, &old_value);
-
-    e::intrusive_ptr<deferred_key_change> dkc = m_changes.front();
-    m_changes.pop_front();
-    key_change* kc = dkc->kc.get();
-
-    if (!auth_verify_write(sc, has_old_value, old_value, *kc))
-    {
-        add_response(client_response(old_version, dkc->from, dkc->nonce, NET_UNAUTHORIZED));
-        return;
-    }
-
-    network_returncode nrc = kc->check(sc, has_old_value, old_value);
-
-    if (nrc != NET_SUCCESS)
-    {
-        add_response(client_response(old_version, dkc->from, dkc->nonce, nrc));
-        return;
-    }
-
-    if (kc->erase)
-    {
-        e::intrusive_ptr<key_operation> op;
-        op = new key_operation(old_version, dkc->version, false,
-                               false, std::vector<e::slice>(sc.attrs_sz - 1),
-                               std::auto_ptr<e::arena>());
-        op->set_continuous();
-        add_response(client_response(dkc->version, dkc->from, dkc->nonce, NET_SUCCESS));
-        m_deferred.push_back(op);
-        return;
-    }
-
-    std::auto_ptr<e::arena> memory(new e::arena());
-    std::vector<e::slice> new_value(sc.attrs_sz - 1);
-
-    // if there is no old value, pretend it is "new_value" which is
-    // zero-initialized
-    if (!has_old_value)
-    {
-        old_value = &new_value;
-    }
-
-    size_t funcs_passed = apply_funcs(sc, kc->funcs, m_key, *old_value, memory.get(), &new_value);
-
-    if (funcs_passed < kc->funcs.size())
-    {
-        add_response(client_response(old_version, dkc->from, dkc->nonce, NET_CMPFAIL));
-        return;
-    }
-
-    e::intrusive_ptr<key_operation> op;
-    op = new key_operation(old_version, dkc->version, !has_old_value,
-                           true, new_value, memory);
-    op->set_continuous();
-    add_response(client_response(dkc->version, dkc->from, dkc->nonce, NET_SUCCESS));
-    m_deferred.push_back(op);
+	assert(!m_changes.empty());
+	if (!m_deferred.empty())
+	{
+		return;
+	}
+	assert(sc.attrs_sz > 0);
+	bool has_old_value = false;
+	uint64_t old_version = 0;
+	const std::vector<e::slice> *old_value = NULL;
+	get_latest(&has_old_value, &old_version, &old_value);
+	e::intrusive_ptr<deferred_key_change> dkc = m_changes.front();
+	m_changes.pop_front();
+	key_change *kc = dkc->kc.get();
+	if (!auth_verify_write(sc, has_old_value, old_value, *kc))
+	{
+		add_response(client_response(old_version, dkc->from, dkc->nonce, NET_UNAUTHORIZED));
+		return;
+	}
+	network_returncode nrc = kc->check(sc, has_old_value, old_value);
+	if (nrc != NET_SUCCESS)
+	{
+		add_response(client_response(old_version, dkc->from, dkc->nonce, nrc));
+		return;
+	}
+	if (kc->erase)
+	{
+		e::intrusive_ptr<key_operation> op;
+		op = new key_operation(old_version, dkc->version, false,
+		                       false, std::vector<e::slice>(sc.attrs_sz - 1),
+		                       std::auto_ptr<e::arena>());
+		op->set_continuous();
+		add_response(client_response(dkc->version, dkc->from, dkc->nonce, NET_SUCCESS));
+		m_deferred.push_back(op);
+		return;
+	}
+	std::auto_ptr<e::arena> memory(new e::arena());
+	std::vector<e::slice> new_value(sc.attrs_sz - 1);
+	// if there is no old value, pretend it is "new_value" which is
+	// zero-initialized
+	if (!has_old_value)
+	{
+		old_value = &new_value;
+	}
+	size_t funcs_passed = apply_funcs(sc, kc->funcs, m_key, *old_value, memory.get(), &new_value);
+	if (funcs_passed < kc->funcs.size())
+	{
+		add_response(client_response(old_version, dkc->from, dkc->nonce, NET_CMPFAIL));
+		return;
+	}
+	e::intrusive_ptr<key_operation> op;
+	op = new key_operation(old_version, dkc->version, !has_old_value,
+	                       true, new_value, memory);
+	op->set_continuous();
+	add_response(client_response(dkc->version, dkc->from, dkc->nonce, NET_SUCCESS));
+	m_deferred.push_back(op);
 }
 
 bool
-key_state :: compare_key_op_ptrs(const e::intrusive_ptr<key_operation>& lhs,
-                                 const e::intrusive_ptr<key_operation>& rhs)
+key_state :: compare_key_op_ptrs(const e::intrusive_ptr<key_operation> &lhs,
+                                 const e::intrusive_ptr<key_operation> &rhs)
 {
-    return lhs->this_version() < rhs->this_version();
+	return lhs->this_version() < rhs->this_version();
 }
 
 void
-key_state :: drain_deferred(replication_manager* rm,
-                            const virtual_server_id& us,
-                            const schema& sc)
+key_state :: drain_deferred(replication_manager *rm,
+                            const virtual_server_id &us,
+                            const schema &sc)
 {
-    assert(!m_deferred.empty());
-    m_deferred.sort(compare_key_op_ptrs);
-    bool has_old_value = false;
-    uint64_t old_version = 0;
-    const std::vector<e::slice>* old_value = NULL;
-    get_latest(&has_old_value, &old_version, &old_value);
-    e::intrusive_ptr<key_operation> op = m_deferred.front();
-
-    if (old_version >= op->this_version())
-    {
-        LOG(WARNING) << "dropping deferred CHAIN_* which was sent out of order: "
-                     << "we're using key " << e::slice(state_key().key).hex() << " in region "
-                     << state_key().region
-                     << ".  We've already seen " << old_version << " and the CHAIN_* "
-                     << "is for version " << op->this_version();
-        m_deferred.pop_front();
-        return;
-    }
-
-    // if the op is continous (the version numbers are assumed to line up), and
-    // the op is not fresh (the only case a continuous op can have discontinuous
-    // version numbers), then it cannot be applied yet
-    if (op->is_continuous() && !op->is_fresh() && old_version != op->prev_version())
-    {
-        return;
-    }
-
-    if (op->is_continuous())
-    {
-        hash_objects(&rm->m_daemon->m_config, m_ri, sc,
-                     op->has_value(), op->value(),
-                     has_old_value, old_value ? *old_value : op->value(), op);
-    }
-
-    // check that this host is supposed to process this op
-    if (op->this_old_region() != m_ri && op->this_new_region() != m_ri)
-    {
-        LOG(WARNING) << "dropping deferred CHAIN_* which didn't get sent to the right host: "
-                     << "we're using key " << e::slice(state_key().key).hex() << " in region "
-                     << state_key().region
-                     << ".  We've already seen " << old_version << " and the CHAIN_* "
-                     << "is for version " << op->this_version();
-        m_deferred.pop_front();
-        return;
-    }
-
-    // check that the sender was the correct sender
-    if (op->is_continuous() &&
-        op->recv_from() != virtual_server_id() &&
-        rm->m_daemon->m_config.next_in_region(op->recv_from()) != us &&
-        !rm->m_daemon->m_config.subspace_adjacent(op->recv_from(), us))
-    {
-        LOG(WARNING) << "dropping deferred CHAIN_OP which didn't come from the right host: "
-                     << "we're using key " << e::slice(state_key().key).hex() << " in region "
-                     << state_key().region
-                     << ".  We received the bad update from " << op->recv_from();
-        m_deferred.pop_front();
-        return;
-    }
-
-    if (op->is_discontinuous() &&
-        op->recv_from() != virtual_server_id() &&
-        rm->m_daemon->m_config.next_in_region(op->recv_from()) != us &&
-        rm->m_daemon->m_config.tail_of_region(op->this_old_region()) != op->recv_from())
-    {
-        LOG(WARNING) << "dropping deferred CHAIN_SUBSPACE which didn't come from the right host: "
-                     << "we're using key " << e::slice(state_key().key).hex() << " in region "
-                     << state_key().region
-                     << ".  We received the bad update from " << op->recv_from();
-        m_deferred.pop_front();
-        return;
-    }
-
-    if (op->is_fresh() || op->is_discontinuous() || old_version == op->prev_version())
-    {
-        m_blocked.push_back(op);
-        m_deferred.pop_front();
-        return;
-    }
+	assert(!m_deferred.empty());
+	m_deferred.sort(compare_key_op_ptrs);
+	bool has_old_value = false;
+	uint64_t old_version = 0;
+	const std::vector<e::slice> *old_value = NULL;
+	get_latest(&has_old_value, &old_version, &old_value);
+	e::intrusive_ptr<key_operation> op = m_deferred.front();
+	if (old_version >= op->this_version())
+	{
+		LOG(WARNING) << "dropping deferred CHAIN_* which was sent out of order: "
+		             << "we're using key " << e::slice(state_key().key).hex() << " in region "
+		             << state_key().region
+		             << ".  We've already seen " << old_version << " and the CHAIN_* "
+		             << "is for version " << op->this_version();
+		m_deferred.pop_front();
+		return;
+	}
+	// if the op is continous (the version numbers are assumed to line up), and
+	// the op is not fresh (the only case a continuous op can have discontinuous
+	// version numbers), then it cannot be applied yet
+	if (op->is_continuous() && !op->is_fresh() && old_version != op->prev_version())
+	{
+		return;
+	}
+	if (op->is_continuous())
+	{
+		hash_objects(&rm->m_daemon->m_config, m_ri, sc,
+		             op->has_value(), op->value(),
+		             has_old_value, old_value ? *old_value : op->value(), op);
+	}
+	// check that this host is supposed to process this op
+	if (op->this_old_region() != m_ri && op->this_new_region() != m_ri)
+	{
+		LOG(WARNING) << "dropping deferred CHAIN_* which didn't get sent to the right host: "
+		             << "we're using key " << e::slice(state_key().key).hex() << " in region "
+		             << state_key().region
+		             << ".  We've already seen " << old_version << " and the CHAIN_* "
+		             << "is for version " << op->this_version();
+		m_deferred.pop_front();
+		return;
+	}
+	// check that the sender was the correct sender
+	if (op->is_continuous() &&
+	    op->recv_from() != virtual_server_id() &&
+	    rm->m_daemon->m_config.next_in_region(op->recv_from()) != us &&
+	    !rm->m_daemon->m_config.subspace_adjacent(op->recv_from(), us))
+	{
+		LOG(WARNING) << "dropping deferred CHAIN_OP which didn't come from the right host: "
+		             << "we're using key " << e::slice(state_key().key).hex() << " in region "
+		             << state_key().region
+		             << ".  We received the bad update from " << op->recv_from();
+		m_deferred.pop_front();
+		return;
+	}
+	if (op->is_discontinuous() &&
+	    op->recv_from() != virtual_server_id() &&
+	    rm->m_daemon->m_config.next_in_region(op->recv_from()) != us &&
+	    rm->m_daemon->m_config.tail_of_region(op->this_old_region()) != op->recv_from())
+	{
+		LOG(WARNING) << "dropping deferred CHAIN_SUBSPACE which didn't come from the right host: "
+		             << "we're using key " << e::slice(state_key().key).hex() << " in region "
+		             << state_key().region
+		             << ".  We received the bad update from " << op->recv_from();
+		m_deferred.pop_front();
+		return;
+	}
+	if (op->is_fresh() || op->is_discontinuous() || old_version == op->prev_version())
+	{
+		m_blocked.push_back(op);
+		m_deferred.pop_front();
+		return;
+	}
 }
 
 void
-key_state :: drain_blocked(replication_manager* rm,
-                           const virtual_server_id& us,
-                           const schema&)
+key_state :: drain_blocked(replication_manager *rm,
+                           const virtual_server_id &us,
+                           const schema &)
 {
-    assert(!m_blocked.empty());
-    e::intrusive_ptr<key_operation> op = m_blocked.front();
-    bool withold = false;
-    // if the op is on either side of a delete, or is a delete itself
-    withold = withold || op->is_fresh();
-    withold = withold || !op->has_value();
-    withold = withold || (!m_committable.empty() && !m_committable.back()->has_value());
-    withold = withold || op->is_discontinuous();
-    withold = withold || (!m_committable.empty() && m_committable.back()->is_discontinuous());
-
-    if (withold && !m_committable.empty())
-    {
-        return;
-    }
-
-    m_committable.push_back(op);
-    m_blocked.pop_front();
-    rm->send_message(us, m_key, op);
+	assert(!m_blocked.empty());
+	e::intrusive_ptr<key_operation> op = m_blocked.front();
+	bool withold = false;
+	// if the op is on either side of a delete, or is a delete itself
+	withold = withold || op->is_fresh();
+	withold = withold || !op->has_value();
+	withold = withold || (!m_committable.empty() && !m_committable.back()->has_value());
+	withold = withold || op->is_discontinuous();
+	withold = withold || (!m_committable.empty() && m_committable.back()->is_discontinuous());
+	if (withold && !m_committable.empty())
+	{
+		return;
+	}
+	m_committable.push_back(op);
+	m_blocked.pop_front();
+	rm->send_message(us, m_key, op);
 }
 
 void
-key_state :: drain_committable(replication_manager* rm,
-                               const virtual_server_id&,
-                               const schema&)
+key_state :: drain_committable(replication_manager *rm,
+                               const virtual_server_id &,
+                               const schema &)
 {
-    assert(!m_committable.empty());
-    bool found = false;
-    uint64_t version = 0;
-
-    for (key_operation_list_t::iterator it = m_committable.begin();
-            it != m_committable.end(); ++it)
-    {
-        key_operation* op = it->get();
-
-        if (op->ackable())
-        {
-            found = true;
-            assert(version <= op->this_version());
-            version = op->this_version();
-        }
-    }
-
-    if (found && m_old_version < version)
-    {
-        CHECK_INVARIANTS();
-        e::intrusive_ptr<key_operation> op = get(version);
-        assert(op);
-        assert(op->this_version() == version);
-        datalayer::returncode rc = datalayer::SUCCESS;
-
-        // if this is a case where we are to remove the object from disk
-        // because of a delete or the first half of a subspace transfer
-        if (!op->has_value() ||
-            (op->this_old_region() != op->this_new_region() && m_ri == op->this_old_region()))
-        {
-            if (m_has_old_value)
-            {
-                rc = rm->m_daemon->m_data.del(m_ri, m_key, m_old_value);
-            }
-        }
-        // otherwise it is a case where we are to place this object on disk
-        else
-        {
-            if (m_has_old_value)
-            {
-                rc = rm->m_daemon->m_data.overput(m_ri, m_key, m_old_value, op->value(), version);
-            }
-            else
-            {
-                rc = rm->m_daemon->m_data.put(m_ri, m_key, op->value(), version);
-            }
-        }
-
-        switch (rc)
-        {
-            case datalayer::SUCCESS:
-                break;
-            case datalayer::NOT_FOUND:
-            case datalayer::BAD_ENCODING:
-            case datalayer::CORRUPTION:
-            case datalayer::IO_ERROR:
-            case datalayer::LEVELDB_ERROR:
-                return; // XXX
-            default:
-                return; // XXX
-        }
-
-        m_has_old_value = op->has_value();
-        m_old_version = version;
-        m_old_value = op->value();
-        m_old_op = op;
-        CHECK_INVARIANTS();
-    }
-
-    while (!m_committable.empty() && m_committable.front()->ackable())
-    {
-        assert(m_committable.front()->this_version() <= m_old_version);
-        m_committable.pop_front();
-        CHECK_INVARIANTS();
-    }
+	assert(!m_committable.empty());
+	bool found = false;
+	uint64_t version = 0;
+	for (key_operation_list_t::iterator it = m_committable.begin();
+	     it != m_committable.end(); ++it)
+	{
+		key_operation *op = it->get();
+		if (op->ackable())
+		{
+			found = true;
+			assert(version <= op->this_version());
+			version = op->this_version();
+		}
+	}
+	if (found && m_old_version < version)
+	{
+		CHECK_INVARIANTS();
+		e::intrusive_ptr<key_operation> op = get(version);
+		assert(op);
+		assert(op->this_version() == version);
+		datalayer::returncode rc = datalayer::SUCCESS;
+		// if this is a case where we are to remove the object from disk
+		// because of a delete or the first half of a subspace transfer
+		if (!op->has_value() ||
+		    (op->this_old_region() != op->this_new_region() && m_ri == op->this_old_region()))
+		{
+			if (m_has_old_value)
+			{
+				rc = rm->m_daemon->m_data.del(m_ri, m_key, m_old_value);
+			}
+		}
+		// otherwise it is a case where we are to place this object on disk
+		else
+		{
+			if (m_has_old_value)
+			{
+				rc = rm->m_daemon->m_data.overput(m_ri, m_key, m_old_value, op->value(), version);
+			}
+			else
+			{
+				rc = rm->m_daemon->m_data.put(m_ri, m_key, op->value(), version);
+			}
+		}
+		switch (rc)
+		{
+		case datalayer::SUCCESS:
+			break;
+		case datalayer::NOT_FOUND:
+		case datalayer::BAD_ENCODING:
+		case datalayer::CORRUPTION:
+		case datalayer::IO_ERROR:
+		case datalayer::LEVELDB_ERROR:
+			return; // XXX
+		default:
+			return; // XXX
+		}
+		m_has_old_value = op->has_value();
+		m_old_version = version;
+		m_old_value = op->value();
+		m_old_op = op;
+		CHECK_INVARIANTS();
+	}
+	while (!m_committable.empty() && m_committable.front()->ackable())
+	{
+		assert(m_committable.front()->this_version() <= m_old_version);
+		m_committable.pop_front();
+		CHECK_INVARIANTS();
+	}
 }
 
 void
-key_state :: hash_objects(const configuration* config,
-                          const region_id& reg,
-                          const schema& sc,
+key_state :: hash_objects(const configuration *config,
+                          const region_id &reg,
+                          const schema &sc,
                           bool has_new_value,
-                          const std::vector<e::slice>& new_value,
+                          const std::vector<e::slice> &new_value,
                           bool has_old_value,
-                          const std::vector<e::slice>& old_value,
+                          const std::vector<e::slice> &old_value,
                           e::intrusive_ptr<key_operation> op)
 {
-    std::vector<uint64_t> old_hashes(sc.attrs_sz);
-    std::vector<uint64_t> new_hashes(sc.attrs_sz);
-    region_id this_old_region;
-    region_id this_new_region;
-    region_id prev_region;
-    region_id next_region;
-    subspace_id subspace_this = config->subspace_of(reg);
-    subspace_id subspace_prev = config->subspace_prev(subspace_this);
-    subspace_id subspace_next = config->subspace_next(subspace_this);
-
-    if (has_old_value && has_new_value)
-    {
-        hyperdex::hash(sc, m_key, new_value, &new_hashes.front());
-        hyperdex::hash(sc, m_key, old_value, &old_hashes.front());
-
-        if (subspace_prev != subspace_id())
-        {
-            config->lookup_region(subspace_prev, new_hashes, &prev_region);
-        }
-
-        config->lookup_region(subspace_this, old_hashes, &this_old_region);
-        config->lookup_region(subspace_this, new_hashes, &this_new_region);
-
-        if (subspace_next != subspace_id())
-        {
-            config->lookup_region(subspace_next, old_hashes, &next_region);
-        }
-    }
-    else if (has_old_value)
-    {
-        hyperdex::hash(sc, m_key, old_value, &old_hashes.front());
-
-        for (size_t i = 0; i < sc.attrs_sz; ++i)
-        {
-            new_hashes[i] = old_hashes[i];
-        }
-
-        if (subspace_prev != subspace_id())
-        {
-            config->lookup_region(subspace_prev, old_hashes, &prev_region);
-        }
-
-        config->lookup_region(subspace_this, old_hashes, &this_old_region);
-        this_new_region = this_old_region;
-
-        if (subspace_next != subspace_id())
-        {
-            config->lookup_region(subspace_next, old_hashes, &next_region);
-        }
-    }
-    else if (has_new_value)
-    {
-        hyperdex::hash(sc, m_key, new_value, &new_hashes.front());
-
-        for (size_t i = 0; i < sc.attrs_sz; ++i)
-        {
-            old_hashes[i] = new_hashes[i];
-        }
-
-        if (subspace_prev != subspace_id())
-        {
-            config->lookup_region(subspace_prev, old_hashes, &prev_region);
-        }
-
-        config->lookup_region(subspace_this, old_hashes, &this_new_region);
-        this_old_region = this_new_region;
-
-        if (subspace_next != subspace_id())
-        {
-            config->lookup_region(subspace_next, old_hashes, &next_region);
-        }
-    }
-    else
-    {
-        abort();
-    }
-
-    op->set_continuous_hashes(prev_region, this_old_region, this_new_region, next_region);
+	std::vector<uint64_t> old_hashes(sc.attrs_sz);
+	std::vector<uint64_t> new_hashes(sc.attrs_sz);
+	region_id this_old_region;
+	region_id this_new_region;
+	region_id prev_region;
+	region_id next_region;
+	subspace_id subspace_this = config->subspace_of(reg);
+	subspace_id subspace_prev = config->subspace_prev(subspace_this);
+	subspace_id subspace_next = config->subspace_next(subspace_this);
+	if (has_old_value && has_new_value)
+	{
+		hyperdex::hash(sc, m_key, new_value, &new_hashes.front());
+		hyperdex::hash(sc, m_key, old_value, &old_hashes.front());
+		if (subspace_prev != subspace_id())
+		{
+			config->lookup_region(subspace_prev, new_hashes, &prev_region);
+		}
+		config->lookup_region(subspace_this, old_hashes, &this_old_region);
+		config->lookup_region(subspace_this, new_hashes, &this_new_region);
+		if (subspace_next != subspace_id())
+		{
+			config->lookup_region(subspace_next, old_hashes, &next_region);
+		}
+	}
+	else if (has_old_value)
+	{
+		hyperdex::hash(sc, m_key, old_value, &old_hashes.front());
+		for (size_t i = 0; i < sc.attrs_sz; ++i)
+		{
+			new_hashes[i] = old_hashes[i];
+		}
+		if (subspace_prev != subspace_id())
+		{
+			config->lookup_region(subspace_prev, old_hashes, &prev_region);
+		}
+		config->lookup_region(subspace_this, old_hashes, &this_old_region);
+		this_new_region = this_old_region;
+		if (subspace_next != subspace_id())
+		{
+			config->lookup_region(subspace_next, old_hashes, &next_region);
+		}
+	}
+	else if (has_new_value)
+	{
+		hyperdex::hash(sc, m_key, new_value, &new_hashes.front());
+		for (size_t i = 0; i < sc.attrs_sz; ++i)
+		{
+			old_hashes[i] = new_hashes[i];
+		}
+		if (subspace_prev != subspace_id())
+		{
+			config->lookup_region(subspace_prev, old_hashes, &prev_region);
+		}
+		config->lookup_region(subspace_this, old_hashes, &this_new_region);
+		this_old_region = this_new_region;
+		if (subspace_next != subspace_id())
+		{
+			config->lookup_region(subspace_next, old_hashes, &next_region);
+		}
+	}
+	else
+	{
+		abort();
+	}
+	op->set_continuous_hashes(prev_region, this_old_region, this_new_region, next_region);
 }
diff --git a/daemon/key_state.h b/daemon/key_state.h
index 2f0925fa0..c89787e6c 100644
--- a/daemon/key_state.h
+++ b/daemon/key_state.h
@@ -44,241 +44,241 @@ class replication_manager;
 
 class key_state
 {
-    public:
-        key_state(const key_region& kr);
-        ~key_state() throw ();
+public:
+	key_state(const key_region &kr);
+	~key_state() throw ();
 
-    public:
-        key_region state_key() const;
-        bool finished();
+public:
+	key_region state_key() const;
+	bool finished();
 
-    public:
-        bool initialized();
-        datalayer::returncode initialize(datalayer* data,
-                                         const schema& sc,
-                                         const region_id& ri);
+public:
+	bool initialized();
+	datalayer::returncode initialize(datalayer *data,
+	                                 const schema &sc,
+	                                 const region_id &ri);
 
-        void enqueue_client_atomic(replication_manager* rm,
-                                   const virtual_server_id& us,
-                                   const schema& sc,
-                                   const server_id& from,
-                                   uint64_t nonce,
-                                   std::auto_ptr<key_change> kc,
-                                   std::auto_ptr<e::buffer> backing);
-        void enqueue_chain_op(replication_manager* rm,
-                              const virtual_server_id& us,
-                              const schema& sc,
-                              const virtual_server_id& from,
-                              uint64_t old_version,
-                              uint64_t new_version,
-                              bool fresh,
-                              bool has_value,
-                              const std::vector<e::slice>& value,
-                              std::auto_ptr<e::buffer> backing);
-        void enqueue_chain_subspace(replication_manager* rm,
-                                    const virtual_server_id& us,
-                                    const schema& sc,
-                                    const virtual_server_id& from,
-                                    uint64_t old_version,
-                                    uint64_t new_version,
-                                    const std::vector<e::slice>& value,
-                                    std::auto_ptr<e::buffer> backing,
-                                    const region_id& prev_region,
-                                    const region_id& this_old_region,
-                                    const region_id& this_new_region,
-                                    const region_id& next_region);
-        void enqueue_chain_ack(replication_manager* rm,
-                                const virtual_server_id& us,
-                                const schema& sc,
-                                const virtual_server_id& from,
-                               uint64_t version);
-        void work_state_machine(replication_manager* rm,
-                                const virtual_server_id& us,
-                                const schema& sc);
+	void enqueue_client_atomic(replication_manager *rm,
+	                           const virtual_server_id &us,
+	                           const schema &sc,
+	                           const server_id &from,
+	                           uint64_t nonce,
+	                           std::auto_ptr<key_change> kc,
+	                           std::auto_ptr<e::buffer> backing);
+	void enqueue_chain_op(replication_manager *rm,
+	                      const virtual_server_id &us,
+	                      const schema &sc,
+	                      const virtual_server_id &from,
+	                      uint64_t old_version,
+	                      uint64_t new_version,
+	                      bool fresh,
+	                      bool has_value,
+	                      const std::vector<e::slice> &value,
+	                      std::auto_ptr<e::buffer> backing);
+	void enqueue_chain_subspace(replication_manager *rm,
+	                            const virtual_server_id &us,
+	                            const schema &sc,
+	                            const virtual_server_id &from,
+	                            uint64_t old_version,
+	                            uint64_t new_version,
+	                            const std::vector<e::slice> &value,
+	                            std::auto_ptr<e::buffer> backing,
+	                            const region_id &prev_region,
+	                            const region_id &this_old_region,
+	                            const region_id &this_new_region,
+	                            const region_id &next_region);
+	void enqueue_chain_ack(replication_manager *rm,
+	                       const virtual_server_id &us,
+	                       const schema &sc,
+	                       const virtual_server_id &from,
+	                       uint64_t version);
+	void work_state_machine(replication_manager *rm,
+	                        const virtual_server_id &us,
+	                        const schema &sc);
 
-        uint64_t max_version();
-        void reconfigure(e::garbage_collector* gc);
-        void reset(e::garbage_collector* gc);
+	uint64_t max_version();
+	void reconfigure(e::garbage_collector *gc);
+	void reset(e::garbage_collector *gc);
 
-        void resend_committable(replication_manager* rm,
-                                const virtual_server_id& us);
+	void resend_committable(replication_manager *rm,
+	                        const virtual_server_id &us);
 
-        void append_all_versions(std::vector<std::pair<region_id, uint64_t> >* versions);
+	void append_all_versions(std::vector<std::pair<region_id, uint64_t> > *versions);
 
-        void debug_dump();
+	void debug_dump();
 
-    private:
-        struct deferred_key_change;
-        struct stub_client_atomic;
-        struct stub_chain_op;
-        struct stub_chain_subspace;
-        struct stub_chain_ack;
-        struct client_response;
-        typedef std::list<e::intrusive_ptr<key_operation> > key_operation_list_t;
-        typedef std::list<e::intrusive_ptr<deferred_key_change> > key_change_list_t;
+private:
+	struct deferred_key_change;
+	struct stub_client_atomic;
+	struct stub_chain_op;
+	struct stub_chain_subspace;
+	struct stub_chain_ack;
+	struct client_response;
+	typedef std::list<e::intrusive_ptr<key_operation> > key_operation_list_t;
+	typedef std::list<e::intrusive_ptr<deferred_key_change> > key_change_list_t;
 
-    private:
-        void check_invariants() const;
-        void someone_needs_to_work_the_state_machine();
-        void work_state_machine_or_pass_the_buck(replication_manager* rm,
-                                                 const virtual_server_id& us,
-                                                 const schema& sc);
-        // returns when m_someone_is_working; must call wsm_with_work_bit after
-        void takeover_state_machine();
-        // returns whether or not the caller took over the state machine, will
-        // return true if must call wsm_with_work_bit after; false otherwise
-        bool possibly_takeover_state_machine();
-        // releases inner state by setting m_someone_is_working = false.
-        void work_state_machine_with_work_bit(replication_manager* rm,
-                                              const virtual_server_id& us,
-                                              const schema& sc);
-        void do_client_atomic(replication_manager* rm,
-                              const virtual_server_id& us,
-                              const schema& sc,
-                              const server_id& from,
-                              uint64_t nonce,
-                              std::auto_ptr<key_change> kc,
-                              std::auto_ptr<e::buffer> backing);
-        void do_chain_op(replication_manager* rm,
-                         const virtual_server_id& us,
-                         const schema& sc,
-                         const virtual_server_id& from,
-                         uint64_t old_version,
-                         uint64_t new_version,
-                         bool fresh,
-                         bool has_value,
-                         const std::vector<e::slice>& value,
-                         std::auto_ptr<e::buffer> backing);
-        void do_chain_subspace(replication_manager* rm,
-                               const virtual_server_id& us,
-                               const schema& sc,
-                               const virtual_server_id& from,
-                               uint64_t old_version,
-                               uint64_t new_version,
-                               const std::vector<e::slice>& value,
-                               std::auto_ptr<e::buffer> backing,
-                               const region_id& prev_region,
-                               const region_id& this_old_region,
-                               const region_id& this_new_region,
-                               const region_id& next_region);
-        void do_chain_ack(replication_manager* rm,
-                          const virtual_server_id& us,
-                          const schema& sc,
-                          const virtual_server_id& from,
-                          uint64_t version);
-        void add_response(const client_response& cr);
-        void send_responses(replication_manager* rm,
-                            const virtual_server_id& us);
-        e::intrusive_ptr<key_operation> get(uint64_t new_version);
-        e::intrusive_ptr<key_operation>
-            enqueue_continuous_key_op(uint64_t old_version,
-                                      uint64_t new_version,
-                                      bool fresh,
-                                      bool has_value,
-                                      const std::vector<e::slice>& value,
-                                      std::auto_ptr<e::arena> memory);
-        e::intrusive_ptr<key_operation>
-            enqueue_discontinuous_key_op(uint64_t old_version,
-                                         uint64_t new_version,
-                                         const std::vector<e::slice>& value,
-                                         std::auto_ptr<e::arena> memory,
-                                         const region_id& prev_region,
-                                         const region_id& this_old_region,
-                                         const region_id& this_new_region,
-                                         const region_id& next_region);
-        void get_latest(bool* has_old_value,
-                        uint64_t* old_version,
-                        const std::vector<e::slice>** old_value);
-        bool drain_queue(replication_manager* rm,
-                         const virtual_server_id& us,
-                         const schema& sc,
-                         key_operation_list_t* q,
-                         void (key_state::*f)(replication_manager* rm,
-                                              const virtual_server_id& us,
-                                              const schema& sc));
-        bool drain_queue(replication_manager* rm,
-                         const virtual_server_id& us,
-                         const schema& sc,
-                         key_change_list_t* q,
-                         void (key_state::*f)(replication_manager* rm,
-                                              const virtual_server_id& us,
-                                              const schema& sc));
-        void drain_changes(replication_manager* rm,
-                           const virtual_server_id& us,
-                           const schema& sc);
-        static bool compare_key_op_ptrs(const e::intrusive_ptr<key_operation>& lhs,
-                                        const e::intrusive_ptr<key_operation>& rhs);
-        void drain_deferred(replication_manager* rm,
-                            const virtual_server_id& us,
-                            const schema& sc);
-        void drain_blocked(replication_manager* rm,
-                           const virtual_server_id& us,
-                           const schema& sc);
-        void drain_committable(replication_manager* rm,
-                               const virtual_server_id& us,
-                               const schema& sc);
-        void hash_objects(const configuration* config,
-                          const region_id& reg,
-                          const schema& sc,
-                          bool has_new_value,
-                          const std::vector<e::slice>& new_value,
-                          bool has_old_value,
-                          const std::vector<e::slice>& old_value,
-                          e::intrusive_ptr<key_operation> pend);
+private:
+	void check_invariants() const;
+	void someone_needs_to_work_the_state_machine();
+	void work_state_machine_or_pass_the_buck(replication_manager *rm,
+	                                         const virtual_server_id &us,
+	                                         const schema &sc);
+	// returns when m_someone_is_working; must call wsm_with_work_bit after
+	void takeover_state_machine();
+	// returns whether or not the caller took over the state machine, will
+	// return true if must call wsm_with_work_bit after; false otherwise
+	bool possibly_takeover_state_machine();
+	// releases inner state by setting m_someone_is_working = false.
+	void work_state_machine_with_work_bit(replication_manager *rm,
+	                                      const virtual_server_id &us,
+	                                      const schema &sc);
+	void do_client_atomic(replication_manager *rm,
+	                      const virtual_server_id &us,
+	                      const schema &sc,
+	                      const server_id &from,
+	                      uint64_t nonce,
+	                      std::auto_ptr<key_change> kc,
+	                      std::auto_ptr<e::buffer> backing);
+	void do_chain_op(replication_manager *rm,
+	                 const virtual_server_id &us,
+	                 const schema &sc,
+	                 const virtual_server_id &from,
+	                 uint64_t old_version,
+	                 uint64_t new_version,
+	                 bool fresh,
+	                 bool has_value,
+	                 const std::vector<e::slice> &value,
+	                 std::auto_ptr<e::buffer> backing);
+	void do_chain_subspace(replication_manager *rm,
+	                       const virtual_server_id &us,
+	                       const schema &sc,
+	                       const virtual_server_id &from,
+	                       uint64_t old_version,
+	                       uint64_t new_version,
+	                       const std::vector<e::slice> &value,
+	                       std::auto_ptr<e::buffer> backing,
+	                       const region_id &prev_region,
+	                       const region_id &this_old_region,
+	                       const region_id &this_new_region,
+	                       const region_id &next_region);
+	void do_chain_ack(replication_manager *rm,
+	                  const virtual_server_id &us,
+	                  const schema &sc,
+	                  const virtual_server_id &from,
+	                  uint64_t version);
+	void add_response(const client_response &cr);
+	void send_responses(replication_manager *rm,
+	                    const virtual_server_id &us);
+	e::intrusive_ptr<key_operation> get(uint64_t new_version);
+	e::intrusive_ptr<key_operation>
+	enqueue_continuous_key_op(uint64_t old_version,
+	                          uint64_t new_version,
+	                          bool fresh,
+	                          bool has_value,
+	                          const std::vector<e::slice> &value,
+	                          std::auto_ptr<e::arena> memory);
+	e::intrusive_ptr<key_operation>
+	enqueue_discontinuous_key_op(uint64_t old_version,
+	                             uint64_t new_version,
+	                             const std::vector<e::slice> &value,
+	                             std::auto_ptr<e::arena> memory,
+	                             const region_id &prev_region,
+	                             const region_id &this_old_region,
+	                             const region_id &this_new_region,
+	                             const region_id &next_region);
+	void get_latest(bool *has_old_value,
+	                uint64_t *old_version,
+	                const std::vector<e::slice> **old_value);
+	bool drain_queue(replication_manager *rm,
+	                 const virtual_server_id &us,
+	                 const schema &sc,
+	                 key_operation_list_t *q,
+	                 void (key_state::*f)(replication_manager *rm,
+	                                      const virtual_server_id &us,
+	                                      const schema &sc));
+	bool drain_queue(replication_manager *rm,
+	                 const virtual_server_id &us,
+	                 const schema &sc,
+	                 key_change_list_t *q,
+	                 void (key_state::*f)(replication_manager *rm,
+	                                      const virtual_server_id &us,
+	                                      const schema &sc));
+	void drain_changes(replication_manager *rm,
+	                   const virtual_server_id &us,
+	                   const schema &sc);
+	static bool compare_key_op_ptrs(const e::intrusive_ptr<key_operation> &lhs,
+	                                const e::intrusive_ptr<key_operation> &rhs);
+	void drain_deferred(replication_manager *rm,
+	                    const virtual_server_id &us,
+	                    const schema &sc);
+	void drain_blocked(replication_manager *rm,
+	                   const virtual_server_id &us,
+	                   const schema &sc);
+	void drain_committable(replication_manager *rm,
+	                       const virtual_server_id &us,
+	                       const schema &sc);
+	void hash_objects(const configuration *config,
+	                  const region_id &reg,
+	                  const schema &sc,
+	                  bool has_new_value,
+	                  const std::vector<e::slice> &new_value,
+	                  bool has_old_value,
+	                  const std::vector<e::slice> &old_value,
+	                  e::intrusive_ptr<key_operation> pend);
 
-    // state synchronized without m_lock (either read-only or otherwise
-    // synchronized)
-    private:
-        const region_id m_ri;
-        const std::string m_key_backing;
-        const e::slice m_key;
+	// state synchronized without m_lock (either read-only or otherwise
+	// synchronized)
+private:
+	const region_id m_ri;
+	const std::string m_key_backing;
+	const e::slice m_key;
 
-        e::lockfree_mpsc_fifo<stub_client_atomic> m_client_atomics;
-        e::lockfree_mpsc_fifo<stub_chain_op> m_chain_ops;
-        e::lockfree_mpsc_fifo<stub_chain_subspace> m_chain_subspaces;
-        e::lockfree_mpsc_fifo<stub_chain_ack> m_chain_acks;
+	e::lockfree_mpsc_fifo<stub_client_atomic> m_client_atomics;
+	e::lockfree_mpsc_fifo<stub_chain_op> m_chain_ops;
+	e::lockfree_mpsc_fifo<stub_chain_subspace> m_chain_subspaces;
+	e::lockfree_mpsc_fifo<stub_chain_ack> m_chain_acks;
 
-    // protected state, synchronized by m_lock;
-    private:
-        po6::threads::mutex m_lock;
-        po6::threads::cond m_avail;
-        bool m_someone_is_working_the_state_machine;
-        bool m_someone_needs_to_work_the_state_machine;
+	// protected state, synchronized by m_lock;
+private:
+	po6::threads::mutex m_lock;
+	po6::threads::cond m_avail;
+	bool m_someone_is_working_the_state_machine;
+	bool m_someone_needs_to_work_the_state_machine;
 
-        bool m_initialized;
+	bool m_initialized;
 
-        // Does this key have a value (before operations are applied)
-        bool m_has_old_value;
-        uint64_t m_old_version;
+	// Does this key have a value (before operations are applied)
+	bool m_has_old_value;
+	uint64_t m_old_version;
 
-        std::vector<e::slice> m_old_value;
-        datalayer::reference m_old_disk_ref;
-        e::intrusive_ptr<key_operation> m_old_op;
+	std::vector<e::slice> m_old_value;
+	datalayer::reference m_old_disk_ref;
+	e::intrusive_ptr<key_operation> m_old_op;
 
-        std::vector<client_response> m_client_responses_heap;
+	std::vector<client_response> m_client_responses_heap;
 
-        // These operations are being actively replicated by HyperDex
-        // and were passed to subsequent nodes in the value dependent chain.
-        key_operation_list_t m_committable;
-        bool m_committable_empty;
+	// These operations are being actively replicated by HyperDex
+	// and were passed to subsequent nodes in the value dependent chain.
+	key_operation_list_t m_committable;
+	bool m_committable_empty;
 
-        // These operations delayed pending completion of all operations
-        // in the committable state.  Generally, it happens on different sides
-        // of deletions in order to enforce proper order of arrival for
-        // operations.  It's like a memory barrier, but for distributed systems.
-        key_operation_list_t m_blocked;
-        bool m_blocked_empty;
+	// These operations delayed pending completion of all operations
+	// in the committable state.  Generally, it happens on different sides
+	// of deletions in order to enforce proper order of arrival for
+	// operations.  It's like a memory barrier, but for distributed systems.
+	key_operation_list_t m_blocked;
+	bool m_blocked_empty;
 
-        // These messages arrived out of order and will be processed
-        // pending future messages arrival.
-        key_operation_list_t m_deferred;
-        bool m_deferred_empty;
+	// These messages arrived out of order and will be processed
+	// pending future messages arrival.
+	key_operation_list_t m_deferred;
+	bool m_deferred_empty;
 
-        // These are client-submitted operations enqueued to be
-        // processed.  Generally the changes queue will be moved to
-        // blocked/committable immediate.
-        key_change_list_t m_changes;
-        bool m_changes_empty;
+	// These are client-submitted operations enqueued to be
+	// processed.  Generally the changes queue will be moved to
+	// blocked/committable immediate.
+	key_change_list_t m_changes;
+	bool m_changes_empty;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/daemon/leveldb.h b/daemon/leveldb.h
index aa1559279..1ca3a7995 100644
--- a/daemon/leveldb.h
+++ b/daemon/leveldb.h
@@ -54,79 +54,78 @@ typedef e::compat::shared_ptr<leveldb::DB> leveldb_db_ptr;
 template<class T>
 struct leveldb_dtor
 {
-    typedef void (leveldb::DB::*func)(T* t);
-    static func get_func();
+	typedef void (leveldb::DB::*func)(T *t);
+	static func get_func();
 };
 
 template <>
 inline leveldb_dtor<const leveldb::Snapshot>::func
 leveldb_dtor<const leveldb::Snapshot> :: get_func()
 {
-    return &leveldb::DB::ReleaseSnapshot;
+	return &leveldb::DB::ReleaseSnapshot;
 }
 
 template <>
 inline leveldb_dtor<leveldb::ReplayIterator>::func
 leveldb_dtor<leveldb::ReplayIterator> :: get_func()
 {
-    return &leveldb::DB::ReleaseReplayIterator;
+	return &leveldb::DB::ReleaseReplayIterator;
 }
 
 template<class T>
 class leveldb_release_ptr
 {
-    public:
-        leveldb_release_ptr()
-            : m_db(), m_resource() {}
-        leveldb_release_ptr(leveldb_db_ptr d, T* t)
-            : m_db(), m_resource() { reset(d, t); }
-        leveldb_release_ptr(const leveldb_release_ptr& other)
-            : m_db(other.m_db), m_resource(other.m_resource) {}
-        ~leveldb_release_ptr() throw () {}
-
-    public:
-        T* get() const { return m_resource->ptr; }
-        leveldb::DB* db() const { return m_db.get(); }
-        void reset(leveldb_db_ptr d, T* t)
-        { m_db = d; m_resource.reset(new wrapper(d, t)); }
-
-    public:
-        T* operator * () const throw () { return get(); }
-        T* operator -> () const throw () { return get(); }
-        leveldb_release_ptr& operator = (const leveldb_release_ptr& rhs)
-        {
-            if (this != &rhs)
-            {
-                m_resource = rhs.m_resource;
-                m_db = rhs.m_db;
-            }
-
-            return *this;
-        }
-
-    private:
-        struct wrapper
-        {
-            wrapper(leveldb_db_ptr d, T* t) : db(d), ptr(t) {}
-            ~wrapper() throw ()
-            {
-                if (ptr)
-                {
-                    (*db.*leveldb_dtor<T>::get_func())(ptr);
-                }
-            }
-
-            leveldb_db_ptr db;
-            T* ptr;
-
-            private:
-                wrapper(const wrapper&);
-                wrapper& operator = (const wrapper&);
-        };
-
-    private:
-        leveldb_db_ptr m_db;
-        e::compat::shared_ptr<wrapper> m_resource;
+public:
+	leveldb_release_ptr()
+		: m_db(), m_resource() {}
+	leveldb_release_ptr(leveldb_db_ptr d, T *t)
+		: m_db(), m_resource() { reset(d, t); }
+	leveldb_release_ptr(const leveldb_release_ptr &other)
+		: m_db(other.m_db), m_resource(other.m_resource) {}
+	~leveldb_release_ptr() throw () {}
+
+public:
+	T *get() const { return m_resource->ptr; }
+	leveldb::DB *db() const { return m_db.get(); }
+	void reset(leveldb_db_ptr d, T *t)
+	{ m_db = d; m_resource.reset(new wrapper(d, t)); }
+
+public:
+	T *operator * () const throw () { return get(); }
+	T *operator -> () const throw () { return get(); }
+	leveldb_release_ptr &operator = (const leveldb_release_ptr &rhs)
+	{
+		if (this != &rhs)
+		{
+			m_resource = rhs.m_resource;
+			m_db = rhs.m_db;
+		}
+		return *this;
+	}
+
+private:
+	struct wrapper
+	{
+		wrapper(leveldb_db_ptr d, T *t) : db(d), ptr(t) {}
+		~wrapper() throw ()
+		{
+			if (ptr)
+			{
+				(*db.*leveldb_dtor<T>::get_func())(ptr);
+			}
+		}
+
+		leveldb_db_ptr db;
+		T *ptr;
+
+	private:
+		wrapper(const wrapper &);
+		wrapper &operator = (const wrapper &);
+	};
+
+private:
+	leveldb_db_ptr m_db;
+	e::compat::shared_ptr<wrapper> m_resource;
 };
 
 typedef leveldb_release_ptr<const leveldb::Snapshot> leveldb_snapshot_ptr;
@@ -134,22 +133,22 @@ typedef leveldb_release_ptr<leveldb::ReplayIterator> leveldb_replay_iterator_ptr
 
 class leveldb_iterator_ptr
 {
-    public:
-        leveldb_iterator_ptr() : m_snap(), m_iter() {}
-        ~leveldb_iterator_ptr() {}
-
-    public:
-        void reset(leveldb_snapshot_ptr s, leveldb::Iterator* iter)
-        { m_iter.reset(iter); m_snap = s; }
-        leveldb::Iterator* get() const { return m_iter.get(); }
-        leveldb_snapshot_ptr snap() const { return m_snap; }
-
-    public:
-        leveldb::Iterator* operator -> () const throw () { return get(); }
-
-    private:
-        leveldb_snapshot_ptr m_snap;
-        e::compat::shared_ptr<leveldb::Iterator> m_iter;
+public:
+	leveldb_iterator_ptr() : m_snap(), m_iter() {}
+	~leveldb_iterator_ptr() {}
+
+public:
+	void reset(leveldb_snapshot_ptr s, leveldb::Iterator *iter)
+	{ m_iter.reset(iter); m_snap = s; }
+	leveldb::Iterator *get() const { return m_iter.get(); }
+	leveldb_snapshot_ptr snap() const { return m_snap; }
+
+public:
+	leveldb::Iterator *operator -> () const throw () { return get(); }
+
+private:
+	leveldb_snapshot_ptr m_snap;
+	e::compat::shared_ptr<leveldb::Iterator> m_iter;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/daemon/main.cc b/daemon/main.cc
index 4eafe1dfa..8731d5d50 100644
--- a/daemon/main.cc
+++ b/daemon/main.cc
@@ -47,165 +47,143 @@
 #include "daemon/daemon.h"
 
 int
-main(int argc, const char* argv[])
+main(int argc, const char *argv[])
 {
-    bool daemonize = true;
-    const char* data = ".";
-    const char* log = NULL;
-    const char* pidfile = "";
-    bool has_pidfile = false;
-    bool listen = false;
-    const char* listen_host = "auto";
-    long listen_port = 2012;
-    bool coordinator = false;
-    const char* coordinator_host = "127.0.0.1";
-    long coordinator_port = 1982;
-    long threads = 0;
-    bool log_immediate = false;
-
-    e::argparser ap;
-    ap.autohelp();
-    ap.arg().name('d', "daemon")
-            .description("run in the background")
-            .set_true(&daemonize);
-    ap.arg().name('f', "foreground")
-            .description("run in the foreground")
-            .set_false(&daemonize);
-    ap.arg().name('D', "data")
-            .description("store persistent state in this directory (default: .)")
-            .metavar("dir").as_string(&data);
-    ap.arg().name('L', "log")
-            .description("store logs in this directory (default: --data)")
-            .metavar("dir").as_string(&log);
-    ap.arg().long_name("pidfile")
-            .description("write the PID to a file (default: don't)")
-            .metavar("file").as_string(&pidfile).set_true(&has_pidfile);
-    ap.arg().name('l', "listen")
-            .description("listen on a specific IP address (default: auto)")
-            .metavar("IP").as_string(&listen_host).set_true(&listen);
-    ap.arg().name('p', "listen-port")
-            .description("listen on an alternative port (default: 1982)")
-            .metavar("port").as_long(&listen_port).set_true(&listen);
-    ap.arg().name('c', "coordinator")
-            .description("join an existing HyperDex cluster through IP address or hostname")
-            .metavar("addr").as_string(&coordinator_host).set_true(&coordinator);
-    ap.arg().name('P', "coordinator-port")
-            .description("connect to an alternative port on the coordinator (default: 1982)")
-            .metavar("port").as_long(&coordinator_port).set_true(&coordinator);
-    ap.arg().name('t', "threads")
-            .description("the number of threads which will handle network traffic")
-            .metavar("N").as_long(&threads);
-    ap.arg().long_name("log-immediate")
-            .description("immediately flush all log output")
-            .set_true(&log_immediate).hidden();
-
-    if (!ap.parse(argc, argv))
-    {
-        return EXIT_FAILURE;
-    }
-
-    if (ap.args_sz() != 0)
-    {
-        std::cerr << "command takes no positional arguments\n" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    if (listen_port >= (1 << 16))
-    {
-        std::cerr << "listen-port is out of range" << std::endl;
-        return EXIT_FAILURE;
-    }
-
-    if (coordinator_port >= (1 << 16))
-    {
-        std::cerr << "coordinator-port is out of range" << std::endl;
-        return EXIT_FAILURE;
-    }
-
-    po6::net::ipaddr listen_ip;
-    po6::net::location bind_to;
-
-    if (strcmp(listen_host, "auto") == 0)
-    {
-        if (!busybee_discover(&listen_ip))
-        {
-            std::cerr << "cannot automatically discover local address; specify one manually" << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        bind_to = po6::net::location(listen_ip, listen_port);
-    }
-    else
-    {
-        try
-        {
-            listen_ip = po6::net::ipaddr(listen_host);
-            bind_to = po6::net::location(listen_ip, listen_port);
-        }
-        catch (std::invalid_argument& e)
-        {
-            // fallthrough
-        }
-
-        if (bind_to == po6::net::location())
-        {
-            bind_to = po6::net::hostname(listen_host, 0).lookup(AF_UNSPEC, IPPROTO_TCP);
-            bind_to.port = listen_port;
-        }
-    }
-
-    if (bind_to == po6::net::location())
-    {
-        std::cerr << "cannot interpret listen address as hostname or IP address" << std::endl;
-        return EXIT_FAILURE;
-    }
-
-    if (bind_to.address == po6::net::ipaddr("0.0.0.0"))
-    {
-        std::cerr << "cannot bind to " << bind_to << " because it is not routable" << std::endl;
-        return EXIT_FAILURE;
-    }
-
-    google::InitGoogleLogging(argv[0]);
-    google::InstallFailureSignalHandler();
-
-    if (log_immediate)
-    {
-        FLAGS_logbufsecs = 0;
-    }
-
-    try
-    {
-        hyperdex::daemon d;
-
-        if (threads <= 0)
-        {
-            threads += sysconf(_SC_NPROCESSORS_ONLN);
-
-            if (threads <= 0)
-            {
-                std::cerr << "cannot create a non-positive number of threads" << std::endl;
-                return EXIT_FAILURE;
-            }
-        }
-        else if (threads > 512)
-        {
-            std::cerr << "refusing to create more than 512 threads" << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        return d.run(daemonize,
-                     std::string(data),
-                     std::string(log ? log : data),
-                     std::string(pidfile), has_pidfile,
-                     listen, bind_to,
-                     coordinator, po6::net::hostname(coordinator_host, coordinator_port),
-                     threads);
-    }
-    catch (std::exception& e)
-    {
-        std::cerr << "error:  " << e.what() << std::endl;
-        return EXIT_FAILURE;
-    }
+	bool daemonize = true;
+	const char *data = ".";
+	const char *log = NULL;
+	const char *pidfile = "";
+	bool has_pidfile = false;
+	bool listen = false;
+	const char *listen_host = "auto";
+	long listen_port = 2012;
+	bool coordinator = false;
+	const char *coordinator_host = "127.0.0.1";
+	long coordinator_port = 1982;
+	long threads = 0;
+	bool log_immediate = false;
+	e::argparser ap;
+	ap.autohelp();
+	ap.arg().name('d', "daemon")
+	.description("run in the background")
+	.set_true(&daemonize);
+	ap.arg().name('f', "foreground")
+	.description("run in the foreground")
+	.set_false(&daemonize);
+	ap.arg().name('D', "data")
+	.description("store persistent state in this directory (default: .)")
+	.metavar("dir").as_string(&data);
+	ap.arg().name('L', "log")
+	.description("store logs in this directory (default: --data)")
+	.metavar("dir").as_string(&log);
+	ap.arg().long_name("pidfile")
+	.description("write the PID to a file (default: don't)")
+	.metavar("file").as_string(&pidfile).set_true(&has_pidfile);
+	ap.arg().name('l', "listen")
+	.description("listen on a specific IP address (default: auto)")
+	.metavar("IP").as_string(&listen_host).set_true(&listen);
+	ap.arg().name('p', "listen-port")
+	.description("listen on an alternative port (default: 1982)")
+	.metavar("port").as_long(&listen_port).set_true(&listen);
+	ap.arg().name('c', "coordinator")
+	.description("join an existing HyperDex cluster through IP address or hostname")
+	.metavar("addr").as_string(&coordinator_host).set_true(&coordinator);
+	ap.arg().name('P', "coordinator-port")
+	.description("connect to an alternative port on the coordinator (default: 1982)")
+	.metavar("port").as_long(&coordinator_port).set_true(&coordinator);
+	ap.arg().name('t', "threads")
+	.description("the number of threads which will handle network traffic")
+	.metavar("N").as_long(&threads);
+	ap.arg().long_name("log-immediate")
+	.description("immediately flush all log output")
+	.set_true(&log_immediate).hidden();
+	if (!ap.parse(argc, argv))
+	{
+		return EXIT_FAILURE;
+	}
+	if (ap.args_sz() != 0)
+	{
+		std::cerr << "command takes no positional arguments\n" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	if (listen_port >= (1 << 16))
+	{
+		std::cerr << "listen-port is out of range" << std::endl;
+		return EXIT_FAILURE;
+	}
+	if (coordinator_port >= (1 << 16))
+	{
+		std::cerr << "coordinator-port is out of range" << std::endl;
+		return EXIT_FAILURE;
+	}
+	po6::net::ipaddr listen_ip;
+	po6::net::location bind_to;
+	if (strcmp(listen_host, "auto") == 0)
+	{
+		if (!busybee_discover(&listen_ip))
+		{
+			std::cerr << "cannot automatically discover local address; specify one manually" << std::endl;
+			return EXIT_FAILURE;
+		}
+		bind_to = po6::net::location(listen_ip, listen_port);
+	}
+	else
+	{
+		if (listen_ip.set(listen_host))
+		{
+			bind_to = po6::net::location(listen_ip, listen_port);
+		}
+		if (bind_to == po6::net::location())
+		{
+			bind_to = po6::net::hostname(listen_host, 0).lookup(AF_UNSPEC, IPPROTO_TCP);
+			bind_to.port = listen_port;
+		}
+	}
+	if (bind_to == po6::net::location())
+	{
+		std::cerr << "cannot interpret listen address as hostname or IP address" << std::endl;
+		return EXIT_FAILURE;
+	}
+	if (bind_to.address == po6::net::ipaddr::ANY())
+	{
+		std::cerr << "cannot bind to " << bind_to << " because it is not routable" << std::endl;
+		return EXIT_FAILURE;
+	}
+	google::InitGoogleLogging(argv[0]);
+	google::InstallFailureSignalHandler();
+	if (log_immediate)
+	{
+		FLAGS_logbufsecs = 0;
+	}
+	try
+	{
+		hyperdex::daemon d;
+		if (threads <= 0)
+		{
+			threads += sysconf(_SC_NPROCESSORS_ONLN);
+			if (threads <= 0)
+			{
+				std::cerr << "cannot create a non-positive number of threads" << std::endl;
+				return EXIT_FAILURE;
+			}
+		}
+		else if (threads > 512)
+		{
+			std::cerr << "refusing to create more than 512 threads" << std::endl;
+			return EXIT_FAILURE;
+		}
+		return d.run(daemonize,
+		             std::string(data),
+		             std::string(log ? log : data),
+		             std::string(pidfile), has_pidfile,
+		             listen, bind_to,
+		             coordinator, po6::net::hostname(coordinator_host, coordinator_port),
+		             threads);
+	}
+	catch (std::exception &e)
+	{
+		std::cerr << "error:  " << e.what() << std::endl;
+		return EXIT_FAILURE;
+	}
 }
diff --git a/daemon/performance_counter.h b/daemon/performance_counter.h
index 968a4f1a6..f0063dffe 100644
--- a/daemon/performance_counter.h
+++ b/daemon/performance_counter.h
@@ -36,23 +36,23 @@ BEGIN_HYPERDEX_NAMESPACE
 // a threadsafe counter
 class performance_counter
 {
-    public:
-        performance_counter() : m_count(0) {}
-        ~performance_counter() throw () {}
-
-    public:
-        // increment the counter
-        // any number of threads can tap simultaneously
-        void tap() { e::atomic::increment_64_nobarrier(&m_count, 1); }
-        // any number of threads can call "read" simultaneously
-        uint64_t read() const { return e::atomic::load_64_nobarrier(&m_count); }
-
-    private:
-        performance_counter(const performance_counter&);
-        performance_counter& operator = (const performance_counter&);
-
-    private:
-        uint64_t m_count;
+public:
+	performance_counter() : m_count(0) {}
+	~performance_counter() throw () {}
+
+public:
+	// increment the counter
+	// any number of threads can tap simultaneously
+	void tap() { e::atomic::increment_64_nobarrier(&m_count, 1); }
+	// any number of threads can call "read" simultaneously
+	uint64_t read() const { return e::atomic::load_64_nobarrier(&m_count); }
+
+private:
+	performance_counter(const performance_counter &);
+	performance_counter &operator = (const performance_counter &);
+
+private:
+	uint64_t m_count;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/daemon/reconfigure_returncode.h b/daemon/reconfigure_returncode.h
index 8daf758f3..cefeb8667 100644
--- a/daemon/reconfigure_returncode.h
+++ b/daemon/reconfigure_returncode.h
@@ -39,14 +39,14 @@ BEGIN_HYPERDEX_NAMESPACE
 // reconfigure_returncode occupies [8704, 8832)
 enum reconfigure_returncode
 {
-    RECONFIGURE_SUCCESS = 8704,
-    RECONFIGURE_WARNING = 8705,
-    RECONFIGURE_FAIL    = 8706,
-    RECONFIGURE_FATAL   = 8707
+	RECONFIGURE_SUCCESS = 8704,
+	RECONFIGURE_WARNING = 8705,
+	RECONFIGURE_FAIL    = 8706,
+	RECONFIGURE_FATAL   = 8707
 };
 
-std::ostream&
-operator << (std::ostream& lhs, reconfigure_returncode rhs);
+std::ostream &
+operator << (std::ostream &lhs, reconfigure_returncode rhs);
 
 END_HYPERDEX_NAMESPACE
 
diff --git a/daemon/region_timestamp.h b/daemon/region_timestamp.h
index 6e011206e..d0947d881 100644
--- a/daemon/region_timestamp.h
+++ b/daemon/region_timestamp.h
@@ -36,17 +36,17 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class region_timestamp
 {
-    public:
-        region_timestamp() : rid(), checkpoint(), local_timestamp() {}
-        region_timestamp(const region_id& r,
-                         uint64_t c,
-                         const std::string& t)
-            : rid(r), checkpoint(c), local_timestamp(t) {}
+public:
+	region_timestamp() : rid(), checkpoint(), local_timestamp() {}
+	region_timestamp(const region_id &r,
+	                 uint64_t c,
+	                 const std::string &t)
+		: rid(r), checkpoint(c), local_timestamp(t) {}
 
-    public:
-        region_id rid;
-        uint64_t checkpoint;
-        std::string local_timestamp;
+public:
+	region_id rid;
+	uint64_t checkpoint;
+	std::string local_timestamp;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/daemon/replication_manager.cc b/daemon/replication_manager.cc
index 942cdd2ab..e8abc2667 100644
--- a/daemon/replication_manager.cc
+++ b/daemon/replication_manager.cc
@@ -52,798 +52,724 @@ using hyperdex::replication_manager;
 
 class replication_manager::retransmitter_thread : public hyperdex::background_thread
 {
-    public:
-        retransmitter_thread(daemon* d);
-        ~retransmitter_thread() throw ();
-
-    public:
-        virtual const char* thread_name() { return "replication"; }
-        virtual bool have_work();
-        virtual void copy_work();
-        virtual void do_work();
-
-    public:
-        void trigger();
-
-    public:
-        replication_manager* m_rm;
-        uint64_t m_trigger;
-
-    private:
-        retransmitter_thread(const retransmitter_thread&);
-        retransmitter_thread& operator = (const retransmitter_thread&);
+public:
+	retransmitter_thread(daemon *d);
+	~retransmitter_thread() throw ();
+
+public:
+	virtual const char *thread_name() { return "replication"; }
+	virtual bool have_work();
+	virtual void copy_work();
+	virtual void do_work();
+
+public:
+	void trigger();
+
+public:
+	replication_manager *m_rm;
+	uint64_t m_trigger;
+
+private:
+	retransmitter_thread(const retransmitter_thread &);
+	retransmitter_thread &operator = (const retransmitter_thread &);
 };
 
-replication_manager :: replication_manager(daemon* d)
-    : m_daemon(d)
-    , m_key_states(&d->m_gc)
-    , m_idgen()
-    , m_idcol(&d->m_gc)
-    , m_stable()
-    , m_retransmitter(new retransmitter_thread(d))
-    , m_protect_stable_stuff()
-    , m_checkpoint(0)
-    , m_need_check(0)
-    , m_timestamps()
-    , m_unstable()
+replication_manager :: replication_manager(daemon *d)
+	: m_daemon(d)
+	, m_key_states(&d->m_gc)
+	, m_idgen()
+	, m_idcol(&d->m_gc)
+	, m_stable()
+	, m_retransmitter(new retransmitter_thread(d))
+	, m_protect_stable_stuff()
+	, m_checkpoint(0)
+	, m_need_check(0)
+	, m_timestamps()
+	, m_unstable()
 {
-    po6::threads::mutex::hold hold(&m_protect_stable_stuff);
-    check_is_needed();
+	po6::threads::mutex::hold hold(&m_protect_stable_stuff);
+	check_is_needed();
 }
 
 replication_manager :: ~replication_manager() throw ()
 {
-    m_retransmitter->shutdown();
+	m_retransmitter->shutdown();
 }
 
 bool
 replication_manager :: setup()
 {
-    m_retransmitter->start();
-    return true;
+	m_retransmitter->start();
+	return true;
 }
 
 void
 replication_manager :: teardown()
 {
-    m_retransmitter->shutdown();
+	m_retransmitter->shutdown();
 }
 
 void
 replication_manager :: pause()
 {
-    m_retransmitter->initiate_pause();
+	m_retransmitter->initiate_pause();
 }
 
 void
 replication_manager :: unpause()
 {
-    m_retransmitter->unpause();
-    m_retransmitter->trigger();
+	m_retransmitter->unpause();
+	m_retransmitter->trigger();
 }
 
 void
-replication_manager :: reconfigure(const configuration&,
-                                   const configuration& new_config,
-                                   const server_id&)
-{
-    m_retransmitter->wait_until_paused();
-    m_retransmitter->trigger();
-
-    std::vector<region_id> key_regions;
-    new_config.key_regions(m_daemon->m_us, &key_regions);
-    m_idgen.adopt(&key_regions[0], key_regions.size());
-    m_idcol.adopt(&key_regions[0], key_regions.size());
-
-    std::vector<region_id> transfers_in_regions;
-    new_config.transfers_in_regions(m_daemon->m_us, &transfers_in_regions);
-
-    // iterate over all key states; cleanup dead ones, and bump idgen
-    for (key_map_t::iterator it(&m_key_states); it.valid(); ++it)
-    {
-        key_state* ks = *it;
-        ks->reconfigure(&m_daemon->m_gc);
-        region_id ri = ks->state_key().region;
-
-        if (std::binary_search(transfers_in_regions.begin(),
-                               transfers_in_regions.end(), ri))
-        {
-            ks->reset(&m_daemon->m_gc);
-        }
-
-        if (std::binary_search(key_regions.begin(),
-                               key_regions.end(), ri))
-        {
-            m_idgen.bump(ri, ks->max_version());
-        }
-    }
-
-    // iterate over all regions on disk/lb, and bump idgen
-    for (size_t i = 0; i < key_regions.size(); ++i)
-    {
-        uint64_t disk_ver = m_daemon->m_data.max_version(key_regions[i]);
-        uint64_t mem_ver = m_idcol.lower_bound(key_regions[i]);
-        uint64_t max_ver = std::max(disk_ver, mem_ver);
-
-        if (max_ver > 0)
-        {
-            m_idgen.bump(key_regions[i], max_ver - 1);
-        }
-    }
-
-    // figure out when we're stable
-    m_stable.copy_from(m_idgen);
-
-    // clear timestamps for regions we no longer manage
-    std::vector<region_id> mapped_regions;
-    m_daemon->m_config.mapped_regions(m_daemon->m_us, &mapped_regions);
-    po6::threads::mutex::hold hold(&m_protect_stable_stuff);
-    reset_to_unstable();
-
-    for (size_t i = 0; i < m_timestamps.size(); )
-    {
-        if (!std::binary_search(mapped_regions.begin(),
-                                mapped_regions.end(),
-                                m_timestamps[i].rid))
-        {
-            m_timestamps[i] = m_timestamps.back();
-            m_timestamps.pop_back();
-        }
-        else
-        {
-            ++i;
-        }
-    }
+replication_manager :: reconfigure(const configuration &,
+                                   const configuration &new_config,
+                                   const server_id &)
+{
+	m_retransmitter->wait_until_paused();
+	m_retransmitter->trigger();
+	std::vector<region_id> key_regions;
+	new_config.key_regions(m_daemon->m_us, &key_regions);
+	m_idgen.adopt(&key_regions[0], key_regions.size());
+	m_idcol.adopt(&key_regions[0], key_regions.size());
+	std::vector<region_id> transfers_in_regions;
+	new_config.transfers_in_regions(m_daemon->m_us, &transfers_in_regions);
+	// iterate over all key states; cleanup dead ones, and bump idgen
+	for (key_map_t::iterator it(&m_key_states); it.valid(); ++it)
+	{
+		key_state *ks = *it;
+		ks->reconfigure(&m_daemon->m_gc);
+		region_id ri = ks->state_key().region;
+		if (std::binary_search(transfers_in_regions.begin(),
+		                       transfers_in_regions.end(), ri))
+		{
+			ks->reset(&m_daemon->m_gc);
+		}
+		if (std::binary_search(key_regions.begin(),
+		                       key_regions.end(), ri))
+		{
+			m_idgen.bump(ri, ks->max_version());
+		}
+	}
+	// iterate over all regions on disk/lb, and bump idgen
+	for (size_t i = 0; i < key_regions.size(); ++i)
+	{
+		uint64_t disk_ver = m_daemon->m_data.max_version(key_regions[i]);
+		uint64_t mem_ver = m_idcol.lower_bound(key_regions[i]);
+		uint64_t max_ver = std::max(disk_ver, mem_ver);
+		if (max_ver > 0)
+		{
+			m_idgen.bump(key_regions[i], max_ver - 1);
+		}
+	}
+	// figure out when we're stable
+	m_stable.copy_from(m_idgen);
+	// clear timestamps for regions we no longer manage
+	std::vector<region_id> mapped_regions;
+	m_daemon->m_config.mapped_regions(m_daemon->m_us, &mapped_regions);
+	po6::threads::mutex::hold hold(&m_protect_stable_stuff);
+	reset_to_unstable();
+	for (size_t i = 0; i < m_timestamps.size(); )
+	{
+		if (!std::binary_search(mapped_regions.begin(),
+		                        mapped_regions.end(),
+		                        m_timestamps[i].rid))
+		{
+			m_timestamps[i] = m_timestamps.back();
+			m_timestamps.pop_back();
+		}
+		else
+		{
+			++i;
+		}
+	}
 }
 
 void
 replication_manager :: debug_dump()
 {
-    m_retransmitter->initiate_pause();
-    m_retransmitter->wait_until_paused();
-    std::vector<region_id> regions;
-    m_daemon->m_config.key_regions(m_daemon->m_us, &regions);
-
-    // print counters
-    LOG(INFO) << "region counters ===============================================================";
-
-    for (size_t i = 0; i < regions.size(); ++i)
-    {
-        uint64_t idgen = m_idgen.peek(regions[i]);
-        uint64_t lb = m_idcol.lower_bound(regions[i]);
-        uint64_t stable = m_stable.peek(regions[i]);
-        LOG(INFO) << regions[i] << " idgen=" << idgen << " lb=" << lb << " stable=" << stable;
-    }
-
-    // print key state
-    LOG(INFO) << "key states ====================================================================";
-
-    for (key_map_t::iterator it(&m_key_states); it.valid(); ++it)
-    {
-        key_state* ks = *it;
-        LOG(INFO) << "state for " << ks->state_key().region << " " << e::slice(ks->state_key().key).hex();
-        ks->debug_dump();
-    }
-
-    m_retransmitter->unpause();
-    m_retransmitter->trigger();
+	m_retransmitter->initiate_pause();
+	m_retransmitter->wait_until_paused();
+	std::vector<region_id> regions;
+	m_daemon->m_config.key_regions(m_daemon->m_us, &regions);
+	// print counters
+	LOG(INFO) << "region counters ===============================================================";
+	for (size_t i = 0; i < regions.size(); ++i)
+	{
+		uint64_t idgen = m_idgen.peek(regions[i]);
+		uint64_t lb = m_idcol.lower_bound(regions[i]);
+		uint64_t stable = m_stable.peek(regions[i]);
+		LOG(INFO) << regions[i] << " idgen=" << idgen << " lb=" << lb << " stable=" << stable;
+	}
+	// print key state
+	LOG(INFO) << "key states ====================================================================";
+	for (key_map_t::iterator it(&m_key_states); it.valid(); ++it)
+	{
+		key_state *ks = *it;
+		LOG(INFO) << "state for " << ks->state_key().region << " " << e::slice(ks->state_key().key).hex();
+		ks->debug_dump();
+	}
+	m_retransmitter->unpause();
+	m_retransmitter->trigger();
 }
 
 void
-replication_manager :: client_atomic(const server_id& from,
-                                     const virtual_server_id& to,
+replication_manager :: client_atomic(const server_id &from,
+                                     const virtual_server_id &to,
                                      uint64_t nonce,
                                      std::auto_ptr<key_change> kc,
                                      std::auto_ptr<e::buffer> backing)
 {
-    const region_id ri(m_daemon->m_config.get_region_id(to));
-    const schema& sc(*m_daemon->m_config.get_schema(ri));
-
-    if (m_daemon->m_config.read_only())
-    {
-        respond_to_client(to, from, nonce, NET_READONLY);
-        return;
-    }
-
-    if (!kc->validate(sc))
-    {
-        LOG(ERROR) << "dropping nonce=" << nonce << " from client=" << from
-                   << " because the key, checks, or funcs don't validate";
-        respond_to_client(to, from, nonce, NET_BADDIMSPEC);
-        return;
-    }
-
-    if (m_daemon->m_config.point_leader(ri, kc->key) != to)
-    {
-        LOG(ERROR) << "dropping nonce=" << nonce << " from client=" << from
-                   << " because it doesn't map to " << ri;
-        respond_to_client(to, from, nonce, NET_NOTUS);
-        return;
-    }
-
-    key_map_t::state_reference ksr;
-    key_state* ks = get_or_create_key_state(ri, kc->key, &ksr);
-    ks->enqueue_client_atomic(this, to, sc, from, nonce, kc, backing);
+	const region_id ri(m_daemon->m_config.get_region_id(to));
+	const schema &sc(*m_daemon->m_config.get_schema(ri));
+	if (m_daemon->m_config.read_only())
+	{
+		respond_to_client(to, from, nonce, NET_READONLY);
+		return;
+	}
+	if (!kc->validate(sc))
+	{
+		LOG(ERROR) << "dropping nonce=" << nonce << " from client=" << from
+		           << " because the key, checks, or funcs don't validate";
+		respond_to_client(to, from, nonce, NET_BADDIMSPEC);
+		return;
+	}
+	if (m_daemon->m_config.point_leader(ri, kc->key) != to)
+	{
+		LOG(ERROR) << "dropping nonce=" << nonce << " from client=" << from
+		           << " because it doesn't map to " << ri;
+		respond_to_client(to, from, nonce, NET_NOTUS);
+		return;
+	}
+	key_map_t::state_reference ksr;
+	key_state *ks = get_or_create_key_state(ri, kc->key, &ksr);
+	ks->enqueue_client_atomic(this, to, sc, from, nonce, kc, backing);
 }
 
 void
-replication_manager :: chain_op(const virtual_server_id& from,
-                                const virtual_server_id& to,
+replication_manager :: chain_op(const virtual_server_id &from,
+                                const virtual_server_id &to,
                                 uint64_t old_version,
                                 uint64_t new_version,
                                 bool fresh,
                                 bool has_value,
-                                const e::slice& key,
-                                const std::vector<e::slice>& value,
+                                const e::slice &key,
+                                const std::vector<e::slice> &value,
                                 std::auto_ptr<e::buffer> backing)
 {
-    const region_id ri(m_daemon->m_config.get_region_id(to));
-    const schema& sc(*m_daemon->m_config.get_schema(ri));
-    bool valid = sc.attrs_sz == value.size() + 1 &&
-                 datatype_info::lookup(sc.attrs[0].type)->validate(key);
-
-    if (has_value)
-    {
-        valid = valid && sc.attrs_sz == value.size() + 1;
-
-        for (size_t i = 0; valid && i + 1 < sc.attrs_sz; ++i)
-        {
-            valid = datatype_info::lookup(sc.attrs[i + 1].type)->validate(value[i]);
-        }
-    }
-
-    if (!valid)
-    {
-        LOG(ERROR) << "dropping CHAIN_OP because the dimensions are incorrect";
-        return;
-    }
-
-    key_map_t::state_reference ksr;
-    key_state* ks = get_or_create_key_state(ri, key, &ksr);
-    ks->enqueue_chain_op(this, to, sc, from, old_version, new_version, fresh, has_value, value, backing);
+	const region_id ri(m_daemon->m_config.get_region_id(to));
+	const schema &sc(*m_daemon->m_config.get_schema(ri));
+	bool valid = sc.attrs_sz == value.size() + 1 &&
+	             datatype_info::lookup(sc.attrs[0].type)->validate(key);
+	if (has_value)
+	{
+		valid = valid && sc.attrs_sz == value.size() + 1;
+		for (size_t i = 0; valid && i + 1 < sc.attrs_sz; ++i)
+		{
+			valid = datatype_info::lookup(sc.attrs[i + 1].type)->validate(value[i]);
+		}
+	}
+	if (!valid)
+	{
+		LOG(ERROR) << "dropping CHAIN_OP because the dimensions are incorrect";
+		return;
+	}
+	key_map_t::state_reference ksr;
+	key_state *ks = get_or_create_key_state(ri, key, &ksr);
+	ks->enqueue_chain_op(this, to, sc, from, old_version, new_version, fresh, has_value, value, backing);
 }
 
 void
-replication_manager :: chain_subspace(const virtual_server_id& from,
-                                      const virtual_server_id& to,
+replication_manager :: chain_subspace(const virtual_server_id &from,
+                                      const virtual_server_id &to,
                                       uint64_t old_version,
                                       uint64_t new_version,
-                                      const e::slice& key,
-                                      const std::vector<e::slice>& value,
+                                      const e::slice &key,
+                                      const std::vector<e::slice> &value,
                                       std::auto_ptr<e::buffer> backing,
-                                      const region_id& prev_region,
-                                      const region_id& this_old_region,
-                                      const region_id& this_new_region,
-                                      const region_id& next_region)
-{
-    const region_id ri(m_daemon->m_config.get_region_id(to));
-    const schema& sc(*m_daemon->m_config.get_schema(ri));
-    bool valid = sc.attrs_sz == value.size() + 1 &&
-                 datatype_info::lookup(sc.attrs[0].type)->validate(key);
-
-    for (size_t i = 0; valid && i + 1 < sc.attrs_sz; ++i)
-    {
-        valid = datatype_info::lookup(sc.attrs[i + 1].type)->validate(value[i]);
-    }
-
-    if (!valid)
-    {
-        LOG(ERROR) << "dropping CHAIN_SUBSPACE because the dimensions are incorrect";
-        return;
-    }
-
-    key_map_t::state_reference ksr;
-    key_state* ks = get_or_create_key_state(ri, key, &ksr);
-    ks->enqueue_chain_subspace(this, to, sc, from, old_version, new_version, value, backing,
-                               prev_region, this_old_region, this_new_region, next_region);
+                                      const region_id &prev_region,
+                                      const region_id &this_old_region,
+                                      const region_id &this_new_region,
+                                      const region_id &next_region)
+{
+	const region_id ri(m_daemon->m_config.get_region_id(to));
+	const schema &sc(*m_daemon->m_config.get_schema(ri));
+	bool valid = sc.attrs_sz == value.size() + 1 &&
+	             datatype_info::lookup(sc.attrs[0].type)->validate(key);
+	for (size_t i = 0; valid && i + 1 < sc.attrs_sz; ++i)
+	{
+		valid = datatype_info::lookup(sc.attrs[i + 1].type)->validate(value[i]);
+	}
+	if (!valid)
+	{
+		LOG(ERROR) << "dropping CHAIN_SUBSPACE because the dimensions are incorrect";
+		return;
+	}
+	key_map_t::state_reference ksr;
+	key_state *ks = get_or_create_key_state(ri, key, &ksr);
+	ks->enqueue_chain_subspace(this, to, sc, from, old_version, new_version, value, backing,
+	                           prev_region, this_old_region, this_new_region, next_region);
 }
 
 void
-replication_manager :: chain_ack(const virtual_server_id& from,
-                                 const virtual_server_id& to,
+replication_manager :: chain_ack(const virtual_server_id &from,
+                                 const virtual_server_id &to,
                                  uint64_t version,
-                                 const e::slice& key)
-{
-    const region_id ri(m_daemon->m_config.get_region_id(to));
-    const schema& sc(*m_daemon->m_config.get_schema(ri));
-    key_map_t::state_reference ksr;
-    key_state* ks = get_key_state(ri, key, &ksr);
-
-    if (!ks)
-    {
-        LOG(ERROR) << "dropping CHAIN_ACK for update we haven't seen";
-        LOG(ERROR) << "troubleshoot info: from=" << from << " to=" << to
-                   << " version=" << version << " key=" << key.hex();
-        return;
-    }
-
-    ks->enqueue_chain_ack(this, to, sc, from, version);
+                                 const e::slice &key)
+{
+	const region_id ri(m_daemon->m_config.get_region_id(to));
+	const schema &sc(*m_daemon->m_config.get_schema(ri));
+	key_map_t::state_reference ksr;
+	key_state *ks = get_key_state(ri, key, &ksr);
+	if (!ks)
+	{
+		LOG(ERROR) << "dropping CHAIN_ACK for update we haven't seen";
+		LOG(ERROR) << "troubleshoot info: from=" << from << " to=" << to
+		           << " version=" << version << " key=" << key.hex();
+		return;
+	}
+	ks->enqueue_chain_ack(this, to, sc, from, version);
 }
 
 void
 replication_manager :: begin_checkpoint(uint64_t checkpoint_num)
 {
-    m_retransmitter->initiate_pause();
-    m_retransmitter->wait_until_paused();
-    std::string timestamp = m_daemon->m_data.get_timestamp();
-
-    {
-        std::vector<region_id> mapped_regions;
-        m_daemon->m_config.mapped_regions(m_daemon->m_us, &mapped_regions);
-        po6::threads::mutex::hold hold(&m_protect_stable_stuff);
-        m_checkpoint = std::max(m_checkpoint, checkpoint_num);
-        reset_to_unstable();
-
-        for (size_t i = 0; i < mapped_regions.size(); ++i)
-        {
-            m_timestamps.push_back(region_timestamp(mapped_regions[i], checkpoint_num, timestamp));
-        }
-    }
-
-    std::vector<region_id> key_regions;
-    m_daemon->m_config.key_regions(m_daemon->m_us, &key_regions);
-
-    for (size_t i = 0; i < key_regions.size(); ++i)
-    {
-        uint64_t id = m_idgen.peek(key_regions[i]);
-
-        if (id > 0)
-        {
-            bool x = m_stable.bump(key_regions[i], id - 1);
-            assert(x);
-        }
-
-        check_stable(key_regions[i]);
-    }
-
-    check_stable();
-    m_retransmitter->unpause();
-    m_retransmitter->trigger();
+	m_retransmitter->initiate_pause();
+	m_retransmitter->wait_until_paused();
+	std::string timestamp = m_daemon->m_data.get_timestamp();
+	{
+		std::vector<region_id> mapped_regions;
+		m_daemon->m_config.mapped_regions(m_daemon->m_us, &mapped_regions);
+		po6::threads::mutex::hold hold(&m_protect_stable_stuff);
+		m_checkpoint = std::max(m_checkpoint, checkpoint_num);
+		reset_to_unstable();
+		for (size_t i = 0; i < mapped_regions.size(); ++i)
+		{
+			m_timestamps.push_back(region_timestamp(mapped_regions[i], checkpoint_num, timestamp));
+		}
+	}
+	std::vector<region_id> key_regions;
+	m_daemon->m_config.key_regions(m_daemon->m_us, &key_regions);
+	for (size_t i = 0; i < key_regions.size(); ++i)
+	{
+		uint64_t id = m_idgen.peek(key_regions[i]);
+		if (id > 0)
+		{
+			bool x = m_stable.bump(key_regions[i], id - 1);
+			assert(x);
+		}
+		check_stable(key_regions[i]);
+	}
+	check_stable();
+	m_retransmitter->unpause();
+	m_retransmitter->trigger();
 }
 
 void
 replication_manager :: end_checkpoint(uint64_t checkpoint_num)
 {
-    m_retransmitter->initiate_pause();
-    m_retransmitter->wait_until_paused();
-    po6::threads::mutex::hold hold(&m_protect_stable_stuff);
-
-    for (size_t i = 0; i < m_timestamps.size(); )
-    {
-        if (m_timestamps[i].checkpoint <= checkpoint_num)
-        {
-            m_daemon->m_data.create_checkpoint(m_timestamps[i]);
-            std::swap(m_timestamps[i], m_timestamps.back());
-            m_timestamps.pop_back();
-        }
-        else
-        {
-            ++i;
-        }
-    }
-
-    m_retransmitter->unpause();
-    m_retransmitter->trigger();
-}
-
-key_state*
-replication_manager :: get_key_state(const region_id& ri,
-                                     const e::slice& key,
-                                     key_map_t::state_reference* ksr)
-{
-    key_region kr(ri, key);
-    key_state* ks = m_key_states.get_state(kr, ksr);
-    return post_get_key_state_init(ri, ks);
-}
-
-key_state*
-replication_manager :: get_or_create_key_state(const region_id& ri,
-                                               const e::slice& key,
-                                               key_map_t::state_reference* ksr)
-{
-    key_region kr(ri, key);
-    key_state* ks = m_key_states.get_or_create_state(kr, ksr);
-    return post_get_key_state_init(ri, ks);
-}
-
-key_state*
-replication_manager :: post_get_key_state_init(region_id ri, key_state* ks)
-{
-    if (!ks || ks->initialized())
-    {
-        return ks;
-    }
-
-    const schema& sc(*m_daemon->m_config.get_schema(ri));
-
-    switch (ks->initialize(&m_daemon->m_data, sc, ri))
-    {
-        case datalayer::SUCCESS:
-        case datalayer::NOT_FOUND:
-            return ks;
-        case datalayer::BAD_ENCODING:
-        case datalayer::CORRUPTION:
-        case datalayer::IO_ERROR:
-        case datalayer::LEVELDB_ERROR:
-        default:
-            LOG(ERROR) << "Data layer returned unexpected result when reading old value.";
-            return NULL;
-    }
+	m_retransmitter->initiate_pause();
+	m_retransmitter->wait_until_paused();
+	po6::threads::mutex::hold hold(&m_protect_stable_stuff);
+	for (size_t i = 0; i < m_timestamps.size(); )
+	{
+		if (m_timestamps[i].checkpoint <= checkpoint_num)
+		{
+			m_daemon->m_data.create_checkpoint(m_timestamps[i]);
+			std::swap(m_timestamps[i], m_timestamps.back());
+			m_timestamps.pop_back();
+		}
+		else
+		{
+			++i;
+		}
+	}
+	m_retransmitter->unpause();
+	m_retransmitter->trigger();
+}
+
+key_state *
+replication_manager :: get_key_state(const region_id &ri,
+                                     const e::slice &key,
+                                     key_map_t::state_reference *ksr)
+{
+	key_region kr(ri, key);
+	key_state *ks = m_key_states.get_state(kr, ksr);
+	return post_get_key_state_init(ri, ks);
+}
+
+key_state *
+replication_manager :: get_or_create_key_state(const region_id &ri,
+                                               const e::slice &key,
+                                               key_map_t::state_reference *ksr)
+{
+	key_region kr(ri, key);
+	key_state *ks = m_key_states.get_or_create_state(kr, ksr);
+	return post_get_key_state_init(ri, ks);
+}
+
+key_state *
+replication_manager :: post_get_key_state_init(region_id ri, key_state *ks)
+{
+	if (!ks || ks->initialized())
+	{
+		return ks;
+	}
+	const schema &sc(*m_daemon->m_config.get_schema(ri));
+	switch (ks->initialize(&m_daemon->m_data, sc, ri))
+	{
+	case datalayer::SUCCESS:
+	case datalayer::NOT_FOUND:
+		return ks;
+	case datalayer::BAD_ENCODING:
+	case datalayer::CORRUPTION:
+	case datalayer::IO_ERROR:
+	case datalayer::LEVELDB_ERROR:
+	default:
+		LOG(ERROR) << "Data layer returned unexpected result when reading old value.";
+		return NULL;
+	}
 }
 
 void
-replication_manager :: respond_to_client(const virtual_server_id& us,
-                                         const server_id& client,
+replication_manager :: respond_to_client(const virtual_server_id &us,
+                                         const server_id &client,
                                          uint64_t nonce,
                                          network_returncode ret)
 {
-    size_t sz = HYPERDEX_HEADER_SIZE_VC
-              + sizeof(uint64_t)
-              + sizeof(uint16_t);
-    std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
-    uint16_t result = static_cast<uint16_t>(ret);
-    msg->pack_at(HYPERDEX_HEADER_SIZE_VC) << nonce << result;
-    m_daemon->m_comm.send_client(us, client, RESP_ATOMIC, msg);
+	size_t sz = HYPERDEX_HEADER_SIZE_VC
+	            + sizeof(uint64_t)
+	            + sizeof(uint16_t);
+	std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
+	uint16_t result = static_cast<uint16_t>(ret);
+	msg->pack_at(HYPERDEX_HEADER_SIZE_VC) << nonce << result;
+	m_daemon->m_comm.send_client(us, client, RESP_ATOMIC, msg);
 }
 
 bool
-replication_manager :: send_message(const virtual_server_id& us,
-                                    const e::slice& key,
+replication_manager :: send_message(const virtual_server_id &us,
+                                    const e::slice &key,
                                     e::intrusive_ptr<key_operation> op)
 {
-    // If we've sent it somewhere, we shouldn't resend.  If the sender intends a
-    // resend, they should clear "sent" first.
-    assert(op->sent_to() == virtual_server_id());
-    region_id ri(m_daemon->m_config.get_region_id(us));
-
-    // If there's an ongoing transfer, don't actually send
-    if (m_daemon->m_config.is_server_blocked_by_live_transfer(m_daemon->m_us, ri))
-    {
-        return false;
-    }
-
-    // facts we use to decide what to do
-    assert(ri == op->this_old_region() || ri == op->this_new_region());
-    bool last_in_chain = m_daemon->m_config.tail_of_region(ri) == us;
-    bool has_next_subspace = op->next_region() != region_id();
-
-    // variables we fill in to determine the message type/destination
-    virtual_server_id dest;
-    network_msgtype type = CHAIN_OP;
-
-    if (op->this_old_region() == op->this_new_region())
-    {
-        if (last_in_chain)
-        {
-            if (has_next_subspace)
-            {
-                dest = m_daemon->m_config.head_of_region(op->next_region());
-                type = CHAIN_OP;
-            }
-            else
-            {
-                if (!op->ackable())
-                {
-                    op->mark_acked();
-                    collect(ri, op);
-                }
-
-                return send_ack(us, key, op);
-            }
-        }
-        else
-        {
-            dest = m_daemon->m_config.next_in_region(us);
-            type = CHAIN_OP;
-        }
-    }
-    else if (op->this_old_region() == ri)
-    {
-        if (last_in_chain)
-        {
-            assert(op->has_value());
-            dest = m_daemon->m_config.head_of_region(op->this_new_region());
-            type = CHAIN_SUBSPACE;
-        }
-        else
-        {
-            dest = m_daemon->m_config.next_in_region(us);
-            type = CHAIN_OP;
-        }
-    }
-    else if (op->this_new_region() == ri)
-    {
-        if (last_in_chain)
-        {
-            if (has_next_subspace)
-            {
-                dest = m_daemon->m_config.head_of_region(op->next_region());
-                type = CHAIN_OP;
-            }
-            else
-            {
-                if (!op->ackable())
-                {
-                    op->mark_acked();
-                    collect(ri, op);
-                }
-
-                return send_ack(us, key, op);
-            }
-        }
-        else
-        {
-            assert(op->has_value());
-            dest = m_daemon->m_config.next_in_region(us);
-            type = CHAIN_SUBSPACE;
-        }
-    }
-    else
-    {
-        abort();
-    }
-
-    std::auto_ptr<e::buffer> msg;
-
-    if (type == CHAIN_OP)
-    {
-        uint8_t flags = (op->is_fresh() ? 1 : 0)
-                      | (op->has_value() ? 2 : 0);
-        size_t sz = HYPERDEX_HEADER_SIZE_VV
-                  + sizeof(uint8_t)
-                  + sizeof(uint64_t)
-                  + sizeof(uint64_t)
-                  + pack_size(key)
-                  + pack_size(op->value());
-        msg.reset(e::buffer::create(sz));
-        msg->pack_at(HYPERDEX_HEADER_SIZE_VV)
-            << flags << op->prev_version() << op->this_version()
-            << key << op->value();
-    }
-    else if (type == CHAIN_SUBSPACE)
-    {
-        size_t sz = HYPERDEX_HEADER_SIZE_VV
-                  + sizeof(uint64_t)
-                  + sizeof(uint64_t)
-                  + pack_size(key)
-                  + pack_size(op->value())
-                  + pack_size(op->prev_region())
-                  + pack_size(op->this_old_region())
-                  + pack_size(op->this_new_region())
-                  + pack_size(op->next_region());
-        msg.reset(e::buffer::create(sz));
-        msg->pack_at(HYPERDEX_HEADER_SIZE_VV)
-            << op->prev_version() << op->this_version()
-            << key << op->value()
-            << op->prev_region()
-            << op->this_old_region()
-            << op->this_new_region()
-            << op->next_region();
-    }
-    else
-    {
-        abort();
-    }
-
-    op->set_sent(m_daemon->m_config.version(), dest);
-    return m_daemon->m_comm.send_exact(us, dest, type, msg);
+	// If we've sent it somewhere, we shouldn't resend.  If the sender intends a
+	// resend, they should clear "sent" first.
+	assert(op->sent_to() == virtual_server_id());
+	region_id ri(m_daemon->m_config.get_region_id(us));
+	// If there's an ongoing transfer, don't actually send
+	if (m_daemon->m_config.is_server_blocked_by_live_transfer(m_daemon->m_us, ri))
+	{
+		return false;
+	}
+	// facts we use to decide what to do
+	assert(ri == op->this_old_region() || ri == op->this_new_region());
+	bool last_in_chain = m_daemon->m_config.tail_of_region(ri) == us;
+	bool has_next_subspace = op->next_region() != region_id();
+	// variables we fill in to determine the message type/destination
+	virtual_server_id dest;
+	network_msgtype type = CHAIN_OP;
+	if (op->this_old_region() == op->this_new_region())
+	{
+		if (last_in_chain)
+		{
+			if (has_next_subspace)
+			{
+				dest = m_daemon->m_config.head_of_region(op->next_region());
+				type = CHAIN_OP;
+			}
+			else
+			{
+				if (!op->ackable())
+				{
+					op->mark_acked();
+					collect(ri, op);
+				}
+				return send_ack(us, key, op);
+			}
+		}
+		else
+		{
+			dest = m_daemon->m_config.next_in_region(us);
+			type = CHAIN_OP;
+		}
+	}
+	else if (op->this_old_region() == ri)
+	{
+		if (last_in_chain)
+		{
+			assert(op->has_value());
+			dest = m_daemon->m_config.head_of_region(op->this_new_region());
+			type = CHAIN_SUBSPACE;
+		}
+		else
+		{
+			dest = m_daemon->m_config.next_in_region(us);
+			type = CHAIN_OP;
+		}
+	}
+	else if (op->this_new_region() == ri)
+	{
+		if (last_in_chain)
+		{
+			if (has_next_subspace)
+			{
+				dest = m_daemon->m_config.head_of_region(op->next_region());
+				type = CHAIN_OP;
+			}
+			else
+			{
+				if (!op->ackable())
+				{
+					op->mark_acked();
+					collect(ri, op);
+				}
+				return send_ack(us, key, op);
+			}
+		}
+		else
+		{
+			assert(op->has_value());
+			dest = m_daemon->m_config.next_in_region(us);
+			type = CHAIN_SUBSPACE;
+		}
+	}
+	else
+	{
+		abort();
+	}
+	std::auto_ptr<e::buffer> msg;
+	if (type == CHAIN_OP)
+	{
+		uint8_t flags = (op->is_fresh() ? 1 : 0)
+		                | (op->has_value() ? 2 : 0);
+		size_t sz = HYPERDEX_HEADER_SIZE_VV
+		            + sizeof(uint8_t)
+		            + sizeof(uint64_t)
+		            + sizeof(uint64_t)
+		            + pack_size(key)
+		            + pack_size(op->value());
+		msg.reset(e::buffer::create(sz));
+		msg->pack_at(HYPERDEX_HEADER_SIZE_VV)
+		        << flags << op->prev_version() << op->this_version()
+		        << key << op->value();
+	}
+	else if (type == CHAIN_SUBSPACE)
+	{
+		size_t sz = HYPERDEX_HEADER_SIZE_VV
+		            + sizeof(uint64_t)
+		            + sizeof(uint64_t)
+		            + pack_size(key)
+		            + pack_size(op->value())
+		            + pack_size(op->prev_region())
+		            + pack_size(op->this_old_region())
+		            + pack_size(op->this_new_region())
+		            + pack_size(op->next_region());
+		msg.reset(e::buffer::create(sz));
+		msg->pack_at(HYPERDEX_HEADER_SIZE_VV)
+		        << op->prev_version() << op->this_version()
+		        << key << op->value()
+		        << op->prev_region()
+		        << op->this_old_region()
+		        << op->this_new_region()
+		        << op->next_region();
+	}
+	else
+	{
+		abort();
+	}
+	op->set_sent(m_daemon->m_config.version(), dest);
+	return m_daemon->m_comm.send_exact(us, dest, type, msg);
 }
 
 bool
-replication_manager :: send_ack(const virtual_server_id& us,
-                                const e::slice& key,
+replication_manager :: send_ack(const virtual_server_id &us,
+                                const e::slice &key,
                                 e::intrusive_ptr<key_operation> op)
 {
-    if (!op->ackable() || !op->recv_from(m_daemon->m_config.version()))
-    {
-        return false;
-    }
-
-    size_t sz = HYPERDEX_HEADER_SIZE_VV + sizeof(uint64_t) + pack_size(key);
-    std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
-    msg->pack_at(HYPERDEX_HEADER_SIZE_VV) << op->this_version() << key;
-    return m_daemon->m_comm.send_exact(us, op->recv_from(), CHAIN_ACK, msg);
+	if (!op->ackable() || !op->recv_from(m_daemon->m_config.version()))
+	{
+		return false;
+	}
+	size_t sz = HYPERDEX_HEADER_SIZE_VV + sizeof(uint64_t) + pack_size(key);
+	std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
+	msg->pack_at(HYPERDEX_HEADER_SIZE_VV) << op->this_version() << key;
+	return m_daemon->m_comm.send_exact(us, op->recv_from(), CHAIN_ACK, msg);
 }
 
 void
-replication_manager :: retransmit(const std::vector<region_id>& point_leaders,
-                                  std::vector<std::pair<region_id, uint64_t> >* versions)
-{
-    for (key_map_t::iterator it(&m_key_states); it.valid(); ++it)
-    {
-        key_state* ks = *it;
-        region_id ri = ks->state_key().region;
-
-        if (std::binary_search(point_leaders.begin(),
-                               point_leaders.end(), ri))
-        {
-            ks->append_all_versions(versions);
-        }
-
-        if (m_daemon->m_config.is_server_blocked_by_live_transfer(m_daemon->m_us, ri))
-        {
-            continue;
-        }
-
-        virtual_server_id us = m_daemon->m_config.get_virtual(ri, m_daemon->m_us);
-
-        if (us == virtual_server_id() || ks->finished())
-        {
-            ks->reset(&m_daemon->m_gc);
-            continue;
-        }
-
-        const schema& sc(*m_daemon->m_config.get_schema(ri));
-        ks->resend_committable(this, us);
-        ks->work_state_machine(this, us, sc);
-    }
-
-    m_daemon->m_comm.wake_one();
+replication_manager :: retransmit(const std::vector<region_id> &point_leaders,
+                                  std::vector<std::pair<region_id, uint64_t> > *versions)
+{
+	for (key_map_t::iterator it(&m_key_states); it.valid(); ++it)
+	{
+		key_state *ks = *it;
+		region_id ri = ks->state_key().region;
+		if (std::binary_search(point_leaders.begin(),
+		                       point_leaders.end(), ri))
+		{
+			ks->append_all_versions(versions);
+		}
+		if (m_daemon->m_config.is_server_blocked_by_live_transfer(m_daemon->m_us, ri))
+		{
+			continue;
+		}
+		virtual_server_id us = m_daemon->m_config.get_virtual(ri, m_daemon->m_us);
+		if (us == virtual_server_id() || ks->finished())
+		{
+			ks->reset(&m_daemon->m_gc);
+			continue;
+		}
+		const schema &sc(*m_daemon->m_config.get_schema(ri));
+		ks->resend_committable(this, us);
+		ks->work_state_machine(this, us, sc);
+	}
+	m_daemon->m_comm.wake_one();
 }
 
 void
-replication_manager :: collect(const region_id& ri, e::intrusive_ptr<key_operation> op)
+replication_manager :: collect(const region_id &ri, e::intrusive_ptr<key_operation> op)
 {
-    if (op->prev_region() == region_id())
-    {
-        collect(ri, op->this_version());
-    }
-
-    check_stable();
+	if (op->prev_region() == region_id())
+	{
+		collect(ri, op->this_version());
+	}
+	check_stable();
 }
 
 void
-replication_manager :: collect(const region_id& ri, uint64_t version)
+replication_manager :: collect(const region_id &ri, uint64_t version)
 {
-    m_idcol.collect(ri, version);
-    check_stable(ri);
+	m_idcol.collect(ri, version);
+	check_stable(ri);
 }
 
 void
-replication_manager :: close_gaps(const std::vector<region_id>& point_leaders,
-                                  const identifier_generator& peek_ids,
-                                  std::vector<std::pair<region_id, uint64_t> >* versions)
-{
-    std::sort(versions->begin(), versions->end());
-
-    for (size_t i = 0; i < point_leaders.size(); ++i)
-    {
-        // figure out the start and end ptrs within versions
-        // s.t. [start, limit) contains all point_leaders[i]
-        std::pair<region_id, uint64_t>* start = &(*versions)[0];
-        std::pair<region_id, uint64_t>* const end = start + versions->size();
-
-        while (start < end && start->first == point_leaders[i])
-        {
-            ++start;
-        }
-
-        std::pair<region_id, uint64_t>* limit = start;
-
-        while (limit < end && limit->first == start->first)
-        {
-            ++limit;
-        }
-
-        // find the next ID to generate for point_leaders[i] (cant_touch_this)
-        uint64_t cant_touch_this = peek_ids.peek(point_leaders[i]);
-
-        // if start == limit, then there are no versions and everything less than
-        // cant_touch_this is collectable and we can short-circuit the
-        // complexity below
-        if (start == limit)
-        {
-            m_idcol.bump(point_leaders[i], cant_touch_this);
-            continue;
-        }
-
-        // find the lower bound for point_leaders[i] (lb)
-        uint64_t lb = m_idcol.lower_bound(point_leaders[i]);
-
-        // for every value [lb, cant_touch_this), call collect if not found in
-        // versions [start, limit)
-        for (uint64_t maybe_next_to_collect = lb;
-                maybe_next_to_collect < cant_touch_this; ++maybe_next_to_collect)
-        {
-            if (!std::binary_search(start, limit,
-                        std::make_pair(point_leaders[i], maybe_next_to_collect)))
-            {
-                m_idcol.collect(point_leaders[i], maybe_next_to_collect);
-            }
-        }
-
-        // compute the lower bound on point_leaders[i] to squash gaps
-        uint64_t tmp = m_idcol.lower_bound(point_leaders[i]);
-        (void) tmp;
-    }
+replication_manager :: close_gaps(const std::vector<region_id> &point_leaders,
+                                  const identifier_generator &peek_ids,
+                                  std::vector<std::pair<region_id, uint64_t> > *versions)
+{
+	std::sort(versions->begin(), versions->end());
+	for (size_t i = 0; i < point_leaders.size(); ++i)
+	{
+		// figure out the start and end ptrs within versions
+		// s.t. [start, limit) contains all point_leaders[i]
+		std::pair<region_id, uint64_t> *start = &(*versions)[0];
+		std::pair<region_id, uint64_t> *const end = start + versions->size();
+		while (start < end && start->first == point_leaders[i])
+		{
+			++start;
+		}
+		std::pair<region_id, uint64_t> *limit = start;
+		while (limit < end && limit->first == start->first)
+		{
+			++limit;
+		}
+		// find the next ID to generate for point_leaders[i] (cant_touch_this)
+		uint64_t cant_touch_this = peek_ids.peek(point_leaders[i]);
+		// if start == limit, then there are no versions and everything less than
+		// cant_touch_this is collectable and we can short-circuit the
+		// complexity below
+		if (start == limit)
+		{
+			m_idcol.bump(point_leaders[i], cant_touch_this);
+			continue;
+		}
+		// find the lower bound for point_leaders[i] (lb)
+		uint64_t lb = m_idcol.lower_bound(point_leaders[i]);
+		// for every value [lb, cant_touch_this), call collect if not found in
+		// versions [start, limit)
+		for (uint64_t maybe_next_to_collect = lb;
+		     maybe_next_to_collect < cant_touch_this; ++maybe_next_to_collect)
+		{
+			if (!std::binary_search(start, limit,
+			                        std::make_pair(point_leaders[i], maybe_next_to_collect)))
+			{
+				m_idcol.collect(point_leaders[i], maybe_next_to_collect);
+			}
+		}
+		// compute the lower bound on point_leaders[i] to squash gaps
+		uint64_t tmp = m_idcol.lower_bound(point_leaders[i]);
+		(void) tmp;
+	}
 }
 
 void
 replication_manager :: reset_to_unstable()
 {
-    m_unstable.clear();
-    m_daemon->m_config.point_leaders(m_daemon->m_us, &m_unstable);
-    check_is_needed();
-    m_retransmitter->trigger();
+	m_unstable.clear();
+	m_daemon->m_config.point_leaders(m_daemon->m_us, &m_unstable);
+	check_is_needed();
+	m_retransmitter->trigger();
 }
 
 void
 replication_manager :: check_stable()
 {
-    bool tell_coord_stable = false;
-    uint64_t checkpoint = 0;
-
-    if (is_check_needed())
-    {
-        po6::threads::mutex::hold hold(&m_protect_stable_stuff);
-        tell_coord_stable = m_unstable.empty();
-        checkpoint = m_checkpoint;
-
-        if (tell_coord_stable)
-        {
-            check_is_not_needed();
-        }
-    }
-
-    if (tell_coord_stable)
-    {
-        m_daemon->m_coord->config_stable(m_daemon->m_config.version());
-        m_daemon->m_coord->checkpoint_report_stable(checkpoint);
-    }
+	bool tell_coord_stable = false;
+	uint64_t checkpoint = 0;
+	if (is_check_needed())
+	{
+		po6::threads::mutex::hold hold(&m_protect_stable_stuff);
+		tell_coord_stable = m_unstable.empty();
+		checkpoint = m_checkpoint;
+		if (tell_coord_stable)
+		{
+			check_is_not_needed();
+		}
+	}
+	if (tell_coord_stable)
+	{
+		m_daemon->m_coord->config_stable(m_daemon->m_config.version());
+		m_daemon->m_coord->checkpoint_report_stable(checkpoint);
+	}
 }
 
 void
-replication_manager :: check_stable(const region_id& ri)
-{
-    if (!is_check_needed())
-    {
-        return;
-    }
-
-    bool tell_coord_stable = false;
-    uint64_t checkpoint = 0;
-    uint64_t lb = m_idcol.lower_bound(ri);
-    uint64_t stable = m_stable.peek(ri);
-
-    if (stable <= lb)
-    {
-        po6::threads::mutex::hold hold(&m_protect_stable_stuff);
-        bool popped = false;
-
-        for (size_t i = 0; i < m_unstable.size(); )
-        {
-            if (m_unstable[i] == ri)
-            {
-                std::swap(m_unstable[i], m_unstable.back());
-                m_unstable.pop_back();
-                popped = true;
-            }
-            else
-            {
-                ++i;
-            }
-        }
-
-        tell_coord_stable = popped && m_unstable.empty();
-        checkpoint = m_checkpoint;
-
-        if (tell_coord_stable)
-        {
-            check_is_not_needed();
-        }
-    }
-
-    if (tell_coord_stable)
-    {
-        m_daemon->m_coord->config_stable(m_daemon->m_config.version());
-        m_daemon->m_coord->checkpoint_report_stable(checkpoint);
-    }
-}
-
-replication_manager :: retransmitter_thread :: retransmitter_thread(daemon* d)
-    : background_thread(d)
-    , m_rm(&d->m_repl)
-    , m_trigger(0)
+replication_manager :: check_stable(const region_id &ri)
+{
+	if (!is_check_needed())
+	{
+		return;
+	}
+	bool tell_coord_stable = false;
+	uint64_t checkpoint = 0;
+	uint64_t lb = m_idcol.lower_bound(ri);
+	uint64_t stable = m_stable.peek(ri);
+	if (stable <= lb)
+	{
+		po6::threads::mutex::hold hold(&m_protect_stable_stuff);
+		bool popped = false;
+		for (size_t i = 0; i < m_unstable.size(); )
+		{
+			if (m_unstable[i] == ri)
+			{
+				std::swap(m_unstable[i], m_unstable.back());
+				m_unstable.pop_back();
+				popped = true;
+			}
+			else
+			{
+				++i;
+			}
+		}
+		tell_coord_stable = popped && m_unstable.empty();
+		checkpoint = m_checkpoint;
+		if (tell_coord_stable)
+		{
+			check_is_not_needed();
+		}
+	}
+	if (tell_coord_stable)
+	{
+		m_daemon->m_coord->config_stable(m_daemon->m_config.version());
+		m_daemon->m_coord->checkpoint_report_stable(checkpoint);
+	}
+}
+
+replication_manager :: retransmitter_thread :: retransmitter_thread(daemon *d)
+	: background_thread(d)
+	, m_rm(&d->m_repl)
+	, m_trigger(0)
 {
 }
 
@@ -854,49 +780,44 @@ replication_manager :: retransmitter_thread :: ~retransmitter_thread() throw ()
 bool
 replication_manager :: retransmitter_thread :: have_work()
 {
-    return m_trigger > 0;
+	return m_trigger > 0;
 }
 
 void
 replication_manager :: retransmitter_thread :: copy_work()
 {
-    assert(m_trigger > 0);
-    --m_trigger;
+	assert(m_trigger > 0);
+	--m_trigger;
 }
 
 void
 replication_manager :: retransmitter_thread :: do_work()
 {
-    // get the list of point leaders
-    std::vector<region_id> point_leaders;
-    m_rm->m_daemon->m_config.point_leaders(m_rm->m_daemon->m_us, &point_leaders);
-    std::sort(point_leaders.begin(), point_leaders.end());
-
-    // peek at the next-to-generate values of m_idgen
-    identifier_generator peeked_values;
-    peeked_values.copy_from(m_rm->m_idgen);
-    std::vector<std::pair<region_id, uint64_t> > versions;
-
-    // retransmit everything
-    m_rm->retransmit(point_leaders, &versions);
-
-    // now close all gaps
-    m_rm->close_gaps(point_leaders, peeked_values, &versions);
-
-    for (size_t i = 0; i < point_leaders.size(); ++i)
-    {
-        m_rm->check_stable(point_leaders[i]);
-    }
-
-    m_rm->check_stable();
-    m_rm->m_daemon->m_comm.wake_one();
+	// get the list of point leaders
+	std::vector<region_id> point_leaders;
+	m_rm->m_daemon->m_config.point_leaders(m_rm->m_daemon->m_us, &point_leaders);
+	std::sort(point_leaders.begin(), point_leaders.end());
+	// peek at the next-to-generate values of m_idgen
+	identifier_generator peeked_values;
+	peeked_values.copy_from(m_rm->m_idgen);
+	std::vector<std::pair<region_id, uint64_t> > versions;
+	// retransmit everything
+	m_rm->retransmit(point_leaders, &versions);
+	// now close all gaps
+	m_rm->close_gaps(point_leaders, peeked_values, &versions);
+	for (size_t i = 0; i < point_leaders.size(); ++i)
+	{
+		m_rm->check_stable(point_leaders[i]);
+	}
+	m_rm->check_stable();
+	m_rm->m_daemon->m_comm.wake_one();
 }
 
 void
 replication_manager :: retransmitter_thread :: trigger()
 {
-    this->lock();
-    ++m_trigger;
-    this->wakeup();
-    this->unlock();
+	this->lock();
+	++m_trigger;
+	this->wakeup();
+	this->unlock();
 }
diff --git a/daemon/replication_manager.h b/daemon/replication_manager.h
index 7fb1ff6a8..c73e006b5 100644
--- a/daemon/replication_manager.h
+++ b/daemon/replication_manager.h
@@ -65,117 +65,117 @@ class daemon;
 // Manage replication.
 class replication_manager
 {
-    public:
-        replication_manager(daemon*);
-        ~replication_manager() throw ();
+public:
+	replication_manager(daemon *);
+	~replication_manager() throw ();
 
-    // Reconfigure this layer.
-    public:
-        bool setup();
-        void teardown();
-        void pause();
-        void unpause();
-        void reconfigure(const configuration& old_config,
-                         const configuration& new_config,
-                         const server_id& us);
-        void debug_dump();
+	// Reconfigure this layer.
+public:
+	bool setup();
+	void teardown();
+	void pause();
+	void unpause();
+	void reconfigure(const configuration &old_config,
+	                 const configuration &new_config,
+	                 const server_id &us);
+	void debug_dump();
 
-    // Network workers call these methods.
-    public:
-        // These are called when the client initiates the action.  This implies
-        // that only the point leader should call these methods.
-        void client_atomic(const server_id& from,
-                           const virtual_server_id& to,
-                           uint64_t nonce,
-                           std::auto_ptr<key_change> kc,
-                           std::auto_ptr<e::buffer> backing);
-        // These are called in response to messages from other hosts.
-        void chain_op(const virtual_server_id& from,
-                      const virtual_server_id& to,
-                      uint64_t old_version,
-                      uint64_t new_version,
-                      bool fresh,
-                      bool has_value,
-                      const e::slice& key,
-                      const std::vector<e::slice>& value,
-                      std::auto_ptr<e::buffer> backing);
-        void chain_subspace(const virtual_server_id& from,
-                            const virtual_server_id& to,
-                            uint64_t old_version,
-                            uint64_t new_version,
-                            const e::slice& key,
-                            const std::vector<e::slice>& value,
-                            std::auto_ptr<e::buffer> backing,
-                            const region_id& prev_region,
-                            const region_id& this_old_region,
-                            const region_id& this_new_region,
-                            const region_id& next_region);
-        void chain_ack(const virtual_server_id& from,
-                       const virtual_server_id& to,
-                       uint64_t version,
-                       const e::slice& key);
-        void begin_checkpoint(uint64_t seq);
-        void end_checkpoint(uint64_t seq);
+	// Network workers call these methods.
+public:
+	// These are called when the client initiates the action.  This implies
+	// that only the point leader should call these methods.
+	void client_atomic(const server_id &from,
+	                   const virtual_server_id &to,
+	                   uint64_t nonce,
+	                   std::auto_ptr<key_change> kc,
+	                   std::auto_ptr<e::buffer> backing);
+	// These are called in response to messages from other hosts.
+	void chain_op(const virtual_server_id &from,
+	              const virtual_server_id &to,
+	              uint64_t old_version,
+	              uint64_t new_version,
+	              bool fresh,
+	              bool has_value,
+	              const e::slice &key,
+	              const std::vector<e::slice> &value,
+	              std::auto_ptr<e::buffer> backing);
+	void chain_subspace(const virtual_server_id &from,
+	                    const virtual_server_id &to,
+	                    uint64_t old_version,
+	                    uint64_t new_version,
+	                    const e::slice &key,
+	                    const std::vector<e::slice> &value,
+	                    std::auto_ptr<e::buffer> backing,
+	                    const region_id &prev_region,
+	                    const region_id &this_old_region,
+	                    const region_id &this_new_region,
+	                    const region_id &next_region);
+	void chain_ack(const virtual_server_id &from,
+	               const virtual_server_id &to,
+	               uint64_t version,
+	               const e::slice &key);
+	void begin_checkpoint(uint64_t seq);
+	void end_checkpoint(uint64_t seq);
 
-    private:
-        class retransmitter_thread;
-        typedef state_hash_table<key_region, key_state> key_map_t;
-        friend class key_state;
+private:
+	class retransmitter_thread;
+	typedef state_hash_table<key_region, key_state> key_map_t;
+	friend class key_state;
 
-    private:
-        // Get the state for the specified key.
-        // Returns NULL if there is no key_state that's currently in use.
-        key_state* get_key_state(const region_id& ri,
-                                 const e::slice& key,
-                                 key_map_t::state_reference* ksr);
-        // Get the state for the specified key.
-        // Will retrieve the state from disk and create the key_state when
-        // necessary.
-        key_state* get_or_create_key_state(const region_id& ri,
-                                           const e::slice& key,
-                                           key_map_t::state_reference* ksr);
-        key_state* post_get_key_state_init(region_id ri, key_state* ks);
-        void respond_to_client(const virtual_server_id& us,
-                               const server_id& client,
-                               uint64_t nonce,
-                               network_returncode ret);
-        bool send_message(const virtual_server_id& us,
-                          const e::slice& key,
-                          e::intrusive_ptr<key_operation> op);
-        bool send_ack(const virtual_server_id& us,
-                      const e::slice& key,
-                      e::intrusive_ptr<key_operation> op);
-        void retransmit(const std::vector<region_id>& point_leaders,
-                        std::vector<std::pair<region_id, uint64_t> >* versions);
-        void collect(const region_id& ri, e::intrusive_ptr<key_operation> op);
-        void collect(const region_id& ri, uint64_t version);
-        void close_gaps(const std::vector<region_id>& point_leaders,
-                        const identifier_generator& peek_ids,
-                        std::vector<std::pair<region_id, uint64_t> >* versions);
-        // call reset_to_unstable holding m_protect_stable_stuff
-        void reset_to_unstable();
-        bool is_check_needed() { return e::atomic::compare_and_swap_32_nobarrier(&m_need_check, 0, 0) == 1; }
-        void check_is_needed() { e::atomic::compare_and_swap_32_nobarrier(&m_need_check, 0, 1); }
-        void check_is_not_needed() { e::atomic::compare_and_swap_32_nobarrier(&m_need_check, 1, 0); }
-        void check_stable();
-        void check_stable(const region_id& ri);
+private:
+	// Get the state for the specified key.
+	// Returns NULL if there is no key_state that's currently in use.
+	key_state *get_key_state(const region_id &ri,
+	                         const e::slice &key,
+	                         key_map_t::state_reference *ksr);
+	// Get the state for the specified key.
+	// Will retrieve the state from disk and create the key_state when
+	// necessary.
+	key_state *get_or_create_key_state(const region_id &ri,
+	                                   const e::slice &key,
+	                                   key_map_t::state_reference *ksr);
+	key_state *post_get_key_state_init(region_id ri, key_state *ks);
+	void respond_to_client(const virtual_server_id &us,
+	                       const server_id &client,
+	                       uint64_t nonce,
+	                       network_returncode ret);
+	bool send_message(const virtual_server_id &us,
+	                  const e::slice &key,
+	                  e::intrusive_ptr<key_operation> op);
+	bool send_ack(const virtual_server_id &us,
+	              const e::slice &key,
+	              e::intrusive_ptr<key_operation> op);
+	void retransmit(const std::vector<region_id> &point_leaders,
+	                std::vector<std::pair<region_id, uint64_t> > *versions);
+	void collect(const region_id &ri, e::intrusive_ptr<key_operation> op);
+	void collect(const region_id &ri, uint64_t version);
+	void close_gaps(const std::vector<region_id> &point_leaders,
+	                const identifier_generator &peek_ids,
+	                std::vector<std::pair<region_id, uint64_t> > *versions);
+	// call reset_to_unstable holding m_protect_stable_stuff
+	void reset_to_unstable();
+	bool is_check_needed() { return e::atomic::compare_and_swap_32_nobarrier(&m_need_check, 0, 0) == 1; }
+	void check_is_needed() { e::atomic::compare_and_swap_32_nobarrier(&m_need_check, 0, 1); }
+	void check_is_not_needed() { e::atomic::compare_and_swap_32_nobarrier(&m_need_check, 1, 0); }
+	void check_stable();
+	void check_stable(const region_id &ri);
 
-    private:
-        daemon* m_daemon;
-        key_map_t m_key_states;
-        identifier_generator m_idgen;
-        identifier_collector m_idcol;
-        identifier_generator m_stable;
-        const std::auto_ptr<retransmitter_thread> m_retransmitter;
-        po6::threads::mutex m_protect_stable_stuff;
-        uint64_t m_checkpoint;
-        uint32_t m_need_check;
-        std::vector<region_timestamp> m_timestamps;
-        std::vector<region_id> m_unstable;
+private:
+	daemon *m_daemon;
+	key_map_t m_key_states;
+	identifier_generator m_idgen;
+	identifier_collector m_idcol;
+	identifier_generator m_stable;
+	const std::auto_ptr<retransmitter_thread> m_retransmitter;
+	po6::threads::mutex m_protect_stable_stuff;
+	uint64_t m_checkpoint;
+	uint32_t m_need_check;
+	std::vector<region_timestamp> m_timestamps;
+	std::vector<region_id> m_unstable;
 
-    private:
-        replication_manager(const replication_manager&);
-        replication_manager& operator = (const replication_manager&);
+private:
+	replication_manager(const replication_manager &);
+	replication_manager &operator = (const replication_manager &);
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/daemon/search_manager.cc b/daemon/search_manager.cc
index 79277ecfe..9727c327d 100644
--- a/daemon/search_manager.cc
+++ b/daemon/search_manager.cc
@@ -39,6 +39,7 @@
 
 // e
 #include <e/intrusive_ptr.h>
+#include <e/endian.h>
 
 // HyperDex
 #include "common/attribute_check.h"
@@ -56,26 +57,26 @@ using hyperdex::reconfigure_returncode;
 
 class search_manager::id
 {
-    public:
-        id(const region_id re, const server_id cl, uint64_t sid);
-        ~id() throw ();
-
-    public:
-        bool operator < (const id& rhs) const;
-        bool operator == (const id& rhs) const;
-
-    public:
-        region_id region;
-        server_id client;
-        uint64_t search_id;
+public:
+	id(const region_id re, const server_id cl, uint64_t sid);
+	~id() throw ();
+
+public:
+	bool operator < (const id &rhs) const;
+	bool operator == (const id &rhs) const;
+
+public:
+	region_id region;
+	server_id client;
+	uint64_t search_id;
 };
 
 search_manager :: id :: id(const region_id re,
                            const server_id cl,
                            uint64_t sid)
-    : region(re)
-    , client(cl)
-    , search_id(sid)
+	: region(re)
+	, client(cl)
+	, search_id(sid)
 {
 }
 
@@ -84,68 +85,66 @@ search_manager :: id :: ~id() throw ()
 }
 
 bool
-search_manager :: id :: operator < (const id& rhs) const
+search_manager :: id :: operator < (const id &rhs) const
 {
-    if (region == rhs.region)
-    {
-        if (client == rhs.client)
-        {
-            return search_id < rhs.search_id;
-        }
-
-        return client < rhs.client;
-    }
-
-    return region < rhs.region;
+	if (region == rhs.region)
+	{
+		if (client == rhs.client)
+		{
+			return search_id < rhs.search_id;
+		}
+		return client < rhs.client;
+	}
+	return region < rhs.region;
 }
 
 bool
-search_manager :: id :: operator == (const id& rhs) const
+search_manager :: id :: operator == (const id &rhs) const
 {
-    return region == rhs.region &&
-           client == rhs.client &&
-           search_id == rhs.search_id;
+	return region == rhs.region &&
+	       client == rhs.client &&
+	       search_id == rhs.search_id;
 }
 
 ///////////////////////////// Search Manager State /////////////////////////////
 
 class search_manager::state
 {
-    public:
-        state(const region_id& region,
-              std::auto_ptr<e::buffer> msg,
-              std::vector<attribute_check>* checks);
-        ~state() throw ();
-
-    public:
-        po6::threads::mutex lock;
-        const region_id region;
-        const std::auto_ptr<e::buffer> backing;
-        std::vector<attribute_check> checks;
-        e::intrusive_ptr<datalayer::iterator> iter;
-
-    private:
-        friend class e::intrusive_ptr<state>;
-
-    private:
-        void inc() { __sync_add_and_fetch(&m_ref, 1); }
-        void dec() { if (__sync_sub_and_fetch(&m_ref, 1) == 0) delete this; }
-
-    private:
-        size_t m_ref;
+public:
+	state(const region_id &region,
+	      std::auto_ptr<e::buffer> msg,
+	      std::vector<attribute_check> *checks);
+	~state() throw ();
+
+public:
+	po6::threads::mutex lock;
+	const region_id region;
+	const std::auto_ptr<e::buffer> backing;
+	std::vector<attribute_check> checks;
+	e::intrusive_ptr<datalayer::iterator> iter;
+
+private:
+	friend class e::intrusive_ptr<state>;
+
+private:
+	void inc() { __sync_add_and_fetch(&m_ref, 1); }
+	void dec() { if (__sync_sub_and_fetch(&m_ref, 1) == 0) delete this; }
+
+private:
+	size_t m_ref;
 };
 
-search_manager :: state :: state(const region_id& r,
+search_manager :: state :: state(const region_id &r,
                                  std::auto_ptr<e::buffer> msg,
-                                 std::vector<attribute_check>* c)
-    : lock()
-    , region(r)
-    , backing(msg)
-    , checks()
-    , iter()
-    , m_ref(0)
-{
-    checks.swap(*c);
+                                 std::vector<attribute_check> *c)
+	: lock()
+	, region(r)
+	, backing(msg)
+	, checks()
+	, iter()
+	, m_ref(0)
+{
+	checks.swap(*c);
 }
 
 search_manager :: state :: ~state() throw ()
@@ -154,9 +153,9 @@ search_manager :: state :: ~state() throw ()
 
 //////////////////////////////// Search Manager ////////////////////////////////
 
-search_manager :: search_manager(daemon* d)
-    : m_daemon(d)
-    , m_searches(10)
+search_manager :: search_manager(daemon *d)
+	: m_daemon(d)
+	, m_searches(10)
 {
 }
 
@@ -167,7 +166,7 @@ search_manager :: ~search_manager() throw ()
 bool
 search_manager :: setup()
 {
-    return true;
+	return true;
 }
 
 void
@@ -186,117 +185,108 @@ search_manager :: unpause()
 }
 
 void
-search_manager :: reconfigure(const configuration&,
-                              const configuration&,
-                              const server_id&)
+search_manager :: reconfigure(const configuration &,
+                              const configuration &,
+                              const server_id &)
 {
-    // XXX cleanup dead or old searches
+	// XXX cleanup dead or old searches
 }
 
 void
-search_manager :: start(const server_id& from,
-                        const virtual_server_id& to,
+search_manager :: start(const server_id &from,
+                        const virtual_server_id &to,
                         std::auto_ptr<e::buffer> msg,
                         uint64_t nonce,
                         uint64_t search_id,
-                        std::vector<attribute_check>* checks)
-{
-    region_id ri(m_daemon->m_config.get_region_id(to));
-    const schema* sc = m_daemon->m_config.get_schema(ri);
-
-    if (sc->authorization)
-    {
-        return;
-    }
-
-    id sid(ri, from, search_id);
-
-    if (m_searches.contains(sid))
-    {
-        LOG(WARNING) << "received request for search " << search_id << " from client "
-                     << from << " but the search is already in progress";
-        return;
-    }
-
-    e::intrusive_ptr<state> st = new state(ri, msg, checks);
-    std::stable_sort(st->checks.begin(), st->checks.end());
-    datalayer::returncode rc = datalayer::SUCCESS;
-    datalayer::snapshot snap = m_daemon->m_data.make_snapshot();
-    st->iter = m_daemon->m_data.make_search_iterator(snap, ri, st->checks, NULL);
-
-    switch (rc)
-    {
-        case datalayer::SUCCESS:
-            break;
-        case datalayer::NOT_FOUND:
-        case datalayer::BAD_ENCODING:
-        case datalayer::CORRUPTION:
-        case datalayer::IO_ERROR:
-        case datalayer::LEVELDB_ERROR:
-            LOG(ERROR) << "could not make snapshot for search:  " << rc;
-            return;
-        default:
-            abort();
-    }
-
-    m_searches.insert(sid, st);
-    next(from, to, nonce, search_id);
+                        std::vector<attribute_check> *checks)
+{
+	region_id ri(m_daemon->m_config.get_region_id(to));
+	const schema *sc = m_daemon->m_config.get_schema(ri);
+	if (sc->authorization)
+	{
+		return;
+	}
+	id sid(ri, from, search_id);
+	if (m_searches.contains(sid))
+	{
+		LOG(WARNING) << "received request for search " << search_id << " from client "
+		             << from << " but the search is already in progress";
+		return;
+	}
+	e::intrusive_ptr<state> st = new state(ri, msg, checks);
+	std::stable_sort(st->checks.begin(), st->checks.end());
+	datalayer::returncode rc = datalayer::SUCCESS;
+	datalayer::snapshot snap = m_daemon->m_data.make_snapshot();
+	st->iter = m_daemon->m_data.make_search_iterator(snap, ri, st->checks, NULL);
+	switch (rc)
+	{
+	case datalayer::SUCCESS:
+		break;
+	case datalayer::NOT_FOUND:
+	case datalayer::BAD_ENCODING:
+	case datalayer::CORRUPTION:
+	case datalayer::IO_ERROR:
+	case datalayer::LEVELDB_ERROR:
+		LOG(ERROR) << "could not make snapshot for search:  " << rc;
+		return;
+	default:
+		abort();
+	}
+	m_searches.insert(sid, st);
+	next(from, to, nonce, search_id);
 }
 
 void
-search_manager :: next(const server_id& from,
-                       const virtual_server_id& to,
+search_manager :: next(const server_id &from,
+                       const virtual_server_id &to,
                        uint64_t nonce,
                        uint64_t search_id)
 {
-    region_id ri(m_daemon->m_config.get_region_id(to));
-    const schema& sc(*m_daemon->m_config.get_schema(ri));
-    id sid(ri, from, search_id);
-    e::intrusive_ptr<state> st;
-
-    if (!m_searches.lookup(sid, &st))
-    {
-        std::auto_ptr<e::buffer> msg(e::buffer::create(HYPERDEX_HEADER_SIZE_VC + sizeof(uint64_t)));
-        msg->pack_at(HYPERDEX_HEADER_SIZE_VC) << nonce;
-        m_daemon->m_comm.send_client(to, from, RESP_SEARCH_DONE, msg);
-        return;
-    }
-
-    po6::threads::mutex::hold hold(&st->lock);
-
-    if (st->iter->valid())
-    {
-        e::slice key;
-        std::vector<e::slice> val;
-        uint64_t ver;
-        datalayer::reference tmp;
-        m_daemon->m_data.get_from_iterator(ri, sc, st->iter.get(), &key, &val, &ver, &tmp);
-        size_t sz = HYPERDEX_HEADER_SIZE_VC
-                  + sizeof(uint64_t)
-                  + pack_size(key)
-                  + pack_size(val);
-        std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
-        msg->pack_at(HYPERDEX_HEADER_SIZE_VC) << nonce << key << val;
-        m_daemon->m_comm.send_client(to, from, RESP_SEARCH_ITEM, msg);
-        st->iter->next();
-    }
-    else
-    {
-        std::auto_ptr<e::buffer> msg(e::buffer::create(HYPERDEX_HEADER_SIZE_VC + sizeof(uint64_t)));
-        msg->pack_at(HYPERDEX_HEADER_SIZE_VC) << nonce;
-        m_daemon->m_comm.send_client(to, from, RESP_SEARCH_DONE, msg);
-        stop(from, to, search_id);
-    }
+	region_id ri(m_daemon->m_config.get_region_id(to));
+	const schema &sc(*m_daemon->m_config.get_schema(ri));
+	id sid(ri, from, search_id);
+	e::intrusive_ptr<state> st;
+	if (!m_searches.lookup(sid, &st))
+	{
+		std::auto_ptr<e::buffer> msg(e::buffer::create(HYPERDEX_HEADER_SIZE_VC + sizeof(uint64_t)));
+		msg->pack_at(HYPERDEX_HEADER_SIZE_VC) << nonce;
+		m_daemon->m_comm.send_client(to, from, RESP_SEARCH_DONE, msg);
+		return;
+	}
+	po6::threads::mutex::hold hold(&st->lock);
+	if (st->iter->valid())
+	{
+		e::slice key;
+		std::vector<e::slice> val;
+		uint64_t ver;
+		datalayer::reference tmp;
+		m_daemon->m_data.get_from_iterator(ri, sc, st->iter.get(), &key, &val, &ver, &tmp);
+		size_t sz = HYPERDEX_HEADER_SIZE_VC
+		            + sizeof(uint64_t)
+		            + pack_size(key)
+		            + pack_size(val);
+		std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
+		msg->pack_at(HYPERDEX_HEADER_SIZE_VC) << nonce << key << val;
+		m_daemon->m_comm.send_client(to, from, RESP_SEARCH_ITEM, msg);
+		st->iter->next();
+	}
+	else
+	{
+		std::auto_ptr<e::buffer> msg(e::buffer::create(HYPERDEX_HEADER_SIZE_VC + sizeof(uint64_t)));
+		msg->pack_at(HYPERDEX_HEADER_SIZE_VC) << nonce;
+		m_daemon->m_comm.send_client(to, from, RESP_SEARCH_DONE, msg);
+		stop(from, to, search_id);
+	}
 }
 
 void
-search_manager :: stop(const server_id& from,
-                       const virtual_server_id& to,
+search_manager :: stop(const server_id &from,
+                       const virtual_server_id &to,
                        uint64_t search_id)
 {
-    region_id ri(m_daemon->m_config.get_region_id(to));
-    id sid(ri, from, search_id);
-    m_searches.remove(sid);
+	region_id ri(m_daemon->m_config.get_region_id(to));
+	id sid(ri, from, search_id);
+	m_searches.remove(sid);
 }
 
 namespace hyperdex
@@ -304,395 +294,474 @@ namespace hyperdex
 
 struct _sorted_search_params
 {
-    _sorted_search_params(const schema* _sc,
-                          uint16_t _sort_by,
-                          bool _maximize)
-        : sc(_sc), sort_by(_sort_by), maximize(_maximize) {}
-    ~_sorted_search_params() throw () {}
-    const schema* sc;
-    uint16_t sort_by;
-    bool maximize;
-
-    private:
-        _sorted_search_params(const _sorted_search_params&);
-        _sorted_search_params& operator = (const _sorted_search_params&);
+	_sorted_search_params(const schema *_sc,
+	                      uint16_t _sort_by,
+	                      bool _maximize)
+		: sc(_sc), sort_by(_sort_by), maximize(_maximize) {}
+	~_sorted_search_params() throw () {}
+	const schema *sc;
+	uint16_t sort_by;
+	bool maximize;
+
+private:
+	_sorted_search_params(const _sorted_search_params &);
+	_sorted_search_params &operator = (const _sorted_search_params &);
 };
 
 struct _sorted_search_item
 {
-    _sorted_search_item(_sorted_search_params* p)
-        : params(p), key(), value(), version(), ref() {}
-    _sorted_search_item(const _sorted_search_item& other);
-    ~_sorted_search_item() throw () {}
-    _sorted_search_item& operator = (const _sorted_search_item& other);
-    _sorted_search_params* params;
-    e::slice key;
-    std::vector<e::slice> value;
-    uint64_t version;
-    datalayer::reference ref;
+	_sorted_search_item(_sorted_search_params *p)
+		: params(p), key(), value(), version(), ref() {}
+	_sorted_search_item(_sorted_search_params *p, uint16_t val_sz)
+		: params(p), key_str(), version(), ref()
+	{
+		value.reserve(val_sz);
+		value_str.reserve(val_sz);
+	}
+	_sorted_search_item(const _sorted_search_item &other);
+	~_sorted_search_item() throw () {}
+	_sorted_search_item &operator = (const _sorted_search_item &other);
+	void assign();
+	_sorted_search_params *params;
+	std::string key_str;
+	e::slice key;
+	std::vector<std::string> value_str;
+	std::vector<e::slice> value;
+	uint64_t version;
+	datalayer::reference ref;
 };
 
-_sorted_search_item :: _sorted_search_item(const _sorted_search_item& other)
-    : params(other.params)
-    , key(other.key)
-    , value(other.value)
-    , version(other.version)
-    , ref(other.ref)
+_sorted_search_item :: _sorted_search_item(const _sorted_search_item &other)
+	: params(other.params)
+	, key_str(other.key_str)
+	, key(other.key)
+	, value_str(other.value_str)
+	, value(other.value)
+	, version(other.version)
+	, ref(other.ref)
+{
+}
+
+_sorted_search_item &
+_sorted_search_item :: _sorted_search_item :: operator = (const _sorted_search_item &other)
 {
+	params = other.params;
+	key_str = other.key_str;
+	key = other.key;
+	value_str = other.value_str;
+	value = other.value;
+	version = other.version;
+	ref = other.ref;
+	return *this;
 }
 
-_sorted_search_item&
-_sorted_search_item :: _sorted_search_item :: operator = (const _sorted_search_item& other)
+void
+_sorted_search_item :: assign ()
 {
-    params = other.params;
-    key = other.key;
-    value = other.value;
-    version = other.version;
-    ref = other.ref;
-    return *this;
+	key = e::slice(key_str);
+	value.clear();
+	for (size_t i = 0; i < value_str.size(); i ++)
+	{
+		value.push_back(e::slice(value_str[i]));
+	}
 }
 
 bool
-operator < (const _sorted_search_item& lhs, const _sorted_search_item& rhs)
-{
-    assert(lhs.params == rhs.params);
-    _sorted_search_params* params = lhs.params;
-
-    if (params->sort_by >= params->sc->attrs_sz)
-    {
-        return false;
-    }
-
-    int cmp = 0;
-
-    if (params->sort_by == 0)
-    {
-        datatype_info* di = datatype_info::lookup(params->sc->attrs[0].type);
-        cmp = di->compare(lhs.key, rhs.key);
-    }
-    else
-    {
-        datatype_info* di = datatype_info::lookup(params->sc->attrs[params->sort_by].type);
-        cmp = di->compare(lhs.value[params->sort_by - 1],
-                          rhs.value[params->sort_by - 1]);
-    }
-
-    if (params->maximize)
-    {
-        return cmp < 0;
-    }
-    else
-    {
-        return cmp > 0;
-    }
+operator < (const _sorted_search_item &lhs, const _sorted_search_item &rhs)
+{
+	assert(lhs.params == rhs.params);
+	_sorted_search_params *params = lhs.params;
+	if (params->sort_by >= params->sc->attrs_sz)
+	{
+		return false;
+	}
+	int cmp = 0;
+	if (params->sort_by == 0)
+	{
+		datatype_info *di = datatype_info::lookup(params->sc->attrs[0].type);
+		e::slice lhs_key(lhs.key_str);
+		e::slice rhs_key(rhs.key_str);
+		cmp = di->compare(lhs_key, rhs_key);
+	}
+	else
+	{
+		datatype_info *di = datatype_info::lookup(params->sc->attrs[params->sort_by].type);
+		e::slice lhs_value(lhs.value_str[params->sort_by - 1]);
+		e::slice rhs_value(rhs.value_str[params->sort_by - 1]);
+		cmp = di->compare(lhs_value, rhs_value);
+	}
+	if (params->maximize)
+	{
+		return cmp < 0;
+	}
+	else
+	{
+		return cmp > 0;
+	}
 }
 
 bool
-operator > (const _sorted_search_item& lhs, const _sorted_search_item& rhs)
-{
-    assert(lhs.params == rhs.params);
-    _sorted_search_params* params = lhs.params;
-
-    if (params->sort_by >= params->sc->attrs_sz)
-    {
-        return false;
-    }
-
-    int cmp = 0;
-
-    if (params->sort_by == 0)
-    {
-        datatype_info* di = datatype_info::lookup(params->sc->attrs[0].type);
-        cmp = di->compare(lhs.key, rhs.key);
-    }
-    else
-    {
-        datatype_info* di = datatype_info::lookup(params->sc->attrs[params->sort_by].type);
-        cmp = di->compare(lhs.value[params->sort_by - 1],
-                          rhs.value[params->sort_by - 1]);
-    }
-
-    if (params->maximize)
-    {
-        return cmp > 0;
-    }
-    else
-    {
-        return cmp < 0;
-    }
+operator > (const _sorted_search_item &lhs, const _sorted_search_item &rhs)
+{
+	assert(lhs.params == rhs.params);
+	_sorted_search_params *params = lhs.params;
+	if (params->sort_by >= params->sc->attrs_sz)
+	{
+		return false;
+	}
+	int cmp = 0;
+	if (params->sort_by == 0)
+	{
+		datatype_info *di = datatype_info::lookup(params->sc->attrs[0].type);
+		e::slice lhs_key(lhs.key_str);
+		e::slice rhs_key(rhs.key_str);
+		cmp = di->compare(lhs_key, rhs_key);
+	}
+	else
+	{
+		datatype_info *di = datatype_info::lookup(params->sc->attrs[params->sort_by].type);
+		e::slice lhs_value(lhs.value_str[params->sort_by - 1]);
+		e::slice rhs_value(rhs.value_str[params->sort_by - 1]);
+		cmp = di->compare(lhs_value, rhs_value);
+	}
+	if (params->maximize)
+	{
+		return cmp > 0;
+	}
+	else
+	{
+		return cmp < 0;
+	}
 }
 
 } // namespace hyperdex
 
 void
-search_manager :: sorted_search(const server_id& from,
-                                const virtual_server_id& to,
+search_manager :: sorted_search(const server_id &from,
+                                const virtual_server_id &to,
                                 uint64_t nonce,
-                                std::vector<attribute_check>* checks,
+                                std::vector<attribute_check> *checks,
                                 uint64_t limit,
                                 uint16_t sort_by,
                                 bool maximize)
 {
-    region_id ri(m_daemon->m_config.get_region_id(to));
-    const schema* sc = m_daemon->m_config.get_schema(ri);
-
-    if (sc->authorization)
-    {
-        return;
-    }
-
-    std::stable_sort(checks->begin(), checks->end());
-    datalayer::returncode rc = datalayer::SUCCESS;
-    datalayer::snapshot snap = m_daemon->m_data.make_snapshot();
-    e::intrusive_ptr<datalayer::iterator> iter;
-    iter = m_daemon->m_data.make_search_iterator(snap, ri, *checks, NULL);
-
-    switch (rc)
-    {
-        case datalayer::SUCCESS:
-            break;
-        case datalayer::NOT_FOUND:
-        case datalayer::BAD_ENCODING:
-        case datalayer::CORRUPTION:
-        case datalayer::IO_ERROR:
-        case datalayer::LEVELDB_ERROR:
-            LOG(ERROR) << "could not make snapshot for search:  " << rc;
-            break;
-        default:
-            abort();
-    }
-
-    _sorted_search_params params(sc, sort_by, maximize);
-    std::vector<_sorted_search_item> top_n;
-    top_n.reserve(limit);
-
-    while (iter->valid())
-    {
-        top_n.push_back(_sorted_search_item(&params));
-        m_daemon->m_data.get_from_iterator(ri, *sc, iter.get(), &top_n.back().key, &top_n.back().value, &top_n.back().version, &top_n.back().ref);
-        std::push_heap(top_n.begin(), top_n.end());
-
-        if (top_n.size() > limit)
-        {
-            std::pop_heap(top_n.begin(), top_n.end());
-            top_n.pop_back();
-        }
-
-        iter->next();
-    }
-
-    std::sort(top_n.begin(), top_n.end(), std::greater<_sorted_search_item>());
-    size_t sz = HYPERDEX_HEADER_SIZE_VC + sizeof(uint64_t) + sizeof(uint64_t);
-
-    for (size_t i = 0; i < top_n.size(); ++i)
-    {
-        sz += pack_size(top_n[i].key) + pack_size(top_n[i].value);
-    }
-
-    std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
-    e::packer pa = msg->pack_at(HYPERDEX_HEADER_SIZE_VC);
-    pa = pa << nonce << static_cast<uint64_t>(top_n.size());
-
-    for (size_t i = 0; i < top_n.size(); ++i)
-    {
-        pa = pa << top_n[i].key << top_n[i].value;
-    }
-
-    m_daemon->m_comm.send_client(to, from, RESP_SORTED_SEARCH, msg);
+	region_id ri(m_daemon->m_config.get_region_id(to));
+	const schema *sc = m_daemon->m_config.get_schema(ri);
+	if (sc->authorization)
+	{
+		return;
+	}
+	std::stable_sort(checks->begin(), checks->end());
+	datalayer::returncode rc = datalayer::SUCCESS;
+	datalayer::snapshot snap = m_daemon->m_data.make_snapshot();
+	e::intrusive_ptr<datalayer::iterator> iter;
+	iter = m_daemon->m_data.make_search_iterator(snap, ri, *checks, NULL);
+	switch (rc)
+	{
+	case datalayer::SUCCESS:
+		break;
+	case datalayer::NOT_FOUND:
+	case datalayer::BAD_ENCODING:
+	case datalayer::CORRUPTION:
+	case datalayer::IO_ERROR:
+	case datalayer::LEVELDB_ERROR:
+		LOG(ERROR) << "could not make snapshot for search:  " << rc;
+		break;
+	default:
+		abort();
+	}
+	_sorted_search_params params(sc, sort_by, maximize);
+	std::vector<_sorted_search_item> top_n;
+	top_n.reserve(limit + 1);
+	while (iter->valid())
+	{
+		e::slice key;
+		std::vector<e::slice> val;
+		uint64_t ver;
+		datalayer::reference tmp;
+		m_daemon->m_data.get_from_iterator(ri, *sc, iter.get(), &key, &val, &ver, &tmp);
+		_sorted_search_item ssi(&params, sc->attrs_sz);
+		ssi.key_str = key.str();
+		for (size_t i = 0; i < val.size(); i ++)
+		{
+			ssi.value_str.push_back(val[i].str());
+		}
+		top_n.push_back(ssi);
+		std::push_heap(top_n.begin(), top_n.end());
+		if (top_n.size() > limit)
+		{
+			std::pop_heap(top_n.begin(), top_n.end());
+			top_n.pop_back();
+		}
+		iter->next();
+	}
+	std::sort(top_n.begin(), top_n.end(), std::greater<_sorted_search_item>());
+	size_t sz = HYPERDEX_HEADER_SIZE_VC + sizeof(uint64_t) + sizeof(uint64_t);
+	for (size_t i = 0; i < top_n.size(); ++i)
+	{
+		top_n[i].assign();
+		sz += pack_size(top_n[i].key) + pack_size(top_n[i].value);
+	}
+	std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
+	e::packer pa = msg->pack_at(HYPERDEX_HEADER_SIZE_VC);
+	pa = pa << nonce << static_cast<uint64_t>(top_n.size());
+	for (size_t i = 0; i < top_n.size(); ++i)
+	{
+		pa = pa << top_n[i].key << top_n[i].value;
+	}
+	m_daemon->m_comm.send_client(to, from, RESP_SORTED_SEARCH, msg);
 }
 
 void
-search_manager :: group_keyop(const server_id& from,
-                              const virtual_server_id& to,
+search_manager :: group_keyop(const server_id &from,
+                              const virtual_server_id &to,
                               uint64_t nonce,
-                              std::vector<attribute_check>* checks,
+                              std::vector<attribute_check> *checks,
                               network_msgtype mt,
-                              const e::slice& remain,
+                              const e::slice &remain,
                               network_msgtype resp)
 {
-    region_id ri(m_daemon->m_config.get_region_id(to));
-    const schema* sc = m_daemon->m_config.get_schema(ri);
-
-    if (sc->authorization)
-    {
-        return;
-    }
-
-    std::stable_sort(checks->begin(), checks->end());
-    datalayer::returncode rc = datalayer::SUCCESS;
-    datalayer::snapshot snap = m_daemon->m_data.make_snapshot();
-    e::intrusive_ptr<datalayer::iterator> iter;
-    iter = m_daemon->m_data.make_search_iterator(snap, ri, *checks, NULL);
-    uint64_t result = 0;
-
-    switch (rc)
-    {
-        case datalayer::SUCCESS:
-            break;
-        case datalayer::NOT_FOUND:
-        case datalayer::BAD_ENCODING:
-        case datalayer::CORRUPTION:
-        case datalayer::IO_ERROR:
-        case datalayer::LEVELDB_ERROR:
-            LOG(ERROR) << "could not make snapshot for search:  " << rc;
-            result = UINT64_MAX;
-            break;
-        default:
-            abort();
-    }
-
-    while (iter->valid() && result < UINT64_MAX)
-    {
-        e::slice key;
-        std::vector<e::slice> val;
-        uint64_t ver;
-        datalayer::reference tmp;
-        m_daemon->m_data.get_from_iterator(ri, *sc, iter.get(), &key, &val, &ver, &tmp);
-        size_t sz = HYPERDEX_HEADER_SIZE_SV // SV because we imitate a client
-                  + sizeof(uint64_t)
-                  + pack_size(key)
-                  + remain.size();
-        std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
-        msg->pack_at(HYPERDEX_HEADER_SIZE_SV)
-            << uint64_t(0) << key << e::pack_memmove(remain.data(), remain.size());
-        virtual_server_id vsi = m_daemon->m_config.point_leader(ri, key);
-
-        if (vsi != virtual_server_id())
-        {
-            m_daemon->m_comm.send(vsi, mt, msg);
-            result++;
-        }
-
-        iter->next();
-    }
-
-    size_t sz = HYPERDEX_HEADER_SIZE_VC
-              + sizeof(uint64_t)
-              + sizeof(uint64_t);
-    std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
-    msg->pack_at(HYPERDEX_HEADER_SIZE_VC) << nonce << result;
-    m_daemon->m_comm.send_client(to, from, resp, msg);
+	region_id ri(m_daemon->m_config.get_region_id(to));
+	const schema *sc = m_daemon->m_config.get_schema(ri);
+	if (sc->authorization)
+	{
+		return;
+	}
+	std::stable_sort(checks->begin(), checks->end());
+	datalayer::returncode rc = datalayer::SUCCESS;
+	datalayer::snapshot snap = m_daemon->m_data.make_snapshot();
+	e::intrusive_ptr<datalayer::iterator> iter;
+	iter = m_daemon->m_data.make_search_iterator(snap, ri, *checks, NULL);
+	uint64_t result = 0;
+	switch (rc)
+	{
+	case datalayer::SUCCESS:
+		break;
+	case datalayer::NOT_FOUND:
+	case datalayer::BAD_ENCODING:
+	case datalayer::CORRUPTION:
+	case datalayer::IO_ERROR:
+	case datalayer::LEVELDB_ERROR:
+		LOG(ERROR) << "could not make snapshot for search:  " << rc;
+		result = UINT64_MAX;
+		break;
+	default:
+		abort();
+	}
+	while (iter->valid() && result < UINT64_MAX)
+	{
+		e::slice key;
+		std::vector<e::slice> val;
+		uint64_t ver;
+		datalayer::reference tmp;
+		m_daemon->m_data.get_from_iterator(ri, *sc, iter.get(), &key, &val, &ver, &tmp);
+		size_t sz = HYPERDEX_HEADER_SIZE_SV // SV because we imitate a client
+		            + sizeof(uint64_t)
+		            + pack_size(key)
+		            + remain.size();
+		std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
+		msg->pack_at(HYPERDEX_HEADER_SIZE_SV)
+		        << uint64_t(0) << key << e::pack_memmove(remain.data(), remain.size());
+		virtual_server_id vsi = m_daemon->m_config.point_leader(ri, key);
+		if (vsi != virtual_server_id())
+		{
+			m_daemon->m_comm.send(vsi, mt, msg);
+			result++;
+		}
+		iter->next();
+	}
+	size_t sz = HYPERDEX_HEADER_SIZE_VC
+	            + sizeof(uint64_t)
+	            + sizeof(uint64_t);
+	std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
+	msg->pack_at(HYPERDEX_HEADER_SIZE_VC) << nonce << result;
+	m_daemon->m_comm.send_client(to, from, resp, msg);
 }
 
 void
-search_manager :: count(const server_id& from,
-                        const virtual_server_id& to,
+search_manager :: count(const server_id &from,
+                        const virtual_server_id &to,
                         uint64_t nonce,
-                        std::vector<attribute_check>* checks)
-{
-    region_id ri(m_daemon->m_config.get_region_id(to));
-    const schema* sc = m_daemon->m_config.get_schema(ri);
-
-    if (sc->authorization)
-    {
-        return;
-    }
-
-    std::stable_sort(checks->begin(), checks->end());
-    datalayer::returncode rc = datalayer::SUCCESS;
-    datalayer::snapshot snap = m_daemon->m_data.make_snapshot();
-    e::intrusive_ptr<datalayer::iterator> iter;
-    iter = m_daemon->m_data.make_search_iterator(snap, ri, *checks, NULL);
-    uint64_t result = 0;
-
-    switch (rc)
-    {
-        case datalayer::SUCCESS:
-            break;
-        case datalayer::NOT_FOUND:
-        case datalayer::BAD_ENCODING:
-        case datalayer::CORRUPTION:
-        case datalayer::IO_ERROR:
-        case datalayer::LEVELDB_ERROR:
-            LOG(ERROR) << "could not make snapshot for search:  " << rc;
-            result = UINT64_MAX;
-            break;
-        default:
-            abort();
-    }
-
-    while (iter->valid() && result < UINT64_MAX)
-    {
-        ++result;
-        iter->next();
-    }
-
-    size_t sz = HYPERDEX_HEADER_SIZE_VC
-              + sizeof(uint64_t)
-              + sizeof(uint64_t);
-    std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
-    msg->pack_at(HYPERDEX_HEADER_SIZE_VC) << nonce << result;
-    m_daemon->m_comm.send_client(to, from, RESP_COUNT, msg);
+                        std::vector<attribute_check> *checks)
+{
+	region_id ri(m_daemon->m_config.get_region_id(to));
+	const schema *sc = m_daemon->m_config.get_schema(ri);
+	if (sc->authorization)
+	{
+		return;
+	}
+	std::stable_sort(checks->begin(), checks->end());
+	datalayer::returncode rc = datalayer::SUCCESS;
+	datalayer::snapshot snap = m_daemon->m_data.make_snapshot();
+	e::intrusive_ptr<datalayer::iterator> iter;
+	iter = m_daemon->m_data.make_search_iterator(snap, ri, *checks, NULL);
+	uint64_t result = 0;
+	switch (rc)
+	{
+	case datalayer::SUCCESS:
+		break;
+	case datalayer::NOT_FOUND:
+	case datalayer::BAD_ENCODING:
+	case datalayer::CORRUPTION:
+	case datalayer::IO_ERROR:
+	case datalayer::LEVELDB_ERROR:
+		LOG(ERROR) << "could not make snapshot for search:  " << rc;
+		result = UINT64_MAX;
+		break;
+	default:
+		abort();
+	}
+	while (iter->valid() && result < UINT64_MAX)
+	{
+		++result;
+		iter->next();
+	}
+	size_t sz = HYPERDEX_HEADER_SIZE_VC
+	            + sizeof(uint64_t)
+	            + sizeof(uint64_t);
+	std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
+	msg->pack_at(HYPERDEX_HEADER_SIZE_VC) << nonce << result;
+	m_daemon->m_comm.send_client(to, from, RESP_COUNT, msg);
 }
 
 void
-search_manager :: search_describe(const server_id& from,
-                                  const virtual_server_id& to,
+search_manager :: sum(const server_id &from,
+                      const virtual_server_id &to,
+                      uint64_t nonce,
+                      std::vector<attribute_check> *checks,
+                      uint16_t sum_idx)
+{
+	region_id ri(m_daemon->m_config.get_region_id(to));
+	const schema *sc = m_daemon->m_config.get_schema(ri);
+	if (sc->authorization)
+	{
+		return;
+	}
+	std::stable_sort(checks->begin(), checks->end());
+	datalayer::returncode rc = datalayer::SUCCESS;
+	datalayer::snapshot snap = m_daemon->m_data.make_snapshot();
+	e::intrusive_ptr<datalayer::iterator> iter;
+	iter = m_daemon->m_data.make_search_iterator(snap, ri, *checks, NULL);
+	uint64_t result = 0;
+	switch (rc)
+	{
+	case datalayer::SUCCESS:
+		break;
+	case datalayer::NOT_FOUND:
+	case datalayer::BAD_ENCODING:
+	case datalayer::CORRUPTION:
+	case datalayer::IO_ERROR:
+	case datalayer::LEVELDB_ERROR:
+		LOG(ERROR) << "could not make snapshot for search:  " << rc;
+		result = UINT64_MAX;
+		break;
+	default:
+		abort();
+	}
+	while (iter->valid() && result < UINT64_MAX)
+	{
+		e::slice key;
+		std::vector<e::slice> val;
+		uint64_t ver;
+		datalayer::reference tmp;
+		m_daemon->m_data.get_from_iterator(ri, *sc, iter.get(), &key, &val, &ver, &tmp);
+		if (val.size() < sum_idx)
+		{
+			LOG(ERROR) << "occur some error for sum:  " << val.size();
+		}
+		switch (sc->attrs[sum_idx].type)
+		{
+		case HYPERDATATYPE_INT64:
+		{
+			uint64_t num = 0;
+			e::unpack64le(val[sum_idx - 1].cdata(), &num);
+			result += num;
+		}
+		break;
+		case HYPERDATATYPE_FLOAT:
+		{
+			double num = 0;
+			e::unpackdoublele(val[sum_idx - 1].cdata(), &num);
+			result += (uint64_t)num;
+		}
+		break;
+		case HYPERDATATYPE_STRING:
+		default:
+			LOG(ERROR) << "could not sum item because of not int and double(" << sc->attrs[sum_idx].type << ")";
+		}
+		iter->next();
+	}
+	//LOG(INFO) << "result(" << result << ")";
+	size_t sz = HYPERDEX_HEADER_SIZE_VC
+	            + sizeof(uint64_t)
+	            + sizeof(uint64_t);
+	std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
+	msg->pack_at(HYPERDEX_HEADER_SIZE_VC) << nonce << result;
+	m_daemon->m_comm.send_client(to, from, RESP_SUM, msg);
+}
+
+void
+search_manager :: search_describe(const server_id &from,
+                                  const virtual_server_id &to,
                                   uint64_t nonce,
-                                  std::vector<attribute_check>* checks)
-{
-    region_id ri(m_daemon->m_config.get_region_id(to));
-    const schema* sc = m_daemon->m_config.get_schema(ri);
-
-    if (sc->authorization)
-    {
-        return;
-    }
-
-    std::stable_sort(checks->begin(), checks->end());
-    datalayer::returncode rc = datalayer::SUCCESS;
-    std::ostringstream ostr;
-    ostr << "search\n";
-    uint64_t t_start = po6::monotonic_time();
-    datalayer::snapshot snap = m_daemon->m_data.make_snapshot();
-    uint64_t t_end = po6::monotonic_time();
-    ostr << " snapshot took " << t_end - t_start << "ns\n";
-    e::intrusive_ptr<datalayer::iterator> iter;
-    t_start = po6::monotonic_time();
-    iter = m_daemon->m_data.make_search_iterator(snap, ri, *checks, &ostr);
-    t_end = po6::monotonic_time();
-    ostr << " iterator took " << t_end - t_start << "ns\n";
-
-    switch (rc)
-    {
-        case datalayer::SUCCESS:
-            break;
-        case datalayer::NOT_FOUND:
-        case datalayer::BAD_ENCODING:
-        case datalayer::CORRUPTION:
-        case datalayer::IO_ERROR:
-        case datalayer::LEVELDB_ERROR:
-            LOG(ERROR) << "could not make snapshot for search:  " << rc;
-            break;
-        default:
-            abort();
-    }
-
-    uint64_t num = 0;
-    t_start = po6::monotonic_time();
-
-    while (iter->valid())
-    {
-        ++num;
-        iter->next();
-    }
-
-    t_end = po6::monotonic_time();
-    ostr << " retrieved " << num << " objects in " << t_end - t_start << "ns\n";
-    std::string str(ostr.str());
-    const char* text = str.c_str();
-    size_t text_sz = strlen(text);
-    size_t sz = HYPERDEX_HEADER_SIZE_VC
-              + sizeof(uint64_t)
-              + text_sz;
-    std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
-    msg->pack_at(HYPERDEX_HEADER_SIZE_VC)
-        << nonce << e::pack_memmove(text, text_sz);
-    m_daemon->m_comm.send_client(to, from, RESP_SEARCH_DESCRIBE, msg);
+                                  std::vector<attribute_check> *checks)
+{
+	region_id ri(m_daemon->m_config.get_region_id(to));
+	const schema *sc = m_daemon->m_config.get_schema(ri);
+	if (sc->authorization)
+	{
+		return;
+	}
+	std::stable_sort(checks->begin(), checks->end());
+	datalayer::returncode rc = datalayer::SUCCESS;
+	std::ostringstream ostr;
+	ostr << "search\n";
+	uint64_t t_start = po6::monotonic_time();
+	datalayer::snapshot snap = m_daemon->m_data.make_snapshot();
+	uint64_t t_end = po6::monotonic_time();
+	ostr << " snapshot took " << t_end - t_start << "ns\n";
+	e::intrusive_ptr<datalayer::iterator> iter;
+	t_start = po6::monotonic_time();
+	iter = m_daemon->m_data.make_search_iterator(snap, ri, *checks, &ostr);
+	t_end = po6::monotonic_time();
+	ostr << " iterator took " << t_end - t_start << "ns\n";
+	switch (rc)
+	{
+	case datalayer::SUCCESS:
+		break;
+	case datalayer::NOT_FOUND:
+	case datalayer::BAD_ENCODING:
+	case datalayer::CORRUPTION:
+	case datalayer::IO_ERROR:
+	case datalayer::LEVELDB_ERROR:
+		LOG(ERROR) << "could not make snapshot for search:  " << rc;
+		break;
+	default:
+		abort();
+	}
+	uint64_t num = 0;
+	t_start = po6::monotonic_time();
+	while (iter->valid())
+	{
+		++num;
+		iter->next();
+	}
+	t_end = po6::monotonic_time();
+	ostr << " retrieved " << num << " objects in " << t_end - t_start << "ns\n";
+	std::string str(ostr.str());
+	const char *text = str.c_str();
+	size_t text_sz = strlen(text);
+	size_t sz = HYPERDEX_HEADER_SIZE_VC
+	            + sizeof(uint64_t)
+	            + text_sz;
+	std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
+	msg->pack_at(HYPERDEX_HEADER_SIZE_VC)
+	        << nonce << e::pack_memmove(text, text_sz);
+	m_daemon->m_comm.send_client(to, from, RESP_SEARCH_DESCRIBE, msg);
 }
 
 uint64_t
-search_manager :: hash(const id& sid)
+search_manager :: hash(const id &sid)
 {
-    return sid.region.get() + sid.client.get() + sid.search_id;
+	return sid.region.get() + sid.client.get() + sid.search_id;
 }
diff --git a/daemon/search_manager.h b/daemon/search_manager.h
index 28e42a0dc..1eefa4074 100644
--- a/daemon/search_manager.h
+++ b/daemon/search_manager.h
@@ -44,77 +44,82 @@ class daemon;
 
 class search_manager
 {
-    public:
-        search_manager(daemon*);
-        ~search_manager() throw ();
-
-    public:
-        bool setup();
-        void teardown();
-        void pause();
-        void unpause();
-        void reconfigure(const configuration& old_config,
-                         const configuration& new_config,
-                         const server_id& us);
-
-    public:
-        void start(const server_id& from,
-                   const virtual_server_id& to,
-                   std::auto_ptr<e::buffer> msg,
-                   uint64_t nonce,
-                   uint64_t search_id,
-                   std::vector<attribute_check>* checks);
-        void next(const server_id& from,
-                  const virtual_server_id& to,
-                  uint64_t nonce,
-                  uint64_t search_id);
-        void stop(const server_id& from,
-                  const virtual_server_id& to,
-                  uint64_t search_id);
-        void sorted_search(const server_id& from,
-                           const virtual_server_id& to,
-                           uint64_t nonce,
-                           std::vector<attribute_check>* checks,
-                           uint64_t limit,
-                           uint16_t sort_by,
-                           bool maximize);
-
-        // Find keys that match the check and forward ops to the corresponding servers
-        // Essentially this splits out the group operation in several seperate operations
-        // (by acting like it was a client)
-        void group_keyop(const server_id& from,
-                         const virtual_server_id& to,
-                         uint64_t nonce,
-                         std::vector<attribute_check>* checks,
-                         network_msgtype mt,
-                         const e::slice& remain,
-                         network_msgtype resp);
-
-        // Calculate the amount of entries that match the checks
-        void count(const server_id& from,
-                   const virtual_server_id& to,
-                   uint64_t nonce,
-                   std::vector<attribute_check>* checks);
-
-        void search_describe(const server_id& from,
-                             const virtual_server_id& to,
-                             uint64_t nonce,
-                             std::vector<attribute_check>* checks);
-
-    private:
-        class id;
-        class state;
-
-    private:
-        search_manager(const search_manager&);
-        search_manager& operator = (const search_manager&);
-
-    private:
-        static uint64_t hash(const id&);
-
-    private:
-        daemon* m_daemon;
-        e::lockfree_hash_map<id, e::intrusive_ptr<state>, hash> m_searches;
+public:
+	search_manager(daemon *);
+	~search_manager() throw ();
+
+public:
+	bool setup();
+	void teardown();
+	void pause();
+	void unpause();
+	void reconfigure(const configuration &old_config,
+	                 const configuration &new_config,
+	                 const server_id &us);
+
+public:
+	void start(const server_id &from,
+	           const virtual_server_id &to,
+	           std::auto_ptr<e::buffer> msg,
+	           uint64_t nonce,
+	           uint64_t search_id,
+	           std::vector<attribute_check> *checks);
+	void next(const server_id &from,
+	          const virtual_server_id &to,
+	          uint64_t nonce,
+	          uint64_t search_id);
+	void stop(const server_id &from,
+	          const virtual_server_id &to,
+	          uint64_t search_id);
+	void sorted_search(const server_id &from,
+	                   const virtual_server_id &to,
+	                   uint64_t nonce,
+	                   std::vector<attribute_check> *checks,
+	                   uint64_t limit,
+	                   uint16_t sort_by,
+	                   bool maximize);
+
+	// Find keys that match the check and forward ops to the corresponding servers
+	// Essentially this splits out the group operation in several seperate operations
+	// (by acting like it was a client)
+	void group_keyop(const server_id &from,
+	                 const virtual_server_id &to,
+	                 uint64_t nonce,
+	                 std::vector<attribute_check> *checks,
+	                 network_msgtype mt,
+	                 const e::slice &remain,
+	                 network_msgtype resp);
+
+	// Calculate the amount of entries that match the checks
+	void count(const server_id &from,
+	           const virtual_server_id &to,
+	           uint64_t nonce,
+	           std::vector<attribute_check> *checks);
+	void sum(const server_id &from,
+	         const virtual_server_id &to,
+	         uint64_t nonce,
+	         std::vector<attribute_check> *checks,
+	         uint16_t sum_idx);
+
+	void search_describe(const server_id &from,
+	                     const virtual_server_id &to,
+	                     uint64_t nonce,
+	                     std::vector<attribute_check> *checks);
+
+private:
+	class id;
+	class state;
+
+private:
+	search_manager(const search_manager &);
+	search_manager &operator = (const search_manager &);
+
+private:
+	static uint64_t hash(const id &);
+
+private:
+	daemon *m_daemon;
+	e::lockfree_hash_map<id, e::intrusive_ptr<state>, hash> m_searches;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/daemon/state_hash_table.h b/daemon/state_hash_table.h
index fc0055a8f..0065d933b 100644
--- a/daemon/state_hash_table.h
+++ b/daemon/state_hash_table.h
@@ -53,378 +53,354 @@ BEGIN_HYPERDEX_NAMESPACE
 
 template <typename T>
 uint64_t
-default_state_hash(const T& t)
+default_state_hash(const T &t)
 {
-    e::compat::hash<T> h;
-    return h(t);
+	e::compat::hash<T> h;
+	return h(t);
 }
 
-template <typename K, typename T, uint64_t (*H)(const K& k) = default_state_hash>
+template <typename K, typename T, uint64_t (*H)(const K &k) = default_state_hash>
 class state_hash_table
 {
-    public:
-        class state_reference;
-        class iterator;
-
-    public:
-        state_hash_table(e::garbage_collector* gc);
-        ~state_hash_table() throw ();
-
-    public:
-        T* create_state(const K& key, state_reference* sr);
-        T* get_state(const K& key, state_reference* sr);
-        T* get_or_create_state(const K& key, state_reference* sr);
-
-    private:
-        class state;
-        typedef typename e::nwf_hash_map<K, e::intrusive_ptr<state>, H> state_map_t;
-        state_map_t m_table;
+public:
+	class state_reference;
+	class iterator;
+
+public:
+	state_hash_table(e::garbage_collector *gc);
+	~state_hash_table() throw ();
+
+public:
+	T *create_state(const K &key, state_reference *sr);
+	T *get_state(const K &key, state_reference *sr);
+	T *get_or_create_state(const K &key, state_reference *sr);
+
+private:
+	class state;
+	typedef typename e::nwf_hash_map<K, e::intrusive_ptr<state>, H> state_map_t;
+	state_map_t m_table;
 };
 
-template <typename K, typename T, uint64_t (*H)(const K& k)>
+template <typename K, typename T, uint64_t (*H)(const K &k)>
 class state_hash_table<K, T, H>::state_reference
 {
-    public:
-        state_reference();
-        ~state_reference() throw ();
-
-    public:
-        void release();
-        T* get();
-
-    private:
-        friend class state_hash_table;
-        void acquire(state_hash_table* sht, e::intrusive_ptr<state> s);
-        void unlock(); // still acquired, but state unlocked
-
-    private:
-        state_hash_table* m_sht;
-        e::intrusive_ptr<state> m_state;
-        bool m_locked;
-
-    private:
-        state_reference(state_reference&);
-        state_reference& operator = (state_reference&);
+public:
+	state_reference();
+	~state_reference() throw ();
+
+public:
+	void release();
+	T *get();
+
+private:
+	friend class state_hash_table;
+	void acquire(state_hash_table *sht, e::intrusive_ptr<state> s);
+	void unlock(); // still acquired, but state unlocked
+
+private:
+	state_hash_table *m_sht;
+	e::intrusive_ptr<state> m_state;
+	bool m_locked;
+
+private:
+	state_reference(state_reference &);
+	state_reference &operator = (state_reference &);
 };
 
-template <typename K, typename T, uint64_t (*H)(const K& k)>
+template <typename K, typename T, uint64_t (*H)(const K &k)>
 class state_hash_table<K, T, H>::iterator
 {
-    public:
-        iterator(state_hash_table* sht);
-        ~iterator() throw ();
-
-    public:
-        bool valid();
-        T* operator * ();
-        T* operator -> ();
-        iterator& operator ++ ();
-
-    private:
-        void prime();
-
-    private:
-        state_hash_table* m_sht;
-        typename state_map_t::iterator m_iter;
-        state_reference m_sr;
-        bool m_primed;
-
-    private:
-        iterator(iterator&);
-        iterator& operator = (iterator&);
+public:
+	iterator(state_hash_table *sht);
+	~iterator() throw ();
+
+public:
+	bool valid();
+	T *operator * ();
+	T *operator -> ();
+	iterator &operator ++ ();
+
+private:
+	void prime();
+
+private:
+	state_hash_table *m_sht;
+	typename state_map_t::iterator m_iter;
+	state_reference m_sr;
+	bool m_primed;
+
+private:
+	iterator(iterator &);
+	iterator &operator = (iterator &);
 };
 
-template <typename K, typename T, uint64_t (*H)(const K& k)>
+template <typename K, typename T, uint64_t (*H)(const K &k)>
 class state_hash_table<K, T, H>::state
 {
-    public:
-        state(const K& k);
-        ~state() throw ();
-
-    public:
-        T t;
-        po6::threads::mutex mtx;
-        uint64_t acquires;
-        bool garbage;
-
-    public:
-        size_t ref;
-        void inc() { __sync_add_and_fetch(&ref, 1); }
-        void dec() { if (__sync_sub_and_fetch(&ref, 1) == 0) delete this; }
+public:
+	state(const K &k);
+	~state() throw ();
+
+public:
+	T t;
+	po6::threads::mutex mtx;
+	uint64_t acquires;
+	bool garbage;
+
+public:
+	size_t ref;
+	void inc() { __sync_add_and_fetch(&ref, 1); }
+	void dec() { if (__sync_sub_and_fetch(&ref, 1) == 0) delete this; }
 };
 
-template <typename K, typename T, uint64_t (*H)(const K& k)>
-state_hash_table<K, T, H> :: state_hash_table(e::garbage_collector* gc)
-    : m_table(gc)
+template <typename K, typename T, uint64_t (*H)(const K &k)>
+state_hash_table<K, T, H> :: state_hash_table(e::garbage_collector *gc)
+	: m_table(gc)
 {
 }
 
-template <typename K, typename T, uint64_t (*H)(const K& k)>
+template <typename K, typename T, uint64_t (*H)(const K &k)>
 state_hash_table<K, T, H> :: ~state_hash_table() throw ()
 {
 }
 
-template <typename K, typename T, uint64_t (*H)(const K& k)>
-T*
-state_hash_table<K, T, H> :: create_state(const K& key, state_reference* sr)
+template <typename K, typename T, uint64_t (*H)(const K &k)>
+T *
+state_hash_table<K, T, H> :: create_state(const K &key, state_reference *sr)
 {
-    sr->release();
-
-    e::intrusive_ptr<state> s = new state(key);
-    sr->acquire(this, s);
-
-    if (m_table.put_ine(key, s))
-    {
-        sr->unlock();
-        return sr->get();
-    }
-
-    sr->release();
-    return NULL;
+	sr->release();
+	e::intrusive_ptr<state> s = new state(key);
+	sr->acquire(this, s);
+	if (m_table.put_ine(key, s))
+	{
+		sr->unlock();
+		return sr->get();
+	}
+	sr->release();
+	return NULL;
 }
 
-template <typename K, typename T, uint64_t (*H)(const K& k)>
-T*
-state_hash_table<K, T, H> :: get_state(const K& key, state_reference* sr)
+template <typename K, typename T, uint64_t (*H)(const K &k)>
+T *
+state_hash_table<K, T, H> :: get_state(const K &key, state_reference *sr)
 {
-    sr->release();
-
-    while (true)
-    {
-        e::intrusive_ptr<state> s;
-
-        if (!m_table.get(key, &s))
-        {
-            return NULL;
-        }
-
-        sr->acquire(this, s);
-
-        if (s->garbage)
-        {
-            sr->release();
-            continue;
-        }
-
-        sr->unlock();
-        return sr->get();
-    }
+	sr->release();
+	while (true)
+	{
+		e::intrusive_ptr<state> s;
+		if (!m_table.get(key, &s))
+		{
+			return NULL;
+		}
+		sr->acquire(this, s);
+		if (s->garbage)
+		{
+			sr->release();
+			continue;
+		}
+		sr->unlock();
+		return sr->get();
+	}
 }
 
-template <typename K, typename T, uint64_t (*H)(const K& k)>
-T*
-state_hash_table<K, T, H> :: get_or_create_state(const K& key, state_reference* sr)
+template <typename K, typename T, uint64_t (*H)(const K &k)>
+T *
+state_hash_table<K, T, H> :: get_or_create_state(const K &key, state_reference *sr)
 {
-    sr->release();
-
-    while (true)
-    {
-        e::intrusive_ptr<state> s;
-
-        if (m_table.get(key, &s))
-        {
-            sr->acquire(this, s);
-        }
-        else
-        {
-            assert(!s);
-            s = new state(key);
-            sr->acquire(this, s);
-
-            if (!m_table.put_ine(key, s))
-            {
-                sr->release();
-                continue;
-            }
-        }
-
-        assert(s);
-
-        if (s->garbage)
-        {
-            sr->release();
-            continue;
-        }
-
-        sr->unlock();
-        return sr->get();
-    }
+	sr->release();
+	while (true)
+	{
+		e::intrusive_ptr<state> s;
+		if (m_table.get(key, &s))
+		{
+			sr->acquire(this, s);
+		}
+		else
+		{
+			assert(!s);
+			s = new state(key);
+			sr->acquire(this, s);
+			if (!m_table.put_ine(key, s))
+			{
+				sr->release();
+				continue;
+			}
+		}
+		assert(s);
+		if (s->garbage)
+		{
+			sr->release();
+			continue;
+		}
+		sr->unlock();
+		return sr->get();
+	}
 }
 
-template <typename K, typename T, uint64_t (*H)(const K& k)>
+template <typename K, typename T, uint64_t (*H)(const K &k)>
 state_hash_table<K, T, H> :: state_reference :: state_reference()
-    : m_sht(NULL)
-    , m_state()
-    , m_locked(false)
+	: m_sht(NULL)
+	, m_state()
+	, m_locked(false)
 {
 }
 
-template <typename K, typename T, uint64_t (*H)(const K& k)>
+template <typename K, typename T, uint64_t (*H)(const K &k)>
 state_hash_table<K, T, H> :: state_reference :: ~state_reference() throw ()
 {
-    release();
+	release();
 }
 
-template <typename K, typename T, uint64_t (*H)(const K& k)>
+template <typename K, typename T, uint64_t (*H)(const K &k)>
 void
 state_hash_table<K, T, H> :: state_reference :: release()
 {
-    if (!m_sht || !m_state)
-    {
-        assert(!m_sht);
-        assert(!m_state);
-        assert(!m_locked);
-        return;
-    }
-
-    assert(m_sht);
-    assert(m_state);
-
-    if (!m_locked)
-    {
-        m_state->mtx.lock();
-        m_locked = true;
-    }
-
-    assert(m_state->acquires > 0);
-    --m_state->acquires;
-
-    if (m_state->acquires == 0 &&
-        !m_state->garbage &&
-        m_state->t.finished())
-    {
-        m_state->garbage = true;
-        m_sht->m_table.del_if(m_state->t.state_key(), m_state);
-    }
-
-    m_state->mtx.unlock();
-    m_sht = NULL;
-    m_state = NULL;
-    m_locked = false;
+	if (!m_sht || !m_state)
+	{
+		assert(!m_sht);
+		assert(!m_state);
+		assert(!m_locked);
+		return;
+	}
+	assert(m_sht);
+	assert(m_state);
+	if (!m_locked)
+	{
+		m_state->mtx.lock();
+		m_locked = true;
+	}
+	assert(m_state->acquires > 0);
+	--m_state->acquires;
+	if (m_state->acquires == 0 &&
+	    !m_state->garbage &&
+	    m_state->t.finished())
+	{
+		m_state->garbage = true;
+		m_sht->m_table.del_if(m_state->t.state_key(), m_state);
+	}
+	m_state->mtx.unlock();
+	m_sht = NULL;
+	m_state = NULL;
+	m_locked = false;
 }
 
-template <typename K, typename T, uint64_t (*H)(const K& k)>
-T*
+template <typename K, typename T, uint64_t (*H)(const K &k)>
+T *
 state_hash_table<K, T, H> :: state_reference :: get()
 {
-    return &m_state->t;
+	return &m_state->t;
 }
 
-template <typename K, typename T, uint64_t (*H)(const K& k)>
+template <typename K, typename T, uint64_t (*H)(const K &k)>
 void
-state_hash_table<K, T, H> :: state_reference :: acquire(state_hash_table* sht, e::intrusive_ptr<state> s)
+state_hash_table<K, T, H> :: state_reference :: acquire(state_hash_table *sht, e::intrusive_ptr<state> s)
 {
-    if (m_sht || m_state || m_locked)
-    {
-        release();
-    }
-
-    m_sht = sht;
-    m_state = s;
-    m_state->mtx.lock();
-    m_locked = true;
-    ++m_state->acquires;
+	if (m_sht || m_state || m_locked)
+	{
+		release();
+	}
+	m_sht = sht;
+	m_state = s;
+	m_state->mtx.lock();
+	m_locked = true;
+	++m_state->acquires;
 }
 
-template <typename K, typename T, uint64_t (*H)(const K& k)>
+template <typename K, typename T, uint64_t (*H)(const K &k)>
 void
 state_hash_table<K, T, H> :: state_reference :: unlock()
 {
-    if (m_locked)
-    {
-        m_locked = false;
-        m_state->mtx.unlock();
-    }
+	if (m_locked)
+	{
+		m_locked = false;
+		m_state->mtx.unlock();
+	}
 }
 
-template <typename K, typename T, uint64_t (*H)(const K& k)>
-state_hash_table<K, T, H> :: iterator :: iterator(state_hash_table* sht)
-    : m_sht(sht)
-    , m_iter(m_sht->m_table.begin())
-    , m_sr()
-    , m_primed(false)
+template <typename K, typename T, uint64_t (*H)(const K &k)>
+state_hash_table<K, T, H> :: iterator :: iterator(state_hash_table *sht)
+	: m_sht(sht)
+	, m_iter(m_sht->m_table.begin())
+	, m_sr()
+	, m_primed(false)
 {
-    prime();
+	prime();
 }
 
-template <typename K, typename T, uint64_t (*H)(const K& k)>
+template <typename K, typename T, uint64_t (*H)(const K &k)>
 state_hash_table<K, T, H> :: iterator :: ~iterator() throw ()
 {
 }
 
-template <typename K, typename T, uint64_t (*H)(const K& k)>
+template <typename K, typename T, uint64_t (*H)(const K &k)>
 bool
 state_hash_table<K, T, H> :: iterator :: valid()
 {
-    prime();
-    return m_iter != m_sht->m_table.end();
+	prime();
+	return m_iter != m_sht->m_table.end();
 }
 
-template <typename K, typename T, uint64_t (*H)(const K& k)>
-T*
+template <typename K, typename T, uint64_t (*H)(const K &k)>
+T *
 state_hash_table<K, T, H> :: iterator :: operator * ()
 {
-    assert(valid());
-    return m_sr.get();
+	assert(valid());
+	return m_sr.get();
 }
 
-template <typename K, typename T, uint64_t (*H)(const K& k)>
-T*
+template <typename K, typename T, uint64_t (*H)(const K &k)>
+T *
 state_hash_table<K, T, H> :: iterator :: operator -> ()
 {
-    assert(valid());
-    return m_sr.get();
+	assert(valid());
+	return m_sr.get();
 }
 
-template <typename K, typename T, uint64_t (*H)(const K& k)>
-typename state_hash_table<K, T, H>::iterator&
+template <typename K, typename T, uint64_t (*H)(const K &k)>
+typename state_hash_table<K, T, H>::iterator &
 state_hash_table<K, T, H> :: iterator :: operator ++ ()
 {
-    m_primed = false;
-    ++m_iter;
-    prime();
-    return *this;
+	m_primed = false;
+	++m_iter;
+	prime();
+	return *this;
 }
 
-template <typename K, typename T, uint64_t (*H)(const K& k)>
+template <typename K, typename T, uint64_t (*H)(const K &k)>
 void
 state_hash_table<K, T, H> :: iterator :: prime()
 {
-    if (m_primed)
-    {
-        return;
-    }
-
-    while (true)
-    {
-        m_sr.release();
-
-        if (m_iter == m_sht->m_table.end() ||
-            m_sht->get_state(m_iter->first, &m_sr))
-        {
-            break;
-        }
-
-        ++m_iter;
-    }
-
-    m_primed = true;
+	if (m_primed)
+	{
+		return;
+	}
+	while (true)
+	{
+		m_sr.release();
+		if (m_iter == m_sht->m_table.end() ||
+		    m_sht->get_state(m_iter->first, &m_sr))
+		{
+			break;
+		}
+		++m_iter;
+	}
+	m_primed = true;
 }
 
-template <typename K, typename T, uint64_t (*H)(const K& k)>
-state_hash_table<K, T, H> :: state :: state(const K& k)
-    : t(k)
-    , mtx()
-    , acquires(0)
-    , garbage(false)
-    , ref(0)
+template <typename K, typename T, uint64_t (*H)(const K &k)>
+state_hash_table<K, T, H> :: state :: state(const K &k)
+	: t(k)
+	, mtx()
+	, acquires(0)
+	, garbage(false)
+	, ref(0)
 {
 }
 
-template <typename K, typename T, uint64_t (*H)(const K& k)>
+template <typename K, typename T, uint64_t (*H)(const K &k)>
 state_hash_table<K, T, H> :: state :: ~state() throw ()
 {
-    assert(acquires == 0);
+	assert(acquires == 0);
 }
 
 END_HYPERDEX_NAMESPACE
diff --git a/daemon/state_transfer_manager.cc b/daemon/state_transfer_manager.cc
index 3be2dfdb7..7b1930285 100644
--- a/daemon/state_transfer_manager.cc
+++ b/daemon/state_transfer_manager.cc
@@ -52,658 +52,594 @@ using hyperdex::transfer_id;
 
 class state_transfer_manager::background_thread : public ::hyperdex::background_thread
 {
-    public:
-        background_thread(state_transfer_manager* stm);
-        ~background_thread() throw ();
-
-    public:
-        virtual const char* thread_name();
-        virtual bool have_work();
-        virtual void copy_work();
-        virtual void do_work();
-
-    public:
-        void kick();
-
-    private:
-        background_thread(const background_thread&);
-        background_thread& operator = (const background_thread&);
-
-    private:
-        state_transfer_manager* m_stm;
-        bool m_need_kickstart;
+public:
+	background_thread(state_transfer_manager *stm);
+	~background_thread() throw ();
+
+public:
+	virtual const char *thread_name();
+	virtual bool have_work();
+	virtual void copy_work();
+	virtual void do_work();
+
+public:
+	void kick();
+
+private:
+	background_thread(const background_thread &);
+	background_thread &operator = (const background_thread &);
+
+private:
+	state_transfer_manager *m_stm;
+	bool m_need_kickstart;
 };
 
-state_transfer_manager :: state_transfer_manager(daemon* d)
-    : m_daemon(d)
-    , m_transfers_in()
-    , m_transfers_out()
-    , m_background_thread(new background_thread(this))
+state_transfer_manager :: state_transfer_manager(daemon *d)
+	: m_daemon(d)
+	, m_transfers_in()
+	, m_transfers_out()
+	, m_background_thread(new background_thread(this))
 {
 }
 
 state_transfer_manager :: ~state_transfer_manager() throw ()
 {
-    m_background_thread->shutdown();
+	m_background_thread->shutdown();
 }
 
 bool
 state_transfer_manager :: setup()
 {
-    m_background_thread->start();
-    return true;
+	m_background_thread->start();
+	return true;
 }
 
 void
 state_transfer_manager :: teardown()
 {
-    m_background_thread->shutdown();
-    m_transfers_in.clear();
-    m_transfers_out.clear();
+	m_background_thread->shutdown();
+	m_transfers_in.clear();
+	m_transfers_out.clear();
 }
 
 void
 state_transfer_manager :: pause()
 {
-    m_background_thread->initiate_pause();
+	m_background_thread->initiate_pause();
 }
 
 void
 state_transfer_manager :: unpause()
 {
-    m_background_thread->kick();
-    m_background_thread->unpause();
+	m_background_thread->kick();
+	m_background_thread->unpause();
 }
 
 template <class S>
 static void
-setup_transfer_state(const char* desc,
+setup_transfer_state(const char *desc,
                      const std::vector<hyperdex::transfer> transfers,
-                     std::vector<e::intrusive_ptr<S> >* transfer_states)
-{
-    std::vector<e::intrusive_ptr<S> > tmp;
-    tmp.reserve(transfers.size());
-    size_t t_idx = 0;
-    size_t ts_idx = 0;
-
-    while (t_idx < transfers.size() && ts_idx < transfer_states->size())
-    {
-        if (transfers[t_idx].id == (*transfer_states)[ts_idx]->xfer.id)
-        {
-            tmp.push_back((*transfer_states)[ts_idx]);
-            ++t_idx;
-            ++ts_idx;
-        }
-        else if (transfers[t_idx].id < (*transfer_states)[ts_idx]->xfer.id)
-        {
-            LOG(INFO) << "initiating " << desc << " " << transfers[t_idx];
-            e::intrusive_ptr<S> new_state(new S(transfers[t_idx]));
-            tmp.push_back(new_state);
-            ++t_idx;
-        }
-        else if (transfers[t_idx].id > (*transfer_states)[ts_idx]->xfer.id)
-        {
-            LOG(INFO) << "ending " << desc << " " << (*transfer_states)[ts_idx]->xfer.id;
-            ++ts_idx;
-        }
-    }
-
-    while (t_idx < transfers.size())
-    {
-        LOG(INFO) << "initiating " << desc << " " << transfers[t_idx];
-        e::intrusive_ptr<S> new_state(new S(transfers[t_idx]));
-        tmp.push_back(new_state);
-        ++t_idx;
-    }
-
-    while (ts_idx < transfer_states->size())
-    {
-        LOG(INFO) << "ending " << desc << " " << (*transfer_states)[ts_idx]->xfer.id;
-        ++ts_idx;
-    }
-
-    tmp.swap(*transfer_states);
+                     std::vector<e::intrusive_ptr<S> > *transfer_states)
+{
+	std::vector<e::intrusive_ptr<S> > tmp;
+	tmp.reserve(transfers.size());
+	size_t t_idx = 0;
+	size_t ts_idx = 0;
+	while (t_idx < transfers.size() && ts_idx < transfer_states->size())
+	{
+		if (transfers[t_idx].id == (*transfer_states)[ts_idx]->xfer.id)
+		{
+			tmp.push_back((*transfer_states)[ts_idx]);
+			++t_idx;
+			++ts_idx;
+		}
+		else if (transfers[t_idx].id < (*transfer_states)[ts_idx]->xfer.id)
+		{
+			LOG(INFO) << "initiating " << desc << " " << transfers[t_idx];
+			e::intrusive_ptr<S> new_state(new S(transfers[t_idx]));
+			tmp.push_back(new_state);
+			++t_idx;
+		}
+		else if (transfers[t_idx].id > (*transfer_states)[ts_idx]->xfer.id)
+		{
+			LOG(INFO) << "ending " << desc << " " << (*transfer_states)[ts_idx]->xfer.id;
+			++ts_idx;
+		}
+	}
+	while (t_idx < transfers.size())
+	{
+		LOG(INFO) << "initiating " << desc << " " << transfers[t_idx];
+		e::intrusive_ptr<S> new_state(new S(transfers[t_idx]));
+		tmp.push_back(new_state);
+		++t_idx;
+	}
+	while (ts_idx < transfer_states->size())
+	{
+		LOG(INFO) << "ending " << desc << " " << (*transfer_states)[ts_idx]->xfer.id;
+		++ts_idx;
+	}
+	tmp.swap(*transfer_states);
 }
 
 void
-state_transfer_manager :: reconfigure(const configuration&,
-                                      const configuration& new_config,
-                                      const server_id&)
-{
-    m_background_thread->wait_until_paused();
-
-    // Setup transfers in
-    std::vector<transfer> transfers_in;
-    new_config.transfers_in(m_daemon->m_us, &transfers_in);
-    std::sort(transfers_in.begin(), transfers_in.end());
-    setup_transfer_state("incoming", transfers_in, &m_transfers_in);
-
-    // Setup transfers out
-    std::vector<transfer> transfers_out;
-    new_config.transfers_out(m_daemon->m_us, &transfers_out);
-    std::sort(transfers_out.begin(), transfers_out.end());
-    setup_transfer_state("outgoing", transfers_out, &m_transfers_out);
+state_transfer_manager :: reconfigure(const configuration &,
+                                      const configuration &new_config,
+                                      const server_id &)
+{
+	m_background_thread->wait_until_paused();
+	// Setup transfers in
+	std::vector<transfer> transfers_in;
+	new_config.transfers_in(m_daemon->m_us, &transfers_in);
+	std::sort(transfers_in.begin(), transfers_in.end());
+	setup_transfer_state("incoming", transfers_in, &m_transfers_in);
+	// Setup transfers out
+	std::vector<transfer> transfers_out;
+	new_config.transfers_out(m_daemon->m_us, &transfers_out);
+	std::sort(transfers_out.begin(), transfers_out.end());
+	setup_transfer_state("outgoing", transfers_out, &m_transfers_out);
 }
 
 void
 state_transfer_manager :: debug_dump()
 {
-    LOG(INFO) << "state transfer manager ========================================================";
-    pause();
-    m_background_thread->wait_until_paused();
-    LOG(INFO) << "transfer-in states ============================================================";
-
-    for (size_t i = 0; i < m_transfers_in.size(); ++i)
-    {
-        m_transfers_in[i]->debug_dump();
-    }
-
-    LOG(INFO) << "transfer-out states ===========================================================";
-
-    for (size_t i = 0; i < m_transfers_out.size(); ++i)
-    {
-        m_transfers_out[i]->debug_dump();
-    }
-
-    unpause();
+	LOG(INFO) << "state transfer manager ========================================================";
+	pause();
+	m_background_thread->wait_until_paused();
+	LOG(INFO) << "transfer-in states ============================================================";
+	for (size_t i = 0; i < m_transfers_in.size(); ++i)
+	{
+		m_transfers_in[i]->debug_dump();
+	}
+	LOG(INFO) << "transfer-out states ===========================================================";
+	for (size_t i = 0; i < m_transfers_out.size(); ++i)
+	{
+		m_transfers_out[i]->debug_dump();
+	}
+	unpause();
 }
 
 void
-state_transfer_manager :: handshake_syn(const virtual_server_id& from,
-                                        const transfer_id& xid)
-{
-    transfer_in_state* tis = get_tis(xid);
-
-    if (!tis)
-    {
-        LOG(INFO) << "dropping XFER_HS for " << xid << " which we don't know about";
-        return;
-    }
-
-    po6::threads::mutex::hold hold(&tis->mtx);
-
-    if (tis->xfer.vsrc != from || tis->xfer.id != xid)
-    {
-        LOG(INFO) << "dropping XFER_HS that came from the wrong host";
-        return;
-    }
-
-    uint64_t timestamp = 0;
-    m_daemon->m_data.largest_checkpoint_for(tis->xfer.rid, &timestamp);
-    send_handshake_synack(tis->xfer, timestamp);
-    LOG(INFO) << "received handshake_syn for " << xid;
+state_transfer_manager :: handshake_syn(const virtual_server_id &from,
+                                        const transfer_id &xid)
+{
+	transfer_in_state *tis = get_tis(xid);
+	if (!tis)
+	{
+		LOG(INFO) << "dropping XFER_HS for " << xid << " which we don't know about";
+		return;
+	}
+	po6::threads::mutex::hold hold(&tis->mtx);
+	if (tis->xfer.vsrc != from || tis->xfer.id != xid)
+	{
+		LOG(INFO) << "dropping XFER_HS that came from the wrong host";
+		return;
+	}
+	uint64_t timestamp = 0;
+	m_daemon->m_data.largest_checkpoint_for(tis->xfer.rid, &timestamp);
+	send_handshake_synack(tis->xfer, timestamp);
+	LOG(INFO) << "received handshake_syn for " << xid;
 }
 
 void
-state_transfer_manager :: handshake_synack(const server_id& from,
-                                           const virtual_server_id& to,
-                                           const transfer_id& xid,
+state_transfer_manager :: handshake_synack(const server_id &from,
+                                           const virtual_server_id &to,
+                                           const transfer_id &xid,
                                            uint64_t timestamp)
 {
-    transfer_out_state* tos = get_tos(xid);
-
-    if (!tos)
-    {
-        LOG(INFO) << "dropping XFER_HSA for " << xid << " which we don't know about";
-        return;
-    }
-
-    po6::threads::mutex::hold hold(&tos->mtx);
-
-    if (tos->xfer.dst != from || tos->xfer.vsrc != to || tos->xfer.id != xid)
-    {
-        LOG(INFO) << "dropping XFER_HSA that came from the wrong host";
-        return;
-    }
-
-    bool wipe = false;
-    std::auto_ptr<datalayer::replay_iterator> iter;
-    iter.reset(m_daemon->m_data.replay_region_from_checkpoint(tos->xfer.rid, timestamp, &wipe));
-    tos->handshake_syn = true;
-    tos->wipe = wipe;
-    tos->iter = iter;
-    send_handshake_ack(tos->xfer, tos->wipe);
-    transfer_more_state(tos);
-    LOG(INFO) << "received handshake_synack for " << xid << " @ " << timestamp;
+	transfer_out_state *tos = get_tos(xid);
+	if (!tos)
+	{
+		LOG(INFO) << "dropping XFER_HSA for " << xid << " which we don't know about";
+		return;
+	}
+	po6::threads::mutex::hold hold(&tos->mtx);
+	if (tos->xfer.dst != from || tos->xfer.vsrc != to || tos->xfer.id != xid)
+	{
+		LOG(INFO) << "dropping XFER_HSA that came from the wrong host";
+		return;
+	}
+	bool wipe = false;
+	std::auto_ptr<datalayer::replay_iterator> iter;
+	iter.reset(m_daemon->m_data.replay_region_from_checkpoint(tos->xfer.rid, timestamp, &wipe));
+	tos->handshake_syn = true;
+	tos->wipe = wipe;
+	tos->iter = iter;
+	send_handshake_ack(tos->xfer, tos->wipe);
+	transfer_more_state(tos);
+	LOG(INFO) << "received handshake_synack for " << xid << " @ " << timestamp;
 }
 
 void
-state_transfer_manager :: handshake_ack(const virtual_server_id& from,
-                                        const transfer_id& xid,
+state_transfer_manager :: handshake_ack(const virtual_server_id &from,
+                                        const transfer_id &xid,
                                         bool wipe)
 {
-    transfer_in_state* tis = get_tis(xid);
-
-    if (!tis)
-    {
-        LOG(INFO) << "dropping XFER_HA for " << xid << " which we don't know about";
-        return;
-    }
-
-    po6::threads::mutex::hold hold(&tis->mtx);
-
-    if (tis->xfer.vsrc != from || tis->xfer.id != xid)
-    {
-        LOG(INFO) << "dropping XFER_HA that came from the wrong host";
-        return;
-    }
-
-    if (!tis->handshake_complete)
-    {
-        tis->handshake_complete = true;
-        tis->wipe = wipe;
-        LOG(INFO) << "received handshake_ack for " << xid << (wipe ? " (and we must wipe our previous state)" : "");
-    }
-
-    put_to_disk_and_send_acks(tis);
+	transfer_in_state *tis = get_tis(xid);
+	if (!tis)
+	{
+		LOG(INFO) << "dropping XFER_HA for " << xid << " which we don't know about";
+		return;
+	}
+	po6::threads::mutex::hold hold(&tis->mtx);
+	if (tis->xfer.vsrc != from || tis->xfer.id != xid)
+	{
+		LOG(INFO) << "dropping XFER_HA that came from the wrong host";
+		return;
+	}
+	if (!tis->handshake_complete)
+	{
+		tis->handshake_complete = true;
+		tis->wipe = wipe;
+		LOG(INFO) << "received handshake_ack for " << xid << (wipe ? " (and we must wipe our previous state)" : "");
+	}
+	put_to_disk_and_send_acks(tis);
 }
 
 void
-state_transfer_manager :: handshake_wiped(const server_id& from,
-                                          const virtual_server_id& to,
-                                          const transfer_id& xid)
-{
-    transfer_out_state* tos = get_tos(xid);
-
-    if (!tos)
-    {
-        LOG(INFO) << "dropping XFER_HW for " << xid << " which we don't know about";
-        return;
-    }
-
-    po6::threads::mutex::hold hold(&tos->mtx);
-
-    if (tos->xfer.dst != from || tos->xfer.vsrc != to || tos->xfer.id != xid)
-    {
-        LOG(INFO) << "dropping XFER_HW that came from the wrong host";
-        return;
-    }
-
-    tos->handshake_ack = true;
-    transfer_more_state(tos);
-    LOG(INFO) << "received handshake_wiped for " << xid;
+state_transfer_manager :: handshake_wiped(const server_id &from,
+                                          const virtual_server_id &to,
+                                          const transfer_id &xid)
+{
+	transfer_out_state *tos = get_tos(xid);
+	if (!tos)
+	{
+		LOG(INFO) << "dropping XFER_HW for " << xid << " which we don't know about";
+		return;
+	}
+	po6::threads::mutex::hold hold(&tos->mtx);
+	if (tos->xfer.dst != from || tos->xfer.vsrc != to || tos->xfer.id != xid)
+	{
+		LOG(INFO) << "dropping XFER_HW that came from the wrong host";
+		return;
+	}
+	tos->handshake_ack = true;
+	transfer_more_state(tos);
+	LOG(INFO) << "received handshake_wiped for " << xid;
 }
 
 void
-state_transfer_manager :: report_wiped(const transfer_id& xid)
-{
-    transfer_in_state* tis = get_tis(xid);
-
-    if (!tis)
-    {
-        return;
-    }
-
-    m_daemon->m_data.inhibit_wiping();
-
-    if (!m_daemon->m_data.region_will_be_wiped(tis->xfer.rid))
-    {
-        po6::threads::mutex::hold hold(&tis->mtx);
-        tis->wiped = true;
-        put_to_disk_and_send_acks(tis);
-        LOG(INFO) << "we've wiped our state for " << xid;
-    }
-
-    m_daemon->m_data.permit_wiping();
+state_transfer_manager :: report_wiped(const transfer_id &xid)
+{
+	transfer_in_state *tis = get_tis(xid);
+	if (!tis)
+	{
+		return;
+	}
+	m_daemon->m_data.inhibit_wiping();
+	if (!m_daemon->m_data.region_will_be_wiped(tis->xfer.rid))
+	{
+		po6::threads::mutex::hold hold(&tis->mtx);
+		tis->wiped = true;
+		put_to_disk_and_send_acks(tis);
+		LOG(INFO) << "we've wiped our state for " << xid;
+	}
+	m_daemon->m_data.permit_wiping();
 }
 
 void
-state_transfer_manager :: xfer_op(const virtual_server_id& from,
-                                  const transfer_id& xid,
+state_transfer_manager :: xfer_op(const virtual_server_id &from,
+                                  const transfer_id &xid,
                                   uint64_t seq_no,
                                   bool has_value,
                                   uint64_t version,
                                   std::auto_ptr<e::buffer> msg,
-                                  const e::slice& key,
-                                  const std::vector<e::slice>& value)
-{
-    transfer_in_state* tis = get_tis(xid);
-
-    if (!tis)
-    {
-        LOG(INFO) << "dropping XFER_OP for " << xid << " which we don't know about";
-        return;
-    }
-
-    po6::threads::mutex::hold hold(&tis->mtx);
-
-    if (tis->xfer.vsrc != from || tis->xfer.id != xid)
-    {
-        LOG(INFO) << "dropping XFER_OP that came from the wrong host";
-        return;
-    }
-
-    if (seq_no < tis->upper_bound_acked)
-    {
-        return send_ack(tis->xfer, seq_no);
-    }
-
-    std::list<e::intrusive_ptr<pending> >::iterator where_to_put_it;
-
-    for (where_to_put_it = tis->queued.begin();
-            where_to_put_it != tis->queued.end(); ++where_to_put_it)
-    {
-        if ((*where_to_put_it)->seq_no == seq_no)
-        {
-            // silently drop it
-            return;
-        }
-
-        if ((*where_to_put_it)->seq_no > seq_no)
-        {
-            break;
-        }
-    }
-
-    e::intrusive_ptr<pending> op(new pending());
-    op->seq_no = seq_no;
-    op->has_value = has_value;
-    op->version = version;
-    op->key = key;
-    op->value = value;
-    op->msg = msg;
-    tis->queued.insert(where_to_put_it, op);
-    put_to_disk_and_send_acks(tis);
+                                  const e::slice &key,
+                                  const std::vector<e::slice> &value)
+{
+	transfer_in_state *tis = get_tis(xid);
+	if (!tis)
+	{
+		LOG(INFO) << "dropping XFER_OP for " << xid << " which we don't know about";
+		return;
+	}
+	po6::threads::mutex::hold hold(&tis->mtx);
+	if (tis->xfer.vsrc != from || tis->xfer.id != xid)
+	{
+		LOG(INFO) << "dropping XFER_OP that came from the wrong host";
+		return;
+	}
+	if (seq_no < tis->upper_bound_acked)
+	{
+		return send_ack(tis->xfer, seq_no);
+	}
+	std::list<e::intrusive_ptr<pending> >::iterator where_to_put_it;
+	for (where_to_put_it = tis->queued.begin();
+	     where_to_put_it != tis->queued.end(); ++where_to_put_it)
+	{
+		if ((*where_to_put_it)->seq_no == seq_no)
+		{
+			// silently drop it
+			return;
+		}
+		if ((*where_to_put_it)->seq_no > seq_no)
+		{
+			break;
+		}
+	}
+	e::intrusive_ptr<pending> op(new pending());
+	op->seq_no = seq_no;
+	op->has_value = has_value;
+	op->version = version;
+	op->key = key;
+	op->value = value;
+	op->msg = msg;
+	tis->queued.insert(where_to_put_it, op);
+	put_to_disk_and_send_acks(tis);
 }
 
 void
-state_transfer_manager :: xfer_ack(const server_id& from,
-                                   const virtual_server_id& to,
-                                   const transfer_id& xid,
+state_transfer_manager :: xfer_ack(const server_id &from,
+                                   const virtual_server_id &to,
+                                   const transfer_id &xid,
                                    uint64_t seq_no)
 {
-    transfer_out_state* tos = get_tos(xid);
-
-    if (!tos)
-    {
-        LOG(INFO) << "dropping XFER_ACK for " << xid << " which we don't know about";
-        return;
-    }
-
-    po6::threads::mutex::hold hold(&tos->mtx);
-
-    if (tos->xfer.dst != from || tos->xfer.vsrc != to || tos->xfer.id != xid)
-    {
-        LOG(INFO) << "dropping XFER_ACK that came from the wrong host";
-        return;
-    }
-
-    std::list<e::intrusive_ptr<pending> >::iterator it;
-
-    for (it = tos->window.begin(); it != tos->window.end(); ++it)
-    {
-        if ((*it)->seq_no == seq_no)
-        {
-            break;
-        }
-    }
-
-    if (it != tos->window.end())
-    {
-        (*it)->acked = true;
-        tos->handshake_ack = true;
-
-        if (tos->window_sz < 1024)
-        {
-            ++tos->window_sz;
-        }
-    }
-
-    while (!tos->window.empty() && (*tos->window.begin())->acked)
-    {
-        tos->window.pop_front();
-    }
-
-    transfer_more_state(tos);
-}
-
-state_transfer_manager::transfer_in_state*
-state_transfer_manager :: get_tis(const transfer_id& xid)
-{
-    for (size_t i = 0; i < m_transfers_in.size(); ++i)
-    {
-        if (m_transfers_in[i]->xfer.id == xid)
-        {
-            return m_transfers_in[i].get();
-        }
-    }
-
-    return NULL;
-}
-
-state_transfer_manager::transfer_out_state*
-state_transfer_manager :: get_tos(const transfer_id& xid)
-{
-    for (size_t i = 0; i < m_transfers_out.size(); ++i)
-    {
-        if (m_transfers_out[i]->xfer.id == xid)
-        {
-            return m_transfers_out[i].get();
-        }
-    }
-
-    return NULL;
+	transfer_out_state *tos = get_tos(xid);
+	if (!tos)
+	{
+		LOG(INFO) << "dropping XFER_ACK for " << xid << " which we don't know about";
+		return;
+	}
+	po6::threads::mutex::hold hold(&tos->mtx);
+	if (tos->xfer.dst != from || tos->xfer.vsrc != to || tos->xfer.id != xid)
+	{
+		LOG(INFO) << "dropping XFER_ACK that came from the wrong host";
+		return;
+	}
+	std::list<e::intrusive_ptr<pending> >::iterator it;
+	for (it = tos->window.begin(); it != tos->window.end(); ++it)
+	{
+		if ((*it)->seq_no == seq_no)
+		{
+			break;
+		}
+	}
+	if (it != tos->window.end())
+	{
+		(*it)->acked = true;
+		tos->handshake_ack = true;
+		if (tos->window_sz < 1024)
+		{
+			++tos->window_sz;
+		}
+	}
+	while (!tos->window.empty() && (*tos->window.begin())->acked)
+	{
+		tos->window.pop_front();
+	}
+	transfer_more_state(tos);
+}
+
+state_transfer_manager::transfer_in_state *
+state_transfer_manager :: get_tis(const transfer_id &xid)
+{
+	for (size_t i = 0; i < m_transfers_in.size(); ++i)
+	{
+		if (m_transfers_in[i]->xfer.id == xid)
+		{
+			return m_transfers_in[i].get();
+		}
+	}
+	return NULL;
+}
+
+state_transfer_manager::transfer_out_state *
+state_transfer_manager :: get_tos(const transfer_id &xid)
+{
+	for (size_t i = 0; i < m_transfers_out.size(); ++i)
+	{
+		if (m_transfers_out[i]->xfer.id == xid)
+		{
+			return m_transfers_out[i].get();
+		}
+	}
+	return NULL;
 }
 
 void
-state_transfer_manager :: transfer_more_state(transfer_out_state* tos)
-{
-    if (!tos->handshake_syn)
-    {
-        send_handshake_syn(tos->xfer);
-        return;
-    }
-
-    if (!tos->handshake_ack)
-    {
-        send_handshake_ack(tos->xfer, tos->wipe);
-    }
-
-    assert(tos->iter.get());
-
-    while (tos->window.size() < tos->window_sz && tos->iter->valid())
-    {
-        e::intrusive_ptr<pending> op(new pending());
-        op->seq_no = tos->next_seq_no;
-        ++tos->next_seq_no;
-        op->kref.assign(reinterpret_cast<const char*>(tos->iter->key().data()), tos->iter->key().size());
-        op->key = e::slice(op->kref);
-
-        if (tos->iter->has_value())
-        {
-            op->has_value = true;
-
-            if (tos->iter->unpack_value(&op->value, &op->version, &op->vref) != datalayer::SUCCESS)
-            {
-                LOG(ERROR) << "error doing state transfer";
-                break;
-            }
-        }
-        else
-        {
-            op->has_value = false;
-            op->version = 0;
-        }
-
-        tos->window.push_back(op);
-        send_object(tos->xfer, op.get());
-        tos->iter->next();
-    }
-
-    if (!tos->handshake_ack)
-    {
-        // pass!  we need the other end to give us some sign that it's ready,
-        // otherwise we cannot consider moving forward, even if we're ready.
-    }
-    else if (tos->window.empty() && m_daemon->m_config.is_transfer_live(tos->xfer.id))
-    {
-        m_daemon->m_coord->transfer_complete(tos->xfer.id);
-    }
-    else if (tos->window.empty())
-    {
-        m_daemon->m_coord->transfer_go_live(tos->xfer.id);
-    }
+state_transfer_manager :: transfer_more_state(transfer_out_state *tos)
+{
+	if (!tos->handshake_syn)
+	{
+		send_handshake_syn(tos->xfer);
+		return;
+	}
+	if (!tos->handshake_ack)
+	{
+		send_handshake_ack(tos->xfer, tos->wipe);
+	}
+	assert(tos->iter.get());
+	while (tos->window.size() < tos->window_sz && tos->iter->valid())
+	{
+		e::intrusive_ptr<pending> op(new pending());
+		op->seq_no = tos->next_seq_no;
+		++tos->next_seq_no;
+		op->kref.assign(reinterpret_cast<const char *>(tos->iter->key().data()), tos->iter->key().size());
+		op->key = e::slice(op->kref);
+		if (tos->iter->has_value())
+		{
+			op->has_value = true;
+			if (tos->iter->unpack_value(&op->value, &op->version, &op->vref) != datalayer::SUCCESS)
+			{
+				LOG(ERROR) << "error doing state transfer";
+				break;
+			}
+		}
+		else
+		{
+			op->has_value = false;
+			op->version = 0;
+		}
+		tos->window.push_back(op);
+		send_object(tos->xfer, op.get());
+		tos->iter->next();
+	}
+	if (!tos->handshake_ack)
+	{
+		// pass!  we need the other end to give us some sign that it's ready,
+		// otherwise we cannot consider moving forward, even if we're ready.
+	}
+	else if (tos->window.empty() && m_daemon->m_config.is_transfer_live(tos->xfer.id))
+	{
+		m_daemon->m_coord->transfer_complete(tos->xfer.id);
+	}
+	else if (tos->window.empty())
+	{
+		m_daemon->m_coord->transfer_go_live(tos->xfer.id);
+	}
 }
 
 void
-state_transfer_manager :: retransmit(transfer_out_state* tos)
+state_transfer_manager :: retransmit(transfer_out_state *tos)
 {
-    for (std::list<e::intrusive_ptr<pending> >::iterator it = tos->window.begin();
-            it != tos->window.end(); ++it)
-    {
-        send_object(tos->xfer, it->get());
-    }
+	for (std::list<e::intrusive_ptr<pending> >::iterator it = tos->window.begin();
+	     it != tos->window.end(); ++it)
+	{
+		send_object(tos->xfer, it->get());
+	}
 }
 
 void
-state_transfer_manager :: put_to_disk_and_send_acks(transfer_in_state* tis)
-{
-    if (!tis->handshake_complete)
-    {
-        return;
-    }
-
-    if (tis->wipe && !tis->wiped)
-    {
-        m_daemon->m_data.request_wipe(tis->xfer.id, tis->xfer.rid);
-        return;
-    }
-
-    if (tis->queued.empty())
-    {
-        send_handshake_wiped(tis->xfer);
-    }
-
-    while (!tis->queued.empty() &&
-           tis->queued.front()->seq_no == tis->upper_bound_acked)
-    {
-        e::intrusive_ptr<pending> op = tis->queued.front();
-
-        if (op->has_value)
-        {
-            datalayer::returncode rc = m_daemon->m_data.uncertain_put(tis->xfer.rid, op->key, op->value, op->version);
-
-            switch (rc)
-            {
-                case datalayer::SUCCESS:
-                    break;
-                case datalayer::NOT_FOUND:
-                case datalayer::BAD_ENCODING:
-                case datalayer::CORRUPTION:
-                case datalayer::IO_ERROR:
-                case datalayer::LEVELDB_ERROR:
-                    LOG(ERROR) << "state transfer caused error " << rc;
-                    break;
-                default:
-                    LOG(ERROR) << "state transfer caused unknown error";
-                    break;
-            }
-        }
-        else
-        {
-            datalayer::returncode rc = m_daemon->m_data.uncertain_del(tis->xfer.rid, op->key);
-
-            switch (rc)
-            {
-                case datalayer::SUCCESS:
-                case datalayer::NOT_FOUND:
-                    break;
-                case datalayer::BAD_ENCODING:
-                case datalayer::CORRUPTION:
-                case datalayer::IO_ERROR:
-                case datalayer::LEVELDB_ERROR:
-                    LOG(ERROR) << "state transfer caused error " << rc;
-                    break;
-                default:
-                    LOG(ERROR) << "state transfer caused unknown error";
-                    break;
-            }
-        }
-
-        send_ack(tis->xfer, op->seq_no);
-        tis->upper_bound_acked = std::max(tis->upper_bound_acked, op->seq_no + 1);
-        tis->queued.pop_front();
-    }
+state_transfer_manager :: put_to_disk_and_send_acks(transfer_in_state *tis)
+{
+	if (!tis->handshake_complete)
+	{
+		return;
+	}
+	if (tis->wipe && !tis->wiped)
+	{
+		m_daemon->m_data.request_wipe(tis->xfer.id, tis->xfer.rid);
+		return;
+	}
+	if (tis->queued.empty())
+	{
+		send_handshake_wiped(tis->xfer);
+	}
+	while (!tis->queued.empty() &&
+	       tis->queued.front()->seq_no == tis->upper_bound_acked)
+	{
+		e::intrusive_ptr<pending> op = tis->queued.front();
+		if (op->has_value)
+		{
+			datalayer::returncode rc = m_daemon->m_data.uncertain_put(tis->xfer.rid, op->key, op->value, op->version);
+			switch (rc)
+			{
+			case datalayer::SUCCESS:
+				break;
+			case datalayer::NOT_FOUND:
+			case datalayer::BAD_ENCODING:
+			case datalayer::CORRUPTION:
+			case datalayer::IO_ERROR:
+			case datalayer::LEVELDB_ERROR:
+				LOG(ERROR) << "state transfer caused error " << rc;
+				break;
+			default:
+				LOG(ERROR) << "state transfer caused unknown error";
+				break;
+			}
+		}
+		else
+		{
+			datalayer::returncode rc = m_daemon->m_data.uncertain_del(tis->xfer.rid, op->key);
+			switch (rc)
+			{
+			case datalayer::SUCCESS:
+			case datalayer::NOT_FOUND:
+				break;
+			case datalayer::BAD_ENCODING:
+			case datalayer::CORRUPTION:
+			case datalayer::IO_ERROR:
+			case datalayer::LEVELDB_ERROR:
+				LOG(ERROR) << "state transfer caused error " << rc;
+				break;
+			default:
+				LOG(ERROR) << "state transfer caused unknown error";
+				break;
+			}
+		}
+		send_ack(tis->xfer, op->seq_no);
+		tis->upper_bound_acked = std::max(tis->upper_bound_acked, op->seq_no + 1);
+		tis->queued.pop_front();
+	}
 }
 
 void
-state_transfer_manager :: send_handshake_syn(const transfer& xfer)
+state_transfer_manager :: send_handshake_syn(const transfer &xfer)
 {
-    size_t sz = HYPERDEX_HEADER_SIZE_VV
-              + sizeof(uint64_t);
-    std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
-    msg->pack_at(HYPERDEX_HEADER_SIZE_VV) << xfer.id;
-    m_daemon->m_comm.send_exact(xfer.vsrc, xfer.vdst, XFER_HS, msg);
+	size_t sz = HYPERDEX_HEADER_SIZE_VV
+	            + sizeof(uint64_t);
+	std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
+	msg->pack_at(HYPERDEX_HEADER_SIZE_VV) << xfer.id;
+	m_daemon->m_comm.send_exact(xfer.vsrc, xfer.vdst, XFER_HS, msg);
 }
 
 void
-state_transfer_manager :: send_handshake_synack(const transfer& xfer, uint64_t timestamp)
+state_transfer_manager :: send_handshake_synack(const transfer &xfer, uint64_t timestamp)
 {
-    size_t sz = HYPERDEX_HEADER_SIZE_VV
-              + sizeof(uint64_t)
-              + sizeof(uint64_t);
-    std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
-    msg->pack_at(HYPERDEX_HEADER_SIZE_VV) << xfer.id << timestamp;
-    m_daemon->m_comm.send_exact(xfer.vdst, xfer.vsrc, XFER_HSA, msg);
+	size_t sz = HYPERDEX_HEADER_SIZE_VV
+	            + sizeof(uint64_t)
+	            + sizeof(uint64_t);
+	std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
+	msg->pack_at(HYPERDEX_HEADER_SIZE_VV) << xfer.id << timestamp;
+	m_daemon->m_comm.send_exact(xfer.vdst, xfer.vsrc, XFER_HSA, msg);
 }
 
 void
-state_transfer_manager :: send_handshake_ack(const transfer& xfer, bool wipe)
+state_transfer_manager :: send_handshake_ack(const transfer &xfer, bool wipe)
 {
-    uint8_t flags = wipe ? 0x1 : 0;
-    size_t sz = HYPERDEX_HEADER_SIZE_VV
-              + sizeof(uint64_t)
-              + sizeof(uint8_t);
-    std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
-    msg->pack_at(HYPERDEX_HEADER_SIZE_VV) << xfer.id << flags;
-    m_daemon->m_comm.send_exact(xfer.vsrc, xfer.vdst, XFER_HA, msg);
+	uint8_t flags = wipe ? 0x1 : 0;
+	size_t sz = HYPERDEX_HEADER_SIZE_VV
+	            + sizeof(uint64_t)
+	            + sizeof(uint8_t);
+	std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
+	msg->pack_at(HYPERDEX_HEADER_SIZE_VV) << xfer.id << flags;
+	m_daemon->m_comm.send_exact(xfer.vsrc, xfer.vdst, XFER_HA, msg);
 }
 
 void
-state_transfer_manager :: send_handshake_wiped(const transfer& xfer)
+state_transfer_manager :: send_handshake_wiped(const transfer &xfer)
 {
-    size_t sz = HYPERDEX_HEADER_SIZE_VV
-              + sizeof(uint64_t);
-    std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
-    msg->pack_at(HYPERDEX_HEADER_SIZE_VV) << xfer.id;
-    m_daemon->m_comm.send_exact(xfer.vdst, xfer.vsrc, XFER_HW, msg);
+	size_t sz = HYPERDEX_HEADER_SIZE_VV
+	            + sizeof(uint64_t);
+	std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
+	msg->pack_at(HYPERDEX_HEADER_SIZE_VV) << xfer.id;
+	m_daemon->m_comm.send_exact(xfer.vdst, xfer.vsrc, XFER_HW, msg);
 }
 
 void
-state_transfer_manager :: send_object(const transfer& xfer,
-                                      pending* op)
-{
-    uint8_t flags = (op->has_value ? 1 : 0);
-    size_t sz = HYPERDEX_HEADER_SIZE_VV
-              + sizeof(uint8_t)
-              + sizeof(uint64_t)
-              + sizeof(uint64_t)
-              + sizeof(uint64_t)
-              + sizeof(uint32_t) + op->key.size()
-              + pack_size(op->value);
-    std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
-    msg->pack_at(HYPERDEX_HEADER_SIZE_VV) << flags << xfer.id.get() << op->seq_no
-                                          << op->version << op->key << op->value;
-    m_daemon->m_comm.send_exact(xfer.vsrc, xfer.vdst, XFER_OP, msg);
+state_transfer_manager :: send_object(const transfer &xfer,
+                                      pending *op)
+{
+	uint8_t flags = (op->has_value ? 1 : 0);
+	size_t sz = HYPERDEX_HEADER_SIZE_VV
+	            + sizeof(uint8_t)
+	            + sizeof(uint64_t)
+	            + sizeof(uint64_t)
+	            + sizeof(uint64_t)
+	            + sizeof(uint32_t) + op->key.size()
+	            + pack_size(op->value);
+	std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
+	msg->pack_at(HYPERDEX_HEADER_SIZE_VV) << flags << xfer.id.get() << op->seq_no
+	                                      << op->version << op->key << op->value;
+	m_daemon->m_comm.send_exact(xfer.vsrc, xfer.vdst, XFER_OP, msg);
 }
 
 void
-state_transfer_manager :: send_ack(const transfer& xfer, uint64_t seq_no)
+state_transfer_manager :: send_ack(const transfer &xfer, uint64_t seq_no)
 {
-    uint8_t flags = 0;
-    size_t sz = HYPERDEX_HEADER_SIZE_VV
-              + sizeof(uint8_t)
-              + sizeof(uint64_t)
-              + sizeof(uint64_t);
-    std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
-    msg->pack_at(HYPERDEX_HEADER_SIZE_VV) << flags << xfer.id.get() << seq_no;
-    m_daemon->m_comm.send_exact(xfer.vdst, xfer.vsrc, XFER_ACK, msg);
+	uint8_t flags = 0;
+	size_t sz = HYPERDEX_HEADER_SIZE_VV
+	            + sizeof(uint8_t)
+	            + sizeof(uint64_t)
+	            + sizeof(uint64_t);
+	std::auto_ptr<e::buffer> msg(e::buffer::create(sz));
+	msg->pack_at(HYPERDEX_HEADER_SIZE_VV) << flags << xfer.id.get() << seq_no;
+	m_daemon->m_comm.send_exact(xfer.vdst, xfer.vsrc, XFER_ACK, msg);
 }
 
-state_transfer_manager :: background_thread :: background_thread(state_transfer_manager* stm)
-    : hyperdex::background_thread(stm->m_daemon)
-    , m_stm(stm)
-    , m_need_kickstart(false)
+state_transfer_manager :: background_thread :: background_thread(state_transfer_manager *stm)
+	: hyperdex::background_thread(stm->m_daemon)
+	, m_stm(stm)
+	, m_need_kickstart(false)
 {
 }
 
@@ -711,43 +647,42 @@ state_transfer_manager :: background_thread :: ~background_thread() throw ()
 {
 }
 
-const char*
+const char *
 state_transfer_manager :: background_thread :: thread_name()
 {
-    return "state transfer";
+	return "state transfer";
 }
 
 bool
 state_transfer_manager :: background_thread :: have_work()
 {
-    return m_need_kickstart;
+	return m_need_kickstart;
 }
 
 void
 state_transfer_manager :: background_thread :: copy_work()
 {
-    m_need_kickstart = false;
+	m_need_kickstart = false;
 }
 
 void
 state_transfer_manager :: background_thread :: do_work()
 {
-    for (size_t idx = 0; idx < m_stm->m_transfers_out.size(); ++idx)
-    {
-        po6::threads::mutex::hold hold2(&m_stm->m_transfers_out[idx]->mtx);
-        m_stm->retransmit(m_stm->m_transfers_out[idx].get());
-        m_stm->transfer_more_state(m_stm->m_transfers_out[idx].get());
-        ++idx;
-    }
-
-    m_stm->m_daemon->m_comm.wake_one();
+	for (size_t idx = 0; idx < m_stm->m_transfers_out.size(); ++idx)
+	{
+		po6::threads::mutex::hold hold2(&m_stm->m_transfers_out[idx]->mtx);
+		m_stm->retransmit(m_stm->m_transfers_out[idx].get());
+		m_stm->transfer_more_state(m_stm->m_transfers_out[idx].get());
+		++idx;
+	}
+	m_stm->m_daemon->m_comm.wake_one();
 }
 
 void
 state_transfer_manager :: background_thread :: kick()
 {
-    this->lock();
-    m_need_kickstart = true;
-    this->wakeup();
-    this->unlock();
+	this->lock();
+	m_need_kickstart = true;
+	this->wakeup();
+	this->unlock();
 }
diff --git a/daemon/state_transfer_manager.h b/daemon/state_transfer_manager.h
index 49b811d8a..df7a74843 100644
--- a/daemon/state_transfer_manager.h
+++ b/daemon/state_transfer_manager.h
@@ -50,81 +50,81 @@ class daemon;
 
 class state_transfer_manager
 {
-    public:
-        state_transfer_manager(daemon*);
-        ~state_transfer_manager() throw ();
+public:
+	state_transfer_manager(daemon *);
+	~state_transfer_manager() throw ();
 
-    // Reconfigure this layer.
-    public:
-        bool setup();
-        void teardown();
-        void pause();
-        void unpause();
-        void reconfigure(const configuration& old_config,
-                         const configuration& new_config,
-                         const server_id& us);
-        void debug_dump();
+	// Reconfigure this layer.
+public:
+	bool setup();
+	void teardown();
+	void pause();
+	void unpause();
+	void reconfigure(const configuration &old_config,
+	                 const configuration &new_config,
+	                 const server_id &us);
+	void debug_dump();
 
-    public:
-        void handshake_syn(const virtual_server_id& from,
-                           const transfer_id& xid);
-        void handshake_synack(const server_id& from,
-                              const virtual_server_id& to,
-                              const transfer_id& xid,
-                              uint64_t timestamp);
-        void handshake_ack(const virtual_server_id& from,
-                           const transfer_id& xid,
-                           bool wipe);
-        void handshake_wiped(const server_id& from,
-                             const virtual_server_id& to,
-                             const transfer_id& xid);
-        void report_wiped(const transfer_id& xid);
-        void xfer_op(const virtual_server_id& from,
-                     const transfer_id& xid,
-                     uint64_t seq_no,
-                     bool has_value,
-                     uint64_t version,
-                     std::auto_ptr<e::buffer> msg,
-                     const e::slice& key,
-                     const std::vector<e::slice>& value);
-        void xfer_ack(const server_id& from,
-                      const virtual_server_id& to,
-                      const transfer_id& xid,
-                      uint64_t seq_no);
+public:
+	void handshake_syn(const virtual_server_id &from,
+	                   const transfer_id &xid);
+	void handshake_synack(const server_id &from,
+	                      const virtual_server_id &to,
+	                      const transfer_id &xid,
+	                      uint64_t timestamp);
+	void handshake_ack(const virtual_server_id &from,
+	                   const transfer_id &xid,
+	                   bool wipe);
+	void handshake_wiped(const server_id &from,
+	                     const virtual_server_id &to,
+	                     const transfer_id &xid);
+	void report_wiped(const transfer_id &xid);
+	void xfer_op(const virtual_server_id &from,
+	             const transfer_id &xid,
+	             uint64_t seq_no,
+	             bool has_value,
+	             uint64_t version,
+	             std::auto_ptr<e::buffer> msg,
+	             const e::slice &key,
+	             const std::vector<e::slice> &value);
+	void xfer_ack(const server_id &from,
+	              const virtual_server_id &to,
+	              const transfer_id &xid,
+	              uint64_t seq_no);
 
-    private:
-        class pending;
-        class transfer_in_state;
-        class transfer_out_state;
-        class background_thread;
+private:
+	class pending;
+	class transfer_in_state;
+	class transfer_out_state;
+	class background_thread;
 
-    private:
-        // get the appropriate state
-        transfer_in_state* get_tis(const transfer_id& xid);
-        transfer_out_state* get_tos(const transfer_id& xid);
-        // caller must hold mtx on tos
-        void transfer_more_state(transfer_out_state* tos);
-        void retransmit(transfer_out_state* tos);
-        // caller must hold mtx on tis
-        void put_to_disk_and_send_acks(transfer_in_state* tis);
-        // caller must hold mtx on tos
-        // send the last object in tos
-        void send_handshake_syn(const transfer& xfer);
-        void send_handshake_synack(const transfer& xfer, uint64_t timestamp);
-        void send_handshake_ack(const transfer& xfer, bool wipe);
-        void send_handshake_wiped(const transfer& xfer);
-        void send_object(const transfer& xfer, pending* op);
-        void send_ack(const transfer& xfer, uint64_t seq_id);
+private:
+	// get the appropriate state
+	transfer_in_state *get_tis(const transfer_id &xid);
+	transfer_out_state *get_tos(const transfer_id &xid);
+	// caller must hold mtx on tos
+	void transfer_more_state(transfer_out_state *tos);
+	void retransmit(transfer_out_state *tos);
+	// caller must hold mtx on tis
+	void put_to_disk_and_send_acks(transfer_in_state *tis);
+	// caller must hold mtx on tos
+	// send the last object in tos
+	void send_handshake_syn(const transfer &xfer);
+	void send_handshake_synack(const transfer &xfer, uint64_t timestamp);
+	void send_handshake_ack(const transfer &xfer, bool wipe);
+	void send_handshake_wiped(const transfer &xfer);
+	void send_object(const transfer &xfer, pending *op);
+	void send_ack(const transfer &xfer, uint64_t seq_id);
 
-    private:
-        state_transfer_manager(const state_transfer_manager&);
-        state_transfer_manager& operator = (const state_transfer_manager&);
+private:
+	state_transfer_manager(const state_transfer_manager &);
+	state_transfer_manager &operator = (const state_transfer_manager &);
 
-    private:
-        daemon* m_daemon;
-        std::vector<e::intrusive_ptr<transfer_in_state> > m_transfers_in;
-        std::vector<e::intrusive_ptr<transfer_out_state> > m_transfers_out;
-        const std::auto_ptr<background_thread> m_background_thread;
+private:
+	daemon *m_daemon;
+	std::vector<e::intrusive_ptr<transfer_in_state> > m_transfers_in;
+	std::vector<e::intrusive_ptr<transfer_out_state> > m_transfers_out;
+	const std::auto_ptr<background_thread> m_background_thread;
 };
 
 END_HYPERDEX_NAMESPACE
diff --git a/daemon/state_transfer_manager_pending.cc b/daemon/state_transfer_manager_pending.cc
index 09114735e..43d63d5ed 100644
--- a/daemon/state_transfer_manager_pending.cc
+++ b/daemon/state_transfer_manager_pending.cc
@@ -33,16 +33,16 @@
 using hyperdex::state_transfer_manager;
 
 state_transfer_manager :: state_transfer_manager :: pending :: pending()
-    : seq_no(0)
-    , has_value(false)
-    , version(0)
-    , key()
-    , value()
-    , acked(false)
-    , msg()
-    , kref()
-    , vref()
-    , m_ref(0)
+	: seq_no(0)
+	, has_value(false)
+	, version(0)
+	, key()
+	, value()
+	, acked(false)
+	, msg()
+	, kref()
+	, vref()
+	, m_ref(0)
 {
 }
 
diff --git a/daemon/state_transfer_manager_pending.h b/daemon/state_transfer_manager_pending.h
index a12904e70..845607cf4 100644
--- a/daemon/state_transfer_manager_pending.h
+++ b/daemon/state_transfer_manager_pending.h
@@ -34,30 +34,30 @@
 
 class hyperdex::state_transfer_manager::pending
 {
-    public:
-        pending();
-        ~pending() throw ();
-
-    public:
-        uint64_t seq_no;
-        bool has_value;
-        uint64_t version;
-        e::slice key;
-        std::vector<e::slice> value;
-        bool acked;
-        std::auto_ptr<e::buffer> msg;
-        std::string kref;
-        datalayer::reference vref;
-
-    private:
-        friend class e::intrusive_ptr<pending>;
-
-    private:
-        void inc() { ++m_ref; }
-        void dec() { --m_ref; if (m_ref == 0) delete this; }
-
-    private:
-        size_t m_ref;
+public:
+	pending();
+	~pending() throw ();
+
+public:
+	uint64_t seq_no;
+	bool has_value;
+	uint64_t version;
+	e::slice key;
+	std::vector<e::slice> value;
+	bool acked;
+	std::auto_ptr<e::buffer> msg;
+	std::string kref;
+	datalayer::reference vref;
+
+private:
+	friend class e::intrusive_ptr<pending>;
+
+private:
+	void inc() { ++m_ref; }
+	void dec() { --m_ref; if (m_ref == 0) delete this; }
+
+private:
+	size_t m_ref;
 };
 
 #endif // hyperdex_daemon_state_transfer_manager_pending_h_
diff --git a/daemon/state_transfer_manager_transfer_in_state.cc b/daemon/state_transfer_manager_transfer_in_state.cc
index 0c6556b70..809e2f847 100644
--- a/daemon/state_transfer_manager_transfer_in_state.cc
+++ b/daemon/state_transfer_manager_transfer_in_state.cc
@@ -38,15 +38,15 @@
 
 using hyperdex::state_transfer_manager;
 
-state_transfer_manager :: transfer_in_state :: transfer_in_state(const transfer& _xfer)
-    : xfer(_xfer)
-    , mtx()
-    , upper_bound_acked(1)
-    , queued()
-    , handshake_complete(false)
-    , wipe(false)
-    , wiped(false)
-    , m_ref(0)
+state_transfer_manager :: transfer_in_state :: transfer_in_state(const transfer &_xfer)
+	: xfer(_xfer)
+	, mtx()
+	, upper_bound_acked(1)
+	, queued()
+	, handshake_complete(false)
+	, wipe(false)
+	, wiped(false)
+	, m_ref(0)
 {
 }
 
@@ -57,9 +57,9 @@ state_transfer_manager :: transfer_in_state :: ~transfer_in_state() throw ()
 void
 state_transfer_manager :: transfer_in_state :: debug_dump()
 {
-    po6::threads::mutex::hold hold(&mtx);
-    LOG(INFO) << "  transfer=" << xfer;
-    LOG(INFO) << "    upper_bound_acked=" << upper_bound_acked;
-    LOG(INFO) << "    wipe=" << wipe;
-    LOG(INFO) << "    wiped=" << wiped;
+	po6::threads::mutex::hold hold(&mtx);
+	LOG(INFO) << "  transfer=" << xfer;
+	LOG(INFO) << "    upper_bound_acked=" << upper_bound_acked;
+	LOG(INFO) << "    wipe=" << wipe;
+	LOG(INFO) << "    wiped=" << wiped;
 }
diff --git a/daemon/state_transfer_manager_transfer_in_state.h b/daemon/state_transfer_manager_transfer_in_state.h
index 7b36e399c..4c4b0a739 100644
--- a/daemon/state_transfer_manager_transfer_in_state.h
+++ b/daemon/state_transfer_manager_transfer_in_state.h
@@ -36,31 +36,31 @@
 
 class hyperdex::state_transfer_manager::transfer_in_state
 {
-    public:
-        transfer_in_state(const transfer& xfer);
-        ~transfer_in_state() throw ();
+public:
+	transfer_in_state(const transfer &xfer);
+	~transfer_in_state() throw ();
 
-    public:
-        void debug_dump();
+public:
+	void debug_dump();
 
-    public:
-        transfer xfer;
-        po6::threads::mutex mtx;
-        uint64_t upper_bound_acked;
-        std::list<e::intrusive_ptr<pending> > queued;
-        bool handshake_complete;
-        bool wipe;
-        bool wiped;
+public:
+	transfer xfer;
+	po6::threads::mutex mtx;
+	uint64_t upper_bound_acked;
+	std::list<e::intrusive_ptr<pending> > queued;
+	bool handshake_complete;
+	bool wipe;
+	bool wiped;
 
-    private:
-        friend class e::intrusive_ptr<transfer_in_state>;
+private:
+	friend class e::intrusive_ptr<transfer_in_state>;
 
-    private:
-        void inc() { __sync_add_and_fetch(&m_ref, 1); }
-        void dec() { if (__sync_sub_and_fetch(&m_ref, 1) == 0) delete this; }
+private:
+	void inc() { __sync_add_and_fetch(&m_ref, 1); }
+	void dec() { if (__sync_sub_and_fetch(&m_ref, 1) == 0) delete this; }
 
-    private:
-        size_t m_ref;
+private:
+	size_t m_ref;
 };
 
 #endif // hyperdex_daemon_state_transfer_manager_transfer_in_state_h_
diff --git a/daemon/state_transfer_manager_transfer_out_state.cc b/daemon/state_transfer_manager_transfer_out_state.cc
index 7fa036448..39c02b28b 100644
--- a/daemon/state_transfer_manager_transfer_out_state.cc
+++ b/daemon/state_transfer_manager_transfer_out_state.cc
@@ -37,17 +37,17 @@
 
 using hyperdex::state_transfer_manager;
 
-state_transfer_manager :: transfer_out_state :: transfer_out_state(const transfer& _xfer)
-    : xfer(_xfer)
-    , mtx()
-    , next_seq_no(1)
-    , window()
-    , window_sz(1)
-    , iter()
-    , handshake_syn(false)
-    , handshake_ack(false)
-    , wipe(false)
-    , m_ref(0)
+state_transfer_manager :: transfer_out_state :: transfer_out_state(const transfer &_xfer)
+	: xfer(_xfer)
+	, mtx()
+	, next_seq_no(1)
+	, window()
+	, window_sz(1)
+	, iter()
+	, handshake_syn(false)
+	, handshake_ack(false)
+	, wipe(false)
+	, m_ref(0)
 {
 }
 
@@ -58,11 +58,11 @@ state_transfer_manager :: transfer_out_state :: ~transfer_out_state() throw ()
 void
 state_transfer_manager :: transfer_out_state :: debug_dump()
 {
-    po6::threads::mutex::hold hold(&mtx);
-    LOG(INFO) << "  transfer=" << xfer;
-    LOG(INFO) << "    next_seq_no=" << next_seq_no;
-    LOG(INFO) << "    window_sz=" << window_sz;
-    LOG(INFO) << "    handshake_syn=" << handshake_syn;
-    LOG(INFO) << "    handshake_ack=" << handshake_ack;
-    LOG(INFO) << "    wipe=" << wipe;
+	po6::threads::mutex::hold hold(&mtx);
+	LOG(INFO) << "  transfer=" << xfer;
+	LOG(INFO) << "    next_seq_no=" << next_seq_no;
+	LOG(INFO) << "    window_sz=" << window_sz;
+	LOG(INFO) << "    handshake_syn=" << handshake_syn;
+	LOG(INFO) << "    handshake_ack=" << handshake_ack;
+	LOG(INFO) << "    wipe=" << wipe;
 }
diff --git a/daemon/state_transfer_manager_transfer_out_state.h b/daemon/state_transfer_manager_transfer_out_state.h
index 6ced99c56..e00f7d274 100644
--- a/daemon/state_transfer_manager_transfer_out_state.h
+++ b/daemon/state_transfer_manager_transfer_out_state.h
@@ -45,37 +45,37 @@ using hyperdex::state_transfer_manager;
 
 class state_transfer_manager::transfer_out_state
 {
-    public:
-        transfer_out_state(const transfer& xfer);
-        ~transfer_out_state() throw ();
+public:
+	transfer_out_state(const transfer &xfer);
+	~transfer_out_state() throw ();
 
-    public:
-        void debug_dump();
+public:
+	void debug_dump();
 
-    public:
-        transfer xfer;
-        po6::threads::mutex mtx;
-        uint64_t next_seq_no;
-        std::list<e::intrusive_ptr<pending> > window;
-        size_t window_sz;
-        std::auto_ptr<datalayer::replay_iterator> iter;
-        bool handshake_syn; // do we know the other end got a syn?
-        bool handshake_ack; // do we know the other end got a ack?
-        bool wipe;
+public:
+	transfer xfer;
+	po6::threads::mutex mtx;
+	uint64_t next_seq_no;
+	std::list<e::intrusive_ptr<pending> > window;
+	size_t window_sz;
+	std::auto_ptr<datalayer::replay_iterator> iter;
+	bool handshake_syn; // do we know the other end got a syn?
+	bool handshake_ack; // do we know the other end got a ack?
+	bool wipe;
 
-    private:
-        friend class e::intrusive_ptr<transfer_out_state>;
+private:
+	friend class e::intrusive_ptr<transfer_out_state>;
 
-    private:
-        void inc() { __sync_add_and_fetch(&m_ref, 1); }
-        void dec() { if (__sync_sub_and_fetch(&m_ref, 1) == 0) delete this; }
+private:
+	void inc() { __sync_add_and_fetch(&m_ref, 1); }
+	void dec() { if (__sync_sub_and_fetch(&m_ref, 1) == 0) delete this; }
 
-    private:
-        size_t m_ref;
+private:
+	size_t m_ref;
 
-    private:
-        transfer_out_state(const transfer_out_state&);
-        transfer_out_state& operator = (const transfer_out_state&);
+private:
+	transfer_out_state(const transfer_out_state &);
+	transfer_out_state &operator = (const transfer_out_state &);
 };
 
 #endif // hyperdex_daemon_state_transfer_manager_transfer_out_state_h_
diff --git a/daemon/test/identifier_collector.cc b/daemon/test/identifier_collector.cc
index db613b0bc..be5982572 100644
--- a/daemon/test/identifier_collector.cc
+++ b/daemon/test/identifier_collector.cc
@@ -40,50 +40,49 @@ using hyperdex::region_id;
 
 TEST(IdentifierCollector, Test)
 {
-    e::garbage_collector gc;
-    identifier_collector ic(&gc);
-    uint64_t id;
-    // adopt a region
-    region_id ri(1);
-    ic.adopt(&ri, 1);
-    // first try, nothing collected
-    id = ic.lower_bound(ri);
-    ASSERT_EQ(id, 1U);
-    // collect one
-    ic.collect(ri, 1);
-    id = ic.lower_bound(ri);
-    ASSERT_EQ(id, 2U);
-    // collect three
-    ic.collect(ri, 3);
-    id = ic.lower_bound(ri);
-    ASSERT_EQ(id, 2U);
-    // collect three again
-    ic.collect(ri, 3);
-    id = ic.lower_bound(ri);
-    ASSERT_EQ(id, 2U);
-    // collect two
-    ic.collect(ri, 2);
-    id = ic.lower_bound(ri);
-    ASSERT_EQ(id, 4U);
-    // resize
-    region_id ris[2];
-    ris[0] = region_id(2);
-    ris[1] = region_id(1);
-    ic.adopt(ris, 2);
-    // check lower bound
-    id = ic.lower_bound(ri);
-    ASSERT_EQ(id, 4U);
-    // bump!
-    ic.bump(ri, 9);
-    id = ic.lower_bound(ri);
-    ASSERT_EQ(id, 9U);
-    id = ic.lower_bound(ri);
-    ASSERT_EQ(id, 9U);
-
-    for (uint64_t i = 9; i < 65536; ++i)
-    {
-        ic.collect(ri, i);
-        id = ic.lower_bound(ri);
-        ASSERT_EQ(id, i + 1);
-    }
+	e::garbage_collector gc;
+	identifier_collector ic(&gc);
+	uint64_t id;
+	// adopt a region
+	region_id ri(1);
+	ic.adopt(&ri, 1);
+	// first try, nothing collected
+	id = ic.lower_bound(ri);
+	ASSERT_EQ(id, 1U);
+	// collect one
+	ic.collect(ri, 1);
+	id = ic.lower_bound(ri);
+	ASSERT_EQ(id, 2U);
+	// collect three
+	ic.collect(ri, 3);
+	id = ic.lower_bound(ri);
+	ASSERT_EQ(id, 2U);
+	// collect three again
+	ic.collect(ri, 3);
+	id = ic.lower_bound(ri);
+	ASSERT_EQ(id, 2U);
+	// collect two
+	ic.collect(ri, 2);
+	id = ic.lower_bound(ri);
+	ASSERT_EQ(id, 4U);
+	// resize
+	region_id ris[2];
+	ris[0] = region_id(2);
+	ris[1] = region_id(1);
+	ic.adopt(ris, 2);
+	// check lower bound
+	id = ic.lower_bound(ri);
+	ASSERT_EQ(id, 4U);
+	// bump!
+	ic.bump(ri, 9);
+	id = ic.lower_bound(ri);
+	ASSERT_EQ(id, 9U);
+	id = ic.lower_bound(ri);
+	ASSERT_EQ(id, 9U);
+	for (uint64_t i = 9; i < 65536; ++i)
+	{
+		ic.collect(ri, i);
+		id = ic.lower_bound(ri);
+		ASSERT_EQ(id, i + 1);
+	}
 }
diff --git a/daemon/test/identifier_generator.cc b/daemon/test/identifier_generator.cc
index 076a16242..74ba5c0e2 100644
--- a/daemon/test/identifier_generator.cc
+++ b/daemon/test/identifier_generator.cc
@@ -40,30 +40,30 @@ using hyperdex::region_id;
 
 TEST(IdentifierGenerator, Test)
 {
-    identifier_generator ig;
-    uint64_t id;
-    // adopt a region
-    region_id ri(1);
-    ig.adopt(&ri, 1);
-    // try again
-    id = ig.generate_id(ri);
-    ASSERT_EQ(id, 1U);
-    id = ig.generate_id(ri);
-    ASSERT_EQ(id, 2U);
-    id = ig.generate_id(ri);
-    ASSERT_EQ(id, 3U);
-    // resize
-    region_id ris[2];
-    ris[0] = region_id(2);
-    ris[1] = region_id(1);
-    ig.adopt(ris, 2);
-    // generate
-    id = ig.generate_id(ri);
-    ASSERT_EQ(id, 4U);
-    // bump!
-    bool did_it = ig.bump(ri, 8);
-    ASSERT_TRUE(did_it);
-    // generate
-    id = ig.generate_id(ri);
-    ASSERT_EQ(id, 9U);
+	identifier_generator ig;
+	uint64_t id;
+	// adopt a region
+	region_id ri(1);
+	ig.adopt(&ri, 1);
+	// try again
+	id = ig.generate_id(ri);
+	ASSERT_EQ(id, 1U);
+	id = ig.generate_id(ri);
+	ASSERT_EQ(id, 2U);
+	id = ig.generate_id(ri);
+	ASSERT_EQ(id, 3U);
+	// resize
+	region_id ris[2];
+	ris[0] = region_id(2);
+	ris[1] = region_id(1);
+	ig.adopt(ris, 2);
+	// generate
+	id = ig.generate_id(ri);
+	ASSERT_EQ(id, 4U);
+	// bump!
+	bool did_it = ig.bump(ri, 8);
+	ASSERT_TRUE(did_it);
+	// generate
+	id = ig.generate_id(ri);
+	ASSERT_EQ(id, 9U);
 }
diff --git a/doc/2013-06-28-cloudphysics.pdf b/doc/2013-06-28-cloudphysics.pdf
new file mode 100644
index 000000000..ddc437159
Binary files /dev/null and b/doc/2013-06-28-cloudphysics.pdf differ
diff --git a/doc/7427-escriva12-06.pdf b/doc/7427-escriva12-06.pdf
new file mode 100644
index 000000000..c7ce6d880
Binary files /dev/null and b/doc/7427-escriva12-06.pdf differ
diff --git a/doc/c/client/hello-world.c b/doc/c/client/hello-world.c
index ca19e1cce..e0182b032 100644
--- a/doc/c/client/hello-world.c
+++ b/doc/c/client/hello-world.c
@@ -2,44 +2,38 @@
 /* HyperDex Includes */
 #include <hyperdex/client.h>
 int
-main(int argc, const char* argv[])
+main(int argc, const char *argv[])
 {
-    struct hyperdex_client* client = NULL;
-    struct hyperdex_client_attribute attr;
-    struct hyperdex_client_attribute* attrs;
-    size_t attrs_sz = 0;
-    int64_t op_id;
-    enum hyperdex_client_returncode op_status;
-    int64_t loop_id;
-    enum hyperdex_client_returncode loop_status;
-    size_t i;
-
-    client = hyperdex_client_create("127.0.0.1", 1982);
-
-    attr.attr = "v";
-    attr.value = "Hello World!";
-    attr.value_sz = strlen(attr.value);
-    attr.datatype = HYPERDATATYPE_STRING;
-
-    /* perform the "put" */
-    op_id = hyperdex_client_put(client, "kv", "some key", 8,
-                                &attr, 1, &op_status);
-    loop_id = hyperdex_client_loop(client, -1, &loop_status);
-    printf("put \"Hello World!\"\n");
-
-    /* perform the "get" */
-    op_id = hyperdex_client_get(client, "kv", "some key", 8,
-                                &op_status, &attrs, &attrs_sz);
-    loop_id = hyperdex_client_loop(client, -1, &loop_status);
-    printf("get done\n");
-
-    for (i = 0; i < attrs_sz; ++i)
-    {
-        printf("got attribute \"%s\" = \"%.*s\"\n",
-               attrs[i].attr, attrs[i].value_sz, attrs[i].value);
-    }
-
-    hyperdex_client_destroy_attrs(attrs, attrs_sz);
-    hyperdex_client_destroy(client);
-    return EXIT_SUCCESS;
+	struct hyperdex_client *client = NULL;
+	struct hyperdex_client_attribute attr;
+	struct hyperdex_client_attribute *attrs;
+	size_t attrs_sz = 0;
+	int64_t op_id;
+	enum hyperdex_client_returncode op_status;
+	int64_t loop_id;
+	enum hyperdex_client_returncode loop_status;
+	size_t i;
+	client = hyperdex_client_create("127.0.0.1", 1982);
+	attr.attr = "v";
+	attr.value = "Hello World!";
+	attr.value_sz = strlen(attr.value);
+	attr.datatype = HYPERDATATYPE_STRING;
+	/* perform the "put" */
+	op_id = hyperdex_client_put(client, "kv", "some key", 8,
+	                            &attr, 1, &op_status);
+	loop_id = hyperdex_client_loop(client, -1, &loop_status);
+	printf("put \"Hello World!\"\n");
+	/* perform the "get" */
+	op_id = hyperdex_client_get(client, "kv", "some key", 8,
+	                            &op_status, &attrs, &attrs_sz);
+	loop_id = hyperdex_client_loop(client, -1, &loop_status);
+	printf("get done\n");
+	for (i = 0; i < attrs_sz; ++i)
+	{
+		printf("got attribute \"%s\" = \"%.*s\"\n",
+		       attrs[i].attr, attrs[i].value_sz, attrs[i].value);
+	}
+	hyperdex_client_destroy_attrs(attrs, attrs_sz);
+	hyperdex_client_destroy(client);
+	return EXIT_SUCCESS;
 }
diff --git a/doc/c/client/iterate.c b/doc/c/client/iterate.c
index 3954f0aea..629b345e4 100644
--- a/doc/c/client/iterate.c
+++ b/doc/c/client/iterate.c
@@ -6,26 +6,23 @@
 #include <hyperdex/datastructures.h>
 
 int
-main(int argc, const char* argv[])
+main(int argc, const char *argv[])
 {
-   int64_t num;
-   const char* value = "\x01\x00\x00\x00\x00\x00\x00\x00"
-                       "\xff\xff\xff\xff\xff\xff\xff\xff"
-                       "\xef\xbe\xad\xde\x00\x00\x00\x00";
-   size_t value_sz = 24;
-   int status = 0;
-   hyperdex_ds_iterator iter;
-   hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_LIST_INT64, value, value_sz);
-
-   while ((status = hyperdex_ds_iterate_list_int_next(&iter, &num)) > 0)
-   {
-       printf("%ld\n", num);
-   }
-
-   if (status < 0)
-   {
-       printf("error: corrupt list\n");
-   }
-
-   return EXIT_SUCCESS;
+	int64_t num;
+	const char *value = "\x01\x00\x00\x00\x00\x00\x00\x00"
+	                    "\xff\xff\xff\xff\xff\xff\xff\xff"
+	                    "\xef\xbe\xad\xde\x00\x00\x00\x00";
+	size_t value_sz = 24;
+	int status = 0;
+	hyperdex_ds_iterator iter;
+	hyperdex_ds_iterator_init(&iter, HYPERDATATYPE_LIST_INT64, value, value_sz);
+	while ((status = hyperdex_ds_iterate_list_int_next(&iter, &num)) > 0)
+	{
+		printf("%ld\n", num);
+	}
+	if (status < 0)
+	{
+		printf("error: corrupt list\n");
+	}
+	return EXIT_SUCCESS;
 }
diff --git a/doc/warp.pdf b/doc/warp.pdf
new file mode 100644
index 000000000..c36ececc5
Binary files /dev/null and b/doc/warp.pdf differ
diff --git a/example/a.cpp b/example/a.cpp
new file mode 100644
index 000000000..5003e9c35
--- /dev/null
+++ b/example/a.cpp
@@ -0,0 +1,62 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <string>
+#include <pthread.h>
+#include <assert.h>
+#include <hyperdex/admin.hpp>
+#include <hyperdex/client.hpp>
+
+using namespace std;
+using namespace hyperdex;
+
+static const char rcsid[] = "$Id: " __FILE__ ",v 1.0.0-0 " __DATE__ " " __TIME__ " Cnangel Exp $";
+
+int
+main(int argc, const char *argv[])
+{
+	//std::string description;
+	const char *host = "127.0.0.1";
+	uint16_t port = 1982;
+	stringstream ss;
+	ss << "space phonebook1 key username attributes first, last, int phone subspace first, last, phone create 8 partitions tolerate 2 failures";
+	try
+	{
+		Admin h(host, port);
+		hyperdex_admin_returncode rrc;
+		//const char *description = ss.str().c_str();
+		string sa = ss.str();
+		const char *description = sa.c_str();
+		cout << description << endl;
+		int64_t rid = h.add_space(description, &rrc);
+		if (rid < 0)
+		{
+			std::cerr << "could not add space1: " << h.error_message() << std::endl;
+			return EXIT_FAILURE;
+		}
+		hyperdex_admin_returncode lrc;
+		cout << "-------------------" << endl;
+		int64_t lid = h.loop(-1, &lrc);
+		if (lid < 0)
+		{
+			std::cerr << "could not add space2: " << h.error_message() << std::endl;
+			return EXIT_FAILURE;
+		}
+		assert(rid == lid);
+		if (rrc != HYPERDEX_ADMIN_SUCCESS)
+		{
+			std::cerr << "could not add space3: " << h.error_message() << std::endl;
+			return EXIT_FAILURE;
+		}
+		return EXIT_SUCCESS;
+	}
+	catch (std::exception &e)
+	{
+		std::cerr << "error: " << e.what() << std::endl;
+		return EXIT_FAILURE;
+	}
+}
diff --git a/example/b.cpp b/example/b.cpp
new file mode 100644
index 000000000..5b333882a
--- /dev/null
+++ b/example/b.cpp
@@ -0,0 +1,63 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <string>
+#include <pthread.h>
+#include <assert.h>
+#include <hyperdex/admin.hpp>
+#include <hyperdex/client.hpp>
+
+using namespace std;
+using namespace hyperdex;
+
+static const char rcsid[] = "$Id: " __FILE__ ",v 1.0.0-0 " __DATE__ " " __TIME__ " Cnangel Exp $";
+
+int main(int c, char *v[])
+{
+	const char *host = "127.0.0.1";
+	uint16_t port = 1982;
+	try
+	{
+		Admin h(host, port);
+		hyperdex_admin_returncode rrc;
+		const char *spaces;
+		int64_t rid = h.list_spaces(&rrc, &spaces);
+		if (rid < 0)
+		{
+			std::cerr << "could not list spaces: " << h.error_message() << std::endl;
+			return EXIT_FAILURE;
+		}
+		hyperdex_admin_returncode lrc;
+		int64_t lid = h.loop(-1, &lrc);
+		if (lid < 0)
+		{
+			std::cerr << "could not list spaces: " << h.error_message() << std::endl;
+			return EXIT_FAILURE;
+		}
+		assert(rid == lid);
+		if (rrc != HYPERDEX_ADMIN_SUCCESS)
+		{
+			std::cerr << "could not list spaces: " << h.error_message() << std::endl;
+			return EXIT_FAILURE;
+		}
+		if (strcmp(spaces, "") == 0)
+		{
+			std::cout << "No spaces are found." << std::endl;
+		}
+		else
+		{
+			std::cout << spaces;
+			return EXIT_SUCCESS;
+		}
+	}
+	catch (std::exception &e)
+	{
+		std::cerr << "error: " << e.what() << std::endl;
+		return EXIT_FAILURE;
+	}
+	return EXIT_SUCCESS;
+}
diff --git a/example/c.cpp b/example/c.cpp
new file mode 100644
index 000000000..0b0c5826a
--- /dev/null
+++ b/example/c.cpp
@@ -0,0 +1,138 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <string>
+#include <pthread.h>
+#include <assert.h>
+#include <hyperdex/admin.hpp>
+#include <hyperdex/client.hpp>
+#include <hyperdex/client.h>
+
+using namespace std;
+
+int
+main(int argc, const char *argv[])
+{
+	struct hyperdex_client *client = NULL;
+	struct hyperdex_client_attribute attr;
+	struct hyperdex_client_attribute_check check;
+	const struct hyperdex_client_attribute *attrs = NULL;
+	size_t attrs_sz = 0;
+	size_t check_len = 0;
+	uint64_t count;
+	int64_t op_id;
+	enum hyperdex_client_returncode op_status;
+	int64_t loop_id;
+	enum hyperdex_client_returncode loop_status;
+	size_t i;
+	const char *ns = "phonebook";
+	client = hyperdex_client_create("127.0.0.1", 1982);
+	attr.attr = "first";
+	if (argc > 1)
+	{
+		char *pointer = NULL;
+		int arg1 = atoi(argv[1]);
+		if (arg1 == 1)
+		{
+			attr.value = "Hello, World!";
+			attr.value_sz = strlen(attr.value);
+		}
+		else
+		{
+			size_t p_len = 100 * 1024 * 1024;
+			char *p = (char *)malloc(p_len);
+			const char *file = "./data.txt";
+			fstream fs;
+			fs.open(file, ios::in | ios::binary);
+			if (!fs)
+			{
+				cerr << "not exist file: " << file << endl;
+				exit(EXIT_FAILURE);
+			}
+			fs.getline(p, p_len);
+			fs.close();
+			attr.value = p;
+			attr.value_sz = p_len;
+			pointer = p;
+		}
+		int arg2 = argv[2] == NULL ? 0 : atoi(argv[2]);
+		attr.datatype = HYPERDATATYPE_STRING;
+		if (arg2 == 0)
+		{
+			if (arg1 == 1)
+				printf("put \"Hello World!\"\n");
+			else
+				printf("put \"Large Value!\"\n");
+			op_id = hyperdex_client_put(client, ns, "some key", 8, &attr, 1, &op_status);
+			if (op_id < 0)
+			{
+				cout << hyperdex_client_error_message(client) << endl;
+				return EXIT_FAILURE;
+			}
+			loop_id = hyperdex_client_loop(client, -1, &loop_status);
+			if (loop_id < 0)
+			{
+				cout << hyperdex_client_error_message(client) << endl;
+				return EXIT_FAILURE;
+			}
+			assert(op_id == loop_id);
+		}
+		op_id = hyperdex_client_get(client, ns, "some key", 8, &op_status, &attrs, &attrs_sz);
+		if (op_id < 0)
+		{
+			cout << hyperdex_client_error_message(client) << endl;
+			return EXIT_FAILURE;
+		}
+		loop_id = hyperdex_client_loop(client, -1, &loop_status);
+		if (loop_id < 0)
+		{
+			cout << hyperdex_client_error_message(client) << endl;
+			return EXIT_FAILURE;
+		}
+		assert(op_id == loop_id);
+		printf("get done\n");
+		for (i = 0; i < attrs_sz; ++i)
+		{
+			printf("got attribute \"%s\" = \"%.*s\"\n",
+			       attrs[i].attr, attrs[i].value_sz, attrs[i].value);
+		}
+		if (pointer)
+			free(pointer);
+		hyperdex_client_destroy_attrs(attrs, attrs_sz);
+	}
+	else
+	{
+		check.attr = "first";
+		check.value = "John";
+		check.value_sz = strlen(check.value);
+		check.datatype = HYPERDATATYPE_STRING;
+		check.predicate = HYPERPREDICATE_EQUALS;
+		count = 0;
+		check_len += strlen(check.attr);
+		check_len += check.value_sz;
+		check_len += sizeof(size_t);
+		check_len += sizeof(hyperdatatype);
+		check_len += sizeof(hyperpredicate);
+		check_len = 1;
+		op_id = hyperdex_client_count(client, ns, &check, check_len, &op_status, &count);
+		if (op_id < 0)
+		{
+			cout << "count failed: " << hyperdex_client_error_message(client) << endl;
+			return EXIT_FAILURE;
+		}
+		loop_id = hyperdex_client_loop(client, -1, &loop_status);
+		if (loop_id < 0)
+		{
+			cout << hyperdex_client_error_message(client) << endl;
+			return EXIT_FAILURE;
+		}
+		assert(op_id == loop_id);
+		printf("count: %ld\n", count);
+	}
+	hyperdex_client_destroy(client);
+	return EXIT_SUCCESS;
+}
diff --git a/example/d.cpp b/example/d.cpp
new file mode 100644
index 000000000..60ada7765
--- /dev/null
+++ b/example/d.cpp
@@ -0,0 +1,46 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <iostream>
+#include <unistd.h>
+#include <fstream>
+#include <sstream>
+#include <string>
+#include <pthread.h>
+#include <assert.h>
+
+using namespace std;
+
+static const char rcsid[] = "$Id: " __FILE__ ",v 1.0.0-0 " __DATE__ " " __TIME__ " Cnangel Exp $";
+#define BUFFER_SIZE  1024*1024*100
+
+int
+main(int argc, const char *argv[])
+{
+	const char *file = "./data.txt";
+	if (argc == 1)
+	{
+		char *p = (char *)malloc(BUFFER_SIZE);
+		memset(p, 'z', BUFFER_SIZE);
+		fstream fs;
+		fs.open(file, std::ios::out | std::ios::trunc);
+		fs << p;
+		fs.close();
+		free(p);
+	}
+	else if (argc == 2)
+	{
+		char *pp = (char *)malloc(BUFFER_SIZE);
+		fstream fs;
+		fs.open(file, ios::in | ios::binary);
+		fs.getline(pp, BUFFER_SIZE);
+		fs.close();
+		printf("pp: %.*s", 100, pp);
+		free(pp);
+	}
+	else
+	{
+		unlink(file);
+	}
+}
diff --git a/example/e.cpp b/example/e.cpp
new file mode 100644
index 000000000..933ae04a2
--- /dev/null
+++ b/example/e.cpp
@@ -0,0 +1,53 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <string>
+#include <pthread.h>
+#include <assert.h>
+#include <hyperdex/admin.hpp>
+#include <hyperdex/client.hpp>
+
+using namespace std;
+using namespace hyperdex;
+
+static const char rcsid[] = "$Id: " __FILE__ ",v 1.0.0-0 " __DATE__ " " __TIME__ " Cnangel Exp $";
+
+int
+main(int argc, const char *argv[])
+{
+	char *p = (char *)malloc(1000);
+	if (p == NULL)
+	{
+		return 0;
+	}
+	memset(p, 'A', 1000);
+	printf("1 %p\n", p);
+	p = (char *)realloc(p, 200);
+	if (p == NULL)
+	{
+		return 0;
+	}
+	memset(p, 'B', 200);
+	printf("2 %p\n", p);
+	free(p);
+	p = new char[1000];
+	if (p == NULL)
+	{
+		return 0;
+	}
+	memset(p, 'A', 1000);
+	printf("3 %p\n", p);
+	p = new char[200];
+	if (p == NULL)
+	{
+		return 0;
+	}
+	memset(p, 'B', 200);
+	printf("4 %p\n", p);
+	free(p);
+	return 0;
+}
diff --git a/example/f.cpp b/example/f.cpp
new file mode 100644
index 000000000..f06711bd7
--- /dev/null
+++ b/example/f.cpp
@@ -0,0 +1,94 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <string>
+#include <pthread.h>
+#include <unistd.h>
+#include <assert.h>
+#include <hyperdex/admin.hpp>
+#include <hyperdex/client.hpp>
+#include <hyperdex/client.h>
+#include <e/endian.h>
+
+using namespace std;
+
+int
+main(int argc, const char *argv[])
+{
+	struct hyperdex_client *client = NULL;
+	struct hyperdex_client_attribute attr;
+	struct hyperdex_client_attribute_check check;
+	const struct hyperdex_client_attribute *attrs = NULL;
+	size_t attrs_sz = 0;
+	size_t check_len = 0;
+	uint64_t count;
+	int64_t op_id;
+	enum hyperdex_client_returncode op_status;
+	int64_t loop_id;
+	enum hyperdex_client_returncode loop_status;
+	size_t i;
+	const char *ns = "phonebook";
+	client = hyperdex_client_create("127.0.0.1", 1982);
+	check.attr = "first";
+	check.value = "Jack";
+	check.value_sz = strlen(check.value);
+	check.datatype = HYPERDATATYPE_STRING;
+	check.predicate = HYPERPREDICATE_EQUALS;
+	op_id = hyperdex_client_search(client, ns, &check, 1, &op_status, &attrs, &attrs_sz);
+	if (op_id < 0)
+	{
+		cerr << "search failed: " << hyperdex_client_error_message(client) << endl;
+		hyperdex_client_destroy(client);
+		return EXIT_FAILURE;
+	}
+	while (true)
+	{
+		loop_id = hyperdex_client_loop(client, -1, &loop_status);
+		if (loop_id < 0)
+		{
+			cerr << hyperdex_client_error_message(client) << endl;
+			break;
+		}
+		if (op_status == HYPERDEX_CLIENT_SEARCHDONE)
+		{
+			break;
+		}
+		assert(op_id == loop_id);
+		if (loop_status == HYPERDEX_CLIENT_SUCCESS)
+		{
+			printf("get done(%d)\n", attrs_sz);
+			for (i = 0; i < attrs_sz; ++i)
+			{
+				switch (attrs[i].datatype)
+				{
+				case HYPERDATATYPE_STRING:
+					printf("got attribute \"%s\" = \"%.*s\"\n", attrs[i].attr, attrs[i].value_sz, attrs[i].value);
+					break;
+				case HYPERDATATYPE_INT64:
+				{
+					uint64_t num = 0;
+					e::unpack64le(attrs[i].value, &num);
+					printf("got attribute \"%s\" = \"%lu\"\n", attrs[i].attr, num);
+				}
+				break;
+				case HYPERDATATYPE_FLOAT:
+				{
+					double num = 0;
+					e::unpackdoublele(attrs[i].value, &num);
+					printf("got attribute \"%s\" = \"%f\"\n", attrs[i].attr, num);
+				}
+				break;
+				default:
+					printf("got error attribute\n");
+				}
+			}
+		}
+	}
+	hyperdex_client_destroy_attrs(attrs, attrs_sz);
+	hyperdex_client_destroy(client);
+	return EXIT_SUCCESS;
+}
diff --git a/example/g.cpp b/example/g.cpp
new file mode 100644
index 000000000..7b06c1088
--- /dev/null
+++ b/example/g.cpp
@@ -0,0 +1,96 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <string>
+#include <pthread.h>
+#include <unistd.h>
+#include <assert.h>
+#include <hyperdex/admin.hpp>
+#include <hyperdex/client.hpp>
+#include <hyperdex/client.h>
+#include <e/endian.h>
+
+using namespace std;
+
+int
+main(int argc, const char *argv[])
+{
+	struct hyperdex_client *client = NULL;
+	struct hyperdex_client_attribute attr;
+	struct hyperdex_client_attribute_check check;
+	const struct hyperdex_client_attribute *attrs = NULL;
+	size_t attrs_sz = 0;
+	size_t check_len = 0;
+	uint64_t count;
+	int64_t op_id;
+	enum hyperdex_client_returncode op_status;
+	int64_t loop_id;
+	enum hyperdex_client_returncode loop_status;
+	size_t i;
+	const char *ns = "phonebook";
+	client = hyperdex_client_create("127.0.0.1", 1982);
+	const char *key = "jsmith3";
+	size_t key_len = strlen(key);
+	//check.attr = "first";
+	//check.value = "Jack";
+	//check.value_sz = strlen(check.value);
+	//check.datatype = HYPERDATATYPE_STRING;
+	//check.predicate = HYPERPREDICATE_EQUALS;
+	op_id = hyperdex_client_get(client, ns, key, key_len, &op_status, &attrs, &attrs_sz);
+	if (op_id < 0)
+	{
+		cerr << "get failed: " << hyperdex_client_error_message(client) << endl;
+		hyperdex_client_destroy(client);
+		return EXIT_FAILURE;
+	}
+	while (true)
+	{
+		loop_id = hyperdex_client_loop(client, -1, &loop_status);
+		if (loop_id < 0)
+		{
+			cerr << hyperdex_client_error_message(client) << endl;
+			break;
+		}
+		if (op_status == HYPERDEX_CLIENT_SEARCHDONE)
+		{
+			break;
+		}
+		assert(op_id == loop_id);
+		if (loop_status == HYPERDEX_CLIENT_SUCCESS)
+		{
+			printf("get done(%d)\n", attrs_sz);
+			for (i = 0; i < attrs_sz; ++i)
+			{
+				switch (attrs[i].datatype)
+				{
+				case HYPERDATATYPE_STRING:
+					printf("got attribute \"%s\" = \"%.*s\"\n", attrs[i].attr, attrs[i].value_sz, attrs[i].value);
+					break;
+				case HYPERDATATYPE_INT64:
+				{
+					uint64_t num = 0;
+					e::unpack64le(attrs[i].value, &num);
+					printf("got attribute \"%s\" = \"%lu\"\n", attrs[i].attr, num);
+				}
+				break;
+				case HYPERDATATYPE_FLOAT:
+				{
+					double num = 0;
+					e::unpackdoublele(attrs[i].value, &num);
+					printf("got attribute \"%s\" = \"%f\"\n", attrs[i].attr, num);
+				}
+				break;
+				default:
+					printf("got error attribute\n");
+				}
+			}
+		}
+	}
+	hyperdex_client_destroy_attrs(attrs, attrs_sz);
+	hyperdex_client_destroy(client);
+	return EXIT_SUCCESS;
+}
diff --git a/example/s.cpp b/example/s.cpp
new file mode 100644
index 000000000..c5457c3cb
--- /dev/null
+++ b/example/s.cpp
@@ -0,0 +1,110 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <string>
+#include <pthread.h>
+#include <unistd.h>
+#include <assert.h>
+#include <set>
+#include <hyperdex/admin.hpp>
+#include <hyperdex/client.hpp>
+#include <hyperdex/client.h>
+#include <e/endian.h>
+
+using namespace std;
+
+int
+main(int argc, const char *argv[])
+{
+	struct hyperdex_client *client = NULL;
+	struct hyperdex_client_attribute attr;
+	struct hyperdex_client_attribute_check check;
+	const struct hyperdex_client_attribute *attrs = NULL;
+	size_t attrs_sz = 0;
+	size_t check_len = 0;
+	uint64_t count;
+	int64_t op_id;
+	enum hyperdex_client_returncode op_status;
+	int64_t loop_id;
+	enum hyperdex_client_returncode loop_status;
+	size_t i;
+	const char *ns = "phonebook";
+	client = hyperdex_client_create("127.0.0.1", 1982);
+	const char *sortby = "first";
+	check.attr = "first";
+	check.value = "Jack";
+	check.value_sz = strlen(check.value);
+	check.datatype = HYPERDATATYPE_STRING;
+	check.predicate = HYPERPREDICATE_EQUALS;
+	int cnt = 1;
+	int max = 1;
+	if (argc == 2)
+	{
+		cnt = atoi(argv[1]);
+	}
+	else if (argc == 3)
+	{
+		cnt = atoi(argv[1]);
+		max = atoi(argv[2]);
+	}
+	op_id = hyperdex_client_sorted_search(client, ns, &check, 0, sortby, cnt, max, &op_status, &attrs, &attrs_sz);
+	if (op_id < 0)
+	{
+		cerr << "get failed: " << hyperdex_client_error_message(client) << endl;
+		hyperdex_client_destroy(client);
+		return EXIT_FAILURE;
+	}
+	while (true)
+	{
+		loop_id = hyperdex_client_loop(client, -1, &loop_status);
+		if (loop_id < 0)
+		{
+			cerr << hyperdex_client_error_message(client) << endl;
+			break;
+		}
+		if (op_status == HYPERDEX_CLIENT_SEARCHDONE)
+		{
+			break;
+		}
+		if (loop_status == HYPERDEX_CLIENT_SUCCESS)
+		{
+			printf("get done(%d)\n", attrs_sz);
+			for (i = 0; i < attrs_sz; ++i)
+			{
+				if (attrs[i].value_sz == 0)
+				{
+					continue;
+				}
+				switch (attrs[i].datatype)
+				{
+				case HYPERDATATYPE_STRING:
+					printf("got attribute \"%s\" = \"%.*s\"\n", attrs[i].attr, attrs[i].value_sz, attrs[i].value);
+					break;
+				case HYPERDATATYPE_INT64:
+				{
+					uint64_t num = 0;
+					e::unpack64le(attrs[i].value, &num);
+					printf("got attribute \"%s\" = \"%lu\"\n", attrs[i].attr, num);
+				}
+				break;
+				case HYPERDATATYPE_FLOAT:
+				{
+					double num = 0;
+					e::unpackdoublele(attrs[i].value, &num);
+					printf("got attribute \"%s\" = \"%f\"\n", attrs[i].attr, num);
+				}
+				break;
+				default:
+					printf("got error attribute\n");
+				}
+			}
+		}
+	}
+	hyperdex_client_destroy_attrs(attrs, attrs_sz);
+	hyperdex_client_destroy(client);
+	return EXIT_SUCCESS;
+}
diff --git a/example/sum.cpp b/example/sum.cpp
new file mode 100644
index 000000000..9382942db
--- /dev/null
+++ b/example/sum.cpp
@@ -0,0 +1,69 @@
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <string>
+#include <pthread.h>
+#include <unistd.h>
+#include <assert.h>
+#include "hyperdex/admin.hpp"
+#include "hyperdex/client.hpp"
+#include "hyperdex/client.h"
+#include <e/endian.h>
+
+using namespace std;
+
+int
+main(int argc, const char *argv[])
+{
+	struct hyperdex_client *client = NULL;
+	struct hyperdex_client_attribute attr;
+	struct hyperdex_client_attribute_check check;
+	const struct hyperdex_client_attribute *attrs = NULL;
+	size_t attrs_sz = 0;
+	size_t check_len = 0;
+	uint64_t sum = 0;
+	int64_t op_id;
+	enum hyperdex_client_returncode op_status;
+	int64_t loop_id;
+	enum hyperdex_client_returncode loop_status;
+	size_t i;
+	const char *ns = "phonebook";
+	client = hyperdex_client_create("127.0.0.1", 1982);
+	const char *row_key = "phone";
+	check.attr = "first";
+	check.value = "Jack";
+	check.value_sz = strlen(check.value);
+	check.datatype = HYPERDATATYPE_STRING;
+	check.predicate = HYPERPREDICATE_EQUALS;
+	op_id = hyperdex_client_sum(client, ns, &check, 1, row_key, &op_status, &sum);
+	if (op_id < 0)
+	{
+		cerr << "search failed: " << hyperdex_client_error_message(client) << endl;
+		hyperdex_client_destroy(client);
+		return EXIT_FAILURE;
+	}
+	while (true)
+	{
+		loop_id = hyperdex_client_loop(client, -1, &loop_status);
+		if (loop_id < 0)
+		{
+			cerr << hyperdex_client_error_message(client) << endl;
+			break;
+		}
+		//if (op_status == HYPERDEX_CLIENT_SEARCHDONE) {
+		//	break;
+		//}
+		assert(op_id == loop_id);
+		if (loop_status == HYPERDEX_CLIENT_SUCCESS)
+		{
+			printf("get done(%llu)\n", sum);
+		}
+	}
+	hyperdex_client_destroy_attrs(attrs, attrs_sz);
+	hyperdex_client_destroy(client);
+	return EXIT_SUCCESS;
+}
diff --git a/hyperdex.cc b/hyperdex.cc
index 02083c980..3a7144d07 100644
--- a/hyperdex.cc
+++ b/hyperdex.cc
@@ -36,36 +36,36 @@
 #include <e/subcommand.h>
 
 int
-main(int argc, const char* argv[])
+main(int argc, const char *argv[])
 {
-    std::vector<e::subcommand> cmds;
-    cmds.push_back(e::subcommand("coordinator",           "Start a new HyperDex coordinator"));
-    cmds.push_back(e::subcommand("daemon",                "Start a new HyperDex daemon"));
-    cmds.push_back(e::subcommand("add-space",             "Create a new HyperDex space"));
-    cmds.push_back(e::subcommand("rm-space",              "Remove an existing HyperDex space"));
-    cmds.push_back(e::subcommand("mv-space",              "Rename a HyperDex space"));
-    cmds.push_back(e::subcommand("add-index",             "Create a new index on an existing space"));
-    cmds.push_back(e::subcommand("rm-index",              "Remove an existing index"));
-    cmds.push_back(e::subcommand("list-spaces",           "List the names of all spaces"));
-    cmds.push_back(e::subcommand("validate-space",        "Validate a HyperDex space description"));
-    cmds.push_back(e::subcommand("server-register",       "Manually register a new HyperDex server"));
-    cmds.push_back(e::subcommand("server-offline",        "Manually take a daemon offline"));
-    cmds.push_back(e::subcommand("server-online",         "Manually bring a daemon online"));
-    cmds.push_back(e::subcommand("server-kill",           "Manually and permanently kill a daemon"));
-    cmds.push_back(e::subcommand("server-forget",         "Manually remove all trace that a daemon exists"));
-    cmds.push_back(e::subcommand("show-config",           "Output a human-readable version of the cluster configuration"));
-    cmds.push_back(e::subcommand("perf-counters",         "Collect performance counters from a cluster"));
-    cmds.push_back(e::subcommand("set-read-only",         "Put the cluster into read-only mode, blocking writes"));
-    cmds.push_back(e::subcommand("set-read-write",        "Put the cluster into read-write mode, permitting writes"));
-    cmds.push_back(e::subcommand("set-fault-tolerance",   "Set the fault-tolerance for the specified space"));
-    cmds.push_back(e::subcommand("backup",                "Take a backup of the entire HyperDex cluster"));
-    cmds.push_back(e::subcommand("backup-manager",        "Manage incremental backups of the entire HyperDex cluster"));
-    cmds.push_back(e::subcommand("raw-backup",            "Take a raw backup of a single HyperDex daemon"));
-    cmds.push_back(e::subcommand("wait-until-stable",     "Wait for the cluster to become stable on the new configuration"));
-    return dispatch_to_subcommands(argc, argv,
-                                   "hyperdex", "HyperDex",
-                                   PACKAGE_VERSION,
-                                   "hyperdex-",
-                                   "HYPERDEX_EXEC_PATH", HYPERDEX_EXEC_DIR,
-                                   &cmds.front(), cmds.size());
+	std::vector<e::subcommand> cmds;
+	cmds.push_back(e::subcommand("coordinator",           "Start a new HyperDex coordinator"));
+	cmds.push_back(e::subcommand("daemon",                "Start a new HyperDex daemon"));
+	cmds.push_back(e::subcommand("add-space",             "Create a new HyperDex space"));
+	cmds.push_back(e::subcommand("rm-space",              "Remove an existing HyperDex space"));
+	cmds.push_back(e::subcommand("mv-space",              "Rename a HyperDex space"));
+	cmds.push_back(e::subcommand("add-index",             "Create a new index on an existing space"));
+	cmds.push_back(e::subcommand("rm-index",              "Remove an existing index"));
+	cmds.push_back(e::subcommand("list-spaces",           "List the names of all spaces"));
+	cmds.push_back(e::subcommand("validate-space",        "Validate a HyperDex space description"));
+	cmds.push_back(e::subcommand("server-register",       "Manually register a new HyperDex server"));
+	cmds.push_back(e::subcommand("server-offline",        "Manually take a daemon offline"));
+	cmds.push_back(e::subcommand("server-online",         "Manually bring a daemon online"));
+	cmds.push_back(e::subcommand("server-kill",           "Manually and permanently kill a daemon"));
+	cmds.push_back(e::subcommand("server-forget",         "Manually remove all trace that a daemon exists"));
+	cmds.push_back(e::subcommand("show-config",           "Output a human-readable version of the cluster configuration"));
+	cmds.push_back(e::subcommand("perf-counters",         "Collect performance counters from a cluster"));
+	cmds.push_back(e::subcommand("set-read-only",         "Put the cluster into read-only mode, blocking writes"));
+	cmds.push_back(e::subcommand("set-read-write",        "Put the cluster into read-write mode, permitting writes"));
+	cmds.push_back(e::subcommand("set-fault-tolerance",   "Set the fault-tolerance for the specified space"));
+	cmds.push_back(e::subcommand("backup",                "Take a backup of the entire HyperDex cluster"));
+	cmds.push_back(e::subcommand("backup-manager",        "Manage incremental backups of the entire HyperDex cluster"));
+	cmds.push_back(e::subcommand("raw-backup",            "Take a raw backup of a single HyperDex daemon"));
+	cmds.push_back(e::subcommand("wait-until-stable",     "Wait for the cluster to become stable on the new configuration"));
+	return dispatch_to_subcommands(argc, argv,
+	                               "hyperdex", "HyperDex",
+	                               PACKAGE_VERSION,
+	                               "hyperdex-",
+	                               "HYPERDEX_EXEC_PATH", HYPERDEX_EXEC_DIR,
+	                               &cmds.front(), cmds.size());
 }
diff --git a/include/hyperdex.h b/include/hyperdex.h
index 936c9f66b..a94cc97e4 100644
--- a/include/hyperdex.h
+++ b/include/hyperdex.h
@@ -52,72 +52,72 @@ extern "C"
 
 enum hyperdatatype
 {
-    /* Primitive types */
-    HYPERDATATYPE_GENERIC   = 9216,
-    HYPERDATATYPE_STRING    = 9217,
-    HYPERDATATYPE_INT64     = 9218,
-    HYPERDATATYPE_FLOAT     = 9219,
-    HYPERDATATYPE_DOCUMENT  = 9223,
-
-    /* List types */
-    HYPERDATATYPE_LIST_GENERIC = 9280,
-    HYPERDATATYPE_LIST_STRING  = 9281,
-    HYPERDATATYPE_LIST_INT64   = 9282,
-    HYPERDATATYPE_LIST_FLOAT   = 9283,
-
-    /* Set types */
-    HYPERDATATYPE_SET_GENERIC = 9344,
-    HYPERDATATYPE_SET_STRING  = 9345,
-    HYPERDATATYPE_SET_INT64   = 9346,
-    HYPERDATATYPE_SET_FLOAT   = 9347,
-
-    /* Map types */
-    HYPERDATATYPE_MAP_GENERIC        = 9408,
-    HYPERDATATYPE_MAP_STRING_KEYONLY = 9416,
-    HYPERDATATYPE_MAP_STRING_STRING  = 9417,
-    HYPERDATATYPE_MAP_STRING_INT64   = 9418,
-    HYPERDATATYPE_MAP_STRING_FLOAT   = 9419,
-    HYPERDATATYPE_MAP_INT64_KEYONLY  = 9424,
-    HYPERDATATYPE_MAP_INT64_STRING   = 9425,
-    HYPERDATATYPE_MAP_INT64_INT64    = 9426,
-    HYPERDATATYPE_MAP_INT64_FLOAT    = 9427,
-    HYPERDATATYPE_MAP_FLOAT_KEYONLY  = 9432,
-    HYPERDATATYPE_MAP_FLOAT_STRING   = 9433,
-    HYPERDATATYPE_MAP_FLOAT_INT64    = 9434,
-    HYPERDATATYPE_MAP_FLOAT_FLOAT    = 9435,
-
-    /*Timestamp types */
-    HYPERDATATYPE_TIMESTAMP_GENERIC  = 9472,
-    HYPERDATATYPE_TIMESTAMP_SECOND   = 9473,
-    HYPERDATATYPE_TIMESTAMP_MINUTE   = 9474,
-    HYPERDATATYPE_TIMESTAMP_HOUR     = 9475,
-    HYPERDATATYPE_TIMESTAMP_DAY      = 9476,
-    HYPERDATATYPE_TIMESTAMP_WEEK     = 9477,
-    HYPERDATATYPE_TIMESTAMP_MONTH    = 9478,
-
-    /* Special (internal) types */
-    HYPERDATATYPE_MACAROON_SECRET    = 9664,
-
-    /* Returned if the server acts up */
-    HYPERDATATYPE_GARBAGE   = 9727
+	/* Primitive types */
+	HYPERDATATYPE_GENERIC   = 9216,
+	HYPERDATATYPE_STRING    = 9217,
+	HYPERDATATYPE_INT64     = 9218,
+	HYPERDATATYPE_FLOAT     = 9219,
+	HYPERDATATYPE_DOCUMENT  = 9223,
+
+	/* List types */
+	HYPERDATATYPE_LIST_GENERIC = 9280,
+	HYPERDATATYPE_LIST_STRING  = 9281,
+	HYPERDATATYPE_LIST_INT64   = 9282,
+	HYPERDATATYPE_LIST_FLOAT   = 9283,
+
+	/* Set types */
+	HYPERDATATYPE_SET_GENERIC = 9344,
+	HYPERDATATYPE_SET_STRING  = 9345,
+	HYPERDATATYPE_SET_INT64   = 9346,
+	HYPERDATATYPE_SET_FLOAT   = 9347,
+
+	/* Map types */
+	HYPERDATATYPE_MAP_GENERIC        = 9408,
+	HYPERDATATYPE_MAP_STRING_KEYONLY = 9416,
+	HYPERDATATYPE_MAP_STRING_STRING  = 9417,
+	HYPERDATATYPE_MAP_STRING_INT64   = 9418,
+	HYPERDATATYPE_MAP_STRING_FLOAT   = 9419,
+	HYPERDATATYPE_MAP_INT64_KEYONLY  = 9424,
+	HYPERDATATYPE_MAP_INT64_STRING   = 9425,
+	HYPERDATATYPE_MAP_INT64_INT64    = 9426,
+	HYPERDATATYPE_MAP_INT64_FLOAT    = 9427,
+	HYPERDATATYPE_MAP_FLOAT_KEYONLY  = 9432,
+	HYPERDATATYPE_MAP_FLOAT_STRING   = 9433,
+	HYPERDATATYPE_MAP_FLOAT_INT64    = 9434,
+	HYPERDATATYPE_MAP_FLOAT_FLOAT    = 9435,
+
+	/*Timestamp types */
+	HYPERDATATYPE_TIMESTAMP_GENERIC  = 9472,
+	HYPERDATATYPE_TIMESTAMP_SECOND   = 9473,
+	HYPERDATATYPE_TIMESTAMP_MINUTE   = 9474,
+	HYPERDATATYPE_TIMESTAMP_HOUR     = 9475,
+	HYPERDATATYPE_TIMESTAMP_DAY      = 9476,
+	HYPERDATATYPE_TIMESTAMP_WEEK     = 9477,
+	HYPERDATATYPE_TIMESTAMP_MONTH    = 9478,
+
+	/* Special (internal) types */
+	HYPERDATATYPE_MACAROON_SECRET    = 9664,
+
+	/* Returned if the server acts up */
+	HYPERDATATYPE_GARBAGE   = 9727
 };
 
 /* Predicate occupies [9728, 9856) */
 enum hyperpredicate
 {
-    HYPERPREDICATE_FAIL          = 9728,
-    HYPERPREDICATE_EQUALS        = 9729,
-    HYPERPREDICATE_LESS_THAN     = 9738,
-    HYPERPREDICATE_LESS_EQUAL    = 9730,
-    HYPERPREDICATE_GREATER_EQUAL = 9731,
-    HYPERPREDICATE_GREATER_THAN  = 9739,
-    HYPERPREDICATE_CONTAINS_LESS_THAN = 9732, /* alias of HYPERPREDICATE_LENGTH_LESS_EQUAL */
-    HYPERPREDICATE_REGEX         = 9733,
-    HYPERPREDICATE_LENGTH_EQUALS        = 9734,
-    HYPERPREDICATE_LENGTH_LESS_EQUAL    = 9735,
-    HYPERPREDICATE_LENGTH_GREATER_EQUAL = 9736,
-    HYPERPREDICATE_CONTAINS      = 9737
-    /* NEXT = 9740 */
+	HYPERPREDICATE_FAIL          = 9728,
+	HYPERPREDICATE_EQUALS        = 9729,
+	HYPERPREDICATE_LESS_THAN     = 9738,
+	HYPERPREDICATE_LESS_EQUAL    = 9730,
+	HYPERPREDICATE_GREATER_EQUAL = 9731,
+	HYPERPREDICATE_GREATER_THAN  = 9739,
+	HYPERPREDICATE_CONTAINS_LESS_THAN = 9732, /* alias of HYPERPREDICATE_LENGTH_LESS_EQUAL */
+	HYPERPREDICATE_REGEX         = 9733,
+	HYPERPREDICATE_LENGTH_EQUALS        = 9734,
+	HYPERPREDICATE_LENGTH_LESS_EQUAL    = 9735,
+	HYPERPREDICATE_LENGTH_GREATER_EQUAL = 9736,
+	HYPERPREDICATE_CONTAINS      = 9737
+	                               /* NEXT = 9740 */
 };
 
 #ifdef __cplusplus
@@ -126,10 +126,10 @@ enum hyperpredicate
 /* C++ */
 #include <iostream>
 
-std::ostream&
-operator << (std::ostream& lhs, hyperdatatype rhs);
-std::ostream&
-operator << (std::ostream& lhs, hyperpredicate rhs);
+std::ostream &
+operator << (std::ostream &lhs, hyperdatatype rhs);
+std::ostream &
+operator << (std::ostream &lhs, hyperpredicate rhs);
 
 #endif /* __cplusplus */
 #endif /* hyperdex_h_ */
diff --git a/include/hyperdex/admin.h b/include/hyperdex/admin.h
index 1b7a33fb5..28453b244 100644
--- a/include/hyperdex/admin.h
+++ b/include/hyperdex/admin.h
@@ -45,165 +45,165 @@ struct hyperdex_admin;
 
 struct hyperdex_admin_perf_counter
 {
-    uint64_t id;
-    uint64_t time;
-    const char* property;
-    uint64_t measurement;
+	uint64_t id;
+	uint64_t time;
+	const char *property;
+	uint64_t measurement;
 };
 
 /* hyperdex_admin_returncode occupies [8704, 8832) */
 enum hyperdex_admin_returncode
 {
-    HYPERDEX_ADMIN_SUCCESS     = 8704,
-
-    /* Error conditions */
-    HYPERDEX_ADMIN_NOMEM       = 8768,
-    HYPERDEX_ADMIN_NONEPENDING = 8769,
-    HYPERDEX_ADMIN_POLLFAILED  = 8770,
-    HYPERDEX_ADMIN_TIMEOUT     = 8771,
-    HYPERDEX_ADMIN_INTERRUPTED = 8772,
-    HYPERDEX_ADMIN_SERVERERROR = 8773,
-    HYPERDEX_ADMIN_COORDFAIL   = 8774,
-    HYPERDEX_ADMIN_BADSPACE    = 8775,
-    HYPERDEX_ADMIN_DUPLICATE   = 8776,
-    HYPERDEX_ADMIN_NOTFOUND    = 8777,
-    HYPERDEX_ADMIN_LOCALERROR  = 8778,
-
-    /* This should never happen.  It indicates a bug */
-    HYPERDEX_ADMIN_INTERNAL    = 8829,
-    HYPERDEX_ADMIN_EXCEPTION   = 8830,
-    HYPERDEX_ADMIN_GARBAGE     = 8831
+	HYPERDEX_ADMIN_SUCCESS     = 8704,
+
+	/* Error conditions */
+	HYPERDEX_ADMIN_NOMEM       = 8768,
+	HYPERDEX_ADMIN_NONEPENDING = 8769,
+	HYPERDEX_ADMIN_POLLFAILED  = 8770,
+	HYPERDEX_ADMIN_TIMEOUT     = 8771,
+	HYPERDEX_ADMIN_INTERRUPTED = 8772,
+	HYPERDEX_ADMIN_SERVERERROR = 8773,
+	HYPERDEX_ADMIN_COORDFAIL   = 8774,
+	HYPERDEX_ADMIN_BADSPACE    = 8775,
+	HYPERDEX_ADMIN_DUPLICATE   = 8776,
+	HYPERDEX_ADMIN_NOTFOUND    = 8777,
+	HYPERDEX_ADMIN_LOCALERROR  = 8778,
+
+	/* This should never happen.  It indicates a bug */
+	HYPERDEX_ADMIN_INTERNAL    = 8829,
+	HYPERDEX_ADMIN_EXCEPTION   = 8830,
+	HYPERDEX_ADMIN_GARBAGE     = 8831
 };
 
-struct hyperdex_admin*
-hyperdex_admin_create(const char* coordinator, uint16_t port);
+struct hyperdex_admin *
+hyperdex_admin_create(const char *coordinator, uint16_t port);
 
 void
-hyperdex_admin_destroy(struct hyperdex_admin* admin);
+hyperdex_admin_destroy(struct hyperdex_admin *admin);
 
 int64_t
-hyperdex_admin_dump_config(struct hyperdex_admin* admin,
-                           enum hyperdex_admin_returncode* status,
-                           const char** config);
+hyperdex_admin_dump_config(struct hyperdex_admin *admin,
+                           enum hyperdex_admin_returncode *status,
+                           const char **config);
 int64_t
-hyperdex_admin_read_only(struct hyperdex_admin* admin,
+hyperdex_admin_read_only(struct hyperdex_admin *admin,
                          int ro,
-                         enum hyperdex_admin_returncode* status);
+                         enum hyperdex_admin_returncode *status);
 
 int64_t
-hyperdex_admin_wait_until_stable(struct hyperdex_admin* admin,
-                                 enum hyperdex_admin_returncode* status);
+hyperdex_admin_wait_until_stable(struct hyperdex_admin *admin,
+                                 enum hyperdex_admin_returncode *status);
 
 int64_t
-hyperdex_admin_fault_tolerance(struct hyperdex_admin* admin,
-                               const char* space,
+hyperdex_admin_fault_tolerance(struct hyperdex_admin *admin,
+                               const char *space,
                                uint64_t ft,
-                               enum hyperdex_admin_returncode* status);
+                               enum hyperdex_admin_returncode *status);
 
 int
-hyperdex_admin_validate_space(struct hyperdex_admin* admin,
-                              const char* description,
-                              enum hyperdex_admin_returncode* status);
+hyperdex_admin_validate_space(struct hyperdex_admin *admin,
+                              const char *description,
+                              enum hyperdex_admin_returncode *status);
 
 int64_t
-hyperdex_admin_add_space(struct hyperdex_admin* admin,
-                         const char* description,
-                         enum hyperdex_admin_returncode* status);
+hyperdex_admin_add_space(struct hyperdex_admin *admin,
+                         const char *description,
+                         enum hyperdex_admin_returncode *status);
 
 int64_t
-hyperdex_admin_rm_space(struct hyperdex_admin* admin,
-                        const char* space,
-                        enum hyperdex_admin_returncode* status);
+hyperdex_admin_rm_space(struct hyperdex_admin *admin,
+                        const char *space,
+                        enum hyperdex_admin_returncode *status);
 
 int64_t
-hyperdex_admin_mv_space(struct hyperdex_admin* admin,
-                        const char* source,
-                        const char* target,
-                        enum hyperdex_admin_returncode* status);
+hyperdex_admin_mv_space(struct hyperdex_admin *admin,
+                        const char *source,
+                        const char *target,
+                        enum hyperdex_admin_returncode *status);
 
 int64_t
-hyperdex_admin_list_spaces(struct hyperdex_admin* admin,
-                           enum hyperdex_admin_returncode* status,
-                           const char** spaces);
+hyperdex_admin_list_spaces(struct hyperdex_admin *admin,
+                           enum hyperdex_admin_returncode *status,
+                           const char **spaces);
 
 int64_t
-hyperdex_admin_list_indices(struct hyperdex_admin* admin,
-                            const char* space,
-                            enum hyperdex_admin_returncode* status,
-                            const char** indexes);
+hyperdex_admin_list_indices(struct hyperdex_admin *admin,
+                            const char *space,
+                            enum hyperdex_admin_returncode *status,
+                            const char **indexes);
 
 int64_t
-hyperdex_admin_list_subspaces(struct hyperdex_admin* admin,
-                              const char* space,
-                              enum hyperdex_admin_returncode* status,
-                              const char** subspaces);
+hyperdex_admin_list_subspaces(struct hyperdex_admin *admin,
+                              const char *space,
+                              enum hyperdex_admin_returncode *status,
+                              const char **subspaces);
 
 int64_t
-hyperdex_admin_add_index(struct hyperdex_admin* admin,
-                         const char* space,
-                         const char* attribute,
-                         enum hyperdex_admin_returncode* status);
+hyperdex_admin_add_index(struct hyperdex_admin *admin,
+                         const char *space,
+                         const char *attribute,
+                         enum hyperdex_admin_returncode *status);
 
 int64_t
-hyperdex_admin_rm_index(struct hyperdex_admin* admin,
+hyperdex_admin_rm_index(struct hyperdex_admin *admin,
                         uint64_t idxid,
-                        enum hyperdex_admin_returncode* status);
+                        enum hyperdex_admin_returncode *status);
 
 int64_t
-hyperdex_admin_server_register(struct hyperdex_admin* admin,
+hyperdex_admin_server_register(struct hyperdex_admin *admin,
                                uint64_t token,
-                               const char* address,
-                               enum hyperdex_admin_returncode* status);
+                               const char *address,
+                               enum hyperdex_admin_returncode *status);
 
 int64_t
-hyperdex_admin_server_online(struct hyperdex_admin* admin,
+hyperdex_admin_server_online(struct hyperdex_admin *admin,
                              uint64_t token,
-                             enum hyperdex_admin_returncode* status);
+                             enum hyperdex_admin_returncode *status);
 
 int64_t
-hyperdex_admin_server_offline(struct hyperdex_admin* admin,
+hyperdex_admin_server_offline(struct hyperdex_admin *admin,
                               uint64_t token,
-                              enum hyperdex_admin_returncode* status);
+                              enum hyperdex_admin_returncode *status);
 
 int64_t
-hyperdex_admin_server_forget(struct hyperdex_admin* admin,
+hyperdex_admin_server_forget(struct hyperdex_admin *admin,
                              uint64_t token,
-                             enum hyperdex_admin_returncode* status);
+                             enum hyperdex_admin_returncode *status);
 
 int64_t
-hyperdex_admin_server_kill(struct hyperdex_admin* admin,
+hyperdex_admin_server_kill(struct hyperdex_admin *admin,
                            uint64_t token,
-                           enum hyperdex_admin_returncode* status);
+                           enum hyperdex_admin_returncode *status);
 
 int64_t
-hyperdex_admin_backup(struct hyperdex_admin* admin,
-                      const char* backup,
-                      enum hyperdex_admin_returncode* status,
-                      const char** backups);
+hyperdex_admin_backup(struct hyperdex_admin *admin,
+                      const char *backup,
+                      enum hyperdex_admin_returncode *status,
+                      const char **backups);
 
 int64_t
-hyperdex_admin_enable_perf_counters(struct hyperdex_admin* admin,
-                                    enum hyperdex_admin_returncode* status,
-                                    struct hyperdex_admin_perf_counter* pc);
+hyperdex_admin_enable_perf_counters(struct hyperdex_admin *admin,
+                                    enum hyperdex_admin_returncode *status,
+                                    struct hyperdex_admin_perf_counter *pc);
 
 void
-hyperdex_admin_disable_perf_counters(struct hyperdex_admin* admin);
+hyperdex_admin_disable_perf_counters(struct hyperdex_admin *admin);
 
 int64_t
-hyperdex_admin_loop(struct hyperdex_admin* admin, int timeout,
-                    enum hyperdex_admin_returncode* status);
+hyperdex_admin_loop(struct hyperdex_admin *admin, int timeout,
+                    enum hyperdex_admin_returncode *status);
 
 int
-hyperdex_admin_raw_backup(const char* host, uint16_t port,
-                          const char* name,
-                          enum hyperdex_admin_returncode* status);
+hyperdex_admin_raw_backup(const char *host, uint16_t port,
+                          const char *name,
+                          enum hyperdex_admin_returncode *status);
 
-const char*
-hyperdex_admin_error_message(struct hyperdex_admin* admin);
-const char*
-hyperdex_admin_error_location(struct hyperdex_admin* admin);
+const char *
+hyperdex_admin_error_message(struct hyperdex_admin *admin);
+const char *
+hyperdex_admin_error_location(struct hyperdex_admin *admin);
 
-const char*
+const char *
 hyperdex_admin_returncode_to_string(enum hyperdex_admin_returncode);
 
 #ifdef __cplusplus
diff --git a/include/hyperdex/admin.hpp b/include/hyperdex/admin.hpp
index adbe39775..2b8981d0c 100644
--- a/include/hyperdex/admin.hpp
+++ b/include/hyperdex/admin.hpp
@@ -39,89 +39,89 @@ namespace hyperdex
 
 class Admin
 {
-    public:
-        Admin(const char* coordinator, uint16_t port)
-            : m_adm(hyperdex_admin_create(coordinator, port))
-        {
-            if (!m_adm)
-            {
-                throw std::bad_alloc();
-            }
-        }
-        ~Admin() throw ()
-        {
-            hyperdex_admin_destroy(m_adm);
-        }
+public:
+	Admin(const char *coordinator, uint16_t port)
+		: m_adm(hyperdex_admin_create(coordinator, port))
+	{
+		if (!m_adm)
+		{
+			throw std::bad_alloc();
+		}
+	}
+	~Admin() throw ()
+	{
+		hyperdex_admin_destroy(m_adm);
+	}
 
-    public:
-        int64_t dump_config(enum hyperdex_admin_returncode* status,
-                            const char** config)
-            { return hyperdex_admin_dump_config(m_adm, status, config); }
-        int64_t read_only(int ro, enum hyperdex_admin_returncode* status)
-            { return hyperdex_admin_read_only(m_adm, ro, status); }
-        int64_t wait_until_stable(enum hyperdex_admin_returncode* status)
-            { return hyperdex_admin_wait_until_stable(m_adm, status); }
-        int64_t fault_tolerance(const char* space, uint64_t ft,
-                                enum hyperdex_admin_returncode* status)
-            { return hyperdex_admin_fault_tolerance(m_adm, space, ft, status); }
-        int validate_space(const char* description,
-                           enum hyperdex_admin_returncode* status)
-            { return hyperdex_admin_validate_space(m_adm, description, status); }
-        int64_t add_space(const char* description,
-                          enum hyperdex_admin_returncode* status)
-            { return hyperdex_admin_add_space(m_adm, description, status); }
-        int64_t rm_space(const char* name,
-                         enum hyperdex_admin_returncode* status)
-            { return hyperdex_admin_rm_space(m_adm, name, status); }
-        int64_t mv_space(const char* source, const char* target,
-                         enum hyperdex_admin_returncode* status)
-            { return hyperdex_admin_mv_space(m_adm, source, target, status); }
-        int64_t list_spaces(enum hyperdex_admin_returncode* status,
-                            const char** spaces)
-            { return hyperdex_admin_list_spaces(m_adm, status, spaces); }
-        int64_t add_index(const char* space, const char* attr,
-                          enum hyperdex_admin_returncode* status)
-            { return hyperdex_admin_add_index(m_adm, space, attr, status); }
-        int64_t rm_index(uint64_t idxid, enum hyperdex_admin_returncode* status)
-            { return hyperdex_admin_rm_index(m_adm, idxid, status); }
-        int64_t server_register(uint64_t token, const char* address,
-                                enum hyperdex_admin_returncode* status)
-            { return hyperdex_admin_server_register(m_adm, token, address, status); }
-        int64_t server_online(uint64_t token, enum hyperdex_admin_returncode* status)
-            { return hyperdex_admin_server_online(m_adm, token, status); }
-        int64_t server_offline(uint64_t token, enum hyperdex_admin_returncode* status)
-            { return hyperdex_admin_server_offline(m_adm, token, status); }
-        int64_t server_forget(uint64_t token, enum hyperdex_admin_returncode* status)
-            { return hyperdex_admin_server_forget(m_adm, token, status); }
-        int64_t server_kill(uint64_t token, enum hyperdex_admin_returncode* status)
-            { return hyperdex_admin_server_kill(m_adm, token, status); }
-        int64_t backup(const char* name, enum hyperdex_admin_returncode* status, const char** backups)
-            { return hyperdex_admin_backup(m_adm, name, status, backups); }
-        int64_t enable_perf_counters(enum hyperdex_admin_returncode* status,
-                                     struct hyperdex_admin_perf_counter* pc)
-            { return hyperdex_admin_enable_perf_counters(m_adm, status, pc); }
-        void disable_perf_counters()
-            { return hyperdex_admin_disable_perf_counters(m_adm); }
+public:
+	int64_t dump_config(enum hyperdex_admin_returncode *status,
+	                    const char **config)
+	{ return hyperdex_admin_dump_config(m_adm, status, config); }
+	int64_t read_only(int ro, enum hyperdex_admin_returncode *status)
+	{ return hyperdex_admin_read_only(m_adm, ro, status); }
+	int64_t wait_until_stable(enum hyperdex_admin_returncode *status)
+	{ return hyperdex_admin_wait_until_stable(m_adm, status); }
+	int64_t fault_tolerance(const char *space, uint64_t ft,
+	                        enum hyperdex_admin_returncode *status)
+	{ return hyperdex_admin_fault_tolerance(m_adm, space, ft, status); }
+	int validate_space(const char *description,
+	                   enum hyperdex_admin_returncode *status)
+	{ return hyperdex_admin_validate_space(m_adm, description, status); }
+	int64_t add_space(const char *description,
+	                  enum hyperdex_admin_returncode *status)
+	{ return hyperdex_admin_add_space(m_adm, description, status); }
+	int64_t rm_space(const char *name,
+	                 enum hyperdex_admin_returncode *status)
+	{ return hyperdex_admin_rm_space(m_adm, name, status); }
+	int64_t mv_space(const char *source, const char *target,
+	                 enum hyperdex_admin_returncode *status)
+	{ return hyperdex_admin_mv_space(m_adm, source, target, status); }
+	int64_t list_spaces(enum hyperdex_admin_returncode *status,
+	                    const char **spaces)
+	{ return hyperdex_admin_list_spaces(m_adm, status, spaces); }
+	int64_t add_index(const char *space, const char *attr,
+	                  enum hyperdex_admin_returncode *status)
+	{ return hyperdex_admin_add_index(m_adm, space, attr, status); }
+	int64_t rm_index(uint64_t idxid, enum hyperdex_admin_returncode *status)
+	{ return hyperdex_admin_rm_index(m_adm, idxid, status); }
+	int64_t server_register(uint64_t token, const char *address,
+	                        enum hyperdex_admin_returncode *status)
+	{ return hyperdex_admin_server_register(m_adm, token, address, status); }
+	int64_t server_online(uint64_t token, enum hyperdex_admin_returncode *status)
+	{ return hyperdex_admin_server_online(m_adm, token, status); }
+	int64_t server_offline(uint64_t token, enum hyperdex_admin_returncode *status)
+	{ return hyperdex_admin_server_offline(m_adm, token, status); }
+	int64_t server_forget(uint64_t token, enum hyperdex_admin_returncode *status)
+	{ return hyperdex_admin_server_forget(m_adm, token, status); }
+	int64_t server_kill(uint64_t token, enum hyperdex_admin_returncode *status)
+	{ return hyperdex_admin_server_kill(m_adm, token, status); }
+	int64_t backup(const char *name, enum hyperdex_admin_returncode *status, const char **backups)
+	{ return hyperdex_admin_backup(m_adm, name, status, backups); }
+	int64_t enable_perf_counters(enum hyperdex_admin_returncode *status,
+	                             struct hyperdex_admin_perf_counter *pc)
+	{ return hyperdex_admin_enable_perf_counters(m_adm, status, pc); }
+	void disable_perf_counters()
+	{ return hyperdex_admin_disable_perf_counters(m_adm); }
 
-    public:
-        int64_t loop(int timeout, enum hyperdex_admin_returncode* status)
-            { return hyperdex_admin_loop(m_adm, timeout, status); }
-        std::string error_message()
-            { return hyperdex_admin_error_message(m_adm); }
-        std::string error_location()
-            { return hyperdex_admin_error_location(m_adm); }
+public:
+	int64_t loop(int timeout, enum hyperdex_admin_returncode *status)
+	{ return hyperdex_admin_loop(m_adm, timeout, status); }
+	std::string error_message()
+	{ return hyperdex_admin_error_message(m_adm); }
+	std::string error_location()
+	{ return hyperdex_admin_error_location(m_adm); }
 
-    private:
-        Admin(const Admin&);
-        Admin& operator = (const Admin&);
+private:
+	Admin(const Admin &);
+	Admin &operator = (const Admin &);
 
-    private:
-        hyperdex_admin* m_adm;
+private:
+	hyperdex_admin *m_adm;
 };
 
 } // namespace hyperdex
 
-std::ostream&
-operator << (std::ostream& lhs, hyperdex_admin_returncode rhs);
+std::ostream &
+operator << (std::ostream &lhs, hyperdex_admin_returncode rhs);
 
 #endif // hyperdex_admin_hpp_
diff --git a/include/hyperdex/client.h b/include/hyperdex/client.h
index 5e0dfe2d1..8e7f7cc34 100644
--- a/include/hyperdex/client.h
+++ b/include/hyperdex/client.h
@@ -45,1148 +45,1156 @@ struct hyperdex_client_microtransaction;
 
 struct hyperdex_client_attribute
 {
-    const char* attr; /* NULL-terminated */
-    const char* value;
-    size_t value_sz;
-    enum hyperdatatype datatype;
+	const char *attr; /* NULL-terminated */
+	const char *value;
+	size_t value_sz;
+	enum hyperdatatype datatype;
 };
 
 struct hyperdex_client_map_attribute
 {
-    const char* attr; /* NULL-terminated */
-    const char* map_key;
-    size_t map_key_sz;
-    enum hyperdatatype map_key_datatype;
-    const char* value;
-    size_t value_sz;
-    enum hyperdatatype value_datatype;
+	const char *attr; /* NULL-terminated */
+	const char *map_key;
+	size_t map_key_sz;
+	enum hyperdatatype map_key_datatype;
+	const char *value;
+	size_t value_sz;
+	enum hyperdatatype value_datatype;
 };
 
 struct hyperdex_client_attribute_check
 {
-    const char* attr; /* NULL-terminated */
-    const char* value;
-    size_t value_sz;
-    enum hyperdatatype datatype;
-    enum hyperpredicate predicate;
+	const char *attr; /* NULL-terminated */
+	const char *value;
+	size_t value_sz;
+	enum hyperdatatype datatype;
+	enum hyperpredicate predicate;
 };
 
 /* hyperdex_client_returncode occupies [8448, 8576) */
 enum hyperdex_client_returncode
 {
-    HYPERDEX_CLIENT_SUCCESS      = 8448,
-    HYPERDEX_CLIENT_NOTFOUND     = 8449,
-    HYPERDEX_CLIENT_SEARCHDONE   = 8450,
-    HYPERDEX_CLIENT_CMPFAIL      = 8451,
-    HYPERDEX_CLIENT_READONLY     = 8452,
-
-    /* Error conditions */
-    HYPERDEX_CLIENT_UNKNOWNSPACE = 8512,
-    HYPERDEX_CLIENT_COORDFAIL    = 8513,
-    HYPERDEX_CLIENT_SERVERERROR  = 8514,
-    HYPERDEX_CLIENT_POLLFAILED   = 8515,
-    HYPERDEX_CLIENT_OVERFLOW     = 8516,
-    HYPERDEX_CLIENT_RECONFIGURE  = 8517,
-    HYPERDEX_CLIENT_TIMEOUT      = 8519,
-    HYPERDEX_CLIENT_UNKNOWNATTR  = 8520,
-    HYPERDEX_CLIENT_DUPEATTR     = 8521,
-    HYPERDEX_CLIENT_NONEPENDING  = 8523,
-    HYPERDEX_CLIENT_DONTUSEKEY   = 8524,
-    HYPERDEX_CLIENT_WRONGTYPE    = 8525,
-    HYPERDEX_CLIENT_NOMEM        = 8526,
-    HYPERDEX_CLIENT_INTERRUPTED  = 8530,
-    HYPERDEX_CLIENT_CLUSTER_JUMP = 8531,
-    HYPERDEX_CLIENT_OFFLINE      = 8533,
-    HYPERDEX_CLIENT_UNAUTHORIZED = 8534,
-
-    /* This should never happen.  It indicates a bug */
-    HYPERDEX_CLIENT_INTERNAL     = 8573,
-    HYPERDEX_CLIENT_EXCEPTION    = 8574,
-    HYPERDEX_CLIENT_GARBAGE      = 8575
+	HYPERDEX_CLIENT_SUCCESS      = 8448,
+	HYPERDEX_CLIENT_NOTFOUND     = 8449,
+	HYPERDEX_CLIENT_SEARCHDONE   = 8450,
+	HYPERDEX_CLIENT_CMPFAIL      = 8451,
+	HYPERDEX_CLIENT_READONLY     = 8452,
+
+	/* Error conditions */
+	HYPERDEX_CLIENT_UNKNOWNSPACE = 8512,
+	HYPERDEX_CLIENT_COORDFAIL    = 8513,
+	HYPERDEX_CLIENT_SERVERERROR  = 8514,
+	HYPERDEX_CLIENT_POLLFAILED   = 8515,
+	HYPERDEX_CLIENT_OVERFLOW     = 8516,
+	HYPERDEX_CLIENT_RECONFIGURE  = 8517,
+	HYPERDEX_CLIENT_TIMEOUT      = 8519,
+	HYPERDEX_CLIENT_UNKNOWNATTR  = 8520,
+	HYPERDEX_CLIENT_DUPEATTR     = 8521,
+	HYPERDEX_CLIENT_NONEPENDING  = 8523,
+	HYPERDEX_CLIENT_DONTUSEKEY   = 8524,
+	HYPERDEX_CLIENT_WRONGTYPE    = 8525,
+	HYPERDEX_CLIENT_NOMEM        = 8526,
+	HYPERDEX_CLIENT_INTERRUPTED  = 8530,
+	HYPERDEX_CLIENT_CLUSTER_JUMP = 8531,
+	HYPERDEX_CLIENT_OFFLINE      = 8533,
+	HYPERDEX_CLIENT_UNAUTHORIZED = 8534,
+
+	/* This should never happen.  It indicates a bug */
+	HYPERDEX_CLIENT_INTERNAL     = 8573,
+	HYPERDEX_CLIENT_EXCEPTION    = 8574,
+	HYPERDEX_CLIENT_GARBAGE      = 8575
 };
 
 #define HYPERDEX_ATTRIBUTE_SECRET "__secret"
 
-struct hyperdex_client*
-hyperdex_client_create(const char* coordinator, uint16_t port);
-struct hyperdex_client*
-hyperdex_client_create_conn_str(const char* conn_str);
+struct hyperdex_client *
+hyperdex_client_create(const char *coordinator, uint16_t port);
+struct hyperdex_client *
+hyperdex_client_create_conn_str(const char *conn_str);
 void
-hyperdex_client_destroy(struct hyperdex_client* client);
+hyperdex_client_destroy(struct hyperdex_client *client);
 
 struct macaroon;
 
 void
-hyperdex_client_clear_auth_context(struct hyperdex_client* client);
+hyperdex_client_clear_auth_context(struct hyperdex_client *client);
 void
-hyperdex_client_set_auth_context(struct hyperdex_client* client,
-                                 const char** macaroons, size_t macaroons_sz);
+hyperdex_client_set_auth_context(struct hyperdex_client *client,
+                                 const char **macaroons, size_t macaroons_sz);
 
-struct hyperdex_client_microtransaction*
-hyperdex_client_uxact_init(struct hyperdex_client* _cl,
-                      const char* space,
-                      enum hyperdex_client_returncode *status);
+struct hyperdex_client_microtransaction *
+hyperdex_client_uxact_init(struct hyperdex_client *_cl,
+                           const char *space,
+                           enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_uxact_commit(struct hyperdex_client* _cl,
-                                struct hyperdex_client_microtransaction *transaction,
-                                const char* key, size_t key_sz);
-                                
+hyperdex_client_uxact_commit(struct hyperdex_client *_cl,
+                             struct hyperdex_client_microtransaction *transaction,
+                             const char *key, size_t key_sz);
+
 int64_t
-hyperdex_client_uxact_group_commit(struct hyperdex_client* _cl,
-                                struct hyperdex_client_microtransaction *transaction,
-                                const struct hyperdex_client_attribute_check *chks, size_t chks_sz,
-                                uint64_t *count);
-                                
+hyperdex_client_uxact_group_commit(struct hyperdex_client *_cl,
+                                   struct hyperdex_client_microtransaction *transaction,
+                                   const struct hyperdex_client_attribute_check *chks, size_t chks_sz,
+                                   uint64_t *count);
+
 int64_t
-hyperdex_client_uxact_cond_commit(struct hyperdex_client* _cl,
-                                struct hyperdex_client_microtransaction *transaction,
-                                const char* key, size_t key_sz,
-                                const struct hyperdex_client_attribute_check *chks, size_t chks_sz);
+hyperdex_client_uxact_cond_commit(struct hyperdex_client *_cl,
+                                  struct hyperdex_client_microtransaction *transaction,
+                                  const char *key, size_t key_sz,
+                                  const struct hyperdex_client_attribute_check *chks, size_t chks_sz);
 
 int64_t
-hyperdex_client_get(struct hyperdex_client* client,
-                    const char* space,
-                    const char* key, size_t key_sz,
-                    enum hyperdex_client_returncode* status,
-                    const struct hyperdex_client_attribute** attrs, size_t* attrs_sz);
+hyperdex_client_get(struct hyperdex_client *client,
+                    const char *space,
+                    const char *key, size_t key_sz,
+                    enum hyperdex_client_returncode *status,
+                    const struct hyperdex_client_attribute **attrs, size_t *attrs_sz);
 
 int64_t
-hyperdex_client_get_partial(struct hyperdex_client* client,
-                            const char* space,
-                            const char* key, size_t key_sz,
-                            const char** attrnames, size_t attrnames_sz,
-                            enum hyperdex_client_returncode* status,
-                            const struct hyperdex_client_attribute** attrs, size_t* attrs_sz);
+hyperdex_client_get_partial(struct hyperdex_client *client,
+                            const char *space,
+                            const char *key, size_t key_sz,
+                            const char **attrnames, size_t attrnames_sz,
+                            enum hyperdex_client_returncode *status,
+                            const struct hyperdex_client_attribute **attrs, size_t *attrs_sz);
 
 int64_t
-hyperdex_client_put(struct hyperdex_client* client,
-                    const char* space,
-                    const char* key, size_t key_sz,
-                    const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                    enum hyperdex_client_returncode* status);
+hyperdex_client_put(struct hyperdex_client *client,
+                    const char *space,
+                    const char *key, size_t key_sz,
+                    const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                    enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_uxact_put(struct hyperdex_client* client,
-                          struct hyperdex_client_microtransaction* microtransaction,
-                          const struct hyperdex_client_attribute* attrs, size_t attrs_sz);
+hyperdex_client_uxact_put(struct hyperdex_client *client,
+                          struct hyperdex_client_microtransaction *microtransaction,
+                          const struct hyperdex_client_attribute *attrs, size_t attrs_sz);
 
 int64_t
-hyperdex_client_cond_put(struct hyperdex_client* client,
-                         const char* space,
-                         const char* key, size_t key_sz,
-                         const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                         const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                         enum hyperdex_client_returncode* status);
+hyperdex_client_cond_put(struct hyperdex_client *client,
+                         const char *space,
+                         const char *key, size_t key_sz,
+                         const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                         const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                         enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_cond_put_or_create(struct hyperdex_client* client,
-                                   const char* space,
-                                   const char* key, size_t key_sz,
-                                   const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                   const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                   enum hyperdex_client_returncode* status);
+hyperdex_client_cond_put_or_create(struct hyperdex_client *client,
+                                   const char *space,
+                                   const char *key, size_t key_sz,
+                                   const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                   const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                   enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_group_put(struct hyperdex_client* client,
-                          const char* space,
-                          const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                          const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                          enum hyperdex_client_returncode* status,
-                          uint64_t* count);
+hyperdex_client_group_put(struct hyperdex_client *client,
+                          const char *space,
+                          const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                          const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                          enum hyperdex_client_returncode *status,
+                          uint64_t *count);
 
 int64_t
-hyperdex_client_put_if_not_exist(struct hyperdex_client* client,
-                                 const char* space,
-                                 const char* key, size_t key_sz,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                 enum hyperdex_client_returncode* status);
+hyperdex_client_put_if_not_exist(struct hyperdex_client *client,
+                                 const char *space,
+                                 const char *key, size_t key_sz,
+                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                 enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_del(struct hyperdex_client* client,
-                    const char* space,
-                    const char* key, size_t key_sz,
-                    enum hyperdex_client_returncode* status);
+hyperdex_client_del(struct hyperdex_client *client,
+                    const char *space,
+                    const char *key, size_t key_sz,
+                    enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_cond_del(struct hyperdex_client* client,
-                         const char* space,
-                         const char* key, size_t key_sz,
-                         const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                         enum hyperdex_client_returncode* status);
+hyperdex_client_cond_del(struct hyperdex_client *client,
+                         const char *space,
+                         const char *key, size_t key_sz,
+                         const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                         enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_group_del(struct hyperdex_client* client,
-                          const char* space,
-                          const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                          enum hyperdex_client_returncode* status,
-                          uint64_t* count);
+hyperdex_client_group_del(struct hyperdex_client *client,
+                          const char *space,
+                          const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                          enum hyperdex_client_returncode *status,
+                          uint64_t *count);
 
 int64_t
-hyperdex_client_atomic_add(struct hyperdex_client* client,
-                           const char* space,
-                           const char* key, size_t key_sz,
-                           const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                           enum hyperdex_client_returncode* status);
+hyperdex_client_atomic_add(struct hyperdex_client *client,
+                           const char *space,
+                           const char *key, size_t key_sz,
+                           const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                           enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_uxact_atomic_add(struct hyperdex_client* client,
-                                 struct hyperdex_client_microtransaction* microtransaction,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz);
+hyperdex_client_uxact_atomic_add(struct hyperdex_client *client,
+                                 struct hyperdex_client_microtransaction *microtransaction,
+                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz);
 
 int64_t
-hyperdex_client_cond_atomic_add(struct hyperdex_client* client,
-                                const char* space,
-                                const char* key, size_t key_sz,
-                                const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                enum hyperdex_client_returncode* status);
+hyperdex_client_cond_atomic_add(struct hyperdex_client *client,
+                                const char *space,
+                                const char *key, size_t key_sz,
+                                const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_group_atomic_add(struct hyperdex_client* client,
-                                 const char* space,
-                                 const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                 enum hyperdex_client_returncode* status,
-                                 uint64_t* count);
+hyperdex_client_group_atomic_add(struct hyperdex_client *client,
+                                 const char *space,
+                                 const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                 enum hyperdex_client_returncode *status,
+                                 uint64_t *count);
 
 int64_t
-hyperdex_client_atomic_sub(struct hyperdex_client* client,
-                           const char* space,
-                           const char* key, size_t key_sz,
-                           const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                           enum hyperdex_client_returncode* status);
+hyperdex_client_atomic_sub(struct hyperdex_client *client,
+                           const char *space,
+                           const char *key, size_t key_sz,
+                           const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                           enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_uxact_atomic_sub(struct hyperdex_client* client,
-                                 struct hyperdex_client_microtransaction* microtransaction,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz);
+hyperdex_client_uxact_atomic_sub(struct hyperdex_client *client,
+                                 struct hyperdex_client_microtransaction *microtransaction,
+                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz);
 
 int64_t
-hyperdex_client_cond_atomic_sub(struct hyperdex_client* client,
-                                const char* space,
-                                const char* key, size_t key_sz,
-                                const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                enum hyperdex_client_returncode* status);
+hyperdex_client_cond_atomic_sub(struct hyperdex_client *client,
+                                const char *space,
+                                const char *key, size_t key_sz,
+                                const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_group_atomic_sub(struct hyperdex_client* client,
-                                 const char* space,
-                                 const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                 enum hyperdex_client_returncode* status,
-                                 uint64_t* count);
+hyperdex_client_group_atomic_sub(struct hyperdex_client *client,
+                                 const char *space,
+                                 const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                 enum hyperdex_client_returncode *status,
+                                 uint64_t *count);
 
 int64_t
-hyperdex_client_atomic_mul(struct hyperdex_client* client,
-                           const char* space,
-                           const char* key, size_t key_sz,
-                           const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                           enum hyperdex_client_returncode* status);
+hyperdex_client_atomic_mul(struct hyperdex_client *client,
+                           const char *space,
+                           const char *key, size_t key_sz,
+                           const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                           enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_uxact_atomic_mul(struct hyperdex_client* client,
-                                 struct hyperdex_client_microtransaction* microtransaction,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz);
+hyperdex_client_uxact_atomic_mul(struct hyperdex_client *client,
+                                 struct hyperdex_client_microtransaction *microtransaction,
+                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz);
 
 int64_t
-hyperdex_client_cond_atomic_mul(struct hyperdex_client* client,
-                                const char* space,
-                                const char* key, size_t key_sz,
-                                const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                enum hyperdex_client_returncode* status);
+hyperdex_client_cond_atomic_mul(struct hyperdex_client *client,
+                                const char *space,
+                                const char *key, size_t key_sz,
+                                const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_group_atomic_mul(struct hyperdex_client* client,
-                                 const char* space,
-                                 const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                 enum hyperdex_client_returncode* status,
-                                 uint64_t* count);
+hyperdex_client_group_atomic_mul(struct hyperdex_client *client,
+                                 const char *space,
+                                 const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                 enum hyperdex_client_returncode *status,
+                                 uint64_t *count);
 
 int64_t
-hyperdex_client_atomic_div(struct hyperdex_client* client,
-                           const char* space,
-                           const char* key, size_t key_sz,
-                           const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                           enum hyperdex_client_returncode* status);
+hyperdex_client_atomic_div(struct hyperdex_client *client,
+                           const char *space,
+                           const char *key, size_t key_sz,
+                           const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                           enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_uxact_atomic_div(struct hyperdex_client* client,
-                                 struct hyperdex_client_microtransaction* microtransaction,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz);
+hyperdex_client_uxact_atomic_div(struct hyperdex_client *client,
+                                 struct hyperdex_client_microtransaction *microtransaction,
+                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz);
 
 int64_t
-hyperdex_client_cond_atomic_div(struct hyperdex_client* client,
-                                const char* space,
-                                const char* key, size_t key_sz,
-                                const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                enum hyperdex_client_returncode* status);
+hyperdex_client_cond_atomic_div(struct hyperdex_client *client,
+                                const char *space,
+                                const char *key, size_t key_sz,
+                                const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_group_atomic_div(struct hyperdex_client* client,
-                                 const char* space,
-                                 const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                 enum hyperdex_client_returncode* status,
-                                 uint64_t* count);
+hyperdex_client_group_atomic_div(struct hyperdex_client *client,
+                                 const char *space,
+                                 const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                 enum hyperdex_client_returncode *status,
+                                 uint64_t *count);
 
 int64_t
-hyperdex_client_atomic_mod(struct hyperdex_client* client,
-                           const char* space,
-                           const char* key, size_t key_sz,
-                           const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                           enum hyperdex_client_returncode* status);
+hyperdex_client_atomic_mod(struct hyperdex_client *client,
+                           const char *space,
+                           const char *key, size_t key_sz,
+                           const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                           enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_cond_atomic_mod(struct hyperdex_client* client,
-                                const char* space,
-                                const char* key, size_t key_sz,
-                                const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                enum hyperdex_client_returncode* status);
+hyperdex_client_cond_atomic_mod(struct hyperdex_client *client,
+                                const char *space,
+                                const char *key, size_t key_sz,
+                                const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_group_atomic_mod(struct hyperdex_client* client,
-                                 const char* space,
-                                 const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                 enum hyperdex_client_returncode* status,
-                                 uint64_t* count);
+hyperdex_client_group_atomic_mod(struct hyperdex_client *client,
+                                 const char *space,
+                                 const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                 enum hyperdex_client_returncode *status,
+                                 uint64_t *count);
 
 int64_t
-hyperdex_client_atomic_and(struct hyperdex_client* client,
-                           const char* space,
-                           const char* key, size_t key_sz,
-                           const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                           enum hyperdex_client_returncode* status);
+hyperdex_client_atomic_and(struct hyperdex_client *client,
+                           const char *space,
+                           const char *key, size_t key_sz,
+                           const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                           enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_uxact_atomic_and(struct hyperdex_client* client,
-                                 struct hyperdex_client_microtransaction* microtransaction,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz);
+hyperdex_client_uxact_atomic_and(struct hyperdex_client *client,
+                                 struct hyperdex_client_microtransaction *microtransaction,
+                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz);
 
 int64_t
-hyperdex_client_cond_atomic_and(struct hyperdex_client* client,
-                                const char* space,
-                                const char* key, size_t key_sz,
-                                const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                enum hyperdex_client_returncode* status);
+hyperdex_client_cond_atomic_and(struct hyperdex_client *client,
+                                const char *space,
+                                const char *key, size_t key_sz,
+                                const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_group_atomic_and(struct hyperdex_client* client,
-                                 const char* space,
-                                 const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                 enum hyperdex_client_returncode* status,
-                                 uint64_t* count);
+hyperdex_client_group_atomic_and(struct hyperdex_client *client,
+                                 const char *space,
+                                 const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                 enum hyperdex_client_returncode *status,
+                                 uint64_t *count);
 
 int64_t
-hyperdex_client_atomic_or(struct hyperdex_client* client,
-                          const char* space,
-                          const char* key, size_t key_sz,
-                          const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                          enum hyperdex_client_returncode* status);
+hyperdex_client_atomic_or(struct hyperdex_client *client,
+                          const char *space,
+                          const char *key, size_t key_sz,
+                          const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                          enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_uxact_atomic_or(struct hyperdex_client* client,
-                                struct hyperdex_client_microtransaction* microtransaction,
-                                const struct hyperdex_client_attribute* attrs, size_t attrs_sz);
+hyperdex_client_uxact_atomic_or(struct hyperdex_client *client,
+                                struct hyperdex_client_microtransaction *microtransaction,
+                                const struct hyperdex_client_attribute *attrs, size_t attrs_sz);
 
 int64_t
-hyperdex_client_cond_atomic_or(struct hyperdex_client* client,
-                               const char* space,
-                               const char* key, size_t key_sz,
-                               const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                               const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                               enum hyperdex_client_returncode* status);
+hyperdex_client_cond_atomic_or(struct hyperdex_client *client,
+                               const char *space,
+                               const char *key, size_t key_sz,
+                               const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                               const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                               enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_group_atomic_or(struct hyperdex_client* client,
-                                const char* space,
-                                const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                enum hyperdex_client_returncode* status,
-                                uint64_t* count);
+hyperdex_client_group_atomic_or(struct hyperdex_client *client,
+                                const char *space,
+                                const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                enum hyperdex_client_returncode *status,
+                                uint64_t *count);
 
 int64_t
-hyperdex_client_atomic_xor(struct hyperdex_client* client,
-                           const char* space,
-                           const char* key, size_t key_sz,
-                           const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                           enum hyperdex_client_returncode* status);
+hyperdex_client_atomic_xor(struct hyperdex_client *client,
+                           const char *space,
+                           const char *key, size_t key_sz,
+                           const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                           enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_cond_atomic_xor(struct hyperdex_client* client,
-                                const char* space,
-                                const char* key, size_t key_sz,
-                                const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                enum hyperdex_client_returncode* status);
+hyperdex_client_cond_atomic_xor(struct hyperdex_client *client,
+                                const char *space,
+                                const char *key, size_t key_sz,
+                                const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_group_atomic_xor(struct hyperdex_client* client,
-                                 const char* space,
-                                 const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                 enum hyperdex_client_returncode* status,
-                                 uint64_t* count);
+hyperdex_client_group_atomic_xor(struct hyperdex_client *client,
+                                 const char *space,
+                                 const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                 enum hyperdex_client_returncode *status,
+                                 uint64_t *count);
 
 int64_t
-hyperdex_client_atomic_min(struct hyperdex_client* client,
-                           const char* space,
-                           const char* key, size_t key_sz,
-                           const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                           enum hyperdex_client_returncode* status);
+hyperdex_client_atomic_min(struct hyperdex_client *client,
+                           const char *space,
+                           const char *key, size_t key_sz,
+                           const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                           enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_cond_atomic_min(struct hyperdex_client* client,
-                                const char* space,
-                                const char* key, size_t key_sz,
-                                const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                enum hyperdex_client_returncode* status);
+hyperdex_client_cond_atomic_min(struct hyperdex_client *client,
+                                const char *space,
+                                const char *key, size_t key_sz,
+                                const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_group_atomic_min(struct hyperdex_client* client,
-                                 const char* space,
-                                 const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                 enum hyperdex_client_returncode* status,
-                                 uint64_t* count);
+hyperdex_client_group_atomic_min(struct hyperdex_client *client,
+                                 const char *space,
+                                 const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                 enum hyperdex_client_returncode *status,
+                                 uint64_t *count);
 
 int64_t
-hyperdex_client_atomic_max(struct hyperdex_client* client,
-                           const char* space,
-                           const char* key, size_t key_sz,
-                           const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                           enum hyperdex_client_returncode* status);
+hyperdex_client_atomic_max(struct hyperdex_client *client,
+                           const char *space,
+                           const char *key, size_t key_sz,
+                           const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                           enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_cond_atomic_max(struct hyperdex_client* client,
-                                const char* space,
-                                const char* key, size_t key_sz,
-                                const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                enum hyperdex_client_returncode* status);
+hyperdex_client_cond_atomic_max(struct hyperdex_client *client,
+                                const char *space,
+                                const char *key, size_t key_sz,
+                                const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_group_atomic_max(struct hyperdex_client* client,
-                                 const char* space,
-                                 const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                 enum hyperdex_client_returncode* status,
-                                 uint64_t* count);
+hyperdex_client_group_atomic_max(struct hyperdex_client *client,
+                                 const char *space,
+                                 const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                 enum hyperdex_client_returncode *status,
+                                 uint64_t *count);
 
 int64_t
-hyperdex_client_string_prepend(struct hyperdex_client* client,
-                               const char* space,
-                               const char* key, size_t key_sz,
-                               const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                               enum hyperdex_client_returncode* status);
+hyperdex_client_string_prepend(struct hyperdex_client *client,
+                               const char *space,
+                               const char *key, size_t key_sz,
+                               const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                               enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_uxact_string_prepend(struct hyperdex_client* client,
-                                     struct hyperdex_client_microtransaction* microtransaction,
-                                     const struct hyperdex_client_attribute* attrs, size_t attrs_sz);
+hyperdex_client_uxact_string_prepend(struct hyperdex_client *client,
+                                     struct hyperdex_client_microtransaction *microtransaction,
+                                     const struct hyperdex_client_attribute *attrs, size_t attrs_sz);
 
 int64_t
-hyperdex_client_cond_string_prepend(struct hyperdex_client* client,
-                                    const char* space,
-                                    const char* key, size_t key_sz,
-                                    const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                    const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                    enum hyperdex_client_returncode* status);
+hyperdex_client_cond_string_prepend(struct hyperdex_client *client,
+                                    const char *space,
+                                    const char *key, size_t key_sz,
+                                    const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                    const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                    enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_group_string_prepend(struct hyperdex_client* client,
-                                     const char* space,
-                                     const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                     const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                     enum hyperdex_client_returncode* status,
-                                     uint64_t* count);
+hyperdex_client_group_string_prepend(struct hyperdex_client *client,
+                                     const char *space,
+                                     const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                     const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                     enum hyperdex_client_returncode *status,
+                                     uint64_t *count);
 
 int64_t
-hyperdex_client_string_append(struct hyperdex_client* client,
-                              const char* space,
-                              const char* key, size_t key_sz,
-                              const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                              enum hyperdex_client_returncode* status);
+hyperdex_client_string_append(struct hyperdex_client *client,
+                              const char *space,
+                              const char *key, size_t key_sz,
+                              const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                              enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_uxact_string_append(struct hyperdex_client* client,
-                                    struct hyperdex_client_microtransaction* microtransaction,
-                                    const struct hyperdex_client_attribute* attrs, size_t attrs_sz);
+hyperdex_client_uxact_string_append(struct hyperdex_client *client,
+                                    struct hyperdex_client_microtransaction *microtransaction,
+                                    const struct hyperdex_client_attribute *attrs, size_t attrs_sz);
 
 int64_t
-hyperdex_client_cond_string_append(struct hyperdex_client* client,
-                                   const char* space,
-                                   const char* key, size_t key_sz,
-                                   const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                   const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                   enum hyperdex_client_returncode* status);
+hyperdex_client_cond_string_append(struct hyperdex_client *client,
+                                   const char *space,
+                                   const char *key, size_t key_sz,
+                                   const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                   const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                   enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_group_string_append(struct hyperdex_client* client,
-                                    const char* space,
-                                    const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                    const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                    enum hyperdex_client_returncode* status,
-                                    uint64_t* count);
+hyperdex_client_group_string_append(struct hyperdex_client *client,
+                                    const char *space,
+                                    const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                    const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                    enum hyperdex_client_returncode *status,
+                                    uint64_t *count);
 
 int64_t
-hyperdex_client_string_ltrim(struct hyperdex_client* client,
-                             const char* space,
-                             const char* key, size_t key_sz,
-                             const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                             enum hyperdex_client_returncode* status);
+hyperdex_client_string_ltrim(struct hyperdex_client *client,
+                             const char *space,
+                             const char *key, size_t key_sz,
+                             const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                             enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_uxact_string_ltrim(struct hyperdex_client* client,
-                                   struct hyperdex_client_microtransaction* microtransaction,
-                                   const struct hyperdex_client_attribute* attrs, size_t attrs_sz);
+hyperdex_client_uxact_string_ltrim(struct hyperdex_client *client,
+                                   struct hyperdex_client_microtransaction *microtransaction,
+                                   const struct hyperdex_client_attribute *attrs, size_t attrs_sz);
 
 int64_t
-hyperdex_client_cond_string_ltrim(struct hyperdex_client* client,
-                                  const char* space,
-                                  const char* key, size_t key_sz,
-                                  const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                  const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                  enum hyperdex_client_returncode* status);
+hyperdex_client_cond_string_ltrim(struct hyperdex_client *client,
+                                  const char *space,
+                                  const char *key, size_t key_sz,
+                                  const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                  const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                  enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_group_string_ltrim(struct hyperdex_client* client,
-                                   const char* space,
-                                   const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                   const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                   enum hyperdex_client_returncode* status,
-                                   uint64_t* count);
+hyperdex_client_group_string_ltrim(struct hyperdex_client *client,
+                                   const char *space,
+                                   const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                   const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                   enum hyperdex_client_returncode *status,
+                                   uint64_t *count);
 
 int64_t
-hyperdex_client_string_rtrim(struct hyperdex_client* client,
-                             const char* space,
-                             const char* key, size_t key_sz,
-                             const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                             enum hyperdex_client_returncode* status);
+hyperdex_client_string_rtrim(struct hyperdex_client *client,
+                             const char *space,
+                             const char *key, size_t key_sz,
+                             const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                             enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_uxact_string_rtrim(struct hyperdex_client* client,
-                                   struct hyperdex_client_microtransaction* microtransaction,
-                                   const struct hyperdex_client_attribute* attrs, size_t attrs_sz);
+hyperdex_client_uxact_string_rtrim(struct hyperdex_client *client,
+                                   struct hyperdex_client_microtransaction *microtransaction,
+                                   const struct hyperdex_client_attribute *attrs, size_t attrs_sz);
 
 int64_t
-hyperdex_client_cond_string_rtrim(struct hyperdex_client* client,
-                                  const char* space,
-                                  const char* key, size_t key_sz,
-                                  const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                  const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                  enum hyperdex_client_returncode* status);
+hyperdex_client_cond_string_rtrim(struct hyperdex_client *client,
+                                  const char *space,
+                                  const char *key, size_t key_sz,
+                                  const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                  const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                  enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_group_string_rtrim(struct hyperdex_client* client,
-                                   const char* space,
-                                   const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                   const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                   enum hyperdex_client_returncode* status,
-                                   uint64_t* count);
+hyperdex_client_group_string_rtrim(struct hyperdex_client *client,
+                                   const char *space,
+                                   const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                   const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                   enum hyperdex_client_returncode *status,
+                                   uint64_t *count);
 
 int64_t
-hyperdex_client_list_lpush(struct hyperdex_client* client,
-                           const char* space,
-                           const char* key, size_t key_sz,
-                           const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                           enum hyperdex_client_returncode* status);
+hyperdex_client_list_lpush(struct hyperdex_client *client,
+                           const char *space,
+                           const char *key, size_t key_sz,
+                           const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                           enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_uxact_list_lpush(struct hyperdex_client* client,
-                                 struct hyperdex_client_microtransaction* microtransaction,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz);
+hyperdex_client_uxact_list_lpush(struct hyperdex_client *client,
+                                 struct hyperdex_client_microtransaction *microtransaction,
+                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz);
 
 int64_t
-hyperdex_client_cond_list_lpush(struct hyperdex_client* client,
-                                const char* space,
-                                const char* key, size_t key_sz,
-                                const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                enum hyperdex_client_returncode* status);
+hyperdex_client_cond_list_lpush(struct hyperdex_client *client,
+                                const char *space,
+                                const char *key, size_t key_sz,
+                                const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_group_list_lpush(struct hyperdex_client* client,
-                                 const char* space,
-                                 const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                 enum hyperdex_client_returncode* status,
-                                 uint64_t* count);
+hyperdex_client_group_list_lpush(struct hyperdex_client *client,
+                                 const char *space,
+                                 const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                 enum hyperdex_client_returncode *status,
+                                 uint64_t *count);
 
 int64_t
-hyperdex_client_list_rpush(struct hyperdex_client* client,
-                           const char* space,
-                           const char* key, size_t key_sz,
-                           const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                           enum hyperdex_client_returncode* status);
+hyperdex_client_list_rpush(struct hyperdex_client *client,
+                           const char *space,
+                           const char *key, size_t key_sz,
+                           const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                           enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_uxact_list_rpush(struct hyperdex_client* client,
-                                 struct hyperdex_client_microtransaction* microtransaction,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz);
+hyperdex_client_uxact_list_rpush(struct hyperdex_client *client,
+                                 struct hyperdex_client_microtransaction *microtransaction,
+                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz);
 
 int64_t
-hyperdex_client_cond_list_rpush(struct hyperdex_client* client,
-                                const char* space,
-                                const char* key, size_t key_sz,
-                                const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                enum hyperdex_client_returncode* status);
+hyperdex_client_cond_list_rpush(struct hyperdex_client *client,
+                                const char *space,
+                                const char *key, size_t key_sz,
+                                const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_group_list_rpush(struct hyperdex_client* client,
-                                 const char* space,
-                                 const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                 enum hyperdex_client_returncode* status,
-                                 uint64_t* count);
+hyperdex_client_group_list_rpush(struct hyperdex_client *client,
+                                 const char *space,
+                                 const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                 enum hyperdex_client_returncode *status,
+                                 uint64_t *count);
 
 int64_t
-hyperdex_client_set_add(struct hyperdex_client* client,
-                        const char* space,
-                        const char* key, size_t key_sz,
-                        const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                        enum hyperdex_client_returncode* status);
+hyperdex_client_set_add(struct hyperdex_client *client,
+                        const char *space,
+                        const char *key, size_t key_sz,
+                        const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                        enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_cond_set_add(struct hyperdex_client* client,
-                             const char* space,
-                             const char* key, size_t key_sz,
-                             const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                             const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                             enum hyperdex_client_returncode* status);
+hyperdex_client_cond_set_add(struct hyperdex_client *client,
+                             const char *space,
+                             const char *key, size_t key_sz,
+                             const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                             const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                             enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_group_set_add(struct hyperdex_client* client,
-                              const char* space,
-                              const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                              const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                              enum hyperdex_client_returncode* status,
-                              uint64_t* count);
+hyperdex_client_group_set_add(struct hyperdex_client *client,
+                              const char *space,
+                              const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                              const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                              enum hyperdex_client_returncode *status,
+                              uint64_t *count);
 
 int64_t
-hyperdex_client_set_remove(struct hyperdex_client* client,
-                           const char* space,
-                           const char* key, size_t key_sz,
-                           const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                           enum hyperdex_client_returncode* status);
+hyperdex_client_set_remove(struct hyperdex_client *client,
+                           const char *space,
+                           const char *key, size_t key_sz,
+                           const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                           enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_cond_set_remove(struct hyperdex_client* client,
-                                const char* space,
-                                const char* key, size_t key_sz,
-                                const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                enum hyperdex_client_returncode* status);
+hyperdex_client_cond_set_remove(struct hyperdex_client *client,
+                                const char *space,
+                                const char *key, size_t key_sz,
+                                const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_group_set_remove(struct hyperdex_client* client,
-                                 const char* space,
-                                 const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                 enum hyperdex_client_returncode* status,
-                                 uint64_t* count);
+hyperdex_client_group_set_remove(struct hyperdex_client *client,
+                                 const char *space,
+                                 const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                 enum hyperdex_client_returncode *status,
+                                 uint64_t *count);
 
 int64_t
-hyperdex_client_set_intersect(struct hyperdex_client* client,
-                              const char* space,
-                              const char* key, size_t key_sz,
-                              const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                              enum hyperdex_client_returncode* status);
+hyperdex_client_set_intersect(struct hyperdex_client *client,
+                              const char *space,
+                              const char *key, size_t key_sz,
+                              const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                              enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_cond_set_intersect(struct hyperdex_client* client,
-                                   const char* space,
-                                   const char* key, size_t key_sz,
-                                   const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                   const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                   enum hyperdex_client_returncode* status);
+hyperdex_client_cond_set_intersect(struct hyperdex_client *client,
+                                   const char *space,
+                                   const char *key, size_t key_sz,
+                                   const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                   const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                   enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_group_set_intersect(struct hyperdex_client* client,
-                                    const char* space,
-                                    const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                    const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                    enum hyperdex_client_returncode* status,
-                                    uint64_t* count);
+hyperdex_client_group_set_intersect(struct hyperdex_client *client,
+                                    const char *space,
+                                    const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                    const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                    enum hyperdex_client_returncode *status,
+                                    uint64_t *count);
 
 int64_t
-hyperdex_client_set_union(struct hyperdex_client* client,
-                          const char* space,
-                          const char* key, size_t key_sz,
-                          const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                          enum hyperdex_client_returncode* status);
+hyperdex_client_set_union(struct hyperdex_client *client,
+                          const char *space,
+                          const char *key, size_t key_sz,
+                          const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                          enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_cond_set_union(struct hyperdex_client* client,
-                               const char* space,
-                               const char* key, size_t key_sz,
-                               const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                               const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                               enum hyperdex_client_returncode* status);
+hyperdex_client_cond_set_union(struct hyperdex_client *client,
+                               const char *space,
+                               const char *key, size_t key_sz,
+                               const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                               const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                               enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_group_set_union(struct hyperdex_client* client,
-                                const char* space,
-                                const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                enum hyperdex_client_returncode* status,
-                                uint64_t* count);
+hyperdex_client_group_set_union(struct hyperdex_client *client,
+                                const char *space,
+                                const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                enum hyperdex_client_returncode *status,
+                                uint64_t *count);
 
 int64_t
-hyperdex_client_document_rename(struct hyperdex_client* client,
-                                const char* space,
-                                const char* key, size_t key_sz,
-                                const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                enum hyperdex_client_returncode* status);
+hyperdex_client_document_rename(struct hyperdex_client *client,
+                                const char *space,
+                                const char *key, size_t key_sz,
+                                const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_uxact_document_rename(struct hyperdex_client* client,
-                                      struct hyperdex_client_microtransaction* microtransaction,
-                                      const struct hyperdex_client_attribute* attrs, size_t attrs_sz);
+hyperdex_client_uxact_document_rename(struct hyperdex_client *client,
+                                      struct hyperdex_client_microtransaction *microtransaction,
+                                      const struct hyperdex_client_attribute *attrs, size_t attrs_sz);
 
 int64_t
-hyperdex_client_cond_document_rename(struct hyperdex_client* client,
-                                     const char* space,
-                                     const char* key, size_t key_sz,
-                                     const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                     const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                     enum hyperdex_client_returncode* status);
+hyperdex_client_cond_document_rename(struct hyperdex_client *client,
+                                     const char *space,
+                                     const char *key, size_t key_sz,
+                                     const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                     const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                     enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_group_document_rename(struct hyperdex_client* client,
-                                      const char* space,
-                                      const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                      const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                      enum hyperdex_client_returncode* status,
-                                      uint64_t* count);
+hyperdex_client_group_document_rename(struct hyperdex_client *client,
+                                      const char *space,
+                                      const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                      const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                      enum hyperdex_client_returncode *status,
+                                      uint64_t *count);
 
 int64_t
-hyperdex_client_document_unset(struct hyperdex_client* client,
-                               const char* space,
-                               const char* key, size_t key_sz,
-                               const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                               enum hyperdex_client_returncode* status);
+hyperdex_client_document_unset(struct hyperdex_client *client,
+                               const char *space,
+                               const char *key, size_t key_sz,
+                               const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                               enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_uxact_document_unset(struct hyperdex_client* client,
-                                     struct hyperdex_client_microtransaction* microtransaction,
-                                     const struct hyperdex_client_attribute* attrs, size_t attrs_sz);
+hyperdex_client_uxact_document_unset(struct hyperdex_client *client,
+                                     struct hyperdex_client_microtransaction *microtransaction,
+                                     const struct hyperdex_client_attribute *attrs, size_t attrs_sz);
 
 int64_t
-hyperdex_client_cond_document_unset(struct hyperdex_client* client,
-                                    const char* space,
-                                    const char* key, size_t key_sz,
-                                    const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                    const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                    enum hyperdex_client_returncode* status);
+hyperdex_client_cond_document_unset(struct hyperdex_client *client,
+                                    const char *space,
+                                    const char *key, size_t key_sz,
+                                    const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                    const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                    enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_group_document_unset(struct hyperdex_client* client,
-                                     const char* space,
-                                     const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                     const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                     enum hyperdex_client_returncode* status,
-                                     uint64_t* count);
+hyperdex_client_group_document_unset(struct hyperdex_client *client,
+                                     const char *space,
+                                     const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                     const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                     enum hyperdex_client_returncode *status,
+                                     uint64_t *count);
 
 int64_t
-hyperdex_client_map_add(struct hyperdex_client* client,
-                        const char* space,
-                        const char* key, size_t key_sz,
-                        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                        enum hyperdex_client_returncode* status);
+hyperdex_client_map_add(struct hyperdex_client *client,
+                        const char *space,
+                        const char *key, size_t key_sz,
+                        const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+                        enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_cond_map_add(struct hyperdex_client* client,
-                             const char* space,
-                             const char* key, size_t key_sz,
-                             const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                             const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                             enum hyperdex_client_returncode* status);
+hyperdex_client_cond_map_add(struct hyperdex_client *client,
+                             const char *space,
+                             const char *key, size_t key_sz,
+                             const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                             const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+                             enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_group_map_add(struct hyperdex_client* client,
-                              const char* space,
-                              const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                              const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                              enum hyperdex_client_returncode* status,
-                              uint64_t* count);
+hyperdex_client_group_map_add(struct hyperdex_client *client,
+                              const char *space,
+                              const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                              const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+                              enum hyperdex_client_returncode *status,
+                              uint64_t *count);
 
 int64_t
-hyperdex_client_map_remove(struct hyperdex_client* client,
-                           const char* space,
-                           const char* key, size_t key_sz,
-                           const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                           enum hyperdex_client_returncode* status);
+hyperdex_client_map_remove(struct hyperdex_client *client,
+                           const char *space,
+                           const char *key, size_t key_sz,
+                           const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                           enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_cond_map_remove(struct hyperdex_client* client,
-                                const char* space,
-                                const char* key, size_t key_sz,
-                                const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                enum hyperdex_client_returncode* status);
+hyperdex_client_cond_map_remove(struct hyperdex_client *client,
+                                const char *space,
+                                const char *key, size_t key_sz,
+                                const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_group_map_remove(struct hyperdex_client* client,
-                                 const char* space,
-                                 const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                 enum hyperdex_client_returncode* status,
-                                 uint64_t* count);
+hyperdex_client_group_map_remove(struct hyperdex_client *client,
+                                 const char *space,
+                                 const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz,
+                                 enum hyperdex_client_returncode *status,
+                                 uint64_t *count);
 
 int64_t
-hyperdex_client_map_atomic_add(struct hyperdex_client* client,
-                               const char* space,
-                               const char* key, size_t key_sz,
-                               const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                               enum hyperdex_client_returncode* status);
+hyperdex_client_map_atomic_add(struct hyperdex_client *client,
+                               const char *space,
+                               const char *key, size_t key_sz,
+                               const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+                               enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_cond_map_atomic_add(struct hyperdex_client* client,
-                                    const char* space,
-                                    const char* key, size_t key_sz,
-                                    const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                    const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                    enum hyperdex_client_returncode* status);
+hyperdex_client_cond_map_atomic_add(struct hyperdex_client *client,
+                                    const char *space,
+                                    const char *key, size_t key_sz,
+                                    const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                    const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+                                    enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_group_map_atomic_add(struct hyperdex_client* client,
-                                     const char* space,
-                                     const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                     const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                     enum hyperdex_client_returncode* status,
-                                     uint64_t* count);
+hyperdex_client_group_map_atomic_add(struct hyperdex_client *client,
+                                     const char *space,
+                                     const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                     const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+                                     enum hyperdex_client_returncode *status,
+                                     uint64_t *count);
 
 int64_t
-hyperdex_client_map_atomic_sub(struct hyperdex_client* client,
-                               const char* space,
-                               const char* key, size_t key_sz,
-                               const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                               enum hyperdex_client_returncode* status);
+hyperdex_client_map_atomic_sub(struct hyperdex_client *client,
+                               const char *space,
+                               const char *key, size_t key_sz,
+                               const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+                               enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_cond_map_atomic_sub(struct hyperdex_client* client,
-                                    const char* space,
-                                    const char* key, size_t key_sz,
-                                    const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                    const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                    enum hyperdex_client_returncode* status);
+hyperdex_client_cond_map_atomic_sub(struct hyperdex_client *client,
+                                    const char *space,
+                                    const char *key, size_t key_sz,
+                                    const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                    const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+                                    enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_group_map_atomic_sub(struct hyperdex_client* client,
-                                     const char* space,
-                                     const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                     const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                     enum hyperdex_client_returncode* status,
-                                     uint64_t* count);
+hyperdex_client_group_map_atomic_sub(struct hyperdex_client *client,
+                                     const char *space,
+                                     const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                     const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+                                     enum hyperdex_client_returncode *status,
+                                     uint64_t *count);
 
 int64_t
-hyperdex_client_map_atomic_mul(struct hyperdex_client* client,
-                               const char* space,
-                               const char* key, size_t key_sz,
-                               const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                               enum hyperdex_client_returncode* status);
+hyperdex_client_map_atomic_mul(struct hyperdex_client *client,
+                               const char *space,
+                               const char *key, size_t key_sz,
+                               const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+                               enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_cond_map_atomic_mul(struct hyperdex_client* client,
-                                    const char* space,
-                                    const char* key, size_t key_sz,
-                                    const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                    const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                    enum hyperdex_client_returncode* status);
+hyperdex_client_cond_map_atomic_mul(struct hyperdex_client *client,
+                                    const char *space,
+                                    const char *key, size_t key_sz,
+                                    const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                    const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+                                    enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_group_map_atomic_mul(struct hyperdex_client* client,
-                                     const char* space,
-                                     const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                     const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                     enum hyperdex_client_returncode* status,
-                                     uint64_t* count);
+hyperdex_client_group_map_atomic_mul(struct hyperdex_client *client,
+                                     const char *space,
+                                     const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                     const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+                                     enum hyperdex_client_returncode *status,
+                                     uint64_t *count);
 
 int64_t
-hyperdex_client_map_atomic_div(struct hyperdex_client* client,
-                               const char* space,
-                               const char* key, size_t key_sz,
-                               const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                               enum hyperdex_client_returncode* status);
+hyperdex_client_map_atomic_div(struct hyperdex_client *client,
+                               const char *space,
+                               const char *key, size_t key_sz,
+                               const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+                               enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_cond_map_atomic_div(struct hyperdex_client* client,
-                                    const char* space,
-                                    const char* key, size_t key_sz,
-                                    const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                    const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                    enum hyperdex_client_returncode* status);
+hyperdex_client_cond_map_atomic_div(struct hyperdex_client *client,
+                                    const char *space,
+                                    const char *key, size_t key_sz,
+                                    const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                    const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+                                    enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_group_map_atomic_div(struct hyperdex_client* client,
-                                     const char* space,
-                                     const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                     const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                     enum hyperdex_client_returncode* status,
-                                     uint64_t* count);
+hyperdex_client_group_map_atomic_div(struct hyperdex_client *client,
+                                     const char *space,
+                                     const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                     const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+                                     enum hyperdex_client_returncode *status,
+                                     uint64_t *count);
 
 int64_t
-hyperdex_client_map_atomic_mod(struct hyperdex_client* client,
-                               const char* space,
-                               const char* key, size_t key_sz,
-                               const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                               enum hyperdex_client_returncode* status);
+hyperdex_client_map_atomic_mod(struct hyperdex_client *client,
+                               const char *space,
+                               const char *key, size_t key_sz,
+                               const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+                               enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_cond_map_atomic_mod(struct hyperdex_client* client,
-                                    const char* space,
-                                    const char* key, size_t key_sz,
-                                    const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                    const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                    enum hyperdex_client_returncode* status);
+hyperdex_client_cond_map_atomic_mod(struct hyperdex_client *client,
+                                    const char *space,
+                                    const char *key, size_t key_sz,
+                                    const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                    const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+                                    enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_group_map_atomic_mod(struct hyperdex_client* client,
-                                     const char* space,
-                                     const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                     const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                     enum hyperdex_client_returncode* status,
-                                     uint64_t* count);
+hyperdex_client_group_map_atomic_mod(struct hyperdex_client *client,
+                                     const char *space,
+                                     const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                     const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+                                     enum hyperdex_client_returncode *status,
+                                     uint64_t *count);
 
 int64_t
-hyperdex_client_map_atomic_and(struct hyperdex_client* client,
-                               const char* space,
-                               const char* key, size_t key_sz,
-                               const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                               enum hyperdex_client_returncode* status);
+hyperdex_client_map_atomic_and(struct hyperdex_client *client,
+                               const char *space,
+                               const char *key, size_t key_sz,
+                               const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+                               enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_cond_map_atomic_and(struct hyperdex_client* client,
-                                    const char* space,
-                                    const char* key, size_t key_sz,
-                                    const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                    const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                    enum hyperdex_client_returncode* status);
+hyperdex_client_cond_map_atomic_and(struct hyperdex_client *client,
+                                    const char *space,
+                                    const char *key, size_t key_sz,
+                                    const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                    const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+                                    enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_group_map_atomic_and(struct hyperdex_client* client,
-                                     const char* space,
-                                     const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                     const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                     enum hyperdex_client_returncode* status,
-                                     uint64_t* count);
+hyperdex_client_group_map_atomic_and(struct hyperdex_client *client,
+                                     const char *space,
+                                     const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                     const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+                                     enum hyperdex_client_returncode *status,
+                                     uint64_t *count);
 
 int64_t
-hyperdex_client_map_atomic_or(struct hyperdex_client* client,
-                              const char* space,
-                              const char* key, size_t key_sz,
-                              const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                              enum hyperdex_client_returncode* status);
+hyperdex_client_map_atomic_or(struct hyperdex_client *client,
+                              const char *space,
+                              const char *key, size_t key_sz,
+                              const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+                              enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_cond_map_atomic_or(struct hyperdex_client* client,
-                                   const char* space,
-                                   const char* key, size_t key_sz,
-                                   const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                   const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                   enum hyperdex_client_returncode* status);
+hyperdex_client_cond_map_atomic_or(struct hyperdex_client *client,
+                                   const char *space,
+                                   const char *key, size_t key_sz,
+                                   const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                   const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+                                   enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_group_map_atomic_or(struct hyperdex_client* client,
-                                    const char* space,
-                                    const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                    const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                    enum hyperdex_client_returncode* status,
-                                    uint64_t* count);
+hyperdex_client_group_map_atomic_or(struct hyperdex_client *client,
+                                    const char *space,
+                                    const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                    const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+                                    enum hyperdex_client_returncode *status,
+                                    uint64_t *count);
 
 int64_t
-hyperdex_client_map_atomic_xor(struct hyperdex_client* client,
-                               const char* space,
-                               const char* key, size_t key_sz,
-                               const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                               enum hyperdex_client_returncode* status);
+hyperdex_client_map_atomic_xor(struct hyperdex_client *client,
+                               const char *space,
+                               const char *key, size_t key_sz,
+                               const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+                               enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_cond_map_atomic_xor(struct hyperdex_client* client,
-                                    const char* space,
-                                    const char* key, size_t key_sz,
-                                    const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                    const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                    enum hyperdex_client_returncode* status);
+hyperdex_client_cond_map_atomic_xor(struct hyperdex_client *client,
+                                    const char *space,
+                                    const char *key, size_t key_sz,
+                                    const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                    const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+                                    enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_group_map_atomic_xor(struct hyperdex_client* client,
-                                     const char* space,
-                                     const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                     const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                     enum hyperdex_client_returncode* status,
-                                     uint64_t* count);
+hyperdex_client_group_map_atomic_xor(struct hyperdex_client *client,
+                                     const char *space,
+                                     const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                     const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+                                     enum hyperdex_client_returncode *status,
+                                     uint64_t *count);
 
 int64_t
-hyperdex_client_map_string_prepend(struct hyperdex_client* client,
-                                   const char* space,
-                                   const char* key, size_t key_sz,
-                                   const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                   enum hyperdex_client_returncode* status);
+hyperdex_client_map_string_prepend(struct hyperdex_client *client,
+                                   const char *space,
+                                   const char *key, size_t key_sz,
+                                   const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+                                   enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_cond_map_string_prepend(struct hyperdex_client* client,
-                                        const char* space,
-                                        const char* key, size_t key_sz,
-                                        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                        enum hyperdex_client_returncode* status);
+hyperdex_client_cond_map_string_prepend(struct hyperdex_client *client,
+                                        const char *space,
+                                        const char *key, size_t key_sz,
+                                        const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                        const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+                                        enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_group_map_string_prepend(struct hyperdex_client* client,
-                                         const char* space,
-                                         const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                         const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                         enum hyperdex_client_returncode* status,
-                                         uint64_t* count);
+hyperdex_client_group_map_string_prepend(struct hyperdex_client *client,
+                                         const char *space,
+                                         const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                         const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+                                         enum hyperdex_client_returncode *status,
+                                         uint64_t *count);
 
 int64_t
-hyperdex_client_map_string_append(struct hyperdex_client* client,
-                                  const char* space,
-                                  const char* key, size_t key_sz,
-                                  const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                  enum hyperdex_client_returncode* status);
+hyperdex_client_map_string_append(struct hyperdex_client *client,
+                                  const char *space,
+                                  const char *key, size_t key_sz,
+                                  const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+                                  enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_cond_map_string_append(struct hyperdex_client* client,
-                                       const char* space,
-                                       const char* key, size_t key_sz,
-                                       const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                       const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                       enum hyperdex_client_returncode* status);
+hyperdex_client_cond_map_string_append(struct hyperdex_client *client,
+                                       const char *space,
+                                       const char *key, size_t key_sz,
+                                       const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                       const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+                                       enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_group_map_string_append(struct hyperdex_client* client,
-                                        const char* space,
-                                        const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                        const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                        enum hyperdex_client_returncode* status,
-                                        uint64_t* count);
+hyperdex_client_group_map_string_append(struct hyperdex_client *client,
+                                        const char *space,
+                                        const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                        const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+                                        enum hyperdex_client_returncode *status,
+                                        uint64_t *count);
 
 int64_t
-hyperdex_client_map_atomic_min(struct hyperdex_client* client,
-                               const char* space,
-                               const char* key, size_t key_sz,
-                               const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                               enum hyperdex_client_returncode* status);
+hyperdex_client_map_atomic_min(struct hyperdex_client *client,
+                               const char *space,
+                               const char *key, size_t key_sz,
+                               const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+                               enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_cond_map_atomic_min(struct hyperdex_client* client,
-                                    const char* space,
-                                    const char* key, size_t key_sz,
-                                    const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                    const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                    enum hyperdex_client_returncode* status);
+hyperdex_client_cond_map_atomic_min(struct hyperdex_client *client,
+                                    const char *space,
+                                    const char *key, size_t key_sz,
+                                    const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                    const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+                                    enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_group_map_atomic_min(struct hyperdex_client* client,
-                                     const char* space,
-                                     const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                     const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                     enum hyperdex_client_returncode* status,
-                                     uint64_t* count);
+hyperdex_client_group_map_atomic_min(struct hyperdex_client *client,
+                                     const char *space,
+                                     const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                     const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+                                     enum hyperdex_client_returncode *status,
+                                     uint64_t *count);
 
 int64_t
-hyperdex_client_uxact_atomic_min(struct hyperdex_client* client,
-                                 struct hyperdex_client_microtransaction* microtransaction,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz);
+hyperdex_client_uxact_atomic_min(struct hyperdex_client *client,
+                                 struct hyperdex_client_microtransaction *microtransaction,
+                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz);
 
 int64_t
-hyperdex_client_map_atomic_max(struct hyperdex_client* client,
-                               const char* space,
-                               const char* key, size_t key_sz,
-                               const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                               enum hyperdex_client_returncode* status);
+hyperdex_client_map_atomic_max(struct hyperdex_client *client,
+                               const char *space,
+                               const char *key, size_t key_sz,
+                               const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+                               enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_cond_map_atomic_max(struct hyperdex_client* client,
-                                    const char* space,
-                                    const char* key, size_t key_sz,
-                                    const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                    const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                    enum hyperdex_client_returncode* status);
+hyperdex_client_cond_map_atomic_max(struct hyperdex_client *client,
+                                    const char *space,
+                                    const char *key, size_t key_sz,
+                                    const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                    const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+                                    enum hyperdex_client_returncode *status);
 
 int64_t
-hyperdex_client_group_map_atomic_max(struct hyperdex_client* client,
-                                     const char* space,
-                                     const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                     const struct hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                     enum hyperdex_client_returncode* status,
-                                     uint64_t* count);
+hyperdex_client_group_map_atomic_max(struct hyperdex_client *client,
+                                     const char *space,
+                                     const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                     const struct hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+                                     enum hyperdex_client_returncode *status,
+                                     uint64_t *count);
 
 int64_t
-hyperdex_client_uxact_atomic_max(struct hyperdex_client* client,
-                                 struct hyperdex_client_microtransaction* microtransaction,
-                                 const struct hyperdex_client_attribute* attrs, size_t attrs_sz);
+hyperdex_client_uxact_atomic_max(struct hyperdex_client *client,
+                                 struct hyperdex_client_microtransaction *microtransaction,
+                                 const struct hyperdex_client_attribute *attrs, size_t attrs_sz);
 
 int64_t
-hyperdex_client_search(struct hyperdex_client* client,
-                       const char* space,
-                       const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                       enum hyperdex_client_returncode* status,
-                       const struct hyperdex_client_attribute** attrs, size_t* attrs_sz);
+hyperdex_client_search(struct hyperdex_client *client,
+                       const char *space,
+                       const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                       enum hyperdex_client_returncode *status,
+                       const struct hyperdex_client_attribute **attrs, size_t *attrs_sz);
 
 int64_t
-hyperdex_client_search_describe(struct hyperdex_client* client,
-                                const char* space,
-                                const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                enum hyperdex_client_returncode* status,
-                                const char** description);
+hyperdex_client_search_describe(struct hyperdex_client *client,
+                                const char *space,
+                                const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                                enum hyperdex_client_returncode *status,
+                                const char **description);
 
 int64_t
-hyperdex_client_sorted_search(struct hyperdex_client* client,
-                              const char* space,
-                              const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                              const char* sort_by,
+hyperdex_client_sorted_search(struct hyperdex_client *client,
+                              const char *space,
+                              const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                              const char *sort_by,
                               uint64_t limit,
                               int maxmin,
-                              enum hyperdex_client_returncode* status,
-                              const struct hyperdex_client_attribute** attrs, size_t* attrs_sz);
+                              enum hyperdex_client_returncode *status,
+                              const struct hyperdex_client_attribute **attrs, size_t *attrs_sz);
+
+int64_t
+hyperdex_client_count(struct hyperdex_client *client,
+                      const char *space,
+                      const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                      enum hyperdex_client_returncode *status,
+                      uint64_t *count);
 
 int64_t
-hyperdex_client_count(struct hyperdex_client* client,
-                      const char* space,
-                      const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-                      enum hyperdex_client_returncode* status,
-                      uint64_t* count);
+hyperdex_client_sum(struct hyperdex_client *client,
+                    const char *space,
+                    const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+                    const char *sum_key,
+                    enum hyperdex_client_returncode *status,
+                    uint64_t *sum_count);
 
 int64_t
-hyperdex_client_loop(struct hyperdex_client* client, int timeout,
-                     enum hyperdex_client_returncode* status);
+hyperdex_client_loop(struct hyperdex_client *client, int timeout,
+                     enum hyperdex_client_returncode *status);
 
 int
-hyperdex_client_poll_fd(struct hyperdex_client* client);
+hyperdex_client_poll_fd(struct hyperdex_client *client);
 
 int
-hyperdex_client_block(struct hyperdex_client* client, int timeout);
+hyperdex_client_block(struct hyperdex_client *client, int timeout);
 
 enum hyperdatatype
-hyperdex_client_attribute_type(struct hyperdex_client* client,
-                               const char* space, const char* name,
-                               enum hyperdex_client_returncode* status);
+hyperdex_client_attribute_type(struct hyperdex_client *client,
+                               const char *space, const char *name,
+                               enum hyperdex_client_returncode *status);
 
-const char*
-hyperdex_client_error_message(struct hyperdex_client* client);
+const char *
+hyperdex_client_error_message(struct hyperdex_client *client);
 
-const char*
-hyperdex_client_error_location(struct hyperdex_client* client);
+const char *
+hyperdex_client_error_location(struct hyperdex_client *client);
 
-const char*
+const char *
 hyperdex_client_returncode_to_string(enum hyperdex_client_returncode);
 
 void
-hyperdex_client_destroy_attrs(const struct hyperdex_client_attribute* attrs, size_t attrs_sz);
+hyperdex_client_destroy_attrs(const struct hyperdex_client_attribute *attrs, size_t attrs_sz);
 
 #ifdef __cplusplus
 } /* extern "C" */
diff --git a/include/hyperdex/client.hpp b/include/hyperdex/client.hpp
index e74c2e77b..54e4c3a58 100644
--- a/include/hyperdex/client.hpp
+++ b/include/hyperdex/client.hpp
@@ -38,747 +38,753 @@ namespace hyperdex
 
 class Client
 {
-    public:
-        Client(const char* coordinator, uint16_t port)
-            : m_cl(hyperdex_client_create(coordinator, port))
-        {
-            if (!m_cl)
-            {
-                throw std::bad_alloc();
-            }
-        }
-        Client(const char* conn_str)
-            : m_cl(hyperdex_client_create_conn_str(conn_str))
-        {
-            if (!m_cl)
-            {
-                throw std::bad_alloc();
-            }
-        }
-        ~Client() throw ()
-        {
-            hyperdex_client_destroy(m_cl);
-        }
+public:
+	Client(const char *coordinator, uint16_t port)
+		: m_cl(hyperdex_client_create(coordinator, port))
+	{
+		if (!m_cl)
+		{
+			throw std::bad_alloc();
+		}
+	}
+	Client(const char *conn_str)
+		: m_cl(hyperdex_client_create_conn_str(conn_str))
+	{
+		if (!m_cl)
+		{
+			throw std::bad_alloc();
+		}
+	}
+	~Client() throw ()
+	{
+		hyperdex_client_destroy(m_cl);
+	}
 
-    public:
-        int64_t get(const char* space,
-                    const char* key, size_t key_sz,
-                    hyperdex_client_returncode* status,
-                    const hyperdex_client_attribute** attrs, size_t* attrs_sz)
-            { return hyperdex_client_get(m_cl, space, key, key_sz, status, attrs, attrs_sz); }
-        int64_t get_partial(const char* space,
-                            const char* key, size_t key_sz,
-                            const char** attrnames, size_t attrnames_sz,
-                            hyperdex_client_returncode* status,
-                            const hyperdex_client_attribute** attrs, size_t* attrs_sz)
-            { return hyperdex_client_get_partial(m_cl, space, key, key_sz, attrnames, attrnames_sz, status, attrs, attrs_sz); }
-        int64_t put(const char* space,
-                    const char* key, size_t key_sz,
-                    const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                    hyperdex_client_returncode* status)
-            { return hyperdex_client_put(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
-        int64_t cond_put(const char* space,
-                         const char* key, size_t key_sz,
-                         const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                         const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                         hyperdex_client_returncode* status)
-            { return hyperdex_client_cond_put(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
-        int64_t cond_put_or_create(const char* space,
-                                   const char* key, size_t key_sz,
-                                   const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                   const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                   hyperdex_client_returncode* status)
-            { return hyperdex_client_cond_put_or_create(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
-        int64_t group_put(const char* space,
-                          const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                          const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                          hyperdex_client_returncode* status,
-                          uint64_t* count)
-            { return hyperdex_client_group_put(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
-        int64_t put_if_not_exist(const char* space,
-                                 const char* key, size_t key_sz,
-                                 const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                 hyperdex_client_returncode* status)
-            { return hyperdex_client_put_if_not_exist(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
-        int64_t del(const char* space,
-                    const char* key, size_t key_sz,
-                    hyperdex_client_returncode* status)
-            { return hyperdex_client_del(m_cl, space, key, key_sz, status); }
-        int64_t cond_del(const char* space,
-                         const char* key, size_t key_sz,
-                         const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                         hyperdex_client_returncode* status)
-            { return hyperdex_client_cond_del(m_cl, space, key, key_sz, checks, checks_sz, status); }
-        int64_t group_del(const char* space,
-                          const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                          hyperdex_client_returncode* status,
-                          uint64_t* count)
-            { return hyperdex_client_group_del(m_cl, space, checks, checks_sz, status, count); }
-        int64_t atomic_add(const char* space,
-                           const char* key, size_t key_sz,
-                           const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                           hyperdex_client_returncode* status)
-            { return hyperdex_client_atomic_add(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
-        int64_t cond_atomic_add(const char* space,
-                                const char* key, size_t key_sz,
-                                const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                hyperdex_client_returncode* status)
-            { return hyperdex_client_cond_atomic_add(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
-        int64_t group_atomic_add(const char* space,
-                                 const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                 const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                 hyperdex_client_returncode* status,
-                                 uint64_t* count)
-            { return hyperdex_client_group_atomic_add(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
-        int64_t atomic_sub(const char* space,
-                           const char* key, size_t key_sz,
-                           const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                           hyperdex_client_returncode* status)
-            { return hyperdex_client_atomic_sub(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
-        int64_t cond_atomic_sub(const char* space,
-                                const char* key, size_t key_sz,
-                                const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                hyperdex_client_returncode* status)
-            { return hyperdex_client_cond_atomic_sub(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
-        int64_t group_atomic_sub(const char* space,
-                                 const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                 const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                 hyperdex_client_returncode* status,
-                                 uint64_t* count)
-            { return hyperdex_client_group_atomic_sub(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
-        int64_t atomic_mul(const char* space,
-                           const char* key, size_t key_sz,
-                           const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                           hyperdex_client_returncode* status)
-            { return hyperdex_client_atomic_mul(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
-        int64_t cond_atomic_mul(const char* space,
-                                const char* key, size_t key_sz,
-                                const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                hyperdex_client_returncode* status)
-            { return hyperdex_client_cond_atomic_mul(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
-        int64_t group_atomic_mul(const char* space,
-                                 const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                 const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                 hyperdex_client_returncode* status,
-                                 uint64_t* count)
-            { return hyperdex_client_group_atomic_mul(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
-        int64_t atomic_div(const char* space,
-                           const char* key, size_t key_sz,
-                           const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                           hyperdex_client_returncode* status)
-            { return hyperdex_client_atomic_div(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
-        int64_t cond_atomic_div(const char* space,
-                                const char* key, size_t key_sz,
-                                const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                hyperdex_client_returncode* status)
-            { return hyperdex_client_cond_atomic_div(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
-        int64_t group_atomic_div(const char* space,
-                                 const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                 const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                 hyperdex_client_returncode* status,
-                                 uint64_t* count)
-            { return hyperdex_client_group_atomic_div(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
-        int64_t atomic_mod(const char* space,
-                           const char* key, size_t key_sz,
-                           const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                           hyperdex_client_returncode* status)
-            { return hyperdex_client_atomic_mod(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
-        int64_t cond_atomic_mod(const char* space,
-                                const char* key, size_t key_sz,
-                                const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                hyperdex_client_returncode* status)
-            { return hyperdex_client_cond_atomic_mod(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
-        int64_t group_atomic_mod(const char* space,
-                                 const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                 const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                 hyperdex_client_returncode* status,
-                                 uint64_t* count)
-            { return hyperdex_client_group_atomic_mod(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
-        int64_t atomic_and(const char* space,
-                           const char* key, size_t key_sz,
-                           const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                           hyperdex_client_returncode* status)
-            { return hyperdex_client_atomic_and(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
-        int64_t cond_atomic_and(const char* space,
-                                const char* key, size_t key_sz,
-                                const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                hyperdex_client_returncode* status)
-            { return hyperdex_client_cond_atomic_and(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
-        int64_t group_atomic_and(const char* space,
-                                 const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                 const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                 hyperdex_client_returncode* status,
-                                 uint64_t* count)
-            { return hyperdex_client_group_atomic_and(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
-        int64_t atomic_or(const char* space,
-                          const char* key, size_t key_sz,
-                          const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                          hyperdex_client_returncode* status)
-            { return hyperdex_client_atomic_or(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
-        int64_t cond_atomic_or(const char* space,
-                               const char* key, size_t key_sz,
-                               const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                               const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                               hyperdex_client_returncode* status)
-            { return hyperdex_client_cond_atomic_or(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
-        int64_t group_atomic_or(const char* space,
-                                const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                hyperdex_client_returncode* status,
-                                uint64_t* count)
-            { return hyperdex_client_group_atomic_or(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
-        int64_t atomic_xor(const char* space,
-                           const char* key, size_t key_sz,
-                           const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                           hyperdex_client_returncode* status)
-            { return hyperdex_client_atomic_xor(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
-        int64_t cond_atomic_xor(const char* space,
-                                const char* key, size_t key_sz,
-                                const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                hyperdex_client_returncode* status)
-            { return hyperdex_client_cond_atomic_xor(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
-        int64_t group_atomic_xor(const char* space,
-                                 const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                 const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                 hyperdex_client_returncode* status,
-                                 uint64_t* count)
-            { return hyperdex_client_group_atomic_xor(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
-        int64_t atomic_min(const char* space,
-                           const char* key, size_t key_sz,
-                           const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                           hyperdex_client_returncode* status)
-            { return hyperdex_client_atomic_min(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
-        int64_t cond_atomic_min(const char* space,
-                                const char* key, size_t key_sz,
-                                const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                hyperdex_client_returncode* status)
-            { return hyperdex_client_cond_atomic_min(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
-        int64_t group_atomic_min(const char* space,
-                                 const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                 const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                 hyperdex_client_returncode* status,
-                                 uint64_t* count)
-            { return hyperdex_client_group_atomic_min(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
-        int64_t atomic_max(const char* space,
-                           const char* key, size_t key_sz,
-                           const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                           hyperdex_client_returncode* status)
-            { return hyperdex_client_atomic_max(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
-        int64_t cond_atomic_max(const char* space,
-                                const char* key, size_t key_sz,
-                                const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                hyperdex_client_returncode* status)
-            { return hyperdex_client_cond_atomic_max(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
-        int64_t group_atomic_max(const char* space,
-                                 const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                 const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                 hyperdex_client_returncode* status,
-                                 uint64_t* count)
-            { return hyperdex_client_group_atomic_max(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
-        int64_t string_prepend(const char* space,
-                               const char* key, size_t key_sz,
-                               const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                               hyperdex_client_returncode* status)
-            { return hyperdex_client_string_prepend(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
-        int64_t cond_string_prepend(const char* space,
-                                    const char* key, size_t key_sz,
-                                    const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                    const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                    hyperdex_client_returncode* status)
-            { return hyperdex_client_cond_string_prepend(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
-        int64_t group_string_prepend(const char* space,
-                                     const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                     const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                     hyperdex_client_returncode* status,
-                                     uint64_t* count)
-            { return hyperdex_client_group_string_prepend(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
-        int64_t string_append(const char* space,
-                              const char* key, size_t key_sz,
-                              const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                              hyperdex_client_returncode* status)
-            { return hyperdex_client_string_append(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
-        int64_t cond_string_append(const char* space,
-                                   const char* key, size_t key_sz,
-                                   const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                   const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                   hyperdex_client_returncode* status)
-            { return hyperdex_client_cond_string_append(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
-        int64_t group_string_append(const char* space,
-                                    const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                    const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                    hyperdex_client_returncode* status,
-                                    uint64_t* count)
-            { return hyperdex_client_group_string_append(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
-        int64_t string_ltrim(const char* space,
-                             const char* key, size_t key_sz,
-                             const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                             hyperdex_client_returncode* status)
-            { return hyperdex_client_string_ltrim(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
-        int64_t cond_string_ltrim(const char* space,
-                                  const char* key, size_t key_sz,
-                                  const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                  const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                  hyperdex_client_returncode* status)
-            { return hyperdex_client_cond_string_ltrim(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
-        int64_t group_string_ltrim(const char* space,
-                                   const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                   const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                   hyperdex_client_returncode* status,
-                                   uint64_t* count)
-            { return hyperdex_client_group_string_ltrim(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
-        int64_t string_rtrim(const char* space,
-                             const char* key, size_t key_sz,
-                             const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                             hyperdex_client_returncode* status)
-            { return hyperdex_client_string_rtrim(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
-        int64_t cond_string_rtrim(const char* space,
-                                  const char* key, size_t key_sz,
-                                  const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                  const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                  hyperdex_client_returncode* status)
-            { return hyperdex_client_cond_string_rtrim(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
-        int64_t group_string_rtrim(const char* space,
-                                   const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                   const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                   hyperdex_client_returncode* status,
-                                   uint64_t* count)
-            { return hyperdex_client_group_string_rtrim(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
-        int64_t list_lpush(const char* space,
-                           const char* key, size_t key_sz,
-                           const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                           hyperdex_client_returncode* status)
-            { return hyperdex_client_list_lpush(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
-        int64_t cond_list_lpush(const char* space,
-                                const char* key, size_t key_sz,
-                                const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                hyperdex_client_returncode* status)
-            { return hyperdex_client_cond_list_lpush(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
-        int64_t group_list_lpush(const char* space,
-                                 const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                 const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                 hyperdex_client_returncode* status,
-                                 uint64_t* count)
-            { return hyperdex_client_group_list_lpush(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
-        int64_t list_rpush(const char* space,
-                           const char* key, size_t key_sz,
-                           const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                           hyperdex_client_returncode* status)
-            { return hyperdex_client_list_rpush(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
-        int64_t cond_list_rpush(const char* space,
-                                const char* key, size_t key_sz,
-                                const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                hyperdex_client_returncode* status)
-            { return hyperdex_client_cond_list_rpush(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
-        int64_t group_list_rpush(const char* space,
-                                 const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                 const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                 hyperdex_client_returncode* status,
-                                 uint64_t* count)
-            { return hyperdex_client_group_list_rpush(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
-        int64_t set_add(const char* space,
-                        const char* key, size_t key_sz,
-                        const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                        hyperdex_client_returncode* status)
-            { return hyperdex_client_set_add(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
-        int64_t cond_set_add(const char* space,
-                             const char* key, size_t key_sz,
-                             const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                             const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                             hyperdex_client_returncode* status)
-            { return hyperdex_client_cond_set_add(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
-        int64_t group_set_add(const char* space,
-                              const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                              const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                              hyperdex_client_returncode* status,
-                              uint64_t* count)
-            { return hyperdex_client_group_set_add(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
-        int64_t set_remove(const char* space,
-                           const char* key, size_t key_sz,
-                           const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                           hyperdex_client_returncode* status)
-            { return hyperdex_client_set_remove(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
-        int64_t cond_set_remove(const char* space,
-                                const char* key, size_t key_sz,
-                                const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                hyperdex_client_returncode* status)
-            { return hyperdex_client_cond_set_remove(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
-        int64_t group_set_remove(const char* space,
-                                 const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                 const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                 hyperdex_client_returncode* status,
-                                 uint64_t* count)
-            { return hyperdex_client_group_set_remove(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
-        int64_t set_intersect(const char* space,
-                              const char* key, size_t key_sz,
-                              const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                              hyperdex_client_returncode* status)
-            { return hyperdex_client_set_intersect(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
-        int64_t cond_set_intersect(const char* space,
-                                   const char* key, size_t key_sz,
-                                   const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                   const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                   hyperdex_client_returncode* status)
-            { return hyperdex_client_cond_set_intersect(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
-        int64_t group_set_intersect(const char* space,
-                                    const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                    const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                    hyperdex_client_returncode* status,
-                                    uint64_t* count)
-            { return hyperdex_client_group_set_intersect(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
-        int64_t set_union(const char* space,
-                          const char* key, size_t key_sz,
-                          const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                          hyperdex_client_returncode* status)
-            { return hyperdex_client_set_union(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
-        int64_t cond_set_union(const char* space,
-                               const char* key, size_t key_sz,
-                               const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                               const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                               hyperdex_client_returncode* status)
-            { return hyperdex_client_cond_set_union(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
-        int64_t group_set_union(const char* space,
-                                const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                hyperdex_client_returncode* status,
-                                uint64_t* count)
-            { return hyperdex_client_group_set_union(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
-        int64_t document_rename(const char* space,
-                                const char* key, size_t key_sz,
-                                const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                hyperdex_client_returncode* status)
-            { return hyperdex_client_document_rename(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
-        int64_t cond_document_rename(const char* space,
-                                     const char* key, size_t key_sz,
-                                     const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                     const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                     hyperdex_client_returncode* status)
-            { return hyperdex_client_cond_document_rename(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
-        int64_t group_document_rename(const char* space,
-                                      const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                      const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                      hyperdex_client_returncode* status,
-                                      uint64_t* count)
-            { return hyperdex_client_group_document_rename(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
-        int64_t document_unset(const char* space,
-                               const char* key, size_t key_sz,
-                               const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                               hyperdex_client_returncode* status)
-            { return hyperdex_client_document_unset(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
-        int64_t cond_document_unset(const char* space,
-                                    const char* key, size_t key_sz,
-                                    const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                    const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                    hyperdex_client_returncode* status)
-            { return hyperdex_client_cond_document_unset(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
-        int64_t group_document_unset(const char* space,
-                                     const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                     const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                     hyperdex_client_returncode* status,
-                                     uint64_t* count)
-            { return hyperdex_client_group_document_unset(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
-        int64_t map_add(const char* space,
-                        const char* key, size_t key_sz,
-                        const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                        hyperdex_client_returncode* status)
-            { return hyperdex_client_map_add(m_cl, space, key, key_sz, mapattrs, mapattrs_sz, status); }
-        int64_t cond_map_add(const char* space,
-                             const char* key, size_t key_sz,
-                             const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                             const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                             hyperdex_client_returncode* status)
-            { return hyperdex_client_cond_map_add(m_cl, space, key, key_sz, checks, checks_sz, mapattrs, mapattrs_sz, status); }
-        int64_t group_map_add(const char* space,
-                              const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                              const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                              hyperdex_client_returncode* status,
-                              uint64_t* count)
-            { return hyperdex_client_group_map_add(m_cl, space, checks, checks_sz, mapattrs, mapattrs_sz, status, count); }
-        int64_t map_remove(const char* space,
-                           const char* key, size_t key_sz,
-                           const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                           hyperdex_client_returncode* status)
-            { return hyperdex_client_map_remove(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
-        int64_t cond_map_remove(const char* space,
-                                const char* key, size_t key_sz,
-                                const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                hyperdex_client_returncode* status)
-            { return hyperdex_client_cond_map_remove(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
-        int64_t group_map_remove(const char* space,
-                                 const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                 const hyperdex_client_attribute* attrs, size_t attrs_sz,
-                                 hyperdex_client_returncode* status,
-                                 uint64_t* count)
-            { return hyperdex_client_group_map_remove(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
-        int64_t map_atomic_add(const char* space,
-                               const char* key, size_t key_sz,
-                               const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                               hyperdex_client_returncode* status)
-            { return hyperdex_client_map_atomic_add(m_cl, space, key, key_sz, mapattrs, mapattrs_sz, status); }
-        int64_t cond_map_atomic_add(const char* space,
-                                    const char* key, size_t key_sz,
-                                    const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                    const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                    hyperdex_client_returncode* status)
-            { return hyperdex_client_cond_map_atomic_add(m_cl, space, key, key_sz, checks, checks_sz, mapattrs, mapattrs_sz, status); }
-        int64_t group_map_atomic_add(const char* space,
-                                     const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                     const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                     hyperdex_client_returncode* status,
-                                     uint64_t* count)
-            { return hyperdex_client_group_map_atomic_add(m_cl, space, checks, checks_sz, mapattrs, mapattrs_sz, status, count); }
-        int64_t map_atomic_sub(const char* space,
-                               const char* key, size_t key_sz,
-                               const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                               hyperdex_client_returncode* status)
-            { return hyperdex_client_map_atomic_sub(m_cl, space, key, key_sz, mapattrs, mapattrs_sz, status); }
-        int64_t cond_map_atomic_sub(const char* space,
-                                    const char* key, size_t key_sz,
-                                    const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                    const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                    hyperdex_client_returncode* status)
-            { return hyperdex_client_cond_map_atomic_sub(m_cl, space, key, key_sz, checks, checks_sz, mapattrs, mapattrs_sz, status); }
-        int64_t group_map_atomic_sub(const char* space,
-                                     const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                     const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                     hyperdex_client_returncode* status,
-                                     uint64_t* count)
-            { return hyperdex_client_group_map_atomic_sub(m_cl, space, checks, checks_sz, mapattrs, mapattrs_sz, status, count); }
-        int64_t map_atomic_mul(const char* space,
-                               const char* key, size_t key_sz,
-                               const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                               hyperdex_client_returncode* status)
-            { return hyperdex_client_map_atomic_mul(m_cl, space, key, key_sz, mapattrs, mapattrs_sz, status); }
-        int64_t cond_map_atomic_mul(const char* space,
-                                    const char* key, size_t key_sz,
-                                    const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                    const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                    hyperdex_client_returncode* status)
-            { return hyperdex_client_cond_map_atomic_mul(m_cl, space, key, key_sz, checks, checks_sz, mapattrs, mapattrs_sz, status); }
-        int64_t group_map_atomic_mul(const char* space,
-                                     const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                     const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                     hyperdex_client_returncode* status,
-                                     uint64_t* count)
-            { return hyperdex_client_group_map_atomic_mul(m_cl, space, checks, checks_sz, mapattrs, mapattrs_sz, status, count); }
-        int64_t map_atomic_div(const char* space,
-                               const char* key, size_t key_sz,
-                               const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                               hyperdex_client_returncode* status)
-            { return hyperdex_client_map_atomic_div(m_cl, space, key, key_sz, mapattrs, mapattrs_sz, status); }
-        int64_t cond_map_atomic_div(const char* space,
-                                    const char* key, size_t key_sz,
-                                    const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                    const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                    hyperdex_client_returncode* status)
-            { return hyperdex_client_cond_map_atomic_div(m_cl, space, key, key_sz, checks, checks_sz, mapattrs, mapattrs_sz, status); }
-        int64_t group_map_atomic_div(const char* space,
-                                     const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                     const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                     hyperdex_client_returncode* status,
-                                     uint64_t* count)
-            { return hyperdex_client_group_map_atomic_div(m_cl, space, checks, checks_sz, mapattrs, mapattrs_sz, status, count); }
-        int64_t map_atomic_mod(const char* space,
-                               const char* key, size_t key_sz,
-                               const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                               hyperdex_client_returncode* status)
-            { return hyperdex_client_map_atomic_mod(m_cl, space, key, key_sz, mapattrs, mapattrs_sz, status); }
-        int64_t cond_map_atomic_mod(const char* space,
-                                    const char* key, size_t key_sz,
-                                    const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                    const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                    hyperdex_client_returncode* status)
-            { return hyperdex_client_cond_map_atomic_mod(m_cl, space, key, key_sz, checks, checks_sz, mapattrs, mapattrs_sz, status); }
-        int64_t group_map_atomic_mod(const char* space,
-                                     const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                     const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                     hyperdex_client_returncode* status,
-                                     uint64_t* count)
-            { return hyperdex_client_group_map_atomic_mod(m_cl, space, checks, checks_sz, mapattrs, mapattrs_sz, status, count); }
-        int64_t map_atomic_and(const char* space,
-                               const char* key, size_t key_sz,
-                               const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                               hyperdex_client_returncode* status)
-            { return hyperdex_client_map_atomic_and(m_cl, space, key, key_sz, mapattrs, mapattrs_sz, status); }
-        int64_t cond_map_atomic_and(const char* space,
-                                    const char* key, size_t key_sz,
-                                    const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                    const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                    hyperdex_client_returncode* status)
-            { return hyperdex_client_cond_map_atomic_and(m_cl, space, key, key_sz, checks, checks_sz, mapattrs, mapattrs_sz, status); }
-        int64_t group_map_atomic_and(const char* space,
-                                     const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                     const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                     hyperdex_client_returncode* status,
-                                     uint64_t* count)
-            { return hyperdex_client_group_map_atomic_and(m_cl, space, checks, checks_sz, mapattrs, mapattrs_sz, status, count); }
-        int64_t map_atomic_or(const char* space,
-                              const char* key, size_t key_sz,
-                              const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                              hyperdex_client_returncode* status)
-            { return hyperdex_client_map_atomic_or(m_cl, space, key, key_sz, mapattrs, mapattrs_sz, status); }
-        int64_t cond_map_atomic_or(const char* space,
-                                   const char* key, size_t key_sz,
-                                   const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                   const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                   hyperdex_client_returncode* status)
-            { return hyperdex_client_cond_map_atomic_or(m_cl, space, key, key_sz, checks, checks_sz, mapattrs, mapattrs_sz, status); }
-        int64_t group_map_atomic_or(const char* space,
-                                    const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                    const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                    hyperdex_client_returncode* status,
-                                    uint64_t* count)
-            { return hyperdex_client_group_map_atomic_or(m_cl, space, checks, checks_sz, mapattrs, mapattrs_sz, status, count); }
-        int64_t map_atomic_xor(const char* space,
-                               const char* key, size_t key_sz,
-                               const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                               hyperdex_client_returncode* status)
-            { return hyperdex_client_map_atomic_xor(m_cl, space, key, key_sz, mapattrs, mapattrs_sz, status); }
-        int64_t cond_map_atomic_xor(const char* space,
-                                    const char* key, size_t key_sz,
-                                    const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                    const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                    hyperdex_client_returncode* status)
-            { return hyperdex_client_cond_map_atomic_xor(m_cl, space, key, key_sz, checks, checks_sz, mapattrs, mapattrs_sz, status); }
-        int64_t group_map_atomic_xor(const char* space,
-                                     const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                     const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                     hyperdex_client_returncode* status,
-                                     uint64_t* count)
-            { return hyperdex_client_group_map_atomic_xor(m_cl, space, checks, checks_sz, mapattrs, mapattrs_sz, status, count); }
-        int64_t map_string_prepend(const char* space,
-                                   const char* key, size_t key_sz,
-                                   const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                   hyperdex_client_returncode* status)
-            { return hyperdex_client_map_string_prepend(m_cl, space, key, key_sz, mapattrs, mapattrs_sz, status); }
-        int64_t cond_map_string_prepend(const char* space,
-                                        const char* key, size_t key_sz,
-                                        const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                        const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                        hyperdex_client_returncode* status)
-            { return hyperdex_client_cond_map_string_prepend(m_cl, space, key, key_sz, checks, checks_sz, mapattrs, mapattrs_sz, status); }
-        int64_t group_map_string_prepend(const char* space,
-                                         const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                         const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                         hyperdex_client_returncode* status,
-                                         uint64_t* count)
-            { return hyperdex_client_group_map_string_prepend(m_cl, space, checks, checks_sz, mapattrs, mapattrs_sz, status, count); }
-        int64_t map_string_append(const char* space,
-                                  const char* key, size_t key_sz,
-                                  const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                  hyperdex_client_returncode* status)
-            { return hyperdex_client_map_string_append(m_cl, space, key, key_sz, mapattrs, mapattrs_sz, status); }
-        int64_t cond_map_string_append(const char* space,
-                                       const char* key, size_t key_sz,
-                                       const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                       const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                       hyperdex_client_returncode* status)
-            { return hyperdex_client_cond_map_string_append(m_cl, space, key, key_sz, checks, checks_sz, mapattrs, mapattrs_sz, status); }
-        int64_t group_map_string_append(const char* space,
-                                        const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                        const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                        hyperdex_client_returncode* status,
-                                        uint64_t* count)
-            { return hyperdex_client_group_map_string_append(m_cl, space, checks, checks_sz, mapattrs, mapattrs_sz, status, count); }
-        int64_t map_atomic_min(const char* space,
-                               const char* key, size_t key_sz,
-                               const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                               hyperdex_client_returncode* status)
-            { return hyperdex_client_map_atomic_min(m_cl, space, key, key_sz, mapattrs, mapattrs_sz, status); }
-        int64_t cond_map_atomic_min(const char* space,
-                                    const char* key, size_t key_sz,
-                                    const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                    const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                    hyperdex_client_returncode* status)
-            { return hyperdex_client_cond_map_atomic_min(m_cl, space, key, key_sz, checks, checks_sz, mapattrs, mapattrs_sz, status); }
-        int64_t group_map_atomic_min(const char* space,
-                                     const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                     const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                     hyperdex_client_returncode* status,
-                                     uint64_t* count)
-            { return hyperdex_client_group_map_atomic_min(m_cl, space, checks, checks_sz, mapattrs, mapattrs_sz, status, count); }
-        int64_t map_atomic_max(const char* space,
-                               const char* key, size_t key_sz,
-                               const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                               hyperdex_client_returncode* status)
-            { return hyperdex_client_map_atomic_max(m_cl, space, key, key_sz, mapattrs, mapattrs_sz, status); }
-        int64_t cond_map_atomic_max(const char* space,
-                                    const char* key, size_t key_sz,
-                                    const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                    const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                    hyperdex_client_returncode* status)
-            { return hyperdex_client_cond_map_atomic_max(m_cl, space, key, key_sz, checks, checks_sz, mapattrs, mapattrs_sz, status); }
-        int64_t group_map_atomic_max(const char* space,
-                                     const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                     const hyperdex_client_map_attribute* mapattrs, size_t mapattrs_sz,
-                                     hyperdex_client_returncode* status,
-                                     uint64_t* count)
-            { return hyperdex_client_group_map_atomic_max(m_cl, space, checks, checks_sz, mapattrs, mapattrs_sz, status, count); }
-        int64_t search(const char* space,
-                       const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                       hyperdex_client_returncode* status,
-                       const hyperdex_client_attribute** attrs, size_t* attrs_sz)
-            { return hyperdex_client_search(m_cl, space, checks, checks_sz, status, attrs, attrs_sz); }
-        int64_t search_describe(const char* space,
-                                const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                                hyperdex_client_returncode* status,
-                                const char** description)
-            { return hyperdex_client_search_describe(m_cl, space, checks, checks_sz, status, description); }
-        int64_t sorted_search(const char* space,
-                              const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                              const char* sort_by,
-                              uint64_t limit,
-                              int maxmin,
-                              hyperdex_client_returncode* status,
-                              const hyperdex_client_attribute** attrs, size_t* attrs_sz)
-            { return hyperdex_client_sorted_search(m_cl, space, checks, checks_sz, sort_by, limit, maxmin, status, attrs, attrs_sz); }
-        int64_t count(const char* space,
-                      const hyperdex_client_attribute_check* checks, size_t checks_sz,
-                      hyperdex_client_returncode* status,
-                      uint64_t* count)
-            { return hyperdex_client_count(m_cl, space, checks, checks_sz, status, count); }
+public:
+	int64_t get(const char *space,
+	            const char *key, size_t key_sz,
+	            hyperdex_client_returncode *status,
+	            const hyperdex_client_attribute **attrs, size_t *attrs_sz)
+	{ return hyperdex_client_get(m_cl, space, key, key_sz, status, attrs, attrs_sz); }
+	int64_t get_partial(const char *space,
+	                    const char *key, size_t key_sz,
+	                    const char **attrnames, size_t attrnames_sz,
+	                    hyperdex_client_returncode *status,
+	                    const hyperdex_client_attribute **attrs, size_t *attrs_sz)
+	{ return hyperdex_client_get_partial(m_cl, space, key, key_sz, attrnames, attrnames_sz, status, attrs, attrs_sz); }
+	int64_t put(const char *space,
+	            const char *key, size_t key_sz,
+	            const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	            hyperdex_client_returncode *status)
+	{ return hyperdex_client_put(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
+	int64_t cond_put(const char *space,
+	                 const char *key, size_t key_sz,
+	                 const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                 const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                 hyperdex_client_returncode *status)
+	{ return hyperdex_client_cond_put(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
+	int64_t cond_put_or_create(const char *space,
+	                           const char *key, size_t key_sz,
+	                           const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                           const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                           hyperdex_client_returncode *status)
+	{ return hyperdex_client_cond_put_or_create(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
+	int64_t group_put(const char *space,
+	                  const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                  const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                  hyperdex_client_returncode *status,
+	                  uint64_t *count)
+	{ return hyperdex_client_group_put(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
+	int64_t put_if_not_exist(const char *space,
+	                         const char *key, size_t key_sz,
+	                         const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                         hyperdex_client_returncode *status)
+	{ return hyperdex_client_put_if_not_exist(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
+	int64_t del(const char *space,
+	            const char *key, size_t key_sz,
+	            hyperdex_client_returncode *status)
+	{ return hyperdex_client_del(m_cl, space, key, key_sz, status); }
+	int64_t cond_del(const char *space,
+	                 const char *key, size_t key_sz,
+	                 const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                 hyperdex_client_returncode *status)
+	{ return hyperdex_client_cond_del(m_cl, space, key, key_sz, checks, checks_sz, status); }
+	int64_t group_del(const char *space,
+	                  const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                  hyperdex_client_returncode *status,
+	                  uint64_t *count)
+	{ return hyperdex_client_group_del(m_cl, space, checks, checks_sz, status, count); }
+	int64_t atomic_add(const char *space,
+	                   const char *key, size_t key_sz,
+	                   const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                   hyperdex_client_returncode *status)
+	{ return hyperdex_client_atomic_add(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
+	int64_t cond_atomic_add(const char *space,
+	                        const char *key, size_t key_sz,
+	                        const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                        const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                        hyperdex_client_returncode *status)
+	{ return hyperdex_client_cond_atomic_add(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
+	int64_t group_atomic_add(const char *space,
+	                         const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                         const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                         hyperdex_client_returncode *status,
+	                         uint64_t *count)
+	{ return hyperdex_client_group_atomic_add(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
+	int64_t atomic_sub(const char *space,
+	                   const char *key, size_t key_sz,
+	                   const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                   hyperdex_client_returncode *status)
+	{ return hyperdex_client_atomic_sub(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
+	int64_t cond_atomic_sub(const char *space,
+	                        const char *key, size_t key_sz,
+	                        const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                        const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                        hyperdex_client_returncode *status)
+	{ return hyperdex_client_cond_atomic_sub(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
+	int64_t group_atomic_sub(const char *space,
+	                         const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                         const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                         hyperdex_client_returncode *status,
+	                         uint64_t *count)
+	{ return hyperdex_client_group_atomic_sub(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
+	int64_t atomic_mul(const char *space,
+	                   const char *key, size_t key_sz,
+	                   const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                   hyperdex_client_returncode *status)
+	{ return hyperdex_client_atomic_mul(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
+	int64_t cond_atomic_mul(const char *space,
+	                        const char *key, size_t key_sz,
+	                        const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                        const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                        hyperdex_client_returncode *status)
+	{ return hyperdex_client_cond_atomic_mul(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
+	int64_t group_atomic_mul(const char *space,
+	                         const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                         const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                         hyperdex_client_returncode *status,
+	                         uint64_t *count)
+	{ return hyperdex_client_group_atomic_mul(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
+	int64_t atomic_div(const char *space,
+	                   const char *key, size_t key_sz,
+	                   const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                   hyperdex_client_returncode *status)
+	{ return hyperdex_client_atomic_div(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
+	int64_t cond_atomic_div(const char *space,
+	                        const char *key, size_t key_sz,
+	                        const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                        const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                        hyperdex_client_returncode *status)
+	{ return hyperdex_client_cond_atomic_div(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
+	int64_t group_atomic_div(const char *space,
+	                         const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                         const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                         hyperdex_client_returncode *status,
+	                         uint64_t *count)
+	{ return hyperdex_client_group_atomic_div(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
+	int64_t atomic_mod(const char *space,
+	                   const char *key, size_t key_sz,
+	                   const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                   hyperdex_client_returncode *status)
+	{ return hyperdex_client_atomic_mod(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
+	int64_t cond_atomic_mod(const char *space,
+	                        const char *key, size_t key_sz,
+	                        const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                        const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                        hyperdex_client_returncode *status)
+	{ return hyperdex_client_cond_atomic_mod(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
+	int64_t group_atomic_mod(const char *space,
+	                         const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                         const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                         hyperdex_client_returncode *status,
+	                         uint64_t *count)
+	{ return hyperdex_client_group_atomic_mod(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
+	int64_t atomic_and(const char *space,
+	                   const char *key, size_t key_sz,
+	                   const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                   hyperdex_client_returncode *status)
+	{ return hyperdex_client_atomic_and(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
+	int64_t cond_atomic_and(const char *space,
+	                        const char *key, size_t key_sz,
+	                        const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                        const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                        hyperdex_client_returncode *status)
+	{ return hyperdex_client_cond_atomic_and(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
+	int64_t group_atomic_and(const char *space,
+	                         const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                         const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                         hyperdex_client_returncode *status,
+	                         uint64_t *count)
+	{ return hyperdex_client_group_atomic_and(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
+	int64_t atomic_or(const char *space,
+	                  const char *key, size_t key_sz,
+	                  const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                  hyperdex_client_returncode *status)
+	{ return hyperdex_client_atomic_or(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
+	int64_t cond_atomic_or(const char *space,
+	                       const char *key, size_t key_sz,
+	                       const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                       const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                       hyperdex_client_returncode *status)
+	{ return hyperdex_client_cond_atomic_or(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
+	int64_t group_atomic_or(const char *space,
+	                        const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                        const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                        hyperdex_client_returncode *status,
+	                        uint64_t *count)
+	{ return hyperdex_client_group_atomic_or(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
+	int64_t atomic_xor(const char *space,
+	                   const char *key, size_t key_sz,
+	                   const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                   hyperdex_client_returncode *status)
+	{ return hyperdex_client_atomic_xor(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
+	int64_t cond_atomic_xor(const char *space,
+	                        const char *key, size_t key_sz,
+	                        const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                        const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                        hyperdex_client_returncode *status)
+	{ return hyperdex_client_cond_atomic_xor(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
+	int64_t group_atomic_xor(const char *space,
+	                         const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                         const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                         hyperdex_client_returncode *status,
+	                         uint64_t *count)
+	{ return hyperdex_client_group_atomic_xor(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
+	int64_t atomic_min(const char *space,
+	                   const char *key, size_t key_sz,
+	                   const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                   hyperdex_client_returncode *status)
+	{ return hyperdex_client_atomic_min(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
+	int64_t cond_atomic_min(const char *space,
+	                        const char *key, size_t key_sz,
+	                        const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                        const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                        hyperdex_client_returncode *status)
+	{ return hyperdex_client_cond_atomic_min(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
+	int64_t group_atomic_min(const char *space,
+	                         const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                         const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                         hyperdex_client_returncode *status,
+	                         uint64_t *count)
+	{ return hyperdex_client_group_atomic_min(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
+	int64_t atomic_max(const char *space,
+	                   const char *key, size_t key_sz,
+	                   const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                   hyperdex_client_returncode *status)
+	{ return hyperdex_client_atomic_max(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
+	int64_t cond_atomic_max(const char *space,
+	                        const char *key, size_t key_sz,
+	                        const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                        const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                        hyperdex_client_returncode *status)
+	{ return hyperdex_client_cond_atomic_max(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
+	int64_t group_atomic_max(const char *space,
+	                         const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                         const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                         hyperdex_client_returncode *status,
+	                         uint64_t *count)
+	{ return hyperdex_client_group_atomic_max(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
+	int64_t string_prepend(const char *space,
+	                       const char *key, size_t key_sz,
+	                       const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                       hyperdex_client_returncode *status)
+	{ return hyperdex_client_string_prepend(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
+	int64_t cond_string_prepend(const char *space,
+	                            const char *key, size_t key_sz,
+	                            const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                            const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                            hyperdex_client_returncode *status)
+	{ return hyperdex_client_cond_string_prepend(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
+	int64_t group_string_prepend(const char *space,
+	                             const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                             const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                             hyperdex_client_returncode *status,
+	                             uint64_t *count)
+	{ return hyperdex_client_group_string_prepend(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
+	int64_t string_append(const char *space,
+	                      const char *key, size_t key_sz,
+	                      const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                      hyperdex_client_returncode *status)
+	{ return hyperdex_client_string_append(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
+	int64_t cond_string_append(const char *space,
+	                           const char *key, size_t key_sz,
+	                           const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                           const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                           hyperdex_client_returncode *status)
+	{ return hyperdex_client_cond_string_append(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
+	int64_t group_string_append(const char *space,
+	                            const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                            const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                            hyperdex_client_returncode *status,
+	                            uint64_t *count)
+	{ return hyperdex_client_group_string_append(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
+	int64_t string_ltrim(const char *space,
+	                     const char *key, size_t key_sz,
+	                     const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                     hyperdex_client_returncode *status)
+	{ return hyperdex_client_string_ltrim(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
+	int64_t cond_string_ltrim(const char *space,
+	                          const char *key, size_t key_sz,
+	                          const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                          const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                          hyperdex_client_returncode *status)
+	{ return hyperdex_client_cond_string_ltrim(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
+	int64_t group_string_ltrim(const char *space,
+	                           const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                           const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                           hyperdex_client_returncode *status,
+	                           uint64_t *count)
+	{ return hyperdex_client_group_string_ltrim(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
+	int64_t string_rtrim(const char *space,
+	                     const char *key, size_t key_sz,
+	                     const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                     hyperdex_client_returncode *status)
+	{ return hyperdex_client_string_rtrim(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
+	int64_t cond_string_rtrim(const char *space,
+	                          const char *key, size_t key_sz,
+	                          const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                          const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                          hyperdex_client_returncode *status)
+	{ return hyperdex_client_cond_string_rtrim(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
+	int64_t group_string_rtrim(const char *space,
+	                           const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                           const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                           hyperdex_client_returncode *status,
+	                           uint64_t *count)
+	{ return hyperdex_client_group_string_rtrim(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
+	int64_t list_lpush(const char *space,
+	                   const char *key, size_t key_sz,
+	                   const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                   hyperdex_client_returncode *status)
+	{ return hyperdex_client_list_lpush(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
+	int64_t cond_list_lpush(const char *space,
+	                        const char *key, size_t key_sz,
+	                        const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                        const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                        hyperdex_client_returncode *status)
+	{ return hyperdex_client_cond_list_lpush(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
+	int64_t group_list_lpush(const char *space,
+	                         const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                         const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                         hyperdex_client_returncode *status,
+	                         uint64_t *count)
+	{ return hyperdex_client_group_list_lpush(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
+	int64_t list_rpush(const char *space,
+	                   const char *key, size_t key_sz,
+	                   const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                   hyperdex_client_returncode *status)
+	{ return hyperdex_client_list_rpush(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
+	int64_t cond_list_rpush(const char *space,
+	                        const char *key, size_t key_sz,
+	                        const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                        const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                        hyperdex_client_returncode *status)
+	{ return hyperdex_client_cond_list_rpush(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
+	int64_t group_list_rpush(const char *space,
+	                         const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                         const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                         hyperdex_client_returncode *status,
+	                         uint64_t *count)
+	{ return hyperdex_client_group_list_rpush(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
+	int64_t set_add(const char *space,
+	                const char *key, size_t key_sz,
+	                const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                hyperdex_client_returncode *status)
+	{ return hyperdex_client_set_add(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
+	int64_t cond_set_add(const char *space,
+	                     const char *key, size_t key_sz,
+	                     const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                     const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                     hyperdex_client_returncode *status)
+	{ return hyperdex_client_cond_set_add(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
+	int64_t group_set_add(const char *space,
+	                      const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                      const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                      hyperdex_client_returncode *status,
+	                      uint64_t *count)
+	{ return hyperdex_client_group_set_add(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
+	int64_t set_remove(const char *space,
+	                   const char *key, size_t key_sz,
+	                   const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                   hyperdex_client_returncode *status)
+	{ return hyperdex_client_set_remove(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
+	int64_t cond_set_remove(const char *space,
+	                        const char *key, size_t key_sz,
+	                        const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                        const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                        hyperdex_client_returncode *status)
+	{ return hyperdex_client_cond_set_remove(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
+	int64_t group_set_remove(const char *space,
+	                         const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                         const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                         hyperdex_client_returncode *status,
+	                         uint64_t *count)
+	{ return hyperdex_client_group_set_remove(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
+	int64_t set_intersect(const char *space,
+	                      const char *key, size_t key_sz,
+	                      const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                      hyperdex_client_returncode *status)
+	{ return hyperdex_client_set_intersect(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
+	int64_t cond_set_intersect(const char *space,
+	                           const char *key, size_t key_sz,
+	                           const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                           const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                           hyperdex_client_returncode *status)
+	{ return hyperdex_client_cond_set_intersect(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
+	int64_t group_set_intersect(const char *space,
+	                            const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                            const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                            hyperdex_client_returncode *status,
+	                            uint64_t *count)
+	{ return hyperdex_client_group_set_intersect(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
+	int64_t set_union(const char *space,
+	                  const char *key, size_t key_sz,
+	                  const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                  hyperdex_client_returncode *status)
+	{ return hyperdex_client_set_union(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
+	int64_t cond_set_union(const char *space,
+	                       const char *key, size_t key_sz,
+	                       const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                       const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                       hyperdex_client_returncode *status)
+	{ return hyperdex_client_cond_set_union(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
+	int64_t group_set_union(const char *space,
+	                        const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                        const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                        hyperdex_client_returncode *status,
+	                        uint64_t *count)
+	{ return hyperdex_client_group_set_union(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
+	int64_t document_rename(const char *space,
+	                        const char *key, size_t key_sz,
+	                        const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                        hyperdex_client_returncode *status)
+	{ return hyperdex_client_document_rename(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
+	int64_t cond_document_rename(const char *space,
+	                             const char *key, size_t key_sz,
+	                             const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                             const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                             hyperdex_client_returncode *status)
+	{ return hyperdex_client_cond_document_rename(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
+	int64_t group_document_rename(const char *space,
+	                              const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                              const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                              hyperdex_client_returncode *status,
+	                              uint64_t *count)
+	{ return hyperdex_client_group_document_rename(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
+	int64_t document_unset(const char *space,
+	                       const char *key, size_t key_sz,
+	                       const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                       hyperdex_client_returncode *status)
+	{ return hyperdex_client_document_unset(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
+	int64_t cond_document_unset(const char *space,
+	                            const char *key, size_t key_sz,
+	                            const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                            const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                            hyperdex_client_returncode *status)
+	{ return hyperdex_client_cond_document_unset(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
+	int64_t group_document_unset(const char *space,
+	                             const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                             const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                             hyperdex_client_returncode *status,
+	                             uint64_t *count)
+	{ return hyperdex_client_group_document_unset(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
+	int64_t map_add(const char *space,
+	                const char *key, size_t key_sz,
+	                const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                hyperdex_client_returncode *status)
+	{ return hyperdex_client_map_add(m_cl, space, key, key_sz, mapattrs, mapattrs_sz, status); }
+	int64_t cond_map_add(const char *space,
+	                     const char *key, size_t key_sz,
+	                     const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                     const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                     hyperdex_client_returncode *status)
+	{ return hyperdex_client_cond_map_add(m_cl, space, key, key_sz, checks, checks_sz, mapattrs, mapattrs_sz, status); }
+	int64_t group_map_add(const char *space,
+	                      const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                      const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                      hyperdex_client_returncode *status,
+	                      uint64_t *count)
+	{ return hyperdex_client_group_map_add(m_cl, space, checks, checks_sz, mapattrs, mapattrs_sz, status, count); }
+	int64_t map_remove(const char *space,
+	                   const char *key, size_t key_sz,
+	                   const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                   hyperdex_client_returncode *status)
+	{ return hyperdex_client_map_remove(m_cl, space, key, key_sz, attrs, attrs_sz, status); }
+	int64_t cond_map_remove(const char *space,
+	                        const char *key, size_t key_sz,
+	                        const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                        const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                        hyperdex_client_returncode *status)
+	{ return hyperdex_client_cond_map_remove(m_cl, space, key, key_sz, checks, checks_sz, attrs, attrs_sz, status); }
+	int64_t group_map_remove(const char *space,
+	                         const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                         const hyperdex_client_attribute *attrs, size_t attrs_sz,
+	                         hyperdex_client_returncode *status,
+	                         uint64_t *count)
+	{ return hyperdex_client_group_map_remove(m_cl, space, checks, checks_sz, attrs, attrs_sz, status, count); }
+	int64_t map_atomic_add(const char *space,
+	                       const char *key, size_t key_sz,
+	                       const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                       hyperdex_client_returncode *status)
+	{ return hyperdex_client_map_atomic_add(m_cl, space, key, key_sz, mapattrs, mapattrs_sz, status); }
+	int64_t cond_map_atomic_add(const char *space,
+	                            const char *key, size_t key_sz,
+	                            const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                            const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                            hyperdex_client_returncode *status)
+	{ return hyperdex_client_cond_map_atomic_add(m_cl, space, key, key_sz, checks, checks_sz, mapattrs, mapattrs_sz, status); }
+	int64_t group_map_atomic_add(const char *space,
+	                             const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                             const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                             hyperdex_client_returncode *status,
+	                             uint64_t *count)
+	{ return hyperdex_client_group_map_atomic_add(m_cl, space, checks, checks_sz, mapattrs, mapattrs_sz, status, count); }
+	int64_t map_atomic_sub(const char *space,
+	                       const char *key, size_t key_sz,
+	                       const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                       hyperdex_client_returncode *status)
+	{ return hyperdex_client_map_atomic_sub(m_cl, space, key, key_sz, mapattrs, mapattrs_sz, status); }
+	int64_t cond_map_atomic_sub(const char *space,
+	                            const char *key, size_t key_sz,
+	                            const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                            const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                            hyperdex_client_returncode *status)
+	{ return hyperdex_client_cond_map_atomic_sub(m_cl, space, key, key_sz, checks, checks_sz, mapattrs, mapattrs_sz, status); }
+	int64_t group_map_atomic_sub(const char *space,
+	                             const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                             const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                             hyperdex_client_returncode *status,
+	                             uint64_t *count)
+	{ return hyperdex_client_group_map_atomic_sub(m_cl, space, checks, checks_sz, mapattrs, mapattrs_sz, status, count); }
+	int64_t map_atomic_mul(const char *space,
+	                       const char *key, size_t key_sz,
+	                       const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                       hyperdex_client_returncode *status)
+	{ return hyperdex_client_map_atomic_mul(m_cl, space, key, key_sz, mapattrs, mapattrs_sz, status); }
+	int64_t cond_map_atomic_mul(const char *space,
+	                            const char *key, size_t key_sz,
+	                            const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                            const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                            hyperdex_client_returncode *status)
+	{ return hyperdex_client_cond_map_atomic_mul(m_cl, space, key, key_sz, checks, checks_sz, mapattrs, mapattrs_sz, status); }
+	int64_t group_map_atomic_mul(const char *space,
+	                             const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                             const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                             hyperdex_client_returncode *status,
+	                             uint64_t *count)
+	{ return hyperdex_client_group_map_atomic_mul(m_cl, space, checks, checks_sz, mapattrs, mapattrs_sz, status, count); }
+	int64_t map_atomic_div(const char *space,
+	                       const char *key, size_t key_sz,
+	                       const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                       hyperdex_client_returncode *status)
+	{ return hyperdex_client_map_atomic_div(m_cl, space, key, key_sz, mapattrs, mapattrs_sz, status); }
+	int64_t cond_map_atomic_div(const char *space,
+	                            const char *key, size_t key_sz,
+	                            const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                            const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                            hyperdex_client_returncode *status)
+	{ return hyperdex_client_cond_map_atomic_div(m_cl, space, key, key_sz, checks, checks_sz, mapattrs, mapattrs_sz, status); }
+	int64_t group_map_atomic_div(const char *space,
+	                             const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                             const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                             hyperdex_client_returncode *status,
+	                             uint64_t *count)
+	{ return hyperdex_client_group_map_atomic_div(m_cl, space, checks, checks_sz, mapattrs, mapattrs_sz, status, count); }
+	int64_t map_atomic_mod(const char *space,
+	                       const char *key, size_t key_sz,
+	                       const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                       hyperdex_client_returncode *status)
+	{ return hyperdex_client_map_atomic_mod(m_cl, space, key, key_sz, mapattrs, mapattrs_sz, status); }
+	int64_t cond_map_atomic_mod(const char *space,
+	                            const char *key, size_t key_sz,
+	                            const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                            const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                            hyperdex_client_returncode *status)
+	{ return hyperdex_client_cond_map_atomic_mod(m_cl, space, key, key_sz, checks, checks_sz, mapattrs, mapattrs_sz, status); }
+	int64_t group_map_atomic_mod(const char *space,
+	                             const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                             const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                             hyperdex_client_returncode *status,
+	                             uint64_t *count)
+	{ return hyperdex_client_group_map_atomic_mod(m_cl, space, checks, checks_sz, mapattrs, mapattrs_sz, status, count); }
+	int64_t map_atomic_and(const char *space,
+	                       const char *key, size_t key_sz,
+	                       const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                       hyperdex_client_returncode *status)
+	{ return hyperdex_client_map_atomic_and(m_cl, space, key, key_sz, mapattrs, mapattrs_sz, status); }
+	int64_t cond_map_atomic_and(const char *space,
+	                            const char *key, size_t key_sz,
+	                            const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                            const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                            hyperdex_client_returncode *status)
+	{ return hyperdex_client_cond_map_atomic_and(m_cl, space, key, key_sz, checks, checks_sz, mapattrs, mapattrs_sz, status); }
+	int64_t group_map_atomic_and(const char *space,
+	                             const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                             const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                             hyperdex_client_returncode *status,
+	                             uint64_t *count)
+	{ return hyperdex_client_group_map_atomic_and(m_cl, space, checks, checks_sz, mapattrs, mapattrs_sz, status, count); }
+	int64_t map_atomic_or(const char *space,
+	                      const char *key, size_t key_sz,
+	                      const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                      hyperdex_client_returncode *status)
+	{ return hyperdex_client_map_atomic_or(m_cl, space, key, key_sz, mapattrs, mapattrs_sz, status); }
+	int64_t cond_map_atomic_or(const char *space,
+	                           const char *key, size_t key_sz,
+	                           const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                           const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                           hyperdex_client_returncode *status)
+	{ return hyperdex_client_cond_map_atomic_or(m_cl, space, key, key_sz, checks, checks_sz, mapattrs, mapattrs_sz, status); }
+	int64_t group_map_atomic_or(const char *space,
+	                            const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                            const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                            hyperdex_client_returncode *status,
+	                            uint64_t *count)
+	{ return hyperdex_client_group_map_atomic_or(m_cl, space, checks, checks_sz, mapattrs, mapattrs_sz, status, count); }
+	int64_t map_atomic_xor(const char *space,
+	                       const char *key, size_t key_sz,
+	                       const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                       hyperdex_client_returncode *status)
+	{ return hyperdex_client_map_atomic_xor(m_cl, space, key, key_sz, mapattrs, mapattrs_sz, status); }
+	int64_t cond_map_atomic_xor(const char *space,
+	                            const char *key, size_t key_sz,
+	                            const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                            const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                            hyperdex_client_returncode *status)
+	{ return hyperdex_client_cond_map_atomic_xor(m_cl, space, key, key_sz, checks, checks_sz, mapattrs, mapattrs_sz, status); }
+	int64_t group_map_atomic_xor(const char *space,
+	                             const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                             const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                             hyperdex_client_returncode *status,
+	                             uint64_t *count)
+	{ return hyperdex_client_group_map_atomic_xor(m_cl, space, checks, checks_sz, mapattrs, mapattrs_sz, status, count); }
+	int64_t map_string_prepend(const char *space,
+	                           const char *key, size_t key_sz,
+	                           const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                           hyperdex_client_returncode *status)
+	{ return hyperdex_client_map_string_prepend(m_cl, space, key, key_sz, mapattrs, mapattrs_sz, status); }
+	int64_t cond_map_string_prepend(const char *space,
+	                                const char *key, size_t key_sz,
+	                                const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                                hyperdex_client_returncode *status)
+	{ return hyperdex_client_cond_map_string_prepend(m_cl, space, key, key_sz, checks, checks_sz, mapattrs, mapattrs_sz, status); }
+	int64_t group_map_string_prepend(const char *space,
+	                                 const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                 const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                                 hyperdex_client_returncode *status,
+	                                 uint64_t *count)
+	{ return hyperdex_client_group_map_string_prepend(m_cl, space, checks, checks_sz, mapattrs, mapattrs_sz, status, count); }
+	int64_t map_string_append(const char *space,
+	                          const char *key, size_t key_sz,
+	                          const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                          hyperdex_client_returncode *status)
+	{ return hyperdex_client_map_string_append(m_cl, space, key, key_sz, mapattrs, mapattrs_sz, status); }
+	int64_t cond_map_string_append(const char *space,
+	                               const char *key, size_t key_sz,
+	                               const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                               const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                               hyperdex_client_returncode *status)
+	{ return hyperdex_client_cond_map_string_append(m_cl, space, key, key_sz, checks, checks_sz, mapattrs, mapattrs_sz, status); }
+	int64_t group_map_string_append(const char *space,
+	                                const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                                const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                                hyperdex_client_returncode *status,
+	                                uint64_t *count)
+	{ return hyperdex_client_group_map_string_append(m_cl, space, checks, checks_sz, mapattrs, mapattrs_sz, status, count); }
+	int64_t map_atomic_min(const char *space,
+	                       const char *key, size_t key_sz,
+	                       const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                       hyperdex_client_returncode *status)
+	{ return hyperdex_client_map_atomic_min(m_cl, space, key, key_sz, mapattrs, mapattrs_sz, status); }
+	int64_t cond_map_atomic_min(const char *space,
+	                            const char *key, size_t key_sz,
+	                            const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                            const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                            hyperdex_client_returncode *status)
+	{ return hyperdex_client_cond_map_atomic_min(m_cl, space, key, key_sz, checks, checks_sz, mapattrs, mapattrs_sz, status); }
+	int64_t group_map_atomic_min(const char *space,
+	                             const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                             const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                             hyperdex_client_returncode *status,
+	                             uint64_t *count)
+	{ return hyperdex_client_group_map_atomic_min(m_cl, space, checks, checks_sz, mapattrs, mapattrs_sz, status, count); }
+	int64_t map_atomic_max(const char *space,
+	                       const char *key, size_t key_sz,
+	                       const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                       hyperdex_client_returncode *status)
+	{ return hyperdex_client_map_atomic_max(m_cl, space, key, key_sz, mapattrs, mapattrs_sz, status); }
+	int64_t cond_map_atomic_max(const char *space,
+	                            const char *key, size_t key_sz,
+	                            const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                            const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                            hyperdex_client_returncode *status)
+	{ return hyperdex_client_cond_map_atomic_max(m_cl, space, key, key_sz, checks, checks_sz, mapattrs, mapattrs_sz, status); }
+	int64_t group_map_atomic_max(const char *space,
+	                             const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                             const hyperdex_client_map_attribute *mapattrs, size_t mapattrs_sz,
+	                             hyperdex_client_returncode *status,
+	                             uint64_t *count)
+	{ return hyperdex_client_group_map_atomic_max(m_cl, space, checks, checks_sz, mapattrs, mapattrs_sz, status, count); }
+	int64_t search(const char *space,
+	               const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	               hyperdex_client_returncode *status,
+	               const hyperdex_client_attribute **attrs, size_t *attrs_sz)
+	{ return hyperdex_client_search(m_cl, space, checks, checks_sz, status, attrs, attrs_sz); }
+	int64_t search_describe(const char *space,
+	                        const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                        hyperdex_client_returncode *status,
+	                        const char **description)
+	{ return hyperdex_client_search_describe(m_cl, space, checks, checks_sz, status, description); }
+	int64_t sorted_search(const char *space,
+	                      const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	                      const char *sort_by,
+	                      uint64_t limit,
+	                      int maxmin,
+	                      hyperdex_client_returncode *status,
+	                      const hyperdex_client_attribute **attrs, size_t *attrs_sz)
+	{ return hyperdex_client_sorted_search(m_cl, space, checks, checks_sz, sort_by, limit, maxmin, status, attrs, attrs_sz); }
+	int64_t count(const char *space,
+	              const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	              hyperdex_client_returncode *status,
+	              uint64_t *count)
+	{ return hyperdex_client_count(m_cl, space, checks, checks_sz, status, count); }
+	int64_t sum(const char *space,
+	            const hyperdex_client_attribute_check *checks, size_t checks_sz,
+	            const char *sum_key,
+	            hyperdex_client_returncode *status,
+	            uint64_t *count)
+	{ return hyperdex_client_sum(m_cl, space, checks, checks_sz, sum_key, status, count); }
 
-    public:
-        void clear_auth_context()
-            { return hyperdex_client_clear_auth_context(m_cl); }
-        void set_auth_context(const char** macaroons, size_t macaroons_sz)
-            { return hyperdex_client_set_auth_context(m_cl, macaroons, macaroons_sz); }
+public:
+	void clear_auth_context()
+	{ return hyperdex_client_clear_auth_context(m_cl); }
+	void set_auth_context(const char **macaroons, size_t macaroons_sz)
+	{ return hyperdex_client_set_auth_context(m_cl, macaroons, macaroons_sz); }
 
-    public:
-        int64_t loop(int timeout, hyperdex_client_returncode* status)
-            { return hyperdex_client_loop(m_cl, timeout, status); }
-        int poll_fd()
-            { return hyperdex_client_poll_fd(m_cl); }
-        int block(int timeout)
-            { return hyperdex_client_block(m_cl, timeout); }
-        std::string error_message()
-            { return hyperdex_client_error_message(m_cl); }
-        std::string error_location()
-            { return hyperdex_client_error_location(m_cl); }
+public:
+	int64_t loop(int timeout, hyperdex_client_returncode *status)
+	{ return hyperdex_client_loop(m_cl, timeout, status); }
+	int poll_fd()
+	{ return hyperdex_client_poll_fd(m_cl); }
+	int block(int timeout)
+	{ return hyperdex_client_block(m_cl, timeout); }
+	std::string error_message()
+	{ return hyperdex_client_error_message(m_cl); }
+	std::string error_location()
+	{ return hyperdex_client_error_location(m_cl); }
 
-    private:
-        Client(const Client&);
-        Client& operator = (const Client&);
+private:
+	Client(const Client &);
+	Client &operator = (const Client &);
 
-    private:
-        hyperdex_client* m_cl;
+private:
+	hyperdex_client *m_cl;
 };
 
 } // namespace hyperdex
 
-std::ostream&
-operator << (std::ostream& lhs, hyperdex_client_returncode rhs);
+std::ostream &
+operator << (std::ostream &lhs, hyperdex_client_returncode rhs);
 
 #endif // hyperdex_client_hpp_
diff --git a/include/hyperdex/datastructures.h b/include/hyperdex/datastructures.h
index 5949ae134..5fa8c406d 100644
--- a/include/hyperdex/datastructures.h
+++ b/include/hyperdex/datastructures.h
@@ -46,197 +46,197 @@ struct hyperdex_ds_map;
 
 struct hyperdex_ds_iterator
 {
-    enum hyperdatatype datatype;
-    const char* value;
-    const char* value_end;
-    const char* progress;
+	enum hyperdatatype datatype;
+	const char *value;
+	const char *value_end;
+	const char *progress;
 };
 
 /* errors */
 enum hyperdex_ds_returncode
 {
-    HYPERDEX_DS_SUCCESS,
-    HYPERDEX_DS_NOMEM,
-    HYPERDEX_DS_MIXED_TYPES,
-    HYPERDEX_DS_WRONG_STATE,
-    HYPERDEX_DS_STRING_TOO_LONG
+	HYPERDEX_DS_SUCCESS,
+	HYPERDEX_DS_NOMEM,
+	HYPERDEX_DS_MIXED_TYPES,
+	HYPERDEX_DS_WRONG_STATE,
+	HYPERDEX_DS_STRING_TOO_LONG
 };
 
 /* arena manipulation */
-struct hyperdex_ds_arena*
+struct hyperdex_ds_arena *
 hyperdex_ds_arena_create();
 
 void
-hyperdex_ds_arena_destroy(struct hyperdex_ds_arena* arena);
+hyperdex_ds_arena_destroy(struct hyperdex_ds_arena *arena);
 
-void*
-hyperdex_ds_malloc(struct hyperdex_ds_arena* arena, size_t sz);
+void *
+hyperdex_ds_malloc(struct hyperdex_ds_arena *arena, size_t sz);
 
 /* client parameters */
-struct hyperdex_client_attribute*
-hyperdex_ds_allocate_attribute(struct hyperdex_ds_arena* arena, size_t sz);
+struct hyperdex_client_attribute *
+hyperdex_ds_allocate_attribute(struct hyperdex_ds_arena *arena, size_t sz);
 
-struct hyperdex_client_attribute_check*
-hyperdex_ds_allocate_attribute_check(struct hyperdex_ds_arena* arena, size_t sz);
+struct hyperdex_client_attribute_check *
+hyperdex_ds_allocate_attribute_check(struct hyperdex_ds_arena *arena, size_t sz);
 
-struct hyperdex_client_map_attribute*
-hyperdex_ds_allocate_map_attribute(struct hyperdex_ds_arena* arena, size_t sz);
+struct hyperdex_client_map_attribute *
+hyperdex_ds_allocate_map_attribute(struct hyperdex_ds_arena *arena, size_t sz);
 
 /* pack/unpack ints/floats */
 void
-hyperdex_ds_pack_int(int64_t num, char* buf);
+hyperdex_ds_pack_int(int64_t num, char *buf);
 int
-hyperdex_ds_unpack_int(const char* buf, size_t buf_sz, int64_t* num);
+hyperdex_ds_unpack_int(const char *buf, size_t buf_sz, int64_t *num);
 
 void
-hyperdex_ds_pack_float(double num, char* buf);
+hyperdex_ds_pack_float(double num, char *buf);
 int
-hyperdex_ds_unpack_float(const char* buf, size_t buf_sz, double* num);
+hyperdex_ds_unpack_float(const char *buf, size_t buf_sz, double *num);
 
 /* copy strings/ints/floats */
 int
-hyperdex_ds_copy_string(struct hyperdex_ds_arena* arena,
-                        const char* str, size_t str_sz,
-                        enum hyperdex_ds_returncode* status,
-                        const char** value, size_t* value_sz);
+hyperdex_ds_copy_string(struct hyperdex_ds_arena *arena,
+                        const char *str, size_t str_sz,
+                        enum hyperdex_ds_returncode *status,
+                        const char **value, size_t *value_sz);
 int
-hyperdex_ds_copy_int(struct hyperdex_ds_arena* arena, int64_t num,
-                     enum hyperdex_ds_returncode* status,
-                     const char** value, size_t* value_sz);
+hyperdex_ds_copy_int(struct hyperdex_ds_arena *arena, int64_t num,
+                     enum hyperdex_ds_returncode *status,
+                     const char **value, size_t *value_sz);
 int
-hyperdex_ds_copy_float(struct hyperdex_ds_arena* arena, double num,
-                       enum hyperdex_ds_returncode* status,
-                       const char** value, size_t* value_sz);
+hyperdex_ds_copy_float(struct hyperdex_ds_arena *arena, double num,
+                       enum hyperdex_ds_returncode *status,
+                       const char **value, size_t *value_sz);
 
 /* pack lists */
-struct hyperdex_ds_list*
-hyperdex_ds_allocate_list(struct hyperdex_ds_arena* arena);
+struct hyperdex_ds_list *
+hyperdex_ds_allocate_list(struct hyperdex_ds_arena *arena);
 int
-hyperdex_ds_list_append_string(struct hyperdex_ds_list* list,
-                               const char* str, size_t str_sz,
-                               enum hyperdex_ds_returncode* status);
+hyperdex_ds_list_append_string(struct hyperdex_ds_list *list,
+                               const char *str, size_t str_sz,
+                               enum hyperdex_ds_returncode *status);
 int
-hyperdex_ds_list_append_int(struct hyperdex_ds_list* list,
+hyperdex_ds_list_append_int(struct hyperdex_ds_list *list,
                             int64_t num,
-                            enum hyperdex_ds_returncode* status);
+                            enum hyperdex_ds_returncode *status);
 int
-hyperdex_ds_list_append_float(struct hyperdex_ds_list* list,
+hyperdex_ds_list_append_float(struct hyperdex_ds_list *list,
                               double num,
-                              enum hyperdex_ds_returncode* status);
+                              enum hyperdex_ds_returncode *status);
 int
-hyperdex_ds_list_finalize(struct hyperdex_ds_list* list,
-                          enum hyperdex_ds_returncode* status,
-                          const char** value, size_t* value_sz,
-                          enum hyperdatatype* datatype);
+hyperdex_ds_list_finalize(struct hyperdex_ds_list *list,
+                          enum hyperdex_ds_returncode *status,
+                          const char **value, size_t *value_sz,
+                          enum hyperdatatype *datatype);
 
 /* pack sets */
-struct hyperdex_ds_set*
-hyperdex_ds_allocate_set(struct hyperdex_ds_arena* arena);
+struct hyperdex_ds_set *
+hyperdex_ds_allocate_set(struct hyperdex_ds_arena *arena);
 int
-hyperdex_ds_set_insert_string(struct hyperdex_ds_set* set, const char* str, size_t str_sz,
-                              enum hyperdex_ds_returncode* status);
+hyperdex_ds_set_insert_string(struct hyperdex_ds_set *set, const char *str, size_t str_sz,
+                              enum hyperdex_ds_returncode *status);
 int
-hyperdex_ds_set_insert_int(struct hyperdex_ds_set* set, int64_t num,
-                           enum hyperdex_ds_returncode* status);
+hyperdex_ds_set_insert_int(struct hyperdex_ds_set *set, int64_t num,
+                           enum hyperdex_ds_returncode *status);
 int
-hyperdex_ds_set_insert_float(struct hyperdex_ds_set* set, double num,
-                             enum hyperdex_ds_returncode* status);
+hyperdex_ds_set_insert_float(struct hyperdex_ds_set *set, double num,
+                             enum hyperdex_ds_returncode *status);
 int
-hyperdex_ds_set_finalize(struct hyperdex_ds_set*,
-                         enum hyperdex_ds_returncode* status,
-                         const char** value, size_t* value_sz,
-                         enum hyperdatatype* datatype);
+hyperdex_ds_set_finalize(struct hyperdex_ds_set *,
+                         enum hyperdex_ds_returncode *status,
+                         const char **value, size_t *value_sz,
+                         enum hyperdatatype *datatype);
 
 /* pack maps */
-struct hyperdex_ds_map*
-hyperdex_ds_allocate_map(struct hyperdex_ds_arena* arena);
+struct hyperdex_ds_map *
+hyperdex_ds_allocate_map(struct hyperdex_ds_arena *arena);
 int
-hyperdex_ds_map_insert_key_string(struct hyperdex_ds_map* map,
-                                  const char* str, size_t str_sz,
-                                  enum hyperdex_ds_returncode* status);
+hyperdex_ds_map_insert_key_string(struct hyperdex_ds_map *map,
+                                  const char *str, size_t str_sz,
+                                  enum hyperdex_ds_returncode *status);
 int
-hyperdex_ds_map_insert_val_string(struct hyperdex_ds_map* map,
-                                  const char* str, size_t str_sz,
-                                  enum hyperdex_ds_returncode* status);
+hyperdex_ds_map_insert_val_string(struct hyperdex_ds_map *map,
+                                  const char *str, size_t str_sz,
+                                  enum hyperdex_ds_returncode *status);
 int
-hyperdex_ds_map_insert_key_int(struct hyperdex_ds_map* map, int64_t num,
-                               enum hyperdex_ds_returncode* status);
+hyperdex_ds_map_insert_key_int(struct hyperdex_ds_map *map, int64_t num,
+                               enum hyperdex_ds_returncode *status);
 int
-hyperdex_ds_map_insert_val_int(struct hyperdex_ds_map* map, int64_t num,
-                               enum hyperdex_ds_returncode* status);
+hyperdex_ds_map_insert_val_int(struct hyperdex_ds_map *map, int64_t num,
+                               enum hyperdex_ds_returncode *status);
 int
-hyperdex_ds_map_insert_key_float(struct hyperdex_ds_map* map, double num,
-                                 enum hyperdex_ds_returncode* status);
+hyperdex_ds_map_insert_key_float(struct hyperdex_ds_map *map, double num,
+                                 enum hyperdex_ds_returncode *status);
 int
-hyperdex_ds_map_insert_val_float(struct hyperdex_ds_map* map, double num,
-                                 enum hyperdex_ds_returncode* status);
+hyperdex_ds_map_insert_val_float(struct hyperdex_ds_map *map, double num,
+                                 enum hyperdex_ds_returncode *status);
 int
-hyperdex_ds_map_finalize(struct hyperdex_ds_map*,
-                         enum hyperdex_ds_returncode* status,
-                         const char** value, size_t* value_sz,
-                         enum hyperdatatype* datatype);
+hyperdex_ds_map_finalize(struct hyperdex_ds_map *,
+                         enum hyperdex_ds_returncode *status,
+                         const char **value, size_t *value_sz,
+                         enum hyperdatatype *datatype);
 
 /* iterate datatypes */
 void
-hyperdex_ds_iterator_init(struct hyperdex_ds_iterator* iter,
+hyperdex_ds_iterator_init(struct hyperdex_ds_iterator *iter,
                           enum hyperdatatype datatype,
-                          const char* value,
+                          const char *value,
                           size_t value_sz);
 /* list */
 int
-hyperdex_ds_iterate_list_string_next(struct hyperdex_ds_iterator* iter,
-                                     const char** str, size_t* str_sz);
+hyperdex_ds_iterate_list_string_next(struct hyperdex_ds_iterator *iter,
+                                     const char **str, size_t *str_sz);
 int
-hyperdex_ds_iterate_list_int_next(struct hyperdex_ds_iterator* iter, int64_t* num);
+hyperdex_ds_iterate_list_int_next(struct hyperdex_ds_iterator *iter, int64_t *num);
 int
-hyperdex_ds_iterate_list_float_next(struct hyperdex_ds_iterator* iter, double* num);
+hyperdex_ds_iterate_list_float_next(struct hyperdex_ds_iterator *iter, double *num);
 /* set */
 int
-hyperdex_ds_iterate_set_string_next(struct hyperdex_ds_iterator* iter,
-                                    const char** str, size_t* str_sz);
+hyperdex_ds_iterate_set_string_next(struct hyperdex_ds_iterator *iter,
+                                    const char **str, size_t *str_sz);
 int
-hyperdex_ds_iterate_set_int_next(struct hyperdex_ds_iterator* iter, int64_t* num);
+hyperdex_ds_iterate_set_int_next(struct hyperdex_ds_iterator *iter, int64_t *num);
 int
-hyperdex_ds_iterate_set_float_next(struct hyperdex_ds_iterator* iter, double* num);
+hyperdex_ds_iterate_set_float_next(struct hyperdex_ds_iterator *iter, double *num);
 /* map(string, *) */
 int
-hyperdex_ds_iterate_map_string_string_next(struct hyperdex_ds_iterator* iter,
-                                           const char** key, size_t* key_sz,
-                                           const char** val, size_t* val_sz);
+hyperdex_ds_iterate_map_string_string_next(struct hyperdex_ds_iterator *iter,
+                                           const char **key, size_t *key_sz,
+                                           const char **val, size_t *val_sz);
 int
-hyperdex_ds_iterate_map_string_int_next(struct hyperdex_ds_iterator* iter,
-                                        const char** key, size_t* key_sz,
-                                        int64_t* val);
+hyperdex_ds_iterate_map_string_int_next(struct hyperdex_ds_iterator *iter,
+                                        const char **key, size_t *key_sz,
+                                        int64_t *val);
 int
-hyperdex_ds_iterate_map_string_float_next(struct hyperdex_ds_iterator* iter,
-                                          const char** key, size_t* key_sz,
-                                          double* val);
+hyperdex_ds_iterate_map_string_float_next(struct hyperdex_ds_iterator *iter,
+                                          const char **key, size_t *key_sz,
+                                          double *val);
 /* map(int, *) */
 int
-hyperdex_ds_iterate_map_int_string_next(struct hyperdex_ds_iterator* iter,
-                                        int64_t* key,
-                                        const char** val, size_t* val_sz);
+hyperdex_ds_iterate_map_int_string_next(struct hyperdex_ds_iterator *iter,
+                                        int64_t *key,
+                                        const char **val, size_t *val_sz);
 int
-hyperdex_ds_iterate_map_int_int_next(struct hyperdex_ds_iterator* iter,
-                                     int64_t* key,
-                                     int64_t* val);
+hyperdex_ds_iterate_map_int_int_next(struct hyperdex_ds_iterator *iter,
+                                     int64_t *key,
+                                     int64_t *val);
 int
-hyperdex_ds_iterate_map_int_float_next(struct hyperdex_ds_iterator* iter,
-                                       int64_t* key,
-                                       double* val);
+hyperdex_ds_iterate_map_int_float_next(struct hyperdex_ds_iterator *iter,
+                                       int64_t *key,
+                                       double *val);
 /* map(float, *) */
 int
-hyperdex_ds_iterate_map_float_string_next(struct hyperdex_ds_iterator* iter,
-                                          double* key,
-                                          const char** val, size_t* val_sz);
+hyperdex_ds_iterate_map_float_string_next(struct hyperdex_ds_iterator *iter,
+                                          double *key,
+                                          const char **val, size_t *val_sz);
 int
-hyperdex_ds_iterate_map_float_int_next(struct hyperdex_ds_iterator* iter,
-                                       double* key,
-                                       int64_t* val);
+hyperdex_ds_iterate_map_float_int_next(struct hyperdex_ds_iterator *iter,
+                                       double *key,
+                                       int64_t *val);
 int
-hyperdex_ds_iterate_map_float_float_next(struct hyperdex_ds_iterator* iter,
-                                         double* key,
-                                         double* val);
+hyperdex_ds_iterate_map_float_float_next(struct hyperdex_ds_iterator *iter,
+                                         double *key,
+                                         double *val);
 
 #ifdef __cplusplus
 } /* extern "C" */
@@ -244,8 +244,8 @@ hyperdex_ds_iterate_map_float_float_next(struct hyperdex_ds_iterator* iter,
 /* C++ */
 #include <iostream>
 
-std::ostream&
-operator << (std::ostream& lhs, hyperdex_ds_returncode rhs);
+std::ostream &
+operator << (std::ostream &lhs, hyperdex_ds_returncode rhs);
 
 #endif /* __cplusplus */
 #endif /* hyperdex_datastructures_h_ */
diff --git a/include/hyperdex/hyperspace_builder.h b/include/hyperdex/hyperspace_builder.h
index adddfdee8..198ed7bfd 100644
--- a/include/hyperdex/hyperspace_builder.h
+++ b/include/hyperdex/hyperspace_builder.h
@@ -45,59 +45,59 @@ struct hyperspace;
 /* hyperspace_returncode occupies [8576, 8704) */
 enum hyperspace_returncode
 {
-    HYPERSPACE_SUCCESS       = 8576,
-    HYPERSPACE_INVALID_NAME  = 8577,
-    HYPERSPACE_INVALID_TYPE  = 8578,
-    HYPERSPACE_DUPLICATE     = 8579,
-    HYPERSPACE_IS_KEY        = 8580,
-    HYPERSPACE_UNKNOWN_ATTR  = 8581,
-    HYPERSPACE_NO_SUBSPACE   = 8582,
-    HYPERSPACE_OUT_OF_BOUNDS = 8583,
-    HYPERSPACE_UNINDEXABLE   = 8584,
-
-    HYPERSPACE_GARBAGE       = 8703
+	HYPERSPACE_SUCCESS       = 8576,
+	HYPERSPACE_INVALID_NAME  = 8577,
+	HYPERSPACE_INVALID_TYPE  = 8578,
+	HYPERSPACE_DUPLICATE     = 8579,
+	HYPERSPACE_IS_KEY        = 8580,
+	HYPERSPACE_UNKNOWN_ATTR  = 8581,
+	HYPERSPACE_NO_SUBSPACE   = 8582,
+	HYPERSPACE_OUT_OF_BOUNDS = 8583,
+	HYPERSPACE_UNINDEXABLE   = 8584,
+
+	HYPERSPACE_GARBAGE       = 8703
 };
 
-struct hyperspace*
+struct hyperspace *
 hyperspace_create();
-struct hyperspace*
-hyperspace_parse(const char* desc);
+struct hyperspace *
+hyperspace_parse(const char *desc);
 void
-hyperspace_destroy(struct hyperspace* space);
+hyperspace_destroy(struct hyperspace *space);
 
-const char*
-hyperspace_error(struct hyperspace* space);
+const char *
+hyperspace_error(struct hyperspace *space);
 
 enum hyperspace_returncode
-hyperspace_set_name(struct hyperspace* space, const char* name);
+hyperspace_set_name(struct hyperspace *space, const char *name);
 
 enum hyperspace_returncode
-hyperspace_set_key(struct hyperspace* space,
-                   const char* attr,
+hyperspace_set_key(struct hyperspace *space,
+                   const char *attr,
                    enum hyperdatatype datatype);
 
 enum hyperspace_returncode
-hyperspace_add_attribute(struct hyperspace* space,
-                         const char* attr,
+hyperspace_add_attribute(struct hyperspace *space,
+                         const char *attr,
                          enum hyperdatatype datatype);
 
 enum hyperspace_returncode
-hyperspace_add_subspace(struct hyperspace* space);
+hyperspace_add_subspace(struct hyperspace *space);
 
 enum hyperspace_returncode
-hyperspace_add_subspace_attribute(struct hyperspace* space, const char* attr);
+hyperspace_add_subspace_attribute(struct hyperspace *space, const char *attr);
 
 enum hyperspace_returncode
-hyperspace_add_index(struct hyperspace* space, const char* attr);
+hyperspace_add_index(struct hyperspace *space, const char *attr);
 
 enum hyperspace_returncode
-hyperspace_set_fault_tolerance(struct hyperspace* space, uint64_t num);
+hyperspace_set_fault_tolerance(struct hyperspace *space, uint64_t num);
 
 enum hyperspace_returncode
-hyperspace_set_number_of_partitions(struct hyperspace* space, uint64_t num);
+hyperspace_set_number_of_partitions(struct hyperspace *space, uint64_t num);
 
 enum hyperspace_returncode
-hyperspace_use_authorization(struct hyperspace* space);
+hyperspace_use_authorization(struct hyperspace *space);
 
 #ifdef __cplusplus
 } /* extern "C" */
diff --git a/maint/generate-test-packages.py b/maint/generate-test-packages.py
new file mode 100644
index 000000000..909af9609
--- /dev/null
+++ b/maint/generate-test-packages.py
@@ -0,0 +1,160 @@
+# Copyright (c) 2013, Cornell University
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#     * Redistributions of source code must retain the above copyright notice,
+#       this list of conditions and the following disclaimer.
+#     * Redistributions in binary form must reproduce the above copyright
+#       notice, this list of conditions and the following disclaimer in the
+#       documentation and/or other materials provided with the distribution.
+#     * Neither the name of HyperDex nor the names of its contributors may be
+#       used to endorse or promote products derived from this software without
+#       specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+import argparse
+import os
+import re
+import subprocess
+import tarfile
+import tempfile
+
+def add_from_content(tar, name, content, mode=0644):
+    tmp = tempfile.TemporaryFile()
+    tmp.write(content)
+    tmp.flush()
+    tmp.seek(0)
+    os.fchmod(tmp.fileno(), mode)
+    tinfo = tar.gettarinfo(arcname=name, fileobj=tmp)
+    tar.addfile(tinfo, tmp)
+
+def generate_test_tarball(version, name, tests):
+    archive = 'test-hyperdex-' + name + '-' + str(version)
+    tar = tarfile.open(archive + '.tar.gz', 'w:gz')
+    version = subprocess.check_output('grep AC_INIT configure.ac',
+                                      shell=True).split(' ')[1].strip('[,] ')
+    makefile = '''CLASSPATH := /usr/share/java/*:test/java:.
+export CLASSPATH
+export HYPERDEX_SRCDIR=.
+export HYPERDEX_BUILDDIR=.
+
+check:
+{rules}
+'''.format(version=version, rules=''.join(['\t%s\n' % s for s, t in tests]))
+    add_from_content(tar, archive + '/Makefile', makefile, 0644)
+    for sh, test in tests:
+        tar.add(sh, archive + '/' + sh)
+        tar.add(test, archive + '/' + test)
+    tar.add('test/runner.py', archive + '/test/runner.py')
+    tar.add('test/doctest-runner.py', archive + '/test/doctest-runner.py')
+    if argparse.__file__.endswith('.pyc'):
+        tar.add(argparse.__file__[:-1], archive + '/argparse.py')
+    tar.close()
+
+version = re.search('^AC_INIT\(\[.*\], \[(.*)\], \[.*\]\)$',
+            open('configure.ac').read(), re.MULTILINE).group(1)
+
+generate_test_tarball(version, 'doc', [
+    ('test/sh/doc.async-ops.sh', 'test/doc.async-ops.py'),
+    ('test/sh/doc.atomic-ops.sh', 'test/doc.atomic-ops.py'),
+    ('test/sh/doc.data-types.sh', 'test/doc.data-types.py'),
+    ('test/sh/doc.documents.sh', 'test/doc.documents.py'),
+    ('test/sh/doc.quick-start.sh', 'test/doc.quick-start.py'),
+])
+
+generate_test_tarball(version, 'java', [
+    ('test/sh/bindings.java.BasicSearch.sh', 'test/java/BasicSearch.java'),
+    ('test/sh/bindings.java.Basic.sh', 'test/java/Basic.java'),
+    ('test/sh/bindings.java.DataTypeFloat.sh', 'test/java/DataTypeFloat.java'),
+    ('test/sh/bindings.java.DataTypeInt.sh', 'test/java/DataTypeInt.java'),
+    ('test/sh/bindings.java.DataTypeListFloat.sh', 'test/java/DataTypeListFloat.java'),
+    ('test/sh/bindings.java.DataTypeListInt.sh', 'test/java/DataTypeListInt.java'),
+    ('test/sh/bindings.java.DataTypeListString.sh', 'test/java/DataTypeListString.java'),
+    ('test/sh/bindings.java.DataTypeMapFloatFloat.sh', 'test/java/DataTypeMapFloatFloat.java'),
+    ('test/sh/bindings.java.DataTypeMapFloatInt.sh', 'test/java/DataTypeMapFloatInt.java'),
+    ('test/sh/bindings.java.DataTypeMapFloatString.sh', 'test/java/DataTypeMapFloatString.java'),
+    ('test/sh/bindings.java.DataTypeMapIntFloat.sh', 'test/java/DataTypeMapIntFloat.java'),
+    ('test/sh/bindings.java.DataTypeMapIntInt.sh', 'test/java/DataTypeMapIntInt.java'),
+    ('test/sh/bindings.java.DataTypeMapIntString.sh', 'test/java/DataTypeMapIntString.java'),
+    ('test/sh/bindings.java.DataTypeMapStringFloat.sh', 'test/java/DataTypeMapStringFloat.java'),
+    ('test/sh/bindings.java.DataTypeMapStringInt.sh', 'test/java/DataTypeMapStringInt.java'),
+    ('test/sh/bindings.java.DataTypeMapStringString.sh', 'test/java/DataTypeMapStringString.java'),
+    ('test/sh/bindings.java.DataTypeSetFloat.sh', 'test/java/DataTypeSetFloat.java'),
+    ('test/sh/bindings.java.DataTypeSetInt.sh', 'test/java/DataTypeSetInt.java'),
+    ('test/sh/bindings.java.DataTypeSetString.sh', 'test/java/DataTypeSetString.java'),
+    ('test/sh/bindings.java.DataTypeString.sh', 'test/java/DataTypeString.java'),
+    ('test/sh/bindings.java.LengthString.sh', 'test/java/LengthString.java'),
+    ('test/sh/bindings.java.MultiAttribute.sh', 'test/java/MultiAttribute.java'),
+    ('test/sh/bindings.java.RangeSearchInt.sh', 'test/java/RangeSearchInt.java'),
+    ('test/sh/bindings.java.RangeSearchString.sh', 'test/java/RangeSearchString.java'),
+    ('test/sh/bindings.java.RegexSearch.sh', 'test/java/RegexSearch.java'),
+])
+
+generate_test_tarball(version, 'python', [
+    ('test/sh/bindings.python.BasicSearch.sh', 'test/python/BasicSearch.py'),
+    ('test/sh/bindings.python.Basic.sh', 'test/python/Basic.py'),
+    ('test/sh/bindings.python.DataTypeFloat.sh', 'test/python/DataTypeFloat.py'),
+    ('test/sh/bindings.python.DataTypeInt.sh', 'test/python/DataTypeInt.py'),
+    ('test/sh/bindings.python.DataTypeListFloat.sh', 'test/python/DataTypeListFloat.py'),
+    ('test/sh/bindings.python.DataTypeListInt.sh', 'test/python/DataTypeListInt.py'),
+    ('test/sh/bindings.python.DataTypeListString.sh', 'test/python/DataTypeListString.py'),
+    ('test/sh/bindings.python.DataTypeMapFloatFloat.sh', 'test/python/DataTypeMapFloatFloat.py'),
+    ('test/sh/bindings.python.DataTypeMapFloatInt.sh', 'test/python/DataTypeMapFloatInt.py'),
+    ('test/sh/bindings.python.DataTypeMapFloatString.sh', 'test/python/DataTypeMapFloatString.py'),
+    ('test/sh/bindings.python.DataTypeMapIntFloat.sh', 'test/python/DataTypeMapIntFloat.py'),
+    ('test/sh/bindings.python.DataTypeMapIntInt.sh', 'test/python/DataTypeMapIntInt.py'),
+    ('test/sh/bindings.python.DataTypeMapIntString.sh', 'test/python/DataTypeMapIntString.py'),
+    ('test/sh/bindings.python.DataTypeMapStringFloat.sh', 'test/python/DataTypeMapStringFloat.py'),
+    ('test/sh/bindings.python.DataTypeMapStringInt.sh', 'test/python/DataTypeMapStringInt.py'),
+    ('test/sh/bindings.python.DataTypeMapStringString.sh', 'test/python/DataTypeMapStringString.py'),
+    ('test/sh/bindings.python.DataTypeSetFloat.sh', 'test/python/DataTypeSetFloat.py'),
+    ('test/sh/bindings.python.DataTypeSetInt.sh', 'test/python/DataTypeSetInt.py'),
+    ('test/sh/bindings.python.DataTypeSetString.sh', 'test/python/DataTypeSetString.py'),
+    ('test/sh/bindings.python.DataTypeString.sh', 'test/python/DataTypeString.py'),
+    ('test/sh/bindings.python.LengthString.sh', 'test/python/LengthString.py'),
+    ('test/sh/bindings.python.MultiAttribute.sh', 'test/python/MultiAttribute.py'),
+    ('test/sh/bindings.python.RangeSearchInt.sh', 'test/python/RangeSearchInt.py'),
+    ('test/sh/bindings.python.RangeSearchString.sh', 'test/python/RangeSearchString.py'),
+    ('test/sh/bindings.python.RegexSearch.sh', 'test/python/RegexSearch.py'),
+])
+
+generate_test_tarball(version, 'ruby', [
+    ('test/sh/bindings.ruby.BasicSearch.sh', 'test/ruby/BasicSearch.rb'),
+    ('test/sh/bindings.ruby.Basic.sh', 'test/ruby/Basic.rb'),
+    ('test/sh/bindings.ruby.DataTypeFloat.sh', 'test/ruby/DataTypeFloat.rb'),
+    ('test/sh/bindings.ruby.DataTypeInt.sh', 'test/ruby/DataTypeInt.rb'),
+    ('test/sh/bindings.ruby.DataTypeListFloat.sh', 'test/ruby/DataTypeListFloat.rb'),
+    ('test/sh/bindings.ruby.DataTypeListInt.sh', 'test/ruby/DataTypeListInt.rb'),
+    ('test/sh/bindings.ruby.DataTypeListString.sh', 'test/ruby/DataTypeListString.rb'),
+    ('test/sh/bindings.ruby.DataTypeMapFloatFloat.sh', 'test/ruby/DataTypeMapFloatFloat.rb'),
+    ('test/sh/bindings.ruby.DataTypeMapFloatInt.sh', 'test/ruby/DataTypeMapFloatInt.rb'),
+    ('test/sh/bindings.ruby.DataTypeMapFloatString.sh', 'test/ruby/DataTypeMapFloatString.rb'),
+    ('test/sh/bindings.ruby.DataTypeMapIntFloat.sh', 'test/ruby/DataTypeMapIntFloat.rb'),
+    ('test/sh/bindings.ruby.DataTypeMapIntInt.sh', 'test/ruby/DataTypeMapIntInt.rb'),
+    ('test/sh/bindings.ruby.DataTypeMapIntString.sh', 'test/ruby/DataTypeMapIntString.rb'),
+    ('test/sh/bindings.ruby.DataTypeMapStringFloat.sh', 'test/ruby/DataTypeMapStringFloat.rb'),
+    ('test/sh/bindings.ruby.DataTypeMapStringInt.sh', 'test/ruby/DataTypeMapStringInt.rb'),
+    ('test/sh/bindings.ruby.DataTypeMapStringString.sh', 'test/ruby/DataTypeMapStringString.rb'),
+    ('test/sh/bindings.ruby.DataTypeSetFloat.sh', 'test/ruby/DataTypeSetFloat.rb'),
+    ('test/sh/bindings.ruby.DataTypeSetInt.sh', 'test/ruby/DataTypeSetInt.rb'),
+    ('test/sh/bindings.ruby.DataTypeSetString.sh', 'test/ruby/DataTypeSetString.rb'),
+    ('test/sh/bindings.ruby.DataTypeString.sh', 'test/ruby/DataTypeString.rb'),
+    ('test/sh/bindings.ruby.LengthString.sh', 'test/ruby/LengthString.rb'),
+    ('test/sh/bindings.ruby.MultiAttribute.sh', 'test/ruby/MultiAttribute.rb'),
+    ('test/sh/bindings.ruby.RangeSearchInt.sh', 'test/ruby/RangeSearchInt.rb'),
+    ('test/sh/bindings.ruby.RangeSearchString.sh', 'test/ruby/RangeSearchString.rb'),
+    ('test/sh/bindings.ruby.RegexSearch.sh', 'test/ruby/RegexSearch.rb'),
+])
diff --git a/maint/lib-check.c b/maint/lib-check.c
index a682afb88..cb7bbfcea 100644
--- a/maint/lib-check.c
+++ b/maint/lib-check.c
@@ -31,27 +31,23 @@
 #include <dlfcn.h>
 
 int
-main(int argc, const char* argv[])
+main(int argc, const char *argv[])
 {
-    int i = 0;
-    void* ptr = NULL;
-
-    if (argc < 2)
-    {
-        fprintf(stderr, "specify a library\n");
-        return EXIT_FAILURE;
-    }
-
-    for (i = 1; i < argc; ++i)
-    {
-        ptr = dlopen(argv[i], RTLD_NOW|RTLD_GLOBAL);
-
-        if (!ptr)
-        {
-            fprintf(stderr, "%s\n", dlerror());
-            continue;
-        }
-    }
-
-    return EXIT_SUCCESS;
+	int i = 0;
+	void *ptr = NULL;
+	if (argc < 2)
+	{
+		fprintf(stderr, "specify a library\n");
+		return EXIT_FAILURE;
+	}
+	for (i = 1; i < argc; ++i)
+	{
+		ptr = dlopen(argv[i], RTLD_NOW | RTLD_GLOBAL);
+		if (!ptr)
+		{
+			fprintf(stderr, "%s\n", dlerror());
+			continue;
+		}
+	}
+	return EXIT_SUCCESS;
 }
diff --git a/namespace.h b/namespace.h
index 9a402a159..97a196b1f 100644
--- a/namespace.h
+++ b/namespace.h
@@ -29,7 +29,7 @@
 #define hyperdex_namespace_h_
 
 #define BEGIN_HYPERDEX_NAMESPACE \
-    namespace hyperdex __attribute__ ((visibility ("hidden"))) {
+	namespace hyperdex __attribute__ ((visibility ("hidden"))) {
 
 #define END_HYPERDEX_NAMESPACE }
 
diff --git a/osx/ieee754.h b/osx/ieee754.h
index 94d22c8a9..b979a43b6 100644
--- a/osx/ieee754.h
+++ b/osx/ieee754.h
@@ -8,171 +8,171 @@
 #include <float.h>
 
 union ieee754_float
-  {
-    float f;
+{
+	float f;
 
-    /* This is the IEEE 754 single-precision format.  */
-    struct
-      {
+	/* This is the IEEE 754 single-precision format.  */
+	struct
+	{
 #if	__BYTE_ORDER == __BIG_ENDIAN
-	unsigned int negative:1;
-	unsigned int exponent:8;
-	unsigned int mantissa:23;
+		unsigned int negative: 1;
+		unsigned int exponent: 8;
+		unsigned int mantissa: 23;
 #endif				/* Big endian.  */
 #if	__BYTE_ORDER == __LITTLE_ENDIAN
-	unsigned int mantissa:23;
-	unsigned int exponent:8;
-	unsigned int negative:1;
+		unsigned int mantissa: 23;
+		unsigned int exponent: 8;
+		unsigned int negative: 1;
 #endif				/* Little endian.  */
-      } ieee;
+	} ieee;
 
-    /* This format makes it easier to see if a NaN is a signalling NaN.  */
-    struct
-      {
+	/* This format makes it easier to see if a NaN is a signalling NaN.  */
+	struct
+	{
 #if	__BYTE_ORDER == __BIG_ENDIAN
-	unsigned int negative:1;
-	unsigned int exponent:8;
-	unsigned int quiet_nan:1;
-	unsigned int mantissa:22;
+		unsigned int negative: 1;
+		unsigned int exponent: 8;
+		unsigned int quiet_nan: 1;
+		unsigned int mantissa: 22;
 #endif				/* Big endian.  */
 #if	__BYTE_ORDER == __LITTLE_ENDIAN
-	unsigned int mantissa:22;
-	unsigned int quiet_nan:1;
-	unsigned int exponent:8;
-	unsigned int negative:1;
+		unsigned int mantissa: 22;
+		unsigned int quiet_nan: 1;
+		unsigned int exponent: 8;
+		unsigned int negative: 1;
 #endif				/* Little endian.  */
-      } ieee_nan;
-  };
+	} ieee_nan;
+};
 
 #define IEEE754_FLOAT_BIAS	0x7f /* Added to exponent.  */
 
 
 union ieee754_double
-  {
-    double d;
+{
+	double d;
 
-    /* This is the IEEE 754 double-precision format.  */
-    struct
-      {
+	/* This is the IEEE 754 double-precision format.  */
+	struct
+	{
 #if	__BYTE_ORDER == __BIG_ENDIAN
-	unsigned int negative:1;
-	unsigned int exponent:11;
-	/* Together these comprise the mantissa.  */
-	unsigned int mantissa0:20;
-	unsigned int mantissa1:32;
+		unsigned int negative: 1;
+		unsigned int exponent: 11;
+		/* Together these comprise the mantissa.  */
+		unsigned int mantissa0: 20;
+		unsigned int mantissa1: 32;
 #endif				/* Big endian.  */
 #if	__BYTE_ORDER == __LITTLE_ENDIAN
 # if	__FLOAT_WORD_ORDER == BIG_ENDIAN
-	unsigned int mantissa0:20;
-	unsigned int exponent:11;
-	unsigned int negative:1;
-	unsigned int mantissa1:32;
+		unsigned int mantissa0: 20;
+		unsigned int exponent: 11;
+		unsigned int negative: 1;
+		unsigned int mantissa1: 32;
 # else
-	/* Together these comprise the mantissa.  */
-	unsigned int mantissa1:32;
-	unsigned int mantissa0:20;
-	unsigned int exponent:11;
-	unsigned int negative:1;
+		/* Together these comprise the mantissa.  */
+		unsigned int mantissa1: 32;
+		unsigned int mantissa0: 20;
+		unsigned int exponent: 11;
+		unsigned int negative: 1;
 # endif
 #endif				/* Little endian.  */
-      } ieee;
+	} ieee;
 
-    /* This format makes it easier to see if a NaN is a signalling NaN.  */
-    struct
-      {
+	/* This format makes it easier to see if a NaN is a signalling NaN.  */
+	struct
+	{
 #if	__BYTE_ORDER == __BIG_ENDIAN
-	unsigned int negative:1;
-	unsigned int exponent:11;
-	unsigned int quiet_nan:1;
-	/* Together these comprise the mantissa.  */
-	unsigned int mantissa0:19;
-	unsigned int mantissa1:32;
+		unsigned int negative: 1;
+		unsigned int exponent: 11;
+		unsigned int quiet_nan: 1;
+		/* Together these comprise the mantissa.  */
+		unsigned int mantissa0: 19;
+		unsigned int mantissa1: 32;
 #else
 # if	__FLOAT_WORD_ORDER == BIG_ENDIAN
-	unsigned int mantissa0:19;
-	unsigned int quiet_nan:1;
-	unsigned int exponent:11;
-	unsigned int negative:1;
-	unsigned int mantissa1:32;
+		unsigned int mantissa0: 19;
+		unsigned int quiet_nan: 1;
+		unsigned int exponent: 11;
+		unsigned int negative: 1;
+		unsigned int mantissa1: 32;
 # else
-	/* Together these comprise the mantissa.  */
-	unsigned int mantissa1:32;
-	unsigned int mantissa0:19;
-	unsigned int quiet_nan:1;
-	unsigned int exponent:11;
-	unsigned int negative:1;
+		/* Together these comprise the mantissa.  */
+		unsigned int mantissa1: 32;
+		unsigned int mantissa0: 19;
+		unsigned int quiet_nan: 1;
+		unsigned int exponent: 11;
+		unsigned int negative: 1;
 # endif
 #endif
-      } ieee_nan;
-  };
+	} ieee_nan;
+};
 
 #define IEEE754_DOUBLE_BIAS	0x3ff /* Added to exponent.  */
 
 
 union ieee854_long_double
-  {
-    long double d;
+{
+	long double d;
 
-    /* This is the IEEE 854 double-extended-precision format.  */
-    struct
-      {
+	/* This is the IEEE 854 double-extended-precision format.  */
+	struct
+	{
 #if	__BYTE_ORDER == __BIG_ENDIAN
-	unsigned int negative:1;
-	unsigned int exponent:15;
-	unsigned int empty:16;
-	unsigned int mantissa0:32;
-	unsigned int mantissa1:32;
+		unsigned int negative: 1;
+		unsigned int exponent: 15;
+		unsigned int empty: 16;
+		unsigned int mantissa0: 32;
+		unsigned int mantissa1: 32;
 #endif
 #if	__BYTE_ORDER == __LITTLE_ENDIAN
 # if	__FLOAT_WORD_ORDER == BIG_ENDIAN
-	unsigned int exponent:15;
-	unsigned int negative:1;
-	unsigned int empty:16;
-	unsigned int mantissa0:32;
-	unsigned int mantissa1:32;
+		unsigned int exponent: 15;
+		unsigned int negative: 1;
+		unsigned int empty: 16;
+		unsigned int mantissa0: 32;
+		unsigned int mantissa1: 32;
 # else
-	unsigned int mantissa1:32;
-	unsigned int mantissa0:32;
-	unsigned int exponent:15;
-	unsigned int negative:1;
-	unsigned int empty:16;
+		unsigned int mantissa1: 32;
+		unsigned int mantissa0: 32;
+		unsigned int exponent: 15;
+		unsigned int negative: 1;
+		unsigned int empty: 16;
 # endif
 #endif
-      } ieee;
+	} ieee;
 
-    /* This is for NaNs in the IEEE 854 double-extended-precision format.  */
-    struct
-      {
+	/* This is for NaNs in the IEEE 854 double-extended-precision format.  */
+	struct
+	{
 #if	__BYTE_ORDER == __BIG_ENDIAN
-	unsigned int negative:1;
-	unsigned int exponent:15;
-	unsigned int empty:16;
-	unsigned int one:1;
-	unsigned int quiet_nan:1;
-	unsigned int mantissa0:30;
-	unsigned int mantissa1:32;
+		unsigned int negative: 1;
+		unsigned int exponent: 15;
+		unsigned int empty: 16;
+		unsigned int one: 1;
+		unsigned int quiet_nan: 1;
+		unsigned int mantissa0: 30;
+		unsigned int mantissa1: 32;
 #endif
 #if	__BYTE_ORDER == __LITTLE_ENDIAN
 # if	__FLOAT_WORD_ORDER == BIG_ENDIAN
-	unsigned int exponent:15;
-	unsigned int negative:1;
-	unsigned int empty:16;
-	unsigned int mantissa0:30;
-	unsigned int quiet_nan:1;
-	unsigned int one:1;
-	unsigned int mantissa1:32;
+		unsigned int exponent: 15;
+		unsigned int negative: 1;
+		unsigned int empty: 16;
+		unsigned int mantissa0: 30;
+		unsigned int quiet_nan: 1;
+		unsigned int one: 1;
+		unsigned int mantissa1: 32;
 # else
-	unsigned int mantissa1:32;
-	unsigned int mantissa0:30;
-	unsigned int quiet_nan:1;
-	unsigned int one:1;
-	unsigned int exponent:15;
-	unsigned int negative:1;
-	unsigned int empty:16;
+		unsigned int mantissa1: 32;
+		unsigned int mantissa0: 30;
+		unsigned int quiet_nan: 1;
+		unsigned int one: 1;
+		unsigned int exponent: 15;
+		unsigned int negative: 1;
+		unsigned int empty: 16;
 # endif
 #endif
-      } ieee_nan;
-  };
+	} ieee_nan;
+};
 
 #define IEEE854_LONG_DOUBLE_BIAS 0x3fff
 
diff --git a/test/replication-stress-test.cc b/test/replication-stress-test.cc
index 812a71d00..dcdbacc70 100644
--- a/test/replication-stress-test.cc
+++ b/test/replication-stress-test.cc
@@ -46,11 +46,11 @@
 
 static bool _continuous = false;
 static long _partitions = 4;
-const char* _space = "replication";
+const char *_space = "replication";
 
 static bool _quiet = false;
 static int _testno = 0;
-static hyperdex::Client* _cl = NULL;
+static hyperdex::Client *_cl = NULL;
 static std::map<int64_t, e::compat::shared_ptr<hyperdex_client_returncode> > _incompleteops;
 
 static void
@@ -67,299 +67,261 @@ static void
 test4();
 
 int
-main(int argc, const char* argv[])
+main(int argc, const char *argv[])
 {
-    hyperdex::connect_opts conn;
-    e::argparser st;
-    st.arg().name('c', "continuous")
-            .description("run the test continuously (default: no)")
-            .set_true(&_continuous);
-    st.arg().name('n', "partitions")
-            .description("assume each subspace is partitioned into N pieces (default: 4)")
-            .metavar("N").as_long(&_partitions);
-    st.arg().name('s', "space")
-            .description("perform all operations on the specified space (default: \"replication\")")
-            .metavar("space").as_string(&_space);
-    st.arg().name('q', "quiet")
-            .description("silence all output")
-            .set_true(&_quiet);
-
-    e::argparser ap;
-    ap.autohelp();
-    ap.add("Connect to a cluster:", conn.parser());
-    ap.add("Replication stress test:", st);
-
-    if (!ap.parse(argc, argv))
-    {
-        return EXIT_FAILURE;
-    }
-
-    if (!conn.validate())
-    {
-        std::cerr << "invalid host:port specification\n" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    if (ap.args_sz() != 0)
-    {
-        std::cerr << "command takes no arguments" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    hyperdex::Client cl(conn.host(), conn.port());
-    _cl = &cl;
-
-    do
-    {
-        wipe();
-        test0();
-        test1();
-        test2();
-        test3();
-        test4();
-    }
-    while (_continuous);
-
-    return EXIT_SUCCESS;
+	hyperdex::connect_opts conn;
+	e::argparser st;
+	st.arg().name('c', "continuous")
+	.description("run the test continuously (default: no)")
+	.set_true(&_continuous);
+	st.arg().name('n', "partitions")
+	.description("assume each subspace is partitioned into N pieces (default: 4)")
+	.metavar("N").as_long(&_partitions);
+	st.arg().name('s', "space")
+	.description("perform all operations on the specified space (default: \"replication\")")
+	.metavar("space").as_string(&_space);
+	st.arg().name('q', "quiet")
+	.description("silence all output")
+	.set_true(&_quiet);
+	e::argparser ap;
+	ap.autohelp();
+	ap.add("Connect to a cluster:", conn.parser());
+	ap.add("Replication stress test:", st);
+	if (!ap.parse(argc, argv))
+	{
+		return EXIT_FAILURE;
+	}
+	if (!conn.validate())
+	{
+		std::cerr << "invalid host:port specification\n" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	if (ap.args_sz() != 0)
+	{
+		std::cerr << "command takes no arguments" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	hyperdex::Client cl(conn.host(), conn.port());
+	_cl = &cl;
+	do
+	{
+		wipe();
+		test0();
+		test1();
+		test2();
+		test3();
+		test4();
+	}
+	while (_continuous);
+	return EXIT_SUCCESS;
 }
 
 static void
 success()
 {
-    if (!_quiet) std::cout << "Test " << _testno << ":  [\x1b[32mOK\x1b[0m]\n";
+	if (!_quiet) std::cout << "Test " << _testno << ":  [\x1b[32mOK\x1b[0m]\n";
 }
 
 #define FAIL(REASON) \
-    do { \
-    if (!_quiet) std::cout << "Test " << _testno << ":  [\x1b[31mFAIL\x1b[0m]\n" \
-              << "location: " << __FILE__ << ":" << __LINE__ << "\n" \
-              << "reason:  " << REASON << "\n"; \
-    abort(); \
-    } while (0)
+	do { \
+		if (!_quiet) std::cout << "Test " << _testno << ":  [\x1b[31mFAIL\x1b[0m]\n" \
+			                       << "location: " << __FILE__ << ":" << __LINE__ << "\n" \
+			                       << "reason:  " << REASON << "\n"; \
+		abort(); \
+	} while (0)
 
 static uint64_t
 generate_attr(size_t idx)
 {
-    uint64_t partition_size = UINT64_MAX / _partitions;
-    return partition_size * idx + partition_size / 2;
+	uint64_t partition_size = UINT64_MAX / _partitions;
+	return partition_size * idx + partition_size / 2;
 }
 
 static void
 put(uint64_t A, uint64_t B, uint64_t C)
 {
-    char buf[3 * sizeof(uint64_t)];
-    e::pack64le(A, buf + 0 * sizeof(uint64_t));
-    e::pack64le(B, buf + 1 * sizeof(uint64_t));
-    e::pack64le(C, buf + 2 * sizeof(uint64_t));
-    hyperdex_client_attribute attrs[2];
-    attrs[0].attr = "B";
-    attrs[0].value = buf + 1 * sizeof(uint64_t);
-    attrs[0].value_sz = sizeof(uint64_t);
-    attrs[0].datatype = HYPERDATATYPE_INT64;
-    attrs[1].attr = "C";
-    attrs[1].value = buf + 2 * sizeof(uint64_t);
-    attrs[1].value_sz = sizeof(uint64_t);
-    attrs[1].datatype = HYPERDATATYPE_INT64;
-    e::compat::shared_ptr<hyperdex_client_returncode> status(new hyperdex_client_returncode());
-    int64_t id = _cl->put(_space, buf, sizeof(uint64_t), attrs, 2, status.get());
-
-    if (id < 0)
-    {
-        FAIL("put encountered error " << *status);
-    }
-
-    std::pair<std::map<int64_t, e::compat::shared_ptr<hyperdex_client_returncode> >::iterator, bool> res;
-    res = _incompleteops.insert(std::make_pair(id, status));
-
-    if (res.second != true)
-    {
-        FAIL("put could not insert into incompleteops");
-    }
+	char buf[3 * sizeof(uint64_t)];
+	e::pack64le(A, buf + 0 * sizeof(uint64_t));
+	e::pack64le(B, buf + 1 * sizeof(uint64_t));
+	e::pack64le(C, buf + 2 * sizeof(uint64_t));
+	hyperdex_client_attribute attrs[2];
+	attrs[0].attr = "B";
+	attrs[0].value = buf + 1 * sizeof(uint64_t);
+	attrs[0].value_sz = sizeof(uint64_t);
+	attrs[0].datatype = HYPERDATATYPE_INT64;
+	attrs[1].attr = "C";
+	attrs[1].value = buf + 2 * sizeof(uint64_t);
+	attrs[1].value_sz = sizeof(uint64_t);
+	attrs[1].datatype = HYPERDATATYPE_INT64;
+	e::compat::shared_ptr<hyperdex_client_returncode> status(new hyperdex_client_returncode());
+	int64_t id = _cl->put(_space, buf, sizeof(uint64_t), attrs, 2, status.get());
+	if (id < 0)
+	{
+		FAIL("put encountered error " << *status);
+	}
+	std::pair<std::map<int64_t, e::compat::shared_ptr<hyperdex_client_returncode> >::iterator, bool> res;
+	res = _incompleteops.insert(std::make_pair(id, status));
+	if (res.second != true)
+	{
+		FAIL("put could not insert into incompleteops");
+	}
 }
 
 static void
 del(uint64_t A)
 {
-    char buf[sizeof(uint64_t)];
-    e::pack64le(A, buf);
-    e::compat::shared_ptr<hyperdex_client_returncode> status(new hyperdex_client_returncode());
-    int64_t id = _cl->del(_space, buf, sizeof(uint64_t), status.get());
-
-    if (id < 0)
-    {
-        FAIL("del encountered error " << status);
-    }
-
-    std::pair<std::map<int64_t, e::compat::shared_ptr<hyperdex_client_returncode> >::iterator, bool> res;
-    res = _incompleteops.insert(std::make_pair(id, status));
-
-    if (res.second != true)
-    {
-        FAIL("del could not insert into incompleteops");
-    }
+	char buf[sizeof(uint64_t)];
+	e::pack64le(A, buf);
+	e::compat::shared_ptr<hyperdex_client_returncode> status(new hyperdex_client_returncode());
+	int64_t id = _cl->del(_space, buf, sizeof(uint64_t), status.get());
+	if (id < 0)
+	{
+		FAIL("del encountered error " << status);
+	}
+	std::pair<std::map<int64_t, e::compat::shared_ptr<hyperdex_client_returncode> >::iterator, bool> res;
+	res = _incompleteops.insert(std::make_pair(id, status));
+	if (res.second != true)
+	{
+		FAIL("del could not insert into incompleteops");
+	}
 }
 
 static void
 flush()
 {
-    while (!_incompleteops.empty())
-    {
-        hyperdex_client_returncode status;
-        int64_t id = _cl->loop(10000, &status);
-
-        if (id < 0)
-        {
-            FAIL("loop returned error " << status);
-        }
-        else
-        {
-            std::map<int64_t, e::compat::shared_ptr<hyperdex_client_returncode> >::iterator incomplete;
-            incomplete = _incompleteops.find(id);
-
-            if (incomplete == _incompleteops.end())
-            {
-                FAIL("loop returned unknown id " << id);
-            }
-
-            if (*(incomplete->second) != HYPERDEX_CLIENT_SUCCESS)
-            {
-                FAIL("operation " << id << " returned " << *(incomplete->second));
-            }
-
-            _incompleteops.erase(incomplete);
-        }
-    }
+	while (!_incompleteops.empty())
+	{
+		hyperdex_client_returncode status;
+		int64_t id = _cl->loop(10000, &status);
+		if (id < 0)
+		{
+			FAIL("loop returned error " << status);
+		}
+		else
+		{
+			std::map<int64_t, e::compat::shared_ptr<hyperdex_client_returncode> >::iterator incomplete;
+			incomplete = _incompleteops.find(id);
+			if (incomplete == _incompleteops.end())
+			{
+				FAIL("loop returned unknown id " << id);
+			}
+			if (*(incomplete->second) != HYPERDEX_CLIENT_SUCCESS)
+			{
+				FAIL("operation " << id << " returned " << * (incomplete->second));
+			}
+			_incompleteops.erase(incomplete);
+		}
+	}
 }
 
 static void
 present(uint64_t A, uint64_t B, uint64_t C)
 {
-    flush();
-
-    char buf[3 * sizeof(uint64_t)];
-    e::pack64le(A, buf + 0 * sizeof(uint64_t));
-    e::pack64le(B, buf + 1 * sizeof(uint64_t));
-    e::pack64le(C, buf + 2 * sizeof(uint64_t));
-    hyperdex_client_returncode gstatus;
-    hyperdex_client_returncode lstatus;
-    const hyperdex_client_attribute* attrs;
-    size_t attrs_sz;
-    int64_t gid = _cl->get(_space, buf, sizeof(uint64_t), &gstatus, &attrs, &attrs_sz);
-
-    if (gid < 0)
-    {
-        FAIL("get encountered error " << gstatus);
-    }
-
-    int64_t lid = _cl->loop(10000, &lstatus);
-
-    if (lid < 0)
-    {
-        FAIL("loop encountered error " << lstatus);
-    }
-
-    if (gid != lid)
-    {
-        FAIL("loop id (" << lid << ") does not match get id (" << gid << ")");
-    }
-
-    if (gstatus != HYPERDEX_CLIENT_SUCCESS)
-    {
-        FAIL("operation " << gid << " (a presence check) returned " << gstatus);
-    }
-
-    if (attrs_sz != 2)
-    {
-        FAIL("presence check: " << attrs_sz << " attributes instead of 2 attributes");
-    }
-
-    if (strcmp(attrs[0].attr, "B") != 0)
-    {
-        FAIL("presence check: first attribute is \"" << attrs[0].attr << "\" instead of \"B\"");
-    }
-
-    if (attrs[0].datatype != HYPERDATATYPE_INT64)
-    {
-        FAIL("presence check: first attribute is not of datatype \"int\"");
-    }
-
-    if (e::slice(attrs[0].value, attrs[0].value_sz) != e::slice(buf + sizeof(uint64_t), sizeof(uint64_t)))
-    {
-        FAIL("presence check: first attribute does not match " << B
-             << " (" << e::slice(attrs[0].value, attrs[0].value_sz).hex() << " vs. "
-             << e::slice(buf + sizeof(uint64_t), sizeof(uint64_t)).hex() << ")");
-    }
-
-    if (strcmp(attrs[1].attr, "C") != 0)
-    {
-        FAIL("presence check: second attribute is \"" << attrs[1].attr << "\" instead of \"C\"");
-    }
-
-    if (attrs[1].datatype != HYPERDATATYPE_INT64)
-    {
-        FAIL("presence check: second attribute is not of datatype \"int\"");
-    }
-
-    if (e::slice(attrs[1].value, attrs[1].value_sz) != e::slice(buf + 2 * sizeof(uint64_t), sizeof(uint64_t)))
-    {
-        FAIL("presence check: second attribute does not match " << C
-             << " (" << e::slice(attrs[1].value, attrs[1].value_sz).hex() << " vs. "
-             << e::slice(buf + 2 * sizeof(uint64_t), sizeof(uint64_t)).hex() << ")");
-    }
-
-    hyperdex_client_destroy_attrs(attrs, attrs_sz);
+	flush();
+	char buf[3 * sizeof(uint64_t)];
+	e::pack64le(A, buf + 0 * sizeof(uint64_t));
+	e::pack64le(B, buf + 1 * sizeof(uint64_t));
+	e::pack64le(C, buf + 2 * sizeof(uint64_t));
+	hyperdex_client_returncode gstatus;
+	hyperdex_client_returncode lstatus;
+	const hyperdex_client_attribute *attrs;
+	size_t attrs_sz;
+	int64_t gid = _cl->get(_space, buf, sizeof(uint64_t), &gstatus, &attrs, &attrs_sz);
+	if (gid < 0)
+	{
+		FAIL("get encountered error " << gstatus);
+	}
+	int64_t lid = _cl->loop(10000, &lstatus);
+	if (lid < 0)
+	{
+		FAIL("loop encountered error " << lstatus);
+	}
+	if (gid != lid)
+	{
+		FAIL("loop id (" << lid << ") does not match get id (" << gid << ")");
+	}
+	if (gstatus != HYPERDEX_CLIENT_SUCCESS)
+	{
+		FAIL("operation " << gid << " (a presence check) returned " << gstatus);
+	}
+	if (attrs_sz != 2)
+	{
+		FAIL("presence check: " << attrs_sz << " attributes instead of 2 attributes");
+	}
+	if (strcmp(attrs[0].attr, "B") != 0)
+	{
+		FAIL("presence check: first attribute is \"" << attrs[0].attr << "\" instead of \"B\"");
+	}
+	if (attrs[0].datatype != HYPERDATATYPE_INT64)
+	{
+		FAIL("presence check: first attribute is not of datatype \"int\"");
+	}
+	if (e::slice(attrs[0].value, attrs[0].value_sz) != e::slice(buf + sizeof(uint64_t), sizeof(uint64_t)))
+	{
+		FAIL("presence check: first attribute does not match " << B
+		     << " (" << e::slice(attrs[0].value, attrs[0].value_sz).hex() << " vs. "
+		     << e::slice(buf + sizeof(uint64_t), sizeof(uint64_t)).hex() << ")");
+	}
+	if (strcmp(attrs[1].attr, "C") != 0)
+	{
+		FAIL("presence check: second attribute is \"" << attrs[1].attr << "\" instead of \"C\"");
+	}
+	if (attrs[1].datatype != HYPERDATATYPE_INT64)
+	{
+		FAIL("presence check: second attribute is not of datatype \"int\"");
+	}
+	if (e::slice(attrs[1].value, attrs[1].value_sz) != e::slice(buf + 2 * sizeof(uint64_t), sizeof(uint64_t)))
+	{
+		FAIL("presence check: second attribute does not match " << C
+		     << " (" << e::slice(attrs[1].value, attrs[1].value_sz).hex() << " vs. "
+		     << e::slice(buf + 2 * sizeof(uint64_t), sizeof(uint64_t)).hex() << ")");
+	}
+	hyperdex_client_destroy_attrs(attrs, attrs_sz);
 }
 
 static void
 absent(uint64_t A)
 {
-    flush();
-
-    char buf[sizeof(uint64_t)];
-    e::pack64le(A, buf);
-    hyperdex_client_returncode gstatus;
-    hyperdex_client_returncode lstatus;
-    const hyperdex_client_attribute* attrs = NULL;
-    size_t attrs_sz = 0;
-    int64_t gid = _cl->get(_space, buf, sizeof(uint64_t), &gstatus, &attrs, &attrs_sz);
-
-    if (gid < 0)
-    {
-        FAIL("get encountered error " << gstatus);
-    }
-
-    int64_t lid = _cl->loop(10000, &lstatus);
-
-    if (lid < 0)
-    {
-        FAIL("loop returned error " << lstatus);
-    }
-
-    if (gid != lid)
-    {
-        FAIL("loop id (" << lid << ") does not match get id (" << gid << ")");
-    }
-
-    if (gstatus != HYPERDEX_CLIENT_NOTFOUND)
-    {
-        FAIL("operation " << gid << " (an absence check) returned " << gstatus);
-    }
-
-    assert(!attrs && !attrs_sz);
+	flush();
+	char buf[sizeof(uint64_t)];
+	e::pack64le(A, buf);
+	hyperdex_client_returncode gstatus;
+	hyperdex_client_returncode lstatus;
+	const hyperdex_client_attribute *attrs = NULL;
+	size_t attrs_sz = 0;
+	int64_t gid = _cl->get(_space, buf, sizeof(uint64_t), &gstatus, &attrs, &attrs_sz);
+	if (gid < 0)
+	{
+		FAIL("get encountered error " << gstatus);
+	}
+	int64_t lid = _cl->loop(10000, &lstatus);
+	if (lid < 0)
+	{
+		FAIL("loop returned error " << lstatus);
+	}
+	if (gid != lid)
+	{
+		FAIL("loop id (" << lid << ") does not match get id (" << gid << ")");
+	}
+	if (gstatus != HYPERDEX_CLIENT_NOTFOUND)
+	{
+		FAIL("operation " << gid << " (an absence check) returned " << gstatus);
+	}
+	assert(!attrs && !attrs_sz);
 }
 
 void
 wipe()
 {
-    for (long i = 0; i < _partitions; ++i)
-    {
-        uint64_t A = generate_attr(i);
-        put(A, A, A);
-        del(A);
-        flush();
-    }
+	for (long i = 0; i < _partitions; ++i)
+	{
+		uint64_t A = generate_attr(i);
+		put(A, A, A);
+		del(A);
+		flush();
+	}
 }
 
 // This test continually puts keys, ensuring that every way in which one could
@@ -367,33 +329,28 @@ wipe()
 void
 test0()
 {
-    _testno = 0;
-    uint64_t A;
-    uint64_t B;
-    uint64_t C;
-
-    for (long i = 0; i < _partitions; ++i)
-    {
-        A = generate_attr(i);
-        absent(A);
-
-        for (long j = 0; j < _partitions; ++j)
-        {
-            B = generate_attr(j);
-
-            for (long k = 0; k < _partitions; ++k)
-            {
-                C = generate_attr(k);
-                put(A, B, C);
-            }
-        }
-
-        present(A, B, C);
-        del(A);
-        absent(A);
-    }
-
-    success();
+	_testno = 0;
+	uint64_t A;
+	uint64_t B;
+	uint64_t C;
+	for (long i = 0; i < _partitions; ++i)
+	{
+		A = generate_attr(i);
+		absent(A);
+		for (long j = 0; j < _partitions; ++j)
+		{
+			B = generate_attr(j);
+			for (long k = 0; k < _partitions; ++k)
+			{
+				C = generate_attr(k);
+				put(A, B, C);
+			}
+		}
+		present(A, B, C);
+		del(A);
+		absent(A);
+	}
+	success();
 }
 
 // This test continually puts/deletes keys, ensuring that a [PUT, DEL] sequence
@@ -402,32 +359,27 @@ test0()
 void
 test1()
 {
-    _testno = 1;
-    uint64_t A;
-    uint64_t B;
-    uint64_t C;
-
-    for (long i = 0; i < _partitions; ++i)
-    {
-        A = generate_attr(i);
-        absent(A);
-
-        for (long j = 0; j < _partitions; ++j)
-        {
-            B = generate_attr(j);
-
-            for (long k = 0; k < _partitions; ++k)
-            {
-                C = generate_attr(k);
-                put(A, B, C);
-                del(A);
-            }
-        }
-
-        absent(A);
-    }
-
-    success();
+	_testno = 1;
+	uint64_t A;
+	uint64_t B;
+	uint64_t C;
+	for (long i = 0; i < _partitions; ++i)
+	{
+		A = generate_attr(i);
+		absent(A);
+		for (long j = 0; j < _partitions; ++j)
+		{
+			B = generate_attr(j);
+			for (long k = 0; k < _partitions; ++k)
+			{
+				C = generate_attr(k);
+				put(A, B, C);
+				del(A);
+			}
+		}
+		absent(A);
+	}
+	success();
 }
 
 // This test puts keys such that A and B are fixed, but every choice of C for
@@ -437,66 +389,56 @@ test1()
 void
 test2()
 {
-    _testno = 2;
-    uint64_t A = 0;
-    uint64_t B = 0;
-    uint64_t C = 0;
-
-    for (long i = 0; i < _partitions; ++i)
-    {
-        A = generate_attr(i);
-
-        for (long j = 0; j < _partitions; ++j)
-        {
-            B = generate_attr(j);
-            absent(A);
-
-            for (long k = 0; k < _partitions; ++k)
-            {
-                C = generate_attr(k);
-                put(A, B, C);
-            }
-
-            present(A, B, C);
-            del(A);
-            absent(A);
-        }
-    }
-
-    success();
+	_testno = 2;
+	uint64_t A = 0;
+	uint64_t B = 0;
+	uint64_t C = 0;
+	for (long i = 0; i < _partitions; ++i)
+	{
+		A = generate_attr(i);
+		for (long j = 0; j < _partitions; ++j)
+		{
+			B = generate_attr(j);
+			absent(A);
+			for (long k = 0; k < _partitions; ++k)
+			{
+				C = generate_attr(k);
+				put(A, B, C);
+			}
+			present(A, B, C);
+			del(A);
+			absent(A);
+		}
+	}
+	success();
 }
 
 // This is similar to test2 except that columns A and C are fixed.
 void
 test3()
 {
-    _testno = 3;
-    uint64_t A = 0;
-    uint64_t B = 0;
-    uint64_t C = 0;
-
-    for (long i = 0; i < _partitions; ++i)
-    {
-        A = generate_attr(i);
-
-        for (long j = 0; j < _partitions; ++j)
-        {
-            C = generate_attr(j);
-            absent(A);
-
-            for (long k = 0; k < _partitions; ++k)
-            {
-                B = generate_attr(k);
-                put(A, B, C);
-            }
-
-            present(A, B, C);
-            del(A);
-            absent(A);
-        }
-    }
-
-    success();
+	_testno = 3;
+	uint64_t A = 0;
+	uint64_t B = 0;
+	uint64_t C = 0;
+	for (long i = 0; i < _partitions; ++i)
+	{
+		A = generate_attr(i);
+		for (long j = 0; j < _partitions; ++j)
+		{
+			C = generate_attr(j);
+			absent(A);
+			for (long k = 0; k < _partitions; ++k)
+			{
+				B = generate_attr(k);
+				put(A, B, C);
+			}
+			present(A, B, C);
+			del(A);
+			absent(A);
+		}
+	}
+	success();
 }
 
 // This test stresses the interaction of CHAIN_SUBSPACE with DELETE messages.
@@ -506,42 +448,35 @@ test3()
 void
 test4()
 {
-    _testno = 4;
-    uint64_t A;
-    uint64_t B;
-    uint64_t BP;
-    uint64_t C;
-    uint64_t CP;
-
-    for (long h = 0; h < _partitions; ++h)
-    {
-        A = generate_attr(h);
-
-        for (long i = 0; i < _partitions; ++i)
-        {
-            B = generate_attr(i);
-
-            for (long j = 0; j < _partitions; ++j)
-            {
-                C = generate_attr(j);
-
-                for (long k = 0; k < _partitions; ++k)
-                {
-                    BP = generate_attr(k);
-
-                    for (long l = 0; l < _partitions; ++l)
-                    {
-                        CP = generate_attr(l);
-                        put(A, B, C);
-                        put(A, BP, CP);
-                        del(A);
-                    }
-                }
-
-                absent(A);
-            }
-        }
-    }
-
-    success();
+	_testno = 4;
+	uint64_t A;
+	uint64_t B;
+	uint64_t BP;
+	uint64_t C;
+	uint64_t CP;
+	for (long h = 0; h < _partitions; ++h)
+	{
+		A = generate_attr(h);
+		for (long i = 0; i < _partitions; ++i)
+		{
+			B = generate_attr(i);
+			for (long j = 0; j < _partitions; ++j)
+			{
+				C = generate_attr(j);
+				for (long k = 0; k < _partitions; ++k)
+				{
+					BP = generate_attr(k);
+					for (long l = 0; l < _partitions; ++l)
+					{
+						CP = generate_attr(l);
+						put(A, B, C);
+						put(A, BP, CP);
+						del(A);
+					}
+				}
+				absent(A);
+			}
+		}
+	}
+	success();
 }
diff --git a/test/search-stress-test.cc b/test/search-stress-test.cc
index 3e3d10622..54a3ff8fc 100644
--- a/test/search-stress-test.cc
+++ b/test/search-stress-test.cc
@@ -36,738 +36,652 @@
 #include <hyperdex/client.hpp>
 #include "tools/common.h"
 
-const char* _colnames[] = {"bit01", "bit02", "bit03", "bit04", "bit05", "bit06",
+const char *_colnames[] = {"bit01", "bit02", "bit03", "bit04", "bit05", "bit06",
                            "bit07", "bit08", "bit09", "bit10", "bit11", "bit12",
                            "bit13", "bit14", "bit15", "bit16", "bit17", "bit18",
                            "bit19", "bit20", "bit21", "bit22", "bit23", "bit24",
                            "bit25", "bit26", "bit27", "bit28", "bit29", "bit30",
-                           "bit31", "bit32"};
+                           "bit31", "bit32"
+                          };
 static bool _quiet = false;
-static const char* _space = "search";
+static const char *_space = "search";
 static unsigned long _random_iters = 16;
-static const char* _key_type_s = "int";
+static const char *_key_type_s = "int";
 static hyperdatatype _key_type = HYPERDATATYPE_INT64;
 
 static int
-test(hyperdex::Client* cl);
+test(hyperdex::Client *cl);
 
 int
-main(int argc, const char* argv[])
+main(int argc, const char *argv[])
 {
-    hyperdex::connect_opts conn;
-    e::argparser st;
-    st.arg().name('s', "space")
-            .description("perform all operations on the specified space (default: \"search\")")
-            .metavar("space").as_string(&_space);
-    st.arg().name('k', "key-type")
-            .description("one of \"int\", \"string\" (default: \"int\")")
-            .metavar("type").as_string(&_key_type_s);
-    st.arg().name('q', "quiet")
-            .description("silence all output")
-            .set_true(&_quiet);
-
-    e::argparser ap;
-    ap.autohelp();
-    ap.add("Connect to a cluster:", conn.parser());
-    ap.add("Search stress test:", st);
-
-    if (!ap.parse(argc, argv))
-    {
-        return EXIT_FAILURE;
-    }
-
-    if (!conn.validate())
-    {
-        std::cerr << "invalid host:port specification\n" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    if (strcmp(_key_type_s, "int") == 0)
-    {
-        _key_type = HYPERDATATYPE_INT64;
-    }
-    else if (strcmp(_key_type_s, "string") == 0)
-    {
-        _key_type = HYPERDATATYPE_STRING;
-    }
-    else
-    {
-        std::cerr << "unsupported key type \"" << _key_type_s << "\"" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    if (ap.args_sz() != 0)
-    {
-        std::cerr << "command takes no arguments" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    try
-    {
-        hyperdex::Client cl(conn.host(), conn.port());
-        return test(&cl);
-    }
-    catch (std::exception& e)
-    {
-        std::cerr << "error:  " << e.what();
-        return EXIT_FAILURE;
-    }
-
-    return EXIT_SUCCESS;
+	hyperdex::connect_opts conn;
+	e::argparser st;
+	st.arg().name('s', "space")
+	.description("perform all operations on the specified space (default: \"search\")")
+	.metavar("space").as_string(&_space);
+	st.arg().name('k', "key-type")
+	.description("one of \"int\", \"string\" (default: \"int\")")
+	.metavar("type").as_string(&_key_type_s);
+	st.arg().name('q', "quiet")
+	.description("silence all output")
+	.set_true(&_quiet);
+	e::argparser ap;
+	ap.autohelp();
+	ap.add("Connect to a cluster:", conn.parser());
+	ap.add("Search stress test:", st);
+	if (!ap.parse(argc, argv))
+	{
+		return EXIT_FAILURE;
+	}
+	if (!conn.validate())
+	{
+		std::cerr << "invalid host:port specification\n" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	if (strcmp(_key_type_s, "int") == 0)
+	{
+		_key_type = HYPERDATATYPE_INT64;
+	}
+	else if (strcmp(_key_type_s, "string") == 0)
+	{
+		_key_type = HYPERDATATYPE_STRING;
+	}
+	else
+	{
+		std::cerr << "unsupported key type \"" << _key_type_s << "\"" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	if (ap.args_sz() != 0)
+	{
+		std::cerr << "command takes no arguments" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	try
+	{
+		hyperdex::Client cl(conn.host(), conn.port());
+		return test(&cl);
+	}
+	catch (std::exception &e)
+	{
+		std::cerr << "error:  " << e.what();
+		return EXIT_FAILURE;
+	}
+	return EXIT_SUCCESS;
 }
 
 #define HYPERDEX_TEST_SUCCESS(TESTNO) \
-    do { \
-        if (!_quiet) std::cout << "Test " << TESTNO << ":  [\x1b[32mOK\x1b[0m]" << std::endl; \
-    } while (0)
+	do { \
+		if (!_quiet) std::cout << "Test " << TESTNO << ":  [\x1b[32mOK\x1b[0m]" << std::endl; \
+	} while (0)
 
 #define HYPERDEX_TEST_FAIL(TESTNO, REASON) \
-    do { \
-        if (!_quiet) std::cout << "Test " << TESTNO << ":  [\x1b[31mFAIL\x1b[0m]\n" \
-                  << "location: " << __FILE__ << ":" << __LINE__ << "\n" \
-                  << "reason:  " << REASON << std::endl; \
-    abort(); \
-    } while (0)
+	do { \
+		if (!_quiet) std::cout << "Test " << TESTNO << ":  [\x1b[31mFAIL\x1b[0m]\n" \
+			                       << "location: " << __FILE__ << ":" << __LINE__ << "\n" \
+			                       << "reason:  " << REASON << std::endl; \
+		abort(); \
+	} while (0)
 
 #define SEARCH_STRESS_TIMEOUT(testno) (25000 * (1 + testno))
 
 static void
 empty(size_t testno,
-      hyperdex::Client* cl);
+      hyperdex::Client *cl);
 
 static void
 populate(size_t testno,
-         hyperdex::Client* cl);
+         hyperdex::Client *cl);
 
 static void
 search(size_t testno,
-       hyperdex::Client* cl,
-       const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-       const std::vector<bool>& expected);
+       hyperdex::Client *cl,
+       const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+       const std::vector<bool> &expected);
 
 static void
 sorted_search(size_t testno,
-              hyperdex::Client* cl,
-              const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-              const std::vector<bool>& expected);
+              hyperdex::Client *cl,
+              const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+              const std::vector<bool> &expected);
 
 static void
 group_del(size_t testno,
-          hyperdex::Client* cl,
-          const struct hyperdex_client_attribute_check* checks, size_t checks_sz);
+          hyperdex::Client *cl,
+          const struct hyperdex_client_attribute_check *checks, size_t checks_sz);
 
 static void
 count(size_t testno,
-      hyperdex::Client* cl,
-      const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
+      hyperdex::Client *cl,
+      const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
       size_t expected);
 
 static void
 all_search_tests(size_t testno,
-                 hyperdex::Client* cl,
-                 const std::vector<bool>& expecting);
+                 hyperdex::Client *cl,
+                 const std::vector<bool> &expecting);
 
 int
-test(hyperdex::Client* cl)
+test(hyperdex::Client *cl)
 {
-    group_del(16, cl, NULL, 0); // clear everything
-    srand(0xdeadbeef); // yes, I know rand+mod is suboptimal
-    hyperdex_client_attribute_check chk;
-    chk.datatype = HYPERDATATYPE_STRING;
-    chk.predicate = HYPERPREDICATE_EQUALS;
-
-    for (size_t testno = 0; testno < 10; ++testno)
-    {
-        // Check that we start out clean
-        empty(testno, cl);
-        // Populate with all items we expect
-        populate(testno, cl);
-        std::vector<bool> expecting(1ULL << testno, true);
-        all_search_tests(testno, cl, expecting);
-        // group_del everything that is even
-        chk.attr = _colnames[0];
-        chk.value = "0";
-        chk.value_sz = 1;
-        group_del(testno, cl, &chk, 1);
-
-        for (size_t i = 0; i < expecting.size(); ++i)
-        {
-            if (!(i & 1))
-            {
-                expecting[i] = false;
-            }
-        }
-
-        all_search_tests(testno, cl, expecting);
-        // take out the upper half of the objects
-        chk.attr = _colnames[testno > 0 ? testno - 1 : 0];
-        chk.value = "1";
-        chk.value_sz = 1;
-        group_del(testno, cl, &chk, 1);
-
-        for (size_t i = expecting.size() / 2; i < expecting.size(); ++i)
-        {
-            expecting[i] = false;
-        }
-
-        all_search_tests(testno, cl, expecting);
-        // take out the lower quarter of the objects
-        chk.attr = _colnames[testno > 1 ? testno - 2 : 0];
-        chk.value = "0";
-        chk.value_sz = 1;
-        group_del(testno, cl, &chk, 1);
-
-        for (size_t i = 0; i < expecting.size() / 4; ++i)
-        {
-            expecting[i] = false;
-        }
-
-        all_search_tests(testno, cl, expecting);
-        // Blow it all away
-        group_del(testno, cl, NULL, 0);
-        // Check to make sure everything is gone.
-        empty(testno, cl);
-        HYPERDEX_TEST_SUCCESS(testno);
-    }
-
-    return 0;
+	group_del(16, cl, NULL, 0); // clear everything
+	srand(0xdeadbeef); // yes, I know rand+mod is suboptimal
+	hyperdex_client_attribute_check chk;
+	chk.datatype = HYPERDATATYPE_STRING;
+	chk.predicate = HYPERPREDICATE_EQUALS;
+	for (size_t testno = 0; testno < 10; ++testno)
+	{
+		// Check that we start out clean
+		empty(testno, cl);
+		// Populate with all items we expect
+		populate(testno, cl);
+		std::vector<bool> expecting(1ULL << testno, true);
+		all_search_tests(testno, cl, expecting);
+		// group_del everything that is even
+		chk.attr = _colnames[0];
+		chk.value = "0";
+		chk.value_sz = 1;
+		group_del(testno, cl, &chk, 1);
+		for (size_t i = 0; i < expecting.size(); ++i)
+		{
+			if (!(i & 1))
+			{
+				expecting[i] = false;
+			}
+		}
+		all_search_tests(testno, cl, expecting);
+		// take out the upper half of the objects
+		chk.attr = _colnames[testno > 0 ? testno - 1 : 0];
+		chk.value = "1";
+		chk.value_sz = 1;
+		group_del(testno, cl, &chk, 1);
+		for (size_t i = expecting.size() / 2; i < expecting.size(); ++i)
+		{
+			expecting[i] = false;
+		}
+		all_search_tests(testno, cl, expecting);
+		// take out the lower quarter of the objects
+		chk.attr = _colnames[testno > 1 ? testno - 2 : 0];
+		chk.value = "0";
+		chk.value_sz = 1;
+		group_del(testno, cl, &chk, 1);
+		for (size_t i = 0; i < expecting.size() / 4; ++i)
+		{
+			expecting[i] = false;
+		}
+		all_search_tests(testno, cl, expecting);
+		// Blow it all away
+		group_del(testno, cl, NULL, 0);
+		// Check to make sure everything is gone.
+		empty(testno, cl);
+		HYPERDEX_TEST_SUCCESS(testno);
+	}
+	return 0;
 }
 
 void
 empty(size_t testno,
-      hyperdex::Client* cl)
+      hyperdex::Client *cl)
 {
-    count(testno, cl, NULL, 0, 0);
-    std::vector<bool> expected(1ULL << testno, false);
-    search(testno, cl, NULL, 0, expected);
-    sorted_search(testno, cl, NULL, 0, expected);
+	count(testno, cl, NULL, 0, 0);
+	std::vector<bool> expected(1ULL << testno, false);
+	search(testno, cl, NULL, 0, expected);
+	sorted_search(testno, cl, NULL, 0, expected);
 }
 
 static void
 populate(size_t testno,
-         hyperdex::Client* cl)
+         hyperdex::Client *cl)
 {
-    for (int64_t number = 0; number < (1LL << testno); ++number)
-    {
-        hyperdex_client_attribute attrs[32];
-
-        for (size_t i = 0; i < 32; ++i)
-        {
-            attrs[i].attr = _colnames[i];
-            attrs[i].datatype = HYPERDATATYPE_STRING;
-
-            if ((number & (1ULL << i)))
-            {
-                attrs[i].value = "1";
-                attrs[i].value_sz = 1;
-            }
-            else
-            {
-                attrs[i].value = "0";
-                attrs[i].value_sz = 1;
-            }
-        }
-
-        char buf[sizeof(uint64_t)];
-
-        if (_key_type == HYPERDATATYPE_STRING)
-        {
-            e::pack64be(number, buf);
-        }
-        else if (_key_type == HYPERDATATYPE_INT64)
-        {
-            e::pack64le(number, buf);
-        }
-        else
-        {
-            HYPERDEX_TEST_FAIL(testno, "unknown key datatype");
-        }
-
-        hyperdex_client_returncode pstatus;
-        int64_t pid = cl->put(_space, buf, sizeof(uint64_t), attrs, 32, &pstatus);
-
-        if (pid < 0)
-        {
-            HYPERDEX_TEST_FAIL(testno, "put encountered error " << pstatus << " (pid=" << pid << "): " << cl->error_message() << " at " << cl->error_location());
-        }
-
-        hyperdex_client_returncode lstatus;
-        int64_t lid = cl->loop(SEARCH_STRESS_TIMEOUT(testno), &lstatus);
-
-        if (lid < 0)
-        {
-            HYPERDEX_TEST_FAIL(testno, "loop returned error " << lstatus << ": " << cl->error_message() << " at " << cl->error_location());
-        }
-
-        if (pid != lid)
-        {
-            HYPERDEX_TEST_FAIL(testno, "loop id (" << lid << ") does not match put id (" << pid << ")");
-        }
-
-        if (pstatus != HYPERDEX_CLIENT_SUCCESS)
-        {
-            HYPERDEX_TEST_FAIL(testno, "operation " << pid << " (populate) returned " << pstatus << ": " << cl->error_message() << " at " << cl->error_location());
-        }
-    }
+	for (int64_t number = 0; number < (1LL << testno); ++number)
+	{
+		hyperdex_client_attribute attrs[32];
+		for (size_t i = 0; i < 32; ++i)
+		{
+			attrs[i].attr = _colnames[i];
+			attrs[i].datatype = HYPERDATATYPE_STRING;
+			if ((number & (1ULL << i)))
+			{
+				attrs[i].value = "1";
+				attrs[i].value_sz = 1;
+			}
+			else
+			{
+				attrs[i].value = "0";
+				attrs[i].value_sz = 1;
+			}
+		}
+		char buf[sizeof(uint64_t)];
+		if (_key_type == HYPERDATATYPE_STRING)
+		{
+			e::pack64be(number, buf);
+		}
+		else if (_key_type == HYPERDATATYPE_INT64)
+		{
+			e::pack64le(number, buf);
+		}
+		else
+		{
+			HYPERDEX_TEST_FAIL(testno, "unknown key datatype");
+		}
+		hyperdex_client_returncode pstatus;
+		int64_t pid = cl->put(_space, buf, sizeof(uint64_t), attrs, 32, &pstatus);
+		if (pid < 0)
+		{
+			HYPERDEX_TEST_FAIL(testno, "put encountered error " << pstatus << " (pid=" << pid << "): " << cl->error_message() << " at " << cl->error_location());
+		}
+		hyperdex_client_returncode lstatus;
+		int64_t lid = cl->loop(SEARCH_STRESS_TIMEOUT(testno), &lstatus);
+		if (lid < 0)
+		{
+			HYPERDEX_TEST_FAIL(testno, "loop returned error " << lstatus << ": " << cl->error_message() << " at " << cl->error_location());
+		}
+		if (pid != lid)
+		{
+			HYPERDEX_TEST_FAIL(testno, "loop id (" << lid << ") does not match put id (" << pid << ")");
+		}
+		if (pstatus != HYPERDEX_CLIENT_SUCCESS)
+		{
+			HYPERDEX_TEST_FAIL(testno, "operation " << pid << " (populate) returned " << pstatus << ": " << cl->error_message() << " at " << cl->error_location());
+		}
+	}
 }
 
 void
 search(size_t testno,
-       hyperdex::Client* cl,
-       const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-       const std::vector<bool>& expected)
+       hyperdex::Client *cl,
+       const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+       const std::vector<bool> &expected)
 {
-    std::vector<bool> seen(expected.size(), false);
-    const hyperdex_client_attribute* attrs;
-    size_t attrs_sz;
-    hyperdex_client_returncode sstatus = HYPERDEX_CLIENT_SUCCESS;
-    int64_t sid = cl->search(_space, checks, checks_sz, &sstatus, &attrs, &attrs_sz);
-
-    if (sid < 0)
-    {
-        HYPERDEX_TEST_FAIL(testno, "search encountered error " << sstatus << ": " << cl->error_message() << " at " << cl->error_location());
-    }
-
-    while (true)
-    {
-        hyperdex_client_returncode lstatus;
-        int64_t lid = cl->loop(SEARCH_STRESS_TIMEOUT(testno), &lstatus);
-
-        if (lid < 0)
-        {
-            HYPERDEX_TEST_FAIL(testno, "loop returned error " << lstatus << ": " << cl->error_message() << " at " << cl->error_location());
-        }
-
-        if (sid != lid)
-        {
-            HYPERDEX_TEST_FAIL(testno, "loop id (" << lid << ") does not match search id (" << sid << ")");
-        }
-
-        if (sstatus != HYPERDEX_CLIENT_SUCCESS && sstatus != HYPERDEX_CLIENT_SEARCHDONE)
-        {
-            HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (search) returned " << sstatus << ": " << cl->error_message() << " at " << cl->error_location());
-        }
-
-        if (sstatus == HYPERDEX_CLIENT_SUCCESS)
-        {
-            if (attrs_sz != 33)
-            {
-                HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (search) returned " << attrs_sz
-                                           << " attributes instead of 33");
-            }
-
-            if (strcmp(attrs[0].attr, "number") != 0)
-            {
-                HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (search) key was field \""
-                                           << attrs[0].attr << "\" but should have been field \"number\"");
-            }
-
-            if (attrs[0].value_sz != sizeof(uint64_t))
-            {
-                HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (search) key has size "
-                                           << attrs[0].value_sz << " bytes, but should be sizeof(int64_t)");
-            }
-
-            int64_t num = 0;
-
-            if (_key_type == HYPERDATATYPE_STRING)
-            {
-                e::unpack64be(attrs[0].value, &num);
-            }
-            else if (_key_type == HYPERDATATYPE_INT64)
-            {
-                e::unpack64le(attrs[0].value, &num);
-            }
-            else
-            {
-                HYPERDEX_TEST_FAIL(testno, "unknown key datatype");
-            }
-
-            if (num >= (1LL << testno))
-            {
-                HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (search) number " << num << " outside range");
-            }
-
-            if (seen[num])
-            {
-                HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (search) number " << num << " already seen");
-            }
-
-            seen[num] = true;
-
-            if (!expected[num])
-            {
-                HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (search) number " << num << " not expected");
-            }
-
-            for (size_t i = 0; i < 32; ++i)
-            {
-                if (strcmp(attrs[i + 1].attr, _colnames[i]) != 0)
-                {
-                    HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (search) key was field \""
-                                               << attrs[i + 1].attr << "\" but should have been field \""
-                                               << _colnames[i] << "\"");
-                }
-
-                if (attrs[i + 1].value_sz != 1)
-                {
-                    HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (search) attribute has size "
-                                               << attrs[i + 1].value_sz << " bytes, but should be 1");
-                }
-
-                if (*attrs[i + 1].value == '1')
-                {
-                    if (!(num & (1ULL << i)))
-                    {
-                        HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (search) bit " << i
-                                                   << " not set for number " << num);
-                    }
-                }
-                else if (*attrs[i + 1].value == '0')
-                {
-                    if ((num & (1ULL << i)))
-                    {
-                        HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (search) bit " << i
-                                                   << " set for number " << num);
-                    }
-                }
-                else
-                {
-                    HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (search) bit not '0' or '1' (is " << (int)*attrs[i + 1].value << "d)");
-                }
-            }
-        }
-
-        if (sstatus == HYPERDEX_CLIENT_SEARCHDONE)
-        {
-            break;
-        }
-    }
-
-    for (size_t i = 0; i < expected.size(); ++i)
-    {
-        if (expected[i] && !seen[i])
-        {
-            HYPERDEX_TEST_FAIL(testno, "search should have returned " << i << " but did not");
-        }
-    }
+	std::vector<bool> seen(expected.size(), false);
+	const hyperdex_client_attribute *attrs;
+	size_t attrs_sz;
+	hyperdex_client_returncode sstatus = HYPERDEX_CLIENT_SUCCESS;
+	int64_t sid = cl->search(_space, checks, checks_sz, &sstatus, &attrs, &attrs_sz);
+	if (sid < 0)
+	{
+		HYPERDEX_TEST_FAIL(testno, "search encountered error " << sstatus << ": " << cl->error_message() << " at " << cl->error_location());
+	}
+	while (true)
+	{
+		hyperdex_client_returncode lstatus;
+		int64_t lid = cl->loop(SEARCH_STRESS_TIMEOUT(testno), &lstatus);
+		if (lid < 0)
+		{
+			HYPERDEX_TEST_FAIL(testno, "loop returned error " << lstatus << ": " << cl->error_message() << " at " << cl->error_location());
+		}
+		if (sid != lid)
+		{
+			HYPERDEX_TEST_FAIL(testno, "loop id (" << lid << ") does not match search id (" << sid << ")");
+		}
+		if (sstatus != HYPERDEX_CLIENT_SUCCESS && sstatus != HYPERDEX_CLIENT_SEARCHDONE)
+		{
+			HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (search) returned " << sstatus << ": " << cl->error_message() << " at " << cl->error_location());
+		}
+		if (sstatus == HYPERDEX_CLIENT_SUCCESS)
+		{
+			if (attrs_sz != 33)
+			{
+				HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (search) returned " << attrs_sz
+				                   << " attributes instead of 33");
+			}
+			if (strcmp(attrs[0].attr, "number") != 0)
+			{
+				HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (search) key was field \""
+				                   << attrs[0].attr << "\" but should have been field \"number\"");
+			}
+			if (attrs[0].value_sz != sizeof(uint64_t))
+			{
+				HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (search) key has size "
+				                   << attrs[0].value_sz << " bytes, but should be sizeof(int64_t)");
+			}
+			int64_t num = 0;
+			if (_key_type == HYPERDATATYPE_STRING)
+			{
+				e::unpack64be(attrs[0].value, &num);
+			}
+			else if (_key_type == HYPERDATATYPE_INT64)
+			{
+				e::unpack64le(attrs[0].value, &num);
+			}
+			else
+			{
+				HYPERDEX_TEST_FAIL(testno, "unknown key datatype");
+			}
+			if (num >= (1LL << testno))
+			{
+				HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (search) number " << num << " outside range");
+			}
+			if (seen[num])
+			{
+				HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (search) number " << num << " already seen");
+			}
+			seen[num] = true;
+			if (!expected[num])
+			{
+				HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (search) number " << num << " not expected");
+			}
+			for (size_t i = 0; i < 32; ++i)
+			{
+				if (strcmp(attrs[i + 1].attr, _colnames[i]) != 0)
+				{
+					HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (search) key was field \""
+					                   << attrs[i + 1].attr << "\" but should have been field \""
+					                   << _colnames[i] << "\"");
+				}
+				if (attrs[i + 1].value_sz != 1)
+				{
+					HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (search) attribute has size "
+					                   << attrs[i + 1].value_sz << " bytes, but should be 1");
+				}
+				if (*attrs[i + 1].value == '1')
+				{
+					if (!(num & (1ULL << i)))
+					{
+						HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (search) bit " << i
+						                   << " not set for number " << num);
+					}
+				}
+				else if (*attrs[i + 1].value == '0')
+				{
+					if ((num & (1ULL << i)))
+					{
+						HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (search) bit " << i
+						                   << " set for number " << num);
+					}
+				}
+				else
+				{
+					HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (search) bit not '0' or '1' (is " << (int)*attrs[i + 1].value << "d)");
+				}
+			}
+		}
+		if (sstatus == HYPERDEX_CLIENT_SEARCHDONE)
+		{
+			break;
+		}
+	}
+	for (size_t i = 0; i < expected.size(); ++i)
+	{
+		if (expected[i] && !seen[i])
+		{
+			HYPERDEX_TEST_FAIL(testno, "search should have returned " << i << " but did not");
+		}
+	}
 }
 
 void
 sorted_search(size_t testno,
-              hyperdex::Client* cl,
-              const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
-              const std::vector<bool>& expected)
+              hyperdex::Client *cl,
+              const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
+              const std::vector<bool> &expected)
 {
-    std::vector<bool> seen(expected.size(), false);
-    const hyperdex_client_attribute* attrs;
-    size_t attrs_sz;
-    hyperdex_client_returncode sstatus = HYPERDEX_CLIENT_SUCCESS;
-    int64_t sid = cl->sorted_search(_space, checks, checks_sz, "number", 1ULL << testno, false, &sstatus, &attrs, &attrs_sz);
-
-    if (sid < 0)
-    {
-        HYPERDEX_TEST_FAIL(testno, "sorted_search encountered error " << sstatus << ": " << cl->error_message() << " at " << cl->error_location());
-    }
-
-    int64_t old_num = 0;
-
-    while (true)
-    {
-        hyperdex_client_returncode lstatus;
-        int64_t lid = cl->loop(SEARCH_STRESS_TIMEOUT(testno), &lstatus);
-
-        if (lid < 0)
-        {
-            HYPERDEX_TEST_FAIL(testno, "loop returned error " << lstatus << ": " << cl->error_message() << " at " << cl->error_location());
-        }
-
-        if (sid != lid)
-        {
-            HYPERDEX_TEST_FAIL(testno, "loop id (" << lid << ") does not match sorted_search id (" << sid << ")");
-        }
-
-        if (sstatus != HYPERDEX_CLIENT_SUCCESS && sstatus != HYPERDEX_CLIENT_SEARCHDONE)
-        {
-            HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (sorted_search) returned " << sstatus << ": " << cl->error_message() << " at " << cl->error_location());
-        }
-
-        if (sstatus == HYPERDEX_CLIENT_SUCCESS)
-        {
-            if (attrs_sz != 33)
-            {
-                HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (sorted_search) returned " << attrs_sz
-                                           << " attributes instead of 33");
-            }
-
-            if (strcmp(attrs[0].attr, "number") != 0)
-            {
-                HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (sorted_search) key was field \""
-                                           << attrs[0].attr << "\" but should have been field \"number\"");
-            }
-
-            if (attrs[0].value_sz != sizeof(uint64_t))
-            {
-                HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (sorted_search) key has size "
-                                           << attrs[0].value_sz << " bytes, but should be sizeof(int64_t)");
-            }
-
-            int64_t num = 0;
-
-            if (_key_type == HYPERDATATYPE_STRING)
-            {
-                e::unpack64be(attrs[0].value, &num);
-            }
-            else if (_key_type == HYPERDATATYPE_INT64)
-            {
-                e::unpack64le(attrs[0].value, &num);
-            }
-            else
-            {
-                HYPERDEX_TEST_FAIL(testno, "unknown key datatype");
-            }
-
-            if (num >= (1LL << testno))
-            {
-                HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (sorted_search) number " << num << " outside range");
-            }
-
-            if (num < old_num)
-            {
-                HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (sorted_search) number " << num << " out of order (prev was " << old_num << ")");
-            }
-
-            old_num = num;
-
-            if (seen[num])
-            {
-                HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (sorted_search) number " << num << " already seen");
-            }
-
-            seen[num] = true;
-
-            if (!expected[num])
-            {
-                HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (sorted_search) number " << num << " not expected");
-            }
-
-            for (size_t i = 0; i < 32; ++i)
-            {
-                if (strcmp(attrs[i + 1].attr, _colnames[i]) != 0)
-                {
-                    HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (sorted_search) key was field \""
-                                               << attrs[i + 1].attr << "\" but should have been field \""
-                                               << _colnames[i] << "\"");
-                }
-
-                if (attrs[i + 1].value_sz != 1)
-                {
-                    HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (sorted_search) attribute has size "
-                                               << attrs[i + 1].value_sz << " bytes, but should be 1");
-                }
-
-                if (*attrs[i + 1].value == '1')
-                {
-                    if (!(num & (1ULL << i)))
-                    {
-                        HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (sorted_search) bit " << i
-                                                   << " not set for number " << num);
-                    }
-                }
-                else if (*attrs[i + 1].value == '0')
-                {
-                    if ((num & (1ULL << i)))
-                    {
-                        HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (sorted_search) bit " << i
-                                                   << " set for number " << num);
-                    }
-                }
-                else
-                {
-                    HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (sorted_search) bit not '0' or '1' (is " << (int)*attrs[i + 1].value << "d)");
-                }
-            }
-        }
-
-        if (sstatus == HYPERDEX_CLIENT_SEARCHDONE)
-        {
-            break;
-        }
-    }
-
-    for (size_t i = 0; i < expected.size(); ++i)
-    {
-        if (expected[i] && !seen[i])
-        {
-            HYPERDEX_TEST_FAIL(testno, "sorted_search should have returned " << i << " but did not");
-        }
-    }
+	std::vector<bool> seen(expected.size(), false);
+	const hyperdex_client_attribute *attrs;
+	size_t attrs_sz;
+	hyperdex_client_returncode sstatus = HYPERDEX_CLIENT_SUCCESS;
+	int64_t sid = cl->sorted_search(_space, checks, checks_sz, "number", 1ULL << testno, false, &sstatus, &attrs, &attrs_sz);
+	if (sid < 0)
+	{
+		HYPERDEX_TEST_FAIL(testno, "sorted_search encountered error " << sstatus << ": " << cl->error_message() << " at " << cl->error_location());
+	}
+	int64_t old_num = 0;
+	while (true)
+	{
+		hyperdex_client_returncode lstatus;
+		int64_t lid = cl->loop(SEARCH_STRESS_TIMEOUT(testno), &lstatus);
+		if (lid < 0)
+		{
+			HYPERDEX_TEST_FAIL(testno, "loop returned error " << lstatus << ": " << cl->error_message() << " at " << cl->error_location());
+		}
+		if (sid != lid)
+		{
+			HYPERDEX_TEST_FAIL(testno, "loop id (" << lid << ") does not match sorted_search id (" << sid << ")");
+		}
+		if (sstatus != HYPERDEX_CLIENT_SUCCESS && sstatus != HYPERDEX_CLIENT_SEARCHDONE)
+		{
+			HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (sorted_search) returned " << sstatus << ": " << cl->error_message() << " at " << cl->error_location());
+		}
+		if (sstatus == HYPERDEX_CLIENT_SUCCESS)
+		{
+			if (attrs_sz != 33)
+			{
+				HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (sorted_search) returned " << attrs_sz
+				                   << " attributes instead of 33");
+			}
+			if (strcmp(attrs[0].attr, "number") != 0)
+			{
+				HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (sorted_search) key was field \""
+				                   << attrs[0].attr << "\" but should have been field \"number\"");
+			}
+			if (attrs[0].value_sz != sizeof(uint64_t))
+			{
+				HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (sorted_search) key has size "
+				                   << attrs[0].value_sz << " bytes, but should be sizeof(int64_t)");
+			}
+			int64_t num = 0;
+			if (_key_type == HYPERDATATYPE_STRING)
+			{
+				e::unpack64be(attrs[0].value, &num);
+			}
+			else if (_key_type == HYPERDATATYPE_INT64)
+			{
+				e::unpack64le(attrs[0].value, &num);
+			}
+			else
+			{
+				HYPERDEX_TEST_FAIL(testno, "unknown key datatype");
+			}
+			if (num >= (1LL << testno))
+			{
+				HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (sorted_search) number " << num << " outside range");
+			}
+			if (num < old_num)
+			{
+				HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (sorted_search) number " << num << " out of order (prev was " << old_num << ")");
+			}
+			old_num = num;
+			if (seen[num])
+			{
+				HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (sorted_search) number " << num << " already seen");
+			}
+			seen[num] = true;
+			if (!expected[num])
+			{
+				HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (sorted_search) number " << num << " not expected");
+			}
+			for (size_t i = 0; i < 32; ++i)
+			{
+				if (strcmp(attrs[i + 1].attr, _colnames[i]) != 0)
+				{
+					HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (sorted_search) key was field \""
+					                   << attrs[i + 1].attr << "\" but should have been field \""
+					                   << _colnames[i] << "\"");
+				}
+				if (attrs[i + 1].value_sz != 1)
+				{
+					HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (sorted_search) attribute has size "
+					                   << attrs[i + 1].value_sz << " bytes, but should be 1");
+				}
+				if (*attrs[i + 1].value == '1')
+				{
+					if (!(num & (1ULL << i)))
+					{
+						HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (sorted_search) bit " << i
+						                   << " not set for number " << num);
+					}
+				}
+				else if (*attrs[i + 1].value == '0')
+				{
+					if ((num & (1ULL << i)))
+					{
+						HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (sorted_search) bit " << i
+						                   << " set for number " << num);
+					}
+				}
+				else
+				{
+					HYPERDEX_TEST_FAIL(testno, "operation " << sid << " (sorted_search) bit not '0' or '1' (is " << (int)*attrs[i + 1].value << "d)");
+				}
+			}
+		}
+		if (sstatus == HYPERDEX_CLIENT_SEARCHDONE)
+		{
+			break;
+		}
+	}
+	for (size_t i = 0; i < expected.size(); ++i)
+	{
+		if (expected[i] && !seen[i])
+		{
+			HYPERDEX_TEST_FAIL(testno, "sorted_search should have returned " << i << " but did not");
+		}
+	}
 }
 
 static void
 group_del(size_t testno,
-          hyperdex::Client* cl,
-          const struct hyperdex_client_attribute_check* checks, size_t checks_sz)
+          hyperdex::Client *cl,
+          const struct hyperdex_client_attribute_check *checks, size_t checks_sz)
 {
-    hyperdex_client_returncode gstatus;
-    uint64_t count;
-    int64_t gid = cl->group_del(_space, checks, checks_sz, &gstatus, &count);
-
-    if (gid < 0)
-    {
-        HYPERDEX_TEST_FAIL(testno, "group_del encountered error " << gstatus << ": " << cl->error_message() << " at " << cl->error_location());
-    }
-
-    hyperdex_client_returncode lstatus;
-    int64_t lid = cl->loop(SEARCH_STRESS_TIMEOUT(testno), &lstatus);
-
-    if (lid < 0)
-    {
-        HYPERDEX_TEST_FAIL(testno, "loop returned error " << lstatus << ": " << cl->error_message() << " at " << cl->error_location());
-    }
-
-    if (gid != lid)
-    {
-        HYPERDEX_TEST_FAIL(testno, "loop id (" << lid << ") does not match group_del id (" << gid << ")");
-    }
-
-    if (gstatus != HYPERDEX_CLIENT_SUCCESS)
-    {
-        HYPERDEX_TEST_FAIL(testno, "operation " << gid << " (group_del) returned " << gstatus << ": " << cl->error_message() << " at " << cl->error_location());
-    }
-
-    uint64_t sleep = 10000000ULL;
-    sleep *= (1 + testno);
-    struct timespec ts;
-    ts.tv_sec = sleep / 1000000000ULL;
-    ts.tv_nsec = sleep % 1000000000ULL;
-    nanosleep(&ts, NULL);
+	hyperdex_client_returncode gstatus;
+	uint64_t count;
+	int64_t gid = cl->group_del(_space, checks, checks_sz, &gstatus, &count);
+	if (gid < 0)
+	{
+		HYPERDEX_TEST_FAIL(testno, "group_del encountered error " << gstatus << ": " << cl->error_message() << " at " << cl->error_location());
+	}
+	hyperdex_client_returncode lstatus;
+	int64_t lid = cl->loop(SEARCH_STRESS_TIMEOUT(testno), &lstatus);
+	if (lid < 0)
+	{
+		HYPERDEX_TEST_FAIL(testno, "loop returned error " << lstatus << ": " << cl->error_message() << " at " << cl->error_location());
+	}
+	if (gid != lid)
+	{
+		HYPERDEX_TEST_FAIL(testno, "loop id (" << lid << ") does not match group_del id (" << gid << ")");
+	}
+	if (gstatus != HYPERDEX_CLIENT_SUCCESS)
+	{
+		HYPERDEX_TEST_FAIL(testno, "operation " << gid << " (group_del) returned " << gstatus << ": " << cl->error_message() << " at " << cl->error_location());
+	}
+	uint64_t sleep = 10000000ULL;
+	sleep *= (1 + testno);
+	struct timespec ts;
+	ts.tv_sec = sleep / 1000000000ULL;
+	ts.tv_nsec = sleep % 1000000000ULL;
+	nanosleep(&ts, NULL);
 }
 
 static void
 count(size_t testno,
-      hyperdex::Client* cl,
-      const struct hyperdex_client_attribute_check* checks, size_t checks_sz,
+      hyperdex::Client *cl,
+      const struct hyperdex_client_attribute_check *checks, size_t checks_sz,
       size_t expected)
 {
-    uint64_t c = 0;
-    hyperdex_client_returncode cstatus;
-    int64_t cid = cl->count(_space, checks, checks_sz, &cstatus, &c);
-
-    if (cid < 0)
-    {
-        HYPERDEX_TEST_FAIL(testno, "count encountered error " << cstatus << ": " << cl->error_message() << " at " << cl->error_location());
-    }
-
-    hyperdex_client_returncode lstatus;
-    int64_t lid = cl->loop(SEARCH_STRESS_TIMEOUT(testno), &lstatus);
-
-    if (lid < 0)
-    {
-        HYPERDEX_TEST_FAIL(testno, "loop returned error " << lstatus << ": " << cl->error_message() << " at " << cl->error_location());
-    }
-
-    if (cid != lid)
-    {
-        HYPERDEX_TEST_FAIL(testno, "loop id (" << lid << ") does not match count id (" << cid << ")");
-    }
-
-    if (cstatus != HYPERDEX_CLIENT_SUCCESS)
-    {
-        HYPERDEX_TEST_FAIL(testno, "operation " << cid << " (count) returned " << cstatus << ": " << cl->error_message() << " at " << cl->error_location());
-    }
-
-    if (c != expected)
-    {
-        HYPERDEX_TEST_FAIL(testno, "counted " << c << " objects when we should have counted " << expected << " objects");
-    }
+	uint64_t c = 0;
+	hyperdex_client_returncode cstatus;
+	int64_t cid = cl->count(_space, checks, checks_sz, &cstatus, &c);
+	if (cid < 0)
+	{
+		HYPERDEX_TEST_FAIL(testno, "count encountered error " << cstatus << ": " << cl->error_message() << " at " << cl->error_location());
+	}
+	hyperdex_client_returncode lstatus;
+	int64_t lid = cl->loop(SEARCH_STRESS_TIMEOUT(testno), &lstatus);
+	if (lid < 0)
+	{
+		HYPERDEX_TEST_FAIL(testno, "loop returned error " << lstatus << ": " << cl->error_message() << " at " << cl->error_location());
+	}
+	if (cid != lid)
+	{
+		HYPERDEX_TEST_FAIL(testno, "loop id (" << lid << ") does not match count id (" << cid << ")");
+	}
+	if (cstatus != HYPERDEX_CLIENT_SUCCESS)
+	{
+		HYPERDEX_TEST_FAIL(testno, "operation " << cid << " (count) returned " << cstatus << ": " << cl->error_message() << " at " << cl->error_location());
+	}
+	if (c != expected)
+	{
+		HYPERDEX_TEST_FAIL(testno, "counted " << c << " objects when we should have counted " << expected << " objects");
+	}
 }
 
 static void
 setup_random_search(size_t,
-                    hyperdex_client_attribute_check* chks,
-                    size_t* chks_sz,
-                    std::vector<bool>* expecting)
+                    hyperdex_client_attribute_check *chks,
+                    size_t *chks_sz,
+                    std::vector<bool> *expecting)
 {
-    uint32_t mask = rand();
-    uint32_t bits = rand();
-    *chks_sz = 0;
-
-    for (size_t i = 0; i < 32; ++i)
-    {
-        if ((mask & (1ULL << i)))
-        {
-            chks[*chks_sz].attr = _colnames[i];
-
-            if ((bits & (1ULL << i)))
-            {
-                chks[*chks_sz].value = "1";
-            }
-            else
-            {
-                chks[*chks_sz].value = "0";
-            }
-
-            chks[*chks_sz].value_sz = 1;
-            chks[*chks_sz].datatype = HYPERDATATYPE_STRING;
-            chks[*chks_sz].predicate = HYPERPREDICATE_EQUALS;
-            ++(*chks_sz);
-        }
-    }
-
-    for (uint32_t i = 0; i < expecting->size(); ++i)
-    {
-        if ((mask & i) != (mask & bits))
-        {
-            (*expecting)[i] = false;
-        }
-    }
+	uint32_t mask = rand();
+	uint32_t bits = rand();
+	*chks_sz = 0;
+	for (size_t i = 0; i < 32; ++i)
+	{
+		if ((mask & (1ULL << i)))
+		{
+			chks[*chks_sz].attr = _colnames[i];
+			if ((bits & (1ULL << i)))
+			{
+				chks[*chks_sz].value = "1";
+			}
+			else
+			{
+				chks[*chks_sz].value = "0";
+			}
+			chks[*chks_sz].value_sz = 1;
+			chks[*chks_sz].datatype = HYPERDATATYPE_STRING;
+			chks[*chks_sz].predicate = HYPERPREDICATE_EQUALS;
+			++(*chks_sz);
+		}
+	}
+	for (uint32_t i = 0; i < expecting->size(); ++i)
+	{
+		if ((mask & i) != (mask & bits))
+		{
+			(*expecting)[i] = false;
+		}
+	}
 }
 
 void
 all_search_tests(size_t testno,
-                 hyperdex::Client* cl,
-                 const std::vector<bool>& expecting)
+                 hyperdex::Client *cl,
+                 const std::vector<bool> &expecting)
 {
-    struct timespec ts;
-    ts.tv_sec = 0;
-    ts.tv_nsec = 100 * 1000ULL * 1000ULL;
-    nanosleep(&ts, NULL);
-    search(testno, cl, NULL, 0, expecting);
-    sorted_search(testno, cl, NULL, 0, expecting);
-    size_t num = 0;
-
-    for (size_t i = 0; i < expecting.size(); ++i)
-    {
-        if (expecting[i])
-        {
-            ++num;
-        }
-    }
-
-    count(testno, cl, NULL, 0, num);
-    hyperdex_client_attribute_check chks[32];
-
-    for (size_t i = 0; i < _random_iters; ++i)
-    {
-        size_t chks_sz;
-        std::vector<bool> subset_expecting(expecting);
-        setup_random_search(testno, chks, &chks_sz, &subset_expecting);
-        search(testno, cl, chks, chks_sz, subset_expecting);
-        sorted_search(testno, cl, chks, chks_sz, subset_expecting);
-        num = 0;
-
-        for (size_t j = 0; j < subset_expecting.size(); ++j)
-        {
-            if (subset_expecting[j])
-            {
-                ++num;
-            }
-        }
-
-        count(testno, cl, chks, chks_sz, num);
-    }
+	struct timespec ts;
+	ts.tv_sec = 0;
+	ts.tv_nsec = 100 * 1000ULL * 1000ULL;
+	nanosleep(&ts, NULL);
+	search(testno, cl, NULL, 0, expecting);
+	sorted_search(testno, cl, NULL, 0, expecting);
+	size_t num = 0;
+	for (size_t i = 0; i < expecting.size(); ++i)
+	{
+		if (expecting[i])
+		{
+			++num;
+		}
+	}
+	count(testno, cl, NULL, 0, num);
+	hyperdex_client_attribute_check chks[32];
+	for (size_t i = 0; i < _random_iters; ++i)
+	{
+		size_t chks_sz;
+		std::vector<bool> subset_expecting(expecting);
+		setup_random_search(testno, chks, &chks_sz, &subset_expecting);
+		search(testno, cl, chks, chks_sz, subset_expecting);
+		sorted_search(testno, cl, chks, chks_sz, subset_expecting);
+		num = 0;
+		for (size_t j = 0; j < subset_expecting.size(); ++j)
+		{
+			if (subset_expecting[j])
+			{
+				++num;
+			}
+		}
+		count(testno, cl, chks, chks_sz, num);
+	}
 }
diff --git a/test/sh/bindings.go.Basic.sh b/test/sh/bindings.go.Basic.sh
new file mode 100755
index 000000000..a93b9a945
--- /dev/null
+++ b/test/sh/bindings.go.Basic.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attribute v" --daemons=1 -- \
+    go run test/go/Basic.go {HOST} {PORT}
diff --git a/test/sh/bindings.go.BasicSearch.sh b/test/sh/bindings.go.BasicSearch.sh
new file mode 100755
index 000000000..517ec4ed8
--- /dev/null
+++ b/test/sh/bindings.go.BasicSearch.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attribute v" --daemons=1 -- \
+    go run test/go/BasicSearch.go {HOST} {PORT}
diff --git a/test/sh/bindings.go.CondPut.sh b/test/sh/bindings.go.CondPut.sh
new file mode 100755
index 000000000..f8e2dd728
--- /dev/null
+++ b/test/sh/bindings.go.CondPut.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attribute v" --daemons=1 -- \
+    go run test/go/CondPut.go {HOST} {PORT}
diff --git a/test/sh/bindings.go.DataTypeFloat.sh b/test/sh/bindings.go.DataTypeFloat.sh
new file mode 100755
index 000000000..fbd8666c4
--- /dev/null
+++ b/test/sh/bindings.go.DataTypeFloat.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes float v" --daemons=1 -- \
+    go run test/go/DataTypeFloat.go {HOST} {PORT}
diff --git a/test/sh/bindings.go.DataTypeInt.sh b/test/sh/bindings.go.DataTypeInt.sh
new file mode 100755
index 000000000..5494435e8
--- /dev/null
+++ b/test/sh/bindings.go.DataTypeInt.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes int v" --daemons=1 -- \
+    go run test/go/DataTypeInt.go {HOST} {PORT}
diff --git a/test/sh/bindings.go.DataTypeListFloat.sh b/test/sh/bindings.go.DataTypeListFloat.sh
new file mode 100755
index 000000000..3391ad545
--- /dev/null
+++ b/test/sh/bindings.go.DataTypeListFloat.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes list(float) v" --daemons=1 -- \
+    go run test/go/DataTypeListFloat.go {HOST} {PORT}
diff --git a/test/sh/bindings.go.DataTypeListInt.sh b/test/sh/bindings.go.DataTypeListInt.sh
new file mode 100755
index 000000000..2e863b151
--- /dev/null
+++ b/test/sh/bindings.go.DataTypeListInt.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes list(int) v" --daemons=1 -- \
+    go run test/go/DataTypeListInt.go {HOST} {PORT}
diff --git a/test/sh/bindings.go.DataTypeListString.sh b/test/sh/bindings.go.DataTypeListString.sh
new file mode 100755
index 000000000..8e0b8663f
--- /dev/null
+++ b/test/sh/bindings.go.DataTypeListString.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes list(string) v" --daemons=1 -- \
+    go run test/go/DataTypeListString.go {HOST} {PORT}
diff --git a/test/sh/bindings.go.DataTypeMapFloatFloat.sh b/test/sh/bindings.go.DataTypeMapFloatFloat.sh
new file mode 100755
index 000000000..514e4c78c
--- /dev/null
+++ b/test/sh/bindings.go.DataTypeMapFloatFloat.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes map(float, float) v" --daemons=1 -- \
+    go run test/go/DataTypeMapFloatFloat.go {HOST} {PORT}
diff --git a/test/sh/bindings.go.DataTypeMapFloatInt.sh b/test/sh/bindings.go.DataTypeMapFloatInt.sh
new file mode 100755
index 000000000..5c0482c4f
--- /dev/null
+++ b/test/sh/bindings.go.DataTypeMapFloatInt.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes map(float, int) v" --daemons=1 -- \
+    go run test/go/DataTypeMapFloatInt.go {HOST} {PORT}
diff --git a/test/sh/bindings.go.DataTypeMapFloatString.sh b/test/sh/bindings.go.DataTypeMapFloatString.sh
new file mode 100755
index 000000000..7abd3bea4
--- /dev/null
+++ b/test/sh/bindings.go.DataTypeMapFloatString.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes map(float, string) v" --daemons=1 -- \
+    go run test/go/DataTypeMapFloatString.go {HOST} {PORT}
diff --git a/test/sh/bindings.go.DataTypeMapIntFloat.sh b/test/sh/bindings.go.DataTypeMapIntFloat.sh
new file mode 100755
index 000000000..434320d98
--- /dev/null
+++ b/test/sh/bindings.go.DataTypeMapIntFloat.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes map(int, float) v" --daemons=1 -- \
+    go run test/go/DataTypeMapIntFloat.go {HOST} {PORT}
diff --git a/test/sh/bindings.go.DataTypeMapIntInt.sh b/test/sh/bindings.go.DataTypeMapIntInt.sh
new file mode 100755
index 000000000..6fdb202ff
--- /dev/null
+++ b/test/sh/bindings.go.DataTypeMapIntInt.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes map(int, int) v" --daemons=1 -- \
+    go run test/go/DataTypeMapIntInt.go {HOST} {PORT}
diff --git a/test/sh/bindings.go.DataTypeMapIntString.sh b/test/sh/bindings.go.DataTypeMapIntString.sh
new file mode 100755
index 000000000..f0380edb2
--- /dev/null
+++ b/test/sh/bindings.go.DataTypeMapIntString.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes map(int, string) v" --daemons=1 -- \
+    go run test/go/DataTypeMapIntString.go {HOST} {PORT}
diff --git a/test/sh/bindings.go.DataTypeMapStringFloat.sh b/test/sh/bindings.go.DataTypeMapStringFloat.sh
new file mode 100755
index 000000000..271a107fa
--- /dev/null
+++ b/test/sh/bindings.go.DataTypeMapStringFloat.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes map(string, float) v" --daemons=1 -- \
+    go run test/go/DataTypeMapStringFloat.go {HOST} {PORT}
diff --git a/test/sh/bindings.go.DataTypeMapStringInt.sh b/test/sh/bindings.go.DataTypeMapStringInt.sh
new file mode 100755
index 000000000..c898b5737
--- /dev/null
+++ b/test/sh/bindings.go.DataTypeMapStringInt.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes map(string, int) v" --daemons=1 -- \
+    go run test/go/DataTypeMapStringInt.go {HOST} {PORT}
diff --git a/test/sh/bindings.go.DataTypeMapStringString.sh b/test/sh/bindings.go.DataTypeMapStringString.sh
new file mode 100755
index 000000000..90b90815a
--- /dev/null
+++ b/test/sh/bindings.go.DataTypeMapStringString.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes map(string, string) v" --daemons=1 -- \
+    go run test/go/DataTypeMapStringString.go {HOST} {PORT}
diff --git a/test/sh/bindings.go.DataTypeSetFloat.sh b/test/sh/bindings.go.DataTypeSetFloat.sh
new file mode 100755
index 000000000..cc015ac6b
--- /dev/null
+++ b/test/sh/bindings.go.DataTypeSetFloat.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes set(float) v" --daemons=1 -- \
+    go run test/go/DataTypeSetFloat.go {HOST} {PORT}
diff --git a/test/sh/bindings.go.DataTypeSetInt.sh b/test/sh/bindings.go.DataTypeSetInt.sh
new file mode 100755
index 000000000..2f1b803dc
--- /dev/null
+++ b/test/sh/bindings.go.DataTypeSetInt.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes set(int) v" --daemons=1 -- \
+    go run test/go/DataTypeSetInt.go {HOST} {PORT}
diff --git a/test/sh/bindings.go.DataTypeSetString.sh b/test/sh/bindings.go.DataTypeSetString.sh
new file mode 100755
index 000000000..f8f148254
--- /dev/null
+++ b/test/sh/bindings.go.DataTypeSetString.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes set(string) v" --daemons=1 -- \
+    go run test/go/DataTypeSetString.go {HOST} {PORT}
diff --git a/test/sh/bindings.go.DataTypeString.sh b/test/sh/bindings.go.DataTypeString.sh
new file mode 100755
index 000000000..df3d02011
--- /dev/null
+++ b/test/sh/bindings.go.DataTypeString.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes v" --daemons=1 -- \
+    go run test/go/DataTypeString.go {HOST} {PORT}
diff --git a/test/sh/bindings.go.LengthString.sh b/test/sh/bindings.go.LengthString.sh
new file mode 100755
index 000000000..ec32fd8e4
--- /dev/null
+++ b/test/sh/bindings.go.LengthString.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k" --daemons=1 -- \
+    go run test/go/LengthString.go {HOST} {PORT}
diff --git a/test/sh/bindings.go.MultiAttribute.sh b/test/sh/bindings.go.MultiAttribute.sh
new file mode 100755
index 000000000..981219cfe
--- /dev/null
+++ b/test/sh/bindings.go.MultiAttribute.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes v1, v2" --daemons=1 -- \
+    go run test/go/MultiAttribute.go {HOST} {PORT}
diff --git a/test/sh/bindings.go.RangeSearchInt.sh b/test/sh/bindings.go.RangeSearchInt.sh
new file mode 100755
index 000000000..08e51dabe
--- /dev/null
+++ b/test/sh/bindings.go.RangeSearchInt.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key int k attribute int v" --daemons=1 -- \
+    go run test/go/RangeSearchInt.go {HOST} {PORT}
diff --git a/test/sh/bindings.go.RangeSearchString.sh b/test/sh/bindings.go.RangeSearchString.sh
new file mode 100755
index 000000000..8a4312eef
--- /dev/null
+++ b/test/sh/bindings.go.RangeSearchString.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attribute v" --daemons=1 -- \
+    go run test/go/RangeSearchString.go {HOST} {PORT}
diff --git a/test/sh/bindings.go.RegexSearch.sh b/test/sh/bindings.go.RegexSearch.sh
new file mode 100755
index 000000000..9d75e80c0
--- /dev/null
+++ b/test/sh/bindings.go.RegexSearch.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k" --daemons=1 -- \
+    go run test/go/RegexSearch.go {HOST} {PORT}
diff --git a/test/sh/bindings.java.Basic.sh b/test/sh/bindings.java.Basic.sh
new file mode 100755
index 000000000..b8fd055d4
--- /dev/null
+++ b/test/sh/bindings.java.Basic.sh
@@ -0,0 +1,5 @@
+#!/bin/sh
+javac -d "${HYPERDEX_BUILDDIR}"/test/java "${HYPERDEX_SRCDIR}"/test/java/Basic.java
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attribute v" --daemons=1 -- \
+    java -ea -Djava.library.path="${HYPERDEX_BUILDDIR}"/.libs:/usr/local/lib:/usr/local/lib64:/usr/lib:/usr/lib64 Basic {HOST} {PORT}
diff --git a/test/sh/bindings.java.BasicSearch.sh b/test/sh/bindings.java.BasicSearch.sh
new file mode 100755
index 000000000..ed14dfaa4
--- /dev/null
+++ b/test/sh/bindings.java.BasicSearch.sh
@@ -0,0 +1,5 @@
+#!/bin/sh
+javac -d "${HYPERDEX_BUILDDIR}"/test/java "${HYPERDEX_SRCDIR}"/test/java/BasicSearch.java
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attribute v" --daemons=1 -- \
+    java -ea -Djava.library.path="${HYPERDEX_BUILDDIR}"/.libs:/usr/local/lib:/usr/local/lib64:/usr/lib:/usr/lib64 BasicSearch {HOST} {PORT}
diff --git a/test/sh/bindings.java.CondPut.sh b/test/sh/bindings.java.CondPut.sh
new file mode 100755
index 000000000..6c21589d8
--- /dev/null
+++ b/test/sh/bindings.java.CondPut.sh
@@ -0,0 +1,5 @@
+#!/bin/sh
+javac -d "${HYPERDEX_BUILDDIR}"/test/java "${HYPERDEX_SRCDIR}"/test/java/CondPut.java
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attribute v" --daemons=1 -- \
+    java -ea -Djava.library.path="${HYPERDEX_BUILDDIR}"/.libs:/usr/local/lib:/usr/local/lib64:/usr/lib:/usr/lib64 CondPut {HOST} {PORT}
diff --git a/test/sh/bindings.java.DataTypeFloat.sh b/test/sh/bindings.java.DataTypeFloat.sh
new file mode 100755
index 000000000..da1197208
--- /dev/null
+++ b/test/sh/bindings.java.DataTypeFloat.sh
@@ -0,0 +1,5 @@
+#!/bin/sh
+javac -d "${HYPERDEX_BUILDDIR}"/test/java "${HYPERDEX_SRCDIR}"/test/java/DataTypeFloat.java
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes float v" --daemons=1 -- \
+    java -ea -Djava.library.path="${HYPERDEX_BUILDDIR}"/.libs:/usr/local/lib:/usr/local/lib64:/usr/lib:/usr/lib64 DataTypeFloat {HOST} {PORT}
diff --git a/test/sh/bindings.java.DataTypeInt.sh b/test/sh/bindings.java.DataTypeInt.sh
new file mode 100755
index 000000000..563abce98
--- /dev/null
+++ b/test/sh/bindings.java.DataTypeInt.sh
@@ -0,0 +1,5 @@
+#!/bin/sh
+javac -d "${HYPERDEX_BUILDDIR}"/test/java "${HYPERDEX_SRCDIR}"/test/java/DataTypeInt.java
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes int v" --daemons=1 -- \
+    java -ea -Djava.library.path="${HYPERDEX_BUILDDIR}"/.libs:/usr/local/lib:/usr/local/lib64:/usr/lib:/usr/lib64 DataTypeInt {HOST} {PORT}
diff --git a/test/sh/bindings.java.DataTypeListFloat.sh b/test/sh/bindings.java.DataTypeListFloat.sh
new file mode 100755
index 000000000..a3157af7a
--- /dev/null
+++ b/test/sh/bindings.java.DataTypeListFloat.sh
@@ -0,0 +1,5 @@
+#!/bin/sh
+javac -d "${HYPERDEX_BUILDDIR}"/test/java "${HYPERDEX_SRCDIR}"/test/java/DataTypeListFloat.java
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes list(float) v" --daemons=1 -- \
+    java -ea -Djava.library.path="${HYPERDEX_BUILDDIR}"/.libs:/usr/local/lib:/usr/local/lib64:/usr/lib:/usr/lib64 DataTypeListFloat {HOST} {PORT}
diff --git a/test/sh/bindings.java.DataTypeListInt.sh b/test/sh/bindings.java.DataTypeListInt.sh
new file mode 100755
index 000000000..c23687e03
--- /dev/null
+++ b/test/sh/bindings.java.DataTypeListInt.sh
@@ -0,0 +1,5 @@
+#!/bin/sh
+javac -d "${HYPERDEX_BUILDDIR}"/test/java "${HYPERDEX_SRCDIR}"/test/java/DataTypeListInt.java
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes list(int) v" --daemons=1 -- \
+    java -ea -Djava.library.path="${HYPERDEX_BUILDDIR}"/.libs:/usr/local/lib:/usr/local/lib64:/usr/lib:/usr/lib64 DataTypeListInt {HOST} {PORT}
diff --git a/test/sh/bindings.java.DataTypeListString.sh b/test/sh/bindings.java.DataTypeListString.sh
new file mode 100755
index 000000000..800ed7b19
--- /dev/null
+++ b/test/sh/bindings.java.DataTypeListString.sh
@@ -0,0 +1,5 @@
+#!/bin/sh
+javac -d "${HYPERDEX_BUILDDIR}"/test/java "${HYPERDEX_SRCDIR}"/test/java/DataTypeListString.java
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes list(string) v" --daemons=1 -- \
+    java -ea -Djava.library.path="${HYPERDEX_BUILDDIR}"/.libs:/usr/local/lib:/usr/local/lib64:/usr/lib:/usr/lib64 DataTypeListString {HOST} {PORT}
diff --git a/test/sh/bindings.java.DataTypeMapFloatFloat.sh b/test/sh/bindings.java.DataTypeMapFloatFloat.sh
new file mode 100755
index 000000000..c3eb66b91
--- /dev/null
+++ b/test/sh/bindings.java.DataTypeMapFloatFloat.sh
@@ -0,0 +1,5 @@
+#!/bin/sh
+javac -d "${HYPERDEX_BUILDDIR}"/test/java "${HYPERDEX_SRCDIR}"/test/java/DataTypeMapFloatFloat.java
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes map(float, float) v" --daemons=1 -- \
+    java -ea -Djava.library.path="${HYPERDEX_BUILDDIR}"/.libs:/usr/local/lib:/usr/local/lib64:/usr/lib:/usr/lib64 DataTypeMapFloatFloat {HOST} {PORT}
diff --git a/test/sh/bindings.java.DataTypeMapFloatInt.sh b/test/sh/bindings.java.DataTypeMapFloatInt.sh
new file mode 100755
index 000000000..0762bb1b2
--- /dev/null
+++ b/test/sh/bindings.java.DataTypeMapFloatInt.sh
@@ -0,0 +1,5 @@
+#!/bin/sh
+javac -d "${HYPERDEX_BUILDDIR}"/test/java "${HYPERDEX_SRCDIR}"/test/java/DataTypeMapFloatInt.java
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes map(float, int) v" --daemons=1 -- \
+    java -ea -Djava.library.path="${HYPERDEX_BUILDDIR}"/.libs:/usr/local/lib:/usr/local/lib64:/usr/lib:/usr/lib64 DataTypeMapFloatInt {HOST} {PORT}
diff --git a/test/sh/bindings.java.DataTypeMapFloatString.sh b/test/sh/bindings.java.DataTypeMapFloatString.sh
new file mode 100755
index 000000000..cb919c298
--- /dev/null
+++ b/test/sh/bindings.java.DataTypeMapFloatString.sh
@@ -0,0 +1,5 @@
+#!/bin/sh
+javac -d "${HYPERDEX_BUILDDIR}"/test/java "${HYPERDEX_SRCDIR}"/test/java/DataTypeMapFloatString.java
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes map(float, string) v" --daemons=1 -- \
+    java -ea -Djava.library.path="${HYPERDEX_BUILDDIR}"/.libs:/usr/local/lib:/usr/local/lib64:/usr/lib:/usr/lib64 DataTypeMapFloatString {HOST} {PORT}
diff --git a/test/sh/bindings.java.DataTypeMapIntFloat.sh b/test/sh/bindings.java.DataTypeMapIntFloat.sh
new file mode 100755
index 000000000..d68d67a35
--- /dev/null
+++ b/test/sh/bindings.java.DataTypeMapIntFloat.sh
@@ -0,0 +1,5 @@
+#!/bin/sh
+javac -d "${HYPERDEX_BUILDDIR}"/test/java "${HYPERDEX_SRCDIR}"/test/java/DataTypeMapIntFloat.java
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes map(int, float) v" --daemons=1 -- \
+    java -ea -Djava.library.path="${HYPERDEX_BUILDDIR}"/.libs:/usr/local/lib:/usr/local/lib64:/usr/lib:/usr/lib64 DataTypeMapIntFloat {HOST} {PORT}
diff --git a/test/sh/bindings.java.DataTypeMapIntInt.sh b/test/sh/bindings.java.DataTypeMapIntInt.sh
new file mode 100755
index 000000000..3106313f1
--- /dev/null
+++ b/test/sh/bindings.java.DataTypeMapIntInt.sh
@@ -0,0 +1,5 @@
+#!/bin/sh
+javac -d "${HYPERDEX_BUILDDIR}"/test/java "${HYPERDEX_SRCDIR}"/test/java/DataTypeMapIntInt.java
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes map(int, int) v" --daemons=1 -- \
+    java -ea -Djava.library.path="${HYPERDEX_BUILDDIR}"/.libs:/usr/local/lib:/usr/local/lib64:/usr/lib:/usr/lib64 DataTypeMapIntInt {HOST} {PORT}
diff --git a/test/sh/bindings.java.DataTypeMapIntString.sh b/test/sh/bindings.java.DataTypeMapIntString.sh
new file mode 100755
index 000000000..814293097
--- /dev/null
+++ b/test/sh/bindings.java.DataTypeMapIntString.sh
@@ -0,0 +1,5 @@
+#!/bin/sh
+javac -d "${HYPERDEX_BUILDDIR}"/test/java "${HYPERDEX_SRCDIR}"/test/java/DataTypeMapIntString.java
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes map(int, string) v" --daemons=1 -- \
+    java -ea -Djava.library.path="${HYPERDEX_BUILDDIR}"/.libs:/usr/local/lib:/usr/local/lib64:/usr/lib:/usr/lib64 DataTypeMapIntString {HOST} {PORT}
diff --git a/test/sh/bindings.java.DataTypeMapStringFloat.sh b/test/sh/bindings.java.DataTypeMapStringFloat.sh
new file mode 100755
index 000000000..ca6041030
--- /dev/null
+++ b/test/sh/bindings.java.DataTypeMapStringFloat.sh
@@ -0,0 +1,5 @@
+#!/bin/sh
+javac -d "${HYPERDEX_BUILDDIR}"/test/java "${HYPERDEX_SRCDIR}"/test/java/DataTypeMapStringFloat.java
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes map(string, float) v" --daemons=1 -- \
+    java -ea -Djava.library.path="${HYPERDEX_BUILDDIR}"/.libs:/usr/local/lib:/usr/local/lib64:/usr/lib:/usr/lib64 DataTypeMapStringFloat {HOST} {PORT}
diff --git a/test/sh/bindings.java.DataTypeMapStringInt.sh b/test/sh/bindings.java.DataTypeMapStringInt.sh
new file mode 100755
index 000000000..e1b77eb33
--- /dev/null
+++ b/test/sh/bindings.java.DataTypeMapStringInt.sh
@@ -0,0 +1,5 @@
+#!/bin/sh
+javac -d "${HYPERDEX_BUILDDIR}"/test/java "${HYPERDEX_SRCDIR}"/test/java/DataTypeMapStringInt.java
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes map(string, int) v" --daemons=1 -- \
+    java -ea -Djava.library.path="${HYPERDEX_BUILDDIR}"/.libs:/usr/local/lib:/usr/local/lib64:/usr/lib:/usr/lib64 DataTypeMapStringInt {HOST} {PORT}
diff --git a/test/sh/bindings.java.DataTypeMapStringString.sh b/test/sh/bindings.java.DataTypeMapStringString.sh
new file mode 100755
index 000000000..7767fee3d
--- /dev/null
+++ b/test/sh/bindings.java.DataTypeMapStringString.sh
@@ -0,0 +1,5 @@
+#!/bin/sh
+javac -d "${HYPERDEX_BUILDDIR}"/test/java "${HYPERDEX_SRCDIR}"/test/java/DataTypeMapStringString.java
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes map(string, string) v" --daemons=1 -- \
+    java -ea -Djava.library.path="${HYPERDEX_BUILDDIR}"/.libs:/usr/local/lib:/usr/local/lib64:/usr/lib:/usr/lib64 DataTypeMapStringString {HOST} {PORT}
diff --git a/test/sh/bindings.java.DataTypeSetFloat.sh b/test/sh/bindings.java.DataTypeSetFloat.sh
new file mode 100755
index 000000000..1243976e0
--- /dev/null
+++ b/test/sh/bindings.java.DataTypeSetFloat.sh
@@ -0,0 +1,5 @@
+#!/bin/sh
+javac -d "${HYPERDEX_BUILDDIR}"/test/java "${HYPERDEX_SRCDIR}"/test/java/DataTypeSetFloat.java
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes set(float) v" --daemons=1 -- \
+    java -ea -Djava.library.path="${HYPERDEX_BUILDDIR}"/.libs:/usr/local/lib:/usr/local/lib64:/usr/lib:/usr/lib64 DataTypeSetFloat {HOST} {PORT}
diff --git a/test/sh/bindings.java.DataTypeSetInt.sh b/test/sh/bindings.java.DataTypeSetInt.sh
new file mode 100755
index 000000000..53fcabb2a
--- /dev/null
+++ b/test/sh/bindings.java.DataTypeSetInt.sh
@@ -0,0 +1,5 @@
+#!/bin/sh
+javac -d "${HYPERDEX_BUILDDIR}"/test/java "${HYPERDEX_SRCDIR}"/test/java/DataTypeSetInt.java
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes set(int) v" --daemons=1 -- \
+    java -ea -Djava.library.path="${HYPERDEX_BUILDDIR}"/.libs:/usr/local/lib:/usr/local/lib64:/usr/lib:/usr/lib64 DataTypeSetInt {HOST} {PORT}
diff --git a/test/sh/bindings.java.DataTypeSetString.sh b/test/sh/bindings.java.DataTypeSetString.sh
new file mode 100755
index 000000000..2765a3afb
--- /dev/null
+++ b/test/sh/bindings.java.DataTypeSetString.sh
@@ -0,0 +1,5 @@
+#!/bin/sh
+javac -d "${HYPERDEX_BUILDDIR}"/test/java "${HYPERDEX_SRCDIR}"/test/java/DataTypeSetString.java
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes set(string) v" --daemons=1 -- \
+    java -ea -Djava.library.path="${HYPERDEX_BUILDDIR}"/.libs:/usr/local/lib:/usr/local/lib64:/usr/lib:/usr/lib64 DataTypeSetString {HOST} {PORT}
diff --git a/test/sh/bindings.java.DataTypeString.sh b/test/sh/bindings.java.DataTypeString.sh
new file mode 100755
index 000000000..ccd8f4825
--- /dev/null
+++ b/test/sh/bindings.java.DataTypeString.sh
@@ -0,0 +1,5 @@
+#!/bin/sh
+javac -d "${HYPERDEX_BUILDDIR}"/test/java "${HYPERDEX_SRCDIR}"/test/java/DataTypeString.java
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes v" --daemons=1 -- \
+    java -ea -Djava.library.path="${HYPERDEX_BUILDDIR}"/.libs:/usr/local/lib:/usr/local/lib64:/usr/lib:/usr/lib64 DataTypeString {HOST} {PORT}
diff --git a/test/sh/bindings.java.LengthString.sh b/test/sh/bindings.java.LengthString.sh
new file mode 100755
index 000000000..c8544d72e
--- /dev/null
+++ b/test/sh/bindings.java.LengthString.sh
@@ -0,0 +1,5 @@
+#!/bin/sh
+javac -d "${HYPERDEX_BUILDDIR}"/test/java "${HYPERDEX_SRCDIR}"/test/java/LengthString.java
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k" --daemons=1 -- \
+    java -ea -Djava.library.path="${HYPERDEX_BUILDDIR}"/.libs:/usr/local/lib:/usr/local/lib64:/usr/lib:/usr/lib64 LengthString {HOST} {PORT}
diff --git a/test/sh/bindings.java.MultiAttribute.sh b/test/sh/bindings.java.MultiAttribute.sh
new file mode 100755
index 000000000..49a37f844
--- /dev/null
+++ b/test/sh/bindings.java.MultiAttribute.sh
@@ -0,0 +1,5 @@
+#!/bin/sh
+javac -d "${HYPERDEX_BUILDDIR}"/test/java "${HYPERDEX_SRCDIR}"/test/java/MultiAttribute.java
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes v1, v2" --daemons=1 -- \
+    java -ea -Djava.library.path="${HYPERDEX_BUILDDIR}"/.libs:/usr/local/lib:/usr/local/lib64:/usr/lib:/usr/lib64 MultiAttribute {HOST} {PORT}
diff --git a/test/sh/bindings.java.RangeSearchInt.sh b/test/sh/bindings.java.RangeSearchInt.sh
new file mode 100755
index 000000000..16b046036
--- /dev/null
+++ b/test/sh/bindings.java.RangeSearchInt.sh
@@ -0,0 +1,5 @@
+#!/bin/sh
+javac -d "${HYPERDEX_BUILDDIR}"/test/java "${HYPERDEX_SRCDIR}"/test/java/RangeSearchInt.java
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key int k attribute int v" --daemons=1 -- \
+    java -ea -Djava.library.path="${HYPERDEX_BUILDDIR}"/.libs:/usr/local/lib:/usr/local/lib64:/usr/lib:/usr/lib64 RangeSearchInt {HOST} {PORT}
diff --git a/test/sh/bindings.java.RangeSearchString.sh b/test/sh/bindings.java.RangeSearchString.sh
new file mode 100755
index 000000000..16ed9a013
--- /dev/null
+++ b/test/sh/bindings.java.RangeSearchString.sh
@@ -0,0 +1,5 @@
+#!/bin/sh
+javac -d "${HYPERDEX_BUILDDIR}"/test/java "${HYPERDEX_SRCDIR}"/test/java/RangeSearchString.java
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attribute v" --daemons=1 -- \
+    java -ea -Djava.library.path="${HYPERDEX_BUILDDIR}"/.libs:/usr/local/lib:/usr/local/lib64:/usr/lib:/usr/lib64 RangeSearchString {HOST} {PORT}
diff --git a/test/sh/bindings.java.RegexSearch.sh b/test/sh/bindings.java.RegexSearch.sh
new file mode 100755
index 000000000..69d31b020
--- /dev/null
+++ b/test/sh/bindings.java.RegexSearch.sh
@@ -0,0 +1,5 @@
+#!/bin/sh
+javac -d "${HYPERDEX_BUILDDIR}"/test/java "${HYPERDEX_SRCDIR}"/test/java/RegexSearch.java
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k" --daemons=1 -- \
+    java -ea -Djava.library.path="${HYPERDEX_BUILDDIR}"/.libs:/usr/local/lib:/usr/local/lib64:/usr/lib:/usr/lib64 RegexSearch {HOST} {PORT}
diff --git a/test/sh/bindings.python.Admin.sh b/test/sh/bindings.python.Admin.sh
new file mode 100755
index 000000000..982873e43
--- /dev/null
+++ b/test/sh/bindings.python.Admin.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=1 -- \
+    python2 "${HYPERDEX_SRCDIR}"/test/python/Admin.py {HOST} {PORT}
diff --git a/test/sh/bindings.python.Basic.sh b/test/sh/bindings.python.Basic.sh
new file mode 100755
index 000000000..1a1d82e7f
--- /dev/null
+++ b/test/sh/bindings.python.Basic.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attribute v" --daemons=1 -- \
+    python2 "${HYPERDEX_SRCDIR}"/test/python/Basic.py {HOST} {PORT}
diff --git a/test/sh/bindings.python.BasicSearch.sh b/test/sh/bindings.python.BasicSearch.sh
new file mode 100755
index 000000000..325aaea11
--- /dev/null
+++ b/test/sh/bindings.python.BasicSearch.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attribute v" --daemons=1 -- \
+    python2 "${HYPERDEX_SRCDIR}"/test/python/BasicSearch.py {HOST} {PORT}
diff --git a/test/sh/bindings.python.CondPut.sh b/test/sh/bindings.python.CondPut.sh
new file mode 100755
index 000000000..f4d5ab48d
--- /dev/null
+++ b/test/sh/bindings.python.CondPut.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attribute v" --daemons=1 -- \
+    python2 "${HYPERDEX_SRCDIR}"/test/python/CondPut.py {HOST} {PORT}
diff --git a/test/sh/bindings.python.DataTypeDocument.sh b/test/sh/bindings.python.DataTypeDocument.sh
new file mode 100755
index 000000000..dc916aa21
--- /dev/null
+++ b/test/sh/bindings.python.DataTypeDocument.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes document v" --daemons=1 -- \
+    python2 "${HYPERDEX_SRCDIR}"/test/python/DataTypeDocument.py {HOST} {PORT}
diff --git a/test/sh/bindings.python.DataTypeFloat.sh b/test/sh/bindings.python.DataTypeFloat.sh
new file mode 100755
index 000000000..9b3970d9b
--- /dev/null
+++ b/test/sh/bindings.python.DataTypeFloat.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes float v" --daemons=1 -- \
+    python2 "${HYPERDEX_SRCDIR}"/test/python/DataTypeFloat.py {HOST} {PORT}
diff --git a/test/sh/bindings.python.DataTypeInt.sh b/test/sh/bindings.python.DataTypeInt.sh
new file mode 100755
index 000000000..855a394d8
--- /dev/null
+++ b/test/sh/bindings.python.DataTypeInt.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes int v" --daemons=1 -- \
+    python2 "${HYPERDEX_SRCDIR}"/test/python/DataTypeInt.py {HOST} {PORT}
diff --git a/test/sh/bindings.python.DataTypeListFloat.sh b/test/sh/bindings.python.DataTypeListFloat.sh
new file mode 100755
index 000000000..5897e35ca
--- /dev/null
+++ b/test/sh/bindings.python.DataTypeListFloat.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes list(float) v" --daemons=1 -- \
+    python2 "${HYPERDEX_SRCDIR}"/test/python/DataTypeListFloat.py {HOST} {PORT}
diff --git a/test/sh/bindings.python.DataTypeListInt.sh b/test/sh/bindings.python.DataTypeListInt.sh
new file mode 100755
index 000000000..5b62385e7
--- /dev/null
+++ b/test/sh/bindings.python.DataTypeListInt.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes list(int) v" --daemons=1 -- \
+    python2 "${HYPERDEX_SRCDIR}"/test/python/DataTypeListInt.py {HOST} {PORT}
diff --git a/test/sh/bindings.python.DataTypeListString.sh b/test/sh/bindings.python.DataTypeListString.sh
new file mode 100755
index 000000000..f0771b901
--- /dev/null
+++ b/test/sh/bindings.python.DataTypeListString.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes list(string) v" --daemons=1 -- \
+    python2 "${HYPERDEX_SRCDIR}"/test/python/DataTypeListString.py {HOST} {PORT}
diff --git a/test/sh/bindings.python.DataTypeMapFloatFloat.sh b/test/sh/bindings.python.DataTypeMapFloatFloat.sh
new file mode 100755
index 000000000..ffaf2c163
--- /dev/null
+++ b/test/sh/bindings.python.DataTypeMapFloatFloat.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes map(float, float) v" --daemons=1 -- \
+    python2 "${HYPERDEX_SRCDIR}"/test/python/DataTypeMapFloatFloat.py {HOST} {PORT}
diff --git a/test/sh/bindings.python.DataTypeMapFloatInt.sh b/test/sh/bindings.python.DataTypeMapFloatInt.sh
new file mode 100755
index 000000000..4ed578128
--- /dev/null
+++ b/test/sh/bindings.python.DataTypeMapFloatInt.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes map(float, int) v" --daemons=1 -- \
+    python2 "${HYPERDEX_SRCDIR}"/test/python/DataTypeMapFloatInt.py {HOST} {PORT}
diff --git a/test/sh/bindings.python.DataTypeMapFloatString.sh b/test/sh/bindings.python.DataTypeMapFloatString.sh
new file mode 100755
index 000000000..49c253c09
--- /dev/null
+++ b/test/sh/bindings.python.DataTypeMapFloatString.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes map(float, string) v" --daemons=1 -- \
+    python2 "${HYPERDEX_SRCDIR}"/test/python/DataTypeMapFloatString.py {HOST} {PORT}
diff --git a/test/sh/bindings.python.DataTypeMapIntFloat.sh b/test/sh/bindings.python.DataTypeMapIntFloat.sh
new file mode 100755
index 000000000..a361a6168
--- /dev/null
+++ b/test/sh/bindings.python.DataTypeMapIntFloat.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes map(int, float) v" --daemons=1 -- \
+    python2 "${HYPERDEX_SRCDIR}"/test/python/DataTypeMapIntFloat.py {HOST} {PORT}
diff --git a/test/sh/bindings.python.DataTypeMapIntInt.sh b/test/sh/bindings.python.DataTypeMapIntInt.sh
new file mode 100755
index 000000000..50ff44862
--- /dev/null
+++ b/test/sh/bindings.python.DataTypeMapIntInt.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes map(int, int) v" --daemons=1 -- \
+    python2 "${HYPERDEX_SRCDIR}"/test/python/DataTypeMapIntInt.py {HOST} {PORT}
diff --git a/test/sh/bindings.python.DataTypeMapIntString.sh b/test/sh/bindings.python.DataTypeMapIntString.sh
new file mode 100755
index 000000000..adca5145c
--- /dev/null
+++ b/test/sh/bindings.python.DataTypeMapIntString.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes map(int, string) v" --daemons=1 -- \
+    python2 "${HYPERDEX_SRCDIR}"/test/python/DataTypeMapIntString.py {HOST} {PORT}
diff --git a/test/sh/bindings.python.DataTypeMapStringFloat.sh b/test/sh/bindings.python.DataTypeMapStringFloat.sh
new file mode 100755
index 000000000..39e48b462
--- /dev/null
+++ b/test/sh/bindings.python.DataTypeMapStringFloat.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes map(string, float) v" --daemons=1 -- \
+    python2 "${HYPERDEX_SRCDIR}"/test/python/DataTypeMapStringFloat.py {HOST} {PORT}
diff --git a/test/sh/bindings.python.DataTypeMapStringInt.sh b/test/sh/bindings.python.DataTypeMapStringInt.sh
new file mode 100755
index 000000000..bb90e981b
--- /dev/null
+++ b/test/sh/bindings.python.DataTypeMapStringInt.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes map(string, int) v" --daemons=1 -- \
+    python2 "${HYPERDEX_SRCDIR}"/test/python/DataTypeMapStringInt.py {HOST} {PORT}
diff --git a/test/sh/bindings.python.DataTypeMapStringString.sh b/test/sh/bindings.python.DataTypeMapStringString.sh
new file mode 100755
index 000000000..814258f27
--- /dev/null
+++ b/test/sh/bindings.python.DataTypeMapStringString.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes map(string, string) v" --daemons=1 -- \
+    python2 "${HYPERDEX_SRCDIR}"/test/python/DataTypeMapStringString.py {HOST} {PORT}
diff --git a/test/sh/bindings.python.DataTypeSetFloat.sh b/test/sh/bindings.python.DataTypeSetFloat.sh
new file mode 100755
index 000000000..51f7c431e
--- /dev/null
+++ b/test/sh/bindings.python.DataTypeSetFloat.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes set(float) v" --daemons=1 -- \
+    python2 "${HYPERDEX_SRCDIR}"/test/python/DataTypeSetFloat.py {HOST} {PORT}
diff --git a/test/sh/bindings.python.DataTypeSetInt.sh b/test/sh/bindings.python.DataTypeSetInt.sh
new file mode 100755
index 000000000..b0d61bfd0
--- /dev/null
+++ b/test/sh/bindings.python.DataTypeSetInt.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes set(int) v" --daemons=1 -- \
+    python2 "${HYPERDEX_SRCDIR}"/test/python/DataTypeSetInt.py {HOST} {PORT}
diff --git a/test/sh/bindings.python.DataTypeSetString.sh b/test/sh/bindings.python.DataTypeSetString.sh
new file mode 100755
index 000000000..b69acd76b
--- /dev/null
+++ b/test/sh/bindings.python.DataTypeSetString.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes set(string) v" --daemons=1 -- \
+    python2 "${HYPERDEX_SRCDIR}"/test/python/DataTypeSetString.py {HOST} {PORT}
diff --git a/test/sh/bindings.python.DataTypeString.sh b/test/sh/bindings.python.DataTypeString.sh
new file mode 100755
index 000000000..afdbe2360
--- /dev/null
+++ b/test/sh/bindings.python.DataTypeString.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes v" --daemons=1 -- \
+    python2 "${HYPERDEX_SRCDIR}"/test/python/DataTypeString.py {HOST} {PORT}
diff --git a/test/sh/bindings.python.GroupAtomic.sh b/test/sh/bindings.python.GroupAtomic.sh
new file mode 100755
index 000000000..f6187c303
--- /dev/null
+++ b/test/sh/bindings.python.GroupAtomic.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes document v" --daemons=1 -- \
+    python2 "${HYPERDEX_SRCDIR}"/test/python/GroupAtomic.py {HOST} {PORT}
diff --git a/test/sh/bindings.python.HyperMongo.sh b/test/sh/bindings.python.HyperMongo.sh
new file mode 100755
index 000000000..a4f67b32a
--- /dev/null
+++ b/test/sh/bindings.python.HyperMongo.sh
@@ -0,0 +1,5 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes document v" --daemons=1 -- \
+    python2 "${HYPERDEX_SRCDIR}"/test/python/HyperMongo.py {HOST} {PORT}
+
diff --git a/test/sh/bindings.python.LengthString.sh b/test/sh/bindings.python.LengthString.sh
new file mode 100755
index 000000000..e6fe7d8cd
--- /dev/null
+++ b/test/sh/bindings.python.LengthString.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k" --daemons=1 -- \
+    python2 "${HYPERDEX_SRCDIR}"/test/python/LengthString.py {HOST} {PORT}
diff --git a/test/sh/bindings.python.MultiAttribute.sh b/test/sh/bindings.python.MultiAttribute.sh
new file mode 100755
index 000000000..b464c3fb8
--- /dev/null
+++ b/test/sh/bindings.python.MultiAttribute.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes v1, v2" --daemons=1 -- \
+    python2 "${HYPERDEX_SRCDIR}"/test/python/MultiAttribute.py {HOST} {PORT}
diff --git a/test/sh/bindings.python.RangeSearchInt.sh b/test/sh/bindings.python.RangeSearchInt.sh
new file mode 100755
index 000000000..9ee43aa4f
--- /dev/null
+++ b/test/sh/bindings.python.RangeSearchInt.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key int k attribute int v" --daemons=1 -- \
+    python2 "${HYPERDEX_SRCDIR}"/test/python/RangeSearchInt.py {HOST} {PORT}
diff --git a/test/sh/bindings.python.RangeSearchString.sh b/test/sh/bindings.python.RangeSearchString.sh
new file mode 100755
index 000000000..cf238c07e
--- /dev/null
+++ b/test/sh/bindings.python.RangeSearchString.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attribute v" --daemons=1 -- \
+    python2 "${HYPERDEX_SRCDIR}"/test/python/RangeSearchString.py {HOST} {PORT}
diff --git a/test/sh/bindings.python.RegexSearch.sh b/test/sh/bindings.python.RegexSearch.sh
new file mode 100755
index 000000000..a0d21ab1f
--- /dev/null
+++ b/test/sh/bindings.python.RegexSearch.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k" --daemons=1 -- \
+    python2 "${HYPERDEX_SRCDIR}"/test/python/RegexSearch.py {HOST} {PORT}
diff --git a/test/sh/bindings.ruby.Basic.sh b/test/sh/bindings.ruby.Basic.sh
new file mode 100755
index 000000000..c4a181299
--- /dev/null
+++ b/test/sh/bindings.ruby.Basic.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attribute v" --daemons=1 -- \
+    ruby "${HYPERDEX_SRCDIR}"/test/ruby/Basic.rb {HOST} {PORT}
diff --git a/test/sh/bindings.ruby.BasicSearch.sh b/test/sh/bindings.ruby.BasicSearch.sh
new file mode 100755
index 000000000..2c561b8ca
--- /dev/null
+++ b/test/sh/bindings.ruby.BasicSearch.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attribute v" --daemons=1 -- \
+    ruby "${HYPERDEX_SRCDIR}"/test/ruby/BasicSearch.rb {HOST} {PORT}
diff --git a/test/sh/bindings.ruby.CondPut.sh b/test/sh/bindings.ruby.CondPut.sh
new file mode 100755
index 000000000..90b5c218e
--- /dev/null
+++ b/test/sh/bindings.ruby.CondPut.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attribute v" --daemons=1 -- \
+    ruby "${HYPERDEX_SRCDIR}"/test/ruby/CondPut.rb {HOST} {PORT}
diff --git a/test/sh/bindings.ruby.DataTypeFloat.sh b/test/sh/bindings.ruby.DataTypeFloat.sh
new file mode 100755
index 000000000..cbf0e59f0
--- /dev/null
+++ b/test/sh/bindings.ruby.DataTypeFloat.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes float v" --daemons=1 -- \
+    ruby "${HYPERDEX_SRCDIR}"/test/ruby/DataTypeFloat.rb {HOST} {PORT}
diff --git a/test/sh/bindings.ruby.DataTypeInt.sh b/test/sh/bindings.ruby.DataTypeInt.sh
new file mode 100755
index 000000000..c739dd005
--- /dev/null
+++ b/test/sh/bindings.ruby.DataTypeInt.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes int v" --daemons=1 -- \
+    ruby "${HYPERDEX_SRCDIR}"/test/ruby/DataTypeInt.rb {HOST} {PORT}
diff --git a/test/sh/bindings.ruby.DataTypeListFloat.sh b/test/sh/bindings.ruby.DataTypeListFloat.sh
new file mode 100755
index 000000000..1ae8b1eca
--- /dev/null
+++ b/test/sh/bindings.ruby.DataTypeListFloat.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes list(float) v" --daemons=1 -- \
+    ruby "${HYPERDEX_SRCDIR}"/test/ruby/DataTypeListFloat.rb {HOST} {PORT}
diff --git a/test/sh/bindings.ruby.DataTypeListInt.sh b/test/sh/bindings.ruby.DataTypeListInt.sh
new file mode 100755
index 000000000..25e54664f
--- /dev/null
+++ b/test/sh/bindings.ruby.DataTypeListInt.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes list(int) v" --daemons=1 -- \
+    ruby "${HYPERDEX_SRCDIR}"/test/ruby/DataTypeListInt.rb {HOST} {PORT}
diff --git a/test/sh/bindings.ruby.DataTypeListString.sh b/test/sh/bindings.ruby.DataTypeListString.sh
new file mode 100755
index 000000000..7500bdba3
--- /dev/null
+++ b/test/sh/bindings.ruby.DataTypeListString.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes list(string) v" --daemons=1 -- \
+    ruby "${HYPERDEX_SRCDIR}"/test/ruby/DataTypeListString.rb {HOST} {PORT}
diff --git a/test/sh/bindings.ruby.DataTypeMapFloatFloat.sh b/test/sh/bindings.ruby.DataTypeMapFloatFloat.sh
new file mode 100755
index 000000000..68b0b00e9
--- /dev/null
+++ b/test/sh/bindings.ruby.DataTypeMapFloatFloat.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes map(float, float) v" --daemons=1 -- \
+    ruby "${HYPERDEX_SRCDIR}"/test/ruby/DataTypeMapFloatFloat.rb {HOST} {PORT}
diff --git a/test/sh/bindings.ruby.DataTypeMapFloatInt.sh b/test/sh/bindings.ruby.DataTypeMapFloatInt.sh
new file mode 100755
index 000000000..6e7f34649
--- /dev/null
+++ b/test/sh/bindings.ruby.DataTypeMapFloatInt.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes map(float, int) v" --daemons=1 -- \
+    ruby "${HYPERDEX_SRCDIR}"/test/ruby/DataTypeMapFloatInt.rb {HOST} {PORT}
diff --git a/test/sh/bindings.ruby.DataTypeMapFloatString.sh b/test/sh/bindings.ruby.DataTypeMapFloatString.sh
new file mode 100755
index 000000000..2e7547250
--- /dev/null
+++ b/test/sh/bindings.ruby.DataTypeMapFloatString.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes map(float, string) v" --daemons=1 -- \
+    ruby "${HYPERDEX_SRCDIR}"/test/ruby/DataTypeMapFloatString.rb {HOST} {PORT}
diff --git a/test/sh/bindings.ruby.DataTypeMapIntFloat.sh b/test/sh/bindings.ruby.DataTypeMapIntFloat.sh
new file mode 100755
index 000000000..4cf9d1f40
--- /dev/null
+++ b/test/sh/bindings.ruby.DataTypeMapIntFloat.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes map(int, float) v" --daemons=1 -- \
+    ruby "${HYPERDEX_SRCDIR}"/test/ruby/DataTypeMapIntFloat.rb {HOST} {PORT}
diff --git a/test/sh/bindings.ruby.DataTypeMapIntInt.sh b/test/sh/bindings.ruby.DataTypeMapIntInt.sh
new file mode 100755
index 000000000..33c9a64da
--- /dev/null
+++ b/test/sh/bindings.ruby.DataTypeMapIntInt.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes map(int, int) v" --daemons=1 -- \
+    ruby "${HYPERDEX_SRCDIR}"/test/ruby/DataTypeMapIntInt.rb {HOST} {PORT}
diff --git a/test/sh/bindings.ruby.DataTypeMapIntString.sh b/test/sh/bindings.ruby.DataTypeMapIntString.sh
new file mode 100755
index 000000000..a5e8752c9
--- /dev/null
+++ b/test/sh/bindings.ruby.DataTypeMapIntString.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes map(int, string) v" --daemons=1 -- \
+    ruby "${HYPERDEX_SRCDIR}"/test/ruby/DataTypeMapIntString.rb {HOST} {PORT}
diff --git a/test/sh/bindings.ruby.DataTypeMapStringFloat.sh b/test/sh/bindings.ruby.DataTypeMapStringFloat.sh
new file mode 100755
index 000000000..d09ccd1b4
--- /dev/null
+++ b/test/sh/bindings.ruby.DataTypeMapStringFloat.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes map(string, float) v" --daemons=1 -- \
+    ruby "${HYPERDEX_SRCDIR}"/test/ruby/DataTypeMapStringFloat.rb {HOST} {PORT}
diff --git a/test/sh/bindings.ruby.DataTypeMapStringInt.sh b/test/sh/bindings.ruby.DataTypeMapStringInt.sh
new file mode 100755
index 000000000..3eaa052d9
--- /dev/null
+++ b/test/sh/bindings.ruby.DataTypeMapStringInt.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes map(string, int) v" --daemons=1 -- \
+    ruby "${HYPERDEX_SRCDIR}"/test/ruby/DataTypeMapStringInt.rb {HOST} {PORT}
diff --git a/test/sh/bindings.ruby.DataTypeMapStringString.sh b/test/sh/bindings.ruby.DataTypeMapStringString.sh
new file mode 100755
index 000000000..13feeacc8
--- /dev/null
+++ b/test/sh/bindings.ruby.DataTypeMapStringString.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes map(string, string) v" --daemons=1 -- \
+    ruby "${HYPERDEX_SRCDIR}"/test/ruby/DataTypeMapStringString.rb {HOST} {PORT}
diff --git a/test/sh/bindings.ruby.DataTypeSetFloat.sh b/test/sh/bindings.ruby.DataTypeSetFloat.sh
new file mode 100755
index 000000000..2a1f409c6
--- /dev/null
+++ b/test/sh/bindings.ruby.DataTypeSetFloat.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes set(float) v" --daemons=1 -- \
+    ruby "${HYPERDEX_SRCDIR}"/test/ruby/DataTypeSetFloat.rb {HOST} {PORT}
diff --git a/test/sh/bindings.ruby.DataTypeSetInt.sh b/test/sh/bindings.ruby.DataTypeSetInt.sh
new file mode 100755
index 000000000..33fe21ec9
--- /dev/null
+++ b/test/sh/bindings.ruby.DataTypeSetInt.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes set(int) v" --daemons=1 -- \
+    ruby "${HYPERDEX_SRCDIR}"/test/ruby/DataTypeSetInt.rb {HOST} {PORT}
diff --git a/test/sh/bindings.ruby.DataTypeSetString.sh b/test/sh/bindings.ruby.DataTypeSetString.sh
new file mode 100755
index 000000000..5d8682f96
--- /dev/null
+++ b/test/sh/bindings.ruby.DataTypeSetString.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes set(string) v" --daemons=1 -- \
+    ruby "${HYPERDEX_SRCDIR}"/test/ruby/DataTypeSetString.rb {HOST} {PORT}
diff --git a/test/sh/bindings.ruby.DataTypeString.sh b/test/sh/bindings.ruby.DataTypeString.sh
new file mode 100755
index 000000000..ecbab5326
--- /dev/null
+++ b/test/sh/bindings.ruby.DataTypeString.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes v" --daemons=1 -- \
+    ruby "${HYPERDEX_SRCDIR}"/test/ruby/DataTypeString.rb {HOST} {PORT}
diff --git a/test/sh/bindings.ruby.LengthString.sh b/test/sh/bindings.ruby.LengthString.sh
new file mode 100755
index 000000000..8303c4448
--- /dev/null
+++ b/test/sh/bindings.ruby.LengthString.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k" --daemons=1 -- \
+    ruby "${HYPERDEX_SRCDIR}"/test/ruby/LengthString.rb {HOST} {PORT}
diff --git a/test/sh/bindings.ruby.MultiAttribute.sh b/test/sh/bindings.ruby.MultiAttribute.sh
new file mode 100755
index 000000000..f51c85b64
--- /dev/null
+++ b/test/sh/bindings.ruby.MultiAttribute.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attributes v1, v2" --daemons=1 -- \
+    ruby "${HYPERDEX_SRCDIR}"/test/ruby/MultiAttribute.rb {HOST} {PORT}
diff --git a/test/sh/bindings.ruby.RangeSearchInt.sh b/test/sh/bindings.ruby.RangeSearchInt.sh
new file mode 100755
index 000000000..26a6423eb
--- /dev/null
+++ b/test/sh/bindings.ruby.RangeSearchInt.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key int k attribute int v" --daemons=1 -- \
+    ruby "${HYPERDEX_SRCDIR}"/test/ruby/RangeSearchInt.rb {HOST} {PORT}
diff --git a/test/sh/bindings.ruby.RangeSearchString.sh b/test/sh/bindings.ruby.RangeSearchString.sh
new file mode 100755
index 000000000..3889fef70
--- /dev/null
+++ b/test/sh/bindings.ruby.RangeSearchString.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k attribute v" --daemons=1 -- \
+    ruby "${HYPERDEX_SRCDIR}"/test/ruby/RangeSearchString.rb {HOST} {PORT}
diff --git a/test/sh/bindings.ruby.RegexSearch.sh b/test/sh/bindings.ruby.RegexSearch.sh
new file mode 100755
index 000000000..43e3cd2ee
--- /dev/null
+++ b/test/sh/bindings.ruby.RegexSearch.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --space="space kv key k" --daemons=1 -- \
+    ruby "${HYPERDEX_SRCDIR}"/test/ruby/RegexSearch.rb {HOST} {PORT}
diff --git a/test/sh/doc.async-ops.sh b/test/sh/doc.async-ops.sh
new file mode 100755
index 000000000..4e27123fa
--- /dev/null
+++ b/test/sh/doc.async-ops.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=1 -- \
+    python2 "${HYPERDEX_SRCDIR}"/test/doctest-runner.py \
+           "${HYPERDEX_SRCDIR}"/test/doc.async-ops.py {HOST} {PORT}
diff --git a/test/sh/doc.atomic-ops.sh b/test/sh/doc.atomic-ops.sh
new file mode 100755
index 000000000..b55b7b6e5
--- /dev/null
+++ b/test/sh/doc.atomic-ops.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=1 -- \
+    python2 "${HYPERDEX_SRCDIR}"/test/doctest-runner.py \
+           "${HYPERDEX_SRCDIR}"/test/doc.atomic-ops.py {HOST} {PORT}
diff --git a/test/sh/doc.authorization.sh b/test/sh/doc.authorization.sh
new file mode 100755
index 000000000..d7520bb1d
--- /dev/null
+++ b/test/sh/doc.authorization.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=1 -- \
+    python2 "${HYPERDEX_SRCDIR}"/test/doctest-runner.py \
+           "${HYPERDEX_SRCDIR}"/test/doc.authorization.py {HOST} {PORT}
diff --git a/test/sh/doc.data-types.sh b/test/sh/doc.data-types.sh
new file mode 100755
index 000000000..e9b51c23e
--- /dev/null
+++ b/test/sh/doc.data-types.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=1 -- \
+    python2 "${HYPERDEX_SRCDIR}"/test/doctest-runner.py \
+           "${HYPERDEX_SRCDIR}"/test/doc.data-types.py {HOST} {PORT}
diff --git a/test/sh/doc.documents.sh b/test/sh/doc.documents.sh
new file mode 100755
index 000000000..9a3dc510a
--- /dev/null
+++ b/test/sh/doc.documents.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=1 -- \
+    python2 "${HYPERDEX_SRCDIR}"/test/doctest-runner.py \
+           "${HYPERDEX_SRCDIR}"/test/doc.documents.py {HOST} {PORT}
diff --git a/test/sh/doc.quick-start.sh b/test/sh/doc.quick-start.sh
new file mode 100755
index 000000000..a9efc5799
--- /dev/null
+++ b/test/sh/doc.quick-start.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=1 -- \
+    python2 "${HYPERDEX_SRCDIR}"/test/doctest-runner.py \
+           "${HYPERDEX_SRCDIR}"/test/doc.quick-start.py {HOST} {PORT}
diff --git a/test/sh/replication.composite.daemons=1.fault-tolerance=0.sh b/test/sh/replication.composite.daemons=1.fault-tolerance=0.sh
new file mode 100755
index 000000000..021da6b98
--- /dev/null
+++ b/test/sh/replication.composite.daemons=1.fault-tolerance=0.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+SPACE="space replication key int A attributes int B, int C subspace B, C create 1 partitions tolerate 0 failures"
+exec python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=1 --space="${SPACE}" -- \
+     "${HYPERDEX_BUILDDIR}"/test/replication-stress-test --quiet -n 1 -h {HOST} -p {PORT}
diff --git a/test/sh/replication.composite.daemons=4.fault-tolerance=0.sh b/test/sh/replication.composite.daemons=4.fault-tolerance=0.sh
new file mode 100755
index 000000000..4a72b90c8
--- /dev/null
+++ b/test/sh/replication.composite.daemons=4.fault-tolerance=0.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+SPACE="space replication key int A attributes int B, int C subspace B, C create 4 partitions tolerate 0 failures"
+exec python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=4 --space="${SPACE}" -- \
+     "${HYPERDEX_BUILDDIR}"/test/replication-stress-test --quiet -n 4 -h {HOST} -p {PORT}
diff --git a/test/sh/replication.composite.daemons=4.fault-tolerance=1.sh b/test/sh/replication.composite.daemons=4.fault-tolerance=1.sh
new file mode 100755
index 000000000..039132e88
--- /dev/null
+++ b/test/sh/replication.composite.daemons=4.fault-tolerance=1.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+SPACE="space replication key int A attributes int B, int C subspace B, C create 4 partitions tolerate 1 failures"
+exec python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=4 --space="${SPACE}" -- \
+     "${HYPERDEX_BUILDDIR}"/test/replication-stress-test --quiet -n 4 -h {HOST} -p {PORT}
diff --git a/test/sh/replication.composite.daemons=4.fault-tolerance=2.sh b/test/sh/replication.composite.daemons=4.fault-tolerance=2.sh
new file mode 100755
index 000000000..c1a04745d
--- /dev/null
+++ b/test/sh/replication.composite.daemons=4.fault-tolerance=2.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+SPACE="space replication key int A attributes int B, int C subspace B, C create 4 partitions tolerate 2 failures"
+exec python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=4 --space="${SPACE}" -- \
+     "${HYPERDEX_BUILDDIR}"/test/replication-stress-test --quiet -n 4 -h {HOST} -p {PORT}
diff --git a/test/sh/replication.reverse.daemons=1.fault-tolerance=0.sh b/test/sh/replication.reverse.daemons=1.fault-tolerance=0.sh
new file mode 100755
index 000000000..b0bb4b707
--- /dev/null
+++ b/test/sh/replication.reverse.daemons=1.fault-tolerance=0.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+SPACE="space replication key int A attributes int B, int C subspace C subspace B create 1 partitions tolerate 0 failures"
+exec python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=1 --space="${SPACE}" -- \
+     "${HYPERDEX_BUILDDIR}"/test/replication-stress-test --quiet -n 1 -h {HOST} -p {PORT}
diff --git a/test/sh/replication.reverse.daemons=4.fault-tolerance=0.sh b/test/sh/replication.reverse.daemons=4.fault-tolerance=0.sh
new file mode 100755
index 000000000..4e35ede03
--- /dev/null
+++ b/test/sh/replication.reverse.daemons=4.fault-tolerance=0.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+SPACE="space replication key int A attributes int B, int C subspace C subspace B create 4 partitions tolerate 0 failures"
+exec python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=4 --space="${SPACE}" -- \
+     "${HYPERDEX_BUILDDIR}"/test/replication-stress-test --quiet -n 4 -h {HOST} -p {PORT}
diff --git a/test/sh/replication.reverse.daemons=4.fault-tolerance=1.sh b/test/sh/replication.reverse.daemons=4.fault-tolerance=1.sh
new file mode 100755
index 000000000..7f451c8d7
--- /dev/null
+++ b/test/sh/replication.reverse.daemons=4.fault-tolerance=1.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+SPACE="space replication key int A attributes int B, int C subspace C subspace B create 4 partitions tolerate 1 failures"
+exec python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=4 --space="${SPACE}" -- \
+     "${HYPERDEX_BUILDDIR}"/test/replication-stress-test --quiet -n 4 -h {HOST} -p {PORT}
diff --git a/test/sh/replication.reverse.daemons=4.fault-tolerance=2.sh b/test/sh/replication.reverse.daemons=4.fault-tolerance=2.sh
new file mode 100755
index 000000000..ecdae4f87
--- /dev/null
+++ b/test/sh/replication.reverse.daemons=4.fault-tolerance=2.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+SPACE="space replication key int A attributes int B, int C subspace C subspace B create 4 partitions tolerate 2 failures"
+exec python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=4 --space="${SPACE}" -- \
+     "${HYPERDEX_BUILDDIR}"/test/replication-stress-test --quiet -n 4 -h {HOST} -p {PORT}
diff --git a/test/sh/replication.simple.daemons=1.fault-tolerance=0.sh b/test/sh/replication.simple.daemons=1.fault-tolerance=0.sh
new file mode 100755
index 000000000..e1380dec9
--- /dev/null
+++ b/test/sh/replication.simple.daemons=1.fault-tolerance=0.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+SPACE="space replication key int A attributes int B, int C subspace B subspace C create 1 partitions tolerate 0 failures"
+exec python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=1 --space="${SPACE}" -- \
+     "${HYPERDEX_BUILDDIR}"/test/replication-stress-test --quiet -n 1 -h {HOST} -p {PORT}
diff --git a/test/sh/replication.simple.daemons=4.fault-tolerance=0.sh b/test/sh/replication.simple.daemons=4.fault-tolerance=0.sh
new file mode 100755
index 000000000..ce3135a0d
--- /dev/null
+++ b/test/sh/replication.simple.daemons=4.fault-tolerance=0.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+SPACE="space replication key int A attributes int B, int C subspace B subspace C create 4 partitions tolerate 0 failures"
+exec python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=4 --space="${SPACE}" -- \
+     "${HYPERDEX_BUILDDIR}"/test/replication-stress-test --quiet -n 4 -h {HOST} -p {PORT}
diff --git a/test/sh/replication.simple.daemons=4.fault-tolerance=1.sh b/test/sh/replication.simple.daemons=4.fault-tolerance=1.sh
new file mode 100755
index 000000000..412475ae0
--- /dev/null
+++ b/test/sh/replication.simple.daemons=4.fault-tolerance=1.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+SPACE="space replication key int A attributes int B, int C subspace B subspace C create 4 partitions tolerate 1 failures"
+exec python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=4 --space="${SPACE}" -- \
+     "${HYPERDEX_BUILDDIR}"/test/replication-stress-test --quiet -n 4 -h {HOST} -p {PORT}
diff --git a/test/sh/replication.simple.daemons=4.fault-tolerance=2.sh b/test/sh/replication.simple.daemons=4.fault-tolerance=2.sh
new file mode 100755
index 000000000..348e23170
--- /dev/null
+++ b/test/sh/replication.simple.daemons=4.fault-tolerance=2.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+SPACE="space replication key int A attributes int B, int C subspace B subspace C create 4 partitions tolerate 2 failures"
+exec python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=4 --space="${SPACE}" -- \
+     "${HYPERDEX_BUILDDIR}"/test/replication-stress-test --quiet -n 4 -h {HOST} -p {PORT}
diff --git a/test/sh/search.combination.keytype=int,daemons=1.fault-tolerance=0.sh b/test/sh/search.combination.keytype=int,daemons=1.fault-tolerance=0.sh
new file mode 100755
index 000000000..91ba3bf67
--- /dev/null
+++ b/test/sh/search.combination.keytype=int,daemons=1.fault-tolerance=0.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+SPACE="space search key int number attributes     bit01, bit02, bit03, bit04, bit05, bit06, bit07, bit08,     bit09, bit10, bit11, bit12, bit13, bit14, bit15, bit16,     bit17, bit18, bit19, bit20, bit21, bit22, bit23, bit24,     bit25, bit26, bit27, bit28, bit29, bit30, bit31, bit32     subspace bit01, bit02, bit03, bit04, bit05, bit06, bit07, bit08     subspace bit09, bit10, bit11, bit12, bit13, bit14, bit15, bit16     subspace bit17, bit18, bit19, bit20, bit21, bit22, bit23, bit24     subspace bit25, bit26, bit27, bit28, bit29, bit30, bit31, bit32     index bit09     index bit10     index bit11     index bit12     index bit13     index bit14     index bit15     index bit16     index bit17     index bit18     index bit19     index bit20     index bit21     index bit22     index bit23     index bit24     index bit25     index bit26     index bit27     index bit28     index bit29     index bit30     index bit31     index bit32     index bit01     index bit02     index bit03     index bit04     index bit05     index bit06     index bit07     index bit08 create 1 partitions tolerate 0 failures"
+exec python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=1 --space="${SPACE}" -- \
+     "${HYPERDEX_BUILDDIR}"/test/search-stress-test --quiet -h {HOST} -p {PORT} -k int
diff --git a/test/sh/search.combination.keytype=int,daemons=4.fault-tolerance=0.sh b/test/sh/search.combination.keytype=int,daemons=4.fault-tolerance=0.sh
new file mode 100755
index 000000000..0f5b53a1b
--- /dev/null
+++ b/test/sh/search.combination.keytype=int,daemons=4.fault-tolerance=0.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+SPACE="space search key int number attributes     bit01, bit02, bit03, bit04, bit05, bit06, bit07, bit08,     bit09, bit10, bit11, bit12, bit13, bit14, bit15, bit16,     bit17, bit18, bit19, bit20, bit21, bit22, bit23, bit24,     bit25, bit26, bit27, bit28, bit29, bit30, bit31, bit32     subspace bit01, bit02, bit03, bit04, bit05, bit06, bit07, bit08     subspace bit09, bit10, bit11, bit12, bit13, bit14, bit15, bit16     subspace bit17, bit18, bit19, bit20, bit21, bit22, bit23, bit24     subspace bit25, bit26, bit27, bit28, bit29, bit30, bit31, bit32     index bit09     index bit10     index bit11     index bit12     index bit13     index bit14     index bit15     index bit16     index bit17     index bit18     index bit19     index bit20     index bit21     index bit22     index bit23     index bit24     index bit25     index bit26     index bit27     index bit28     index bit29     index bit30     index bit31     index bit32     index bit01     index bit02     index bit03     index bit04     index bit05     index bit06     index bit07     index bit08 create 4 partitions tolerate 0 failures"
+exec python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=4 --space="${SPACE}" -- \
+     "${HYPERDEX_BUILDDIR}"/test/search-stress-test --quiet -h {HOST} -p {PORT} -k int
diff --git a/test/sh/search.combination.keytype=int,daemons=4.fault-tolerance=1.sh b/test/sh/search.combination.keytype=int,daemons=4.fault-tolerance=1.sh
new file mode 100755
index 000000000..6c1d3bb8f
--- /dev/null
+++ b/test/sh/search.combination.keytype=int,daemons=4.fault-tolerance=1.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+SPACE="space search key int number attributes     bit01, bit02, bit03, bit04, bit05, bit06, bit07, bit08,     bit09, bit10, bit11, bit12, bit13, bit14, bit15, bit16,     bit17, bit18, bit19, bit20, bit21, bit22, bit23, bit24,     bit25, bit26, bit27, bit28, bit29, bit30, bit31, bit32     subspace bit01, bit02, bit03, bit04, bit05, bit06, bit07, bit08     subspace bit09, bit10, bit11, bit12, bit13, bit14, bit15, bit16     subspace bit17, bit18, bit19, bit20, bit21, bit22, bit23, bit24     subspace bit25, bit26, bit27, bit28, bit29, bit30, bit31, bit32     index bit09     index bit10     index bit11     index bit12     index bit13     index bit14     index bit15     index bit16     index bit17     index bit18     index bit19     index bit20     index bit21     index bit22     index bit23     index bit24     index bit25     index bit26     index bit27     index bit28     index bit29     index bit30     index bit31     index bit32     index bit01     index bit02     index bit03     index bit04     index bit05     index bit06     index bit07     index bit08 create 4 partitions tolerate 1 failures"
+exec python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=4 --space="${SPACE}" -- \
+     "${HYPERDEX_BUILDDIR}"/test/search-stress-test --quiet -h {HOST} -p {PORT} -k int
diff --git a/test/sh/search.combination.keytype=string,daemons=1.fault-tolerance=0.sh b/test/sh/search.combination.keytype=string,daemons=1.fault-tolerance=0.sh
new file mode 100755
index 000000000..8c895461d
--- /dev/null
+++ b/test/sh/search.combination.keytype=string,daemons=1.fault-tolerance=0.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+SPACE="space search key string number attributes     bit01, bit02, bit03, bit04, bit05, bit06, bit07, bit08,     bit09, bit10, bit11, bit12, bit13, bit14, bit15, bit16,     bit17, bit18, bit19, bit20, bit21, bit22, bit23, bit24,     bit25, bit26, bit27, bit28, bit29, bit30, bit31, bit32     subspace bit01, bit02, bit03, bit04, bit05, bit06, bit07, bit08     subspace bit09, bit10, bit11, bit12, bit13, bit14, bit15, bit16     subspace bit17, bit18, bit19, bit20, bit21, bit22, bit23, bit24     subspace bit25, bit26, bit27, bit28, bit29, bit30, bit31, bit32     index bit09     index bit10     index bit11     index bit12     index bit13     index bit14     index bit15     index bit16     index bit17     index bit18     index bit19     index bit20     index bit21     index bit22     index bit23     index bit24     index bit25     index bit26     index bit27     index bit28     index bit29     index bit30     index bit31     index bit32     index bit01     index bit02     index bit03     index bit04     index bit05     index bit06     index bit07     index bit08 create 1 partitions tolerate 0 failures"
+exec python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=1 --space="${SPACE}" -- \
+     "${HYPERDEX_BUILDDIR}"/test/search-stress-test --quiet -h {HOST} -p {PORT} -k string
diff --git a/test/sh/search.combination.keytype=string,daemons=4.fault-tolerance=0.sh b/test/sh/search.combination.keytype=string,daemons=4.fault-tolerance=0.sh
new file mode 100755
index 000000000..9f16728af
--- /dev/null
+++ b/test/sh/search.combination.keytype=string,daemons=4.fault-tolerance=0.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+SPACE="space search key string number attributes     bit01, bit02, bit03, bit04, bit05, bit06, bit07, bit08,     bit09, bit10, bit11, bit12, bit13, bit14, bit15, bit16,     bit17, bit18, bit19, bit20, bit21, bit22, bit23, bit24,     bit25, bit26, bit27, bit28, bit29, bit30, bit31, bit32     subspace bit01, bit02, bit03, bit04, bit05, bit06, bit07, bit08     subspace bit09, bit10, bit11, bit12, bit13, bit14, bit15, bit16     subspace bit17, bit18, bit19, bit20, bit21, bit22, bit23, bit24     subspace bit25, bit26, bit27, bit28, bit29, bit30, bit31, bit32     index bit09     index bit10     index bit11     index bit12     index bit13     index bit14     index bit15     index bit16     index bit17     index bit18     index bit19     index bit20     index bit21     index bit22     index bit23     index bit24     index bit25     index bit26     index bit27     index bit28     index bit29     index bit30     index bit31     index bit32     index bit01     index bit02     index bit03     index bit04     index bit05     index bit06     index bit07     index bit08 create 4 partitions tolerate 0 failures"
+exec python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=4 --space="${SPACE}" -- \
+     "${HYPERDEX_BUILDDIR}"/test/search-stress-test --quiet -h {HOST} -p {PORT} -k string
diff --git a/test/sh/search.combination.keytype=string,daemons=4.fault-tolerance=1.sh b/test/sh/search.combination.keytype=string,daemons=4.fault-tolerance=1.sh
new file mode 100755
index 000000000..62d7f91bd
--- /dev/null
+++ b/test/sh/search.combination.keytype=string,daemons=4.fault-tolerance=1.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+SPACE="space search key string number attributes     bit01, bit02, bit03, bit04, bit05, bit06, bit07, bit08,     bit09, bit10, bit11, bit12, bit13, bit14, bit15, bit16,     bit17, bit18, bit19, bit20, bit21, bit22, bit23, bit24,     bit25, bit26, bit27, bit28, bit29, bit30, bit31, bit32     subspace bit01, bit02, bit03, bit04, bit05, bit06, bit07, bit08     subspace bit09, bit10, bit11, bit12, bit13, bit14, bit15, bit16     subspace bit17, bit18, bit19, bit20, bit21, bit22, bit23, bit24     subspace bit25, bit26, bit27, bit28, bit29, bit30, bit31, bit32     index bit09     index bit10     index bit11     index bit12     index bit13     index bit14     index bit15     index bit16     index bit17     index bit18     index bit19     index bit20     index bit21     index bit22     index bit23     index bit24     index bit25     index bit26     index bit27     index bit28     index bit29     index bit30     index bit31     index bit32     index bit01     index bit02     index bit03     index bit04     index bit05     index bit06     index bit07     index bit08 create 4 partitions tolerate 1 failures"
+exec python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=4 --space="${SPACE}" -- \
+     "${HYPERDEX_BUILDDIR}"/test/search-stress-test --quiet -h {HOST} -p {PORT} -k string
diff --git a/test/sh/search.index.keytype=int,daemons=1.fault-tolerance=0.sh b/test/sh/search.index.keytype=int,daemons=1.fault-tolerance=0.sh
new file mode 100755
index 000000000..c88998a18
--- /dev/null
+++ b/test/sh/search.index.keytype=int,daemons=1.fault-tolerance=0.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+SPACE="space search key int number attributes     bit01, bit02, bit03, bit04, bit05, bit06, bit07, bit08,     bit09, bit10, bit11, bit12, bit13, bit14, bit15, bit16,     bit17, bit18, bit19, bit20, bit21, bit22, bit23, bit24,     bit25, bit26, bit27, bit28, bit29, bit30, bit31, bit32     index bit01     index bit02     index bit03     index bit04     index bit05     index bit06     index bit07     index bit08     index bit09     index bit10     index bit11     index bit12     index bit13     index bit14     index bit15     index bit16     index bit17     index bit18     index bit19     index bit20     index bit21     index bit22     index bit23     index bit24     index bit25     index bit26     index bit27     index bit28     index bit29     index bit30     index bit31     index bit32 create 1 partitions tolerate 0 failures"
+exec python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=1 --space="${SPACE}" -- \
+     "${HYPERDEX_BUILDDIR}"/test/search-stress-test --quiet -h {HOST} -p {PORT} -k int
diff --git a/test/sh/search.index.keytype=int,daemons=4.fault-tolerance=0.sh b/test/sh/search.index.keytype=int,daemons=4.fault-tolerance=0.sh
new file mode 100755
index 000000000..a2adbe399
--- /dev/null
+++ b/test/sh/search.index.keytype=int,daemons=4.fault-tolerance=0.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+SPACE="space search key int number attributes     bit01, bit02, bit03, bit04, bit05, bit06, bit07, bit08,     bit09, bit10, bit11, bit12, bit13, bit14, bit15, bit16,     bit17, bit18, bit19, bit20, bit21, bit22, bit23, bit24,     bit25, bit26, bit27, bit28, bit29, bit30, bit31, bit32     index bit01     index bit02     index bit03     index bit04     index bit05     index bit06     index bit07     index bit08     index bit09     index bit10     index bit11     index bit12     index bit13     index bit14     index bit15     index bit16     index bit17     index bit18     index bit19     index bit20     index bit21     index bit22     index bit23     index bit24     index bit25     index bit26     index bit27     index bit28     index bit29     index bit30     index bit31     index bit32 create 4 partitions tolerate 0 failures"
+exec python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=4 --space="${SPACE}" -- \
+     "${HYPERDEX_BUILDDIR}"/test/search-stress-test --quiet -h {HOST} -p {PORT} -k int
diff --git a/test/sh/search.index.keytype=int,daemons=4.fault-tolerance=1.sh b/test/sh/search.index.keytype=int,daemons=4.fault-tolerance=1.sh
new file mode 100755
index 000000000..213eef0c6
--- /dev/null
+++ b/test/sh/search.index.keytype=int,daemons=4.fault-tolerance=1.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+SPACE="space search key int number attributes     bit01, bit02, bit03, bit04, bit05, bit06, bit07, bit08,     bit09, bit10, bit11, bit12, bit13, bit14, bit15, bit16,     bit17, bit18, bit19, bit20, bit21, bit22, bit23, bit24,     bit25, bit26, bit27, bit28, bit29, bit30, bit31, bit32     index bit01     index bit02     index bit03     index bit04     index bit05     index bit06     index bit07     index bit08     index bit09     index bit10     index bit11     index bit12     index bit13     index bit14     index bit15     index bit16     index bit17     index bit18     index bit19     index bit20     index bit21     index bit22     index bit23     index bit24     index bit25     index bit26     index bit27     index bit28     index bit29     index bit30     index bit31     index bit32 create 4 partitions tolerate 1 failures"
+exec python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=4 --space="${SPACE}" -- \
+     "${HYPERDEX_BUILDDIR}"/test/search-stress-test --quiet -h {HOST} -p {PORT} -k int
diff --git a/test/sh/search.index.keytype=string,daemons=1.fault-tolerance=0.sh b/test/sh/search.index.keytype=string,daemons=1.fault-tolerance=0.sh
new file mode 100755
index 000000000..18c6910f9
--- /dev/null
+++ b/test/sh/search.index.keytype=string,daemons=1.fault-tolerance=0.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+SPACE="space search key string number attributes     bit01, bit02, bit03, bit04, bit05, bit06, bit07, bit08,     bit09, bit10, bit11, bit12, bit13, bit14, bit15, bit16,     bit17, bit18, bit19, bit20, bit21, bit22, bit23, bit24,     bit25, bit26, bit27, bit28, bit29, bit30, bit31, bit32     index bit01     index bit02     index bit03     index bit04     index bit05     index bit06     index bit07     index bit08     index bit09     index bit10     index bit11     index bit12     index bit13     index bit14     index bit15     index bit16     index bit17     index bit18     index bit19     index bit20     index bit21     index bit22     index bit23     index bit24     index bit25     index bit26     index bit27     index bit28     index bit29     index bit30     index bit31     index bit32 create 1 partitions tolerate 0 failures"
+exec python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=1 --space="${SPACE}" -- \
+     "${HYPERDEX_BUILDDIR}"/test/search-stress-test --quiet -h {HOST} -p {PORT} -k string
diff --git a/test/sh/search.index.keytype=string,daemons=4.fault-tolerance=0.sh b/test/sh/search.index.keytype=string,daemons=4.fault-tolerance=0.sh
new file mode 100755
index 000000000..4002c1e5c
--- /dev/null
+++ b/test/sh/search.index.keytype=string,daemons=4.fault-tolerance=0.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+SPACE="space search key string number attributes     bit01, bit02, bit03, bit04, bit05, bit06, bit07, bit08,     bit09, bit10, bit11, bit12, bit13, bit14, bit15, bit16,     bit17, bit18, bit19, bit20, bit21, bit22, bit23, bit24,     bit25, bit26, bit27, bit28, bit29, bit30, bit31, bit32     index bit01     index bit02     index bit03     index bit04     index bit05     index bit06     index bit07     index bit08     index bit09     index bit10     index bit11     index bit12     index bit13     index bit14     index bit15     index bit16     index bit17     index bit18     index bit19     index bit20     index bit21     index bit22     index bit23     index bit24     index bit25     index bit26     index bit27     index bit28     index bit29     index bit30     index bit31     index bit32 create 4 partitions tolerate 0 failures"
+exec python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=4 --space="${SPACE}" -- \
+     "${HYPERDEX_BUILDDIR}"/test/search-stress-test --quiet -h {HOST} -p {PORT} -k string
diff --git a/test/sh/search.index.keytype=string,daemons=4.fault-tolerance=1.sh b/test/sh/search.index.keytype=string,daemons=4.fault-tolerance=1.sh
new file mode 100755
index 000000000..2dab27a0a
--- /dev/null
+++ b/test/sh/search.index.keytype=string,daemons=4.fault-tolerance=1.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+SPACE="space search key string number attributes     bit01, bit02, bit03, bit04, bit05, bit06, bit07, bit08,     bit09, bit10, bit11, bit12, bit13, bit14, bit15, bit16,     bit17, bit18, bit19, bit20, bit21, bit22, bit23, bit24,     bit25, bit26, bit27, bit28, bit29, bit30, bit31, bit32     index bit01     index bit02     index bit03     index bit04     index bit05     index bit06     index bit07     index bit08     index bit09     index bit10     index bit11     index bit12     index bit13     index bit14     index bit15     index bit16     index bit17     index bit18     index bit19     index bit20     index bit21     index bit22     index bit23     index bit24     index bit25     index bit26     index bit27     index bit28     index bit29     index bit30     index bit31     index bit32 create 4 partitions tolerate 1 failures"
+exec python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=4 --space="${SPACE}" -- \
+     "${HYPERDEX_BUILDDIR}"/test/search-stress-test --quiet -h {HOST} -p {PORT} -k string
diff --git a/test/sh/search.simple.keytype=int,daemons=1.fault-tolerance=0.sh b/test/sh/search.simple.keytype=int,daemons=1.fault-tolerance=0.sh
new file mode 100755
index 000000000..922706aca
--- /dev/null
+++ b/test/sh/search.simple.keytype=int,daemons=1.fault-tolerance=0.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+SPACE="space search key int number attributes     bit01, bit02, bit03, bit04, bit05, bit06, bit07, bit08,     bit09, bit10, bit11, bit12, bit13, bit14, bit15, bit16,     bit17, bit18, bit19, bit20, bit21, bit22, bit23, bit24,     bit25, bit26, bit27, bit28, bit29, bit30, bit31, bit32 create 1 partitions tolerate 0 failures"
+exec python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=1 --space="${SPACE}" -- \
+     "${HYPERDEX_BUILDDIR}"/test/search-stress-test --quiet -h {HOST} -p {PORT} -k int
diff --git a/test/sh/search.simple.keytype=int,daemons=4.fault-tolerance=0.sh b/test/sh/search.simple.keytype=int,daemons=4.fault-tolerance=0.sh
new file mode 100755
index 000000000..90bb275ae
--- /dev/null
+++ b/test/sh/search.simple.keytype=int,daemons=4.fault-tolerance=0.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+SPACE="space search key int number attributes     bit01, bit02, bit03, bit04, bit05, bit06, bit07, bit08,     bit09, bit10, bit11, bit12, bit13, bit14, bit15, bit16,     bit17, bit18, bit19, bit20, bit21, bit22, bit23, bit24,     bit25, bit26, bit27, bit28, bit29, bit30, bit31, bit32 create 4 partitions tolerate 0 failures"
+exec python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=4 --space="${SPACE}" -- \
+     "${HYPERDEX_BUILDDIR}"/test/search-stress-test --quiet -h {HOST} -p {PORT} -k int
diff --git a/test/sh/search.simple.keytype=int,daemons=4.fault-tolerance=1.sh b/test/sh/search.simple.keytype=int,daemons=4.fault-tolerance=1.sh
new file mode 100755
index 000000000..f999e358f
--- /dev/null
+++ b/test/sh/search.simple.keytype=int,daemons=4.fault-tolerance=1.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+SPACE="space search key int number attributes     bit01, bit02, bit03, bit04, bit05, bit06, bit07, bit08,     bit09, bit10, bit11, bit12, bit13, bit14, bit15, bit16,     bit17, bit18, bit19, bit20, bit21, bit22, bit23, bit24,     bit25, bit26, bit27, bit28, bit29, bit30, bit31, bit32 create 4 partitions tolerate 1 failures"
+exec python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=4 --space="${SPACE}" -- \
+     "${HYPERDEX_BUILDDIR}"/test/search-stress-test --quiet -h {HOST} -p {PORT} -k int
diff --git a/test/sh/search.simple.keytype=string,daemons=1.fault-tolerance=0.sh b/test/sh/search.simple.keytype=string,daemons=1.fault-tolerance=0.sh
new file mode 100755
index 000000000..20c4487fe
--- /dev/null
+++ b/test/sh/search.simple.keytype=string,daemons=1.fault-tolerance=0.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+SPACE="space search key string number attributes     bit01, bit02, bit03, bit04, bit05, bit06, bit07, bit08,     bit09, bit10, bit11, bit12, bit13, bit14, bit15, bit16,     bit17, bit18, bit19, bit20, bit21, bit22, bit23, bit24,     bit25, bit26, bit27, bit28, bit29, bit30, bit31, bit32 create 1 partitions tolerate 0 failures"
+exec python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=1 --space="${SPACE}" -- \
+     "${HYPERDEX_BUILDDIR}"/test/search-stress-test --quiet -h {HOST} -p {PORT} -k string
diff --git a/test/sh/search.simple.keytype=string,daemons=4.fault-tolerance=0.sh b/test/sh/search.simple.keytype=string,daemons=4.fault-tolerance=0.sh
new file mode 100755
index 000000000..98ddb961c
--- /dev/null
+++ b/test/sh/search.simple.keytype=string,daemons=4.fault-tolerance=0.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+SPACE="space search key string number attributes     bit01, bit02, bit03, bit04, bit05, bit06, bit07, bit08,     bit09, bit10, bit11, bit12, bit13, bit14, bit15, bit16,     bit17, bit18, bit19, bit20, bit21, bit22, bit23, bit24,     bit25, bit26, bit27, bit28, bit29, bit30, bit31, bit32 create 4 partitions tolerate 0 failures"
+exec python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=4 --space="${SPACE}" -- \
+     "${HYPERDEX_BUILDDIR}"/test/search-stress-test --quiet -h {HOST} -p {PORT} -k string
diff --git a/test/sh/search.simple.keytype=string,daemons=4.fault-tolerance=1.sh b/test/sh/search.simple.keytype=string,daemons=4.fault-tolerance=1.sh
new file mode 100755
index 000000000..76fb05096
--- /dev/null
+++ b/test/sh/search.simple.keytype=string,daemons=4.fault-tolerance=1.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+SPACE="space search key string number attributes     bit01, bit02, bit03, bit04, bit05, bit06, bit07, bit08,     bit09, bit10, bit11, bit12, bit13, bit14, bit15, bit16,     bit17, bit18, bit19, bit20, bit21, bit22, bit23, bit24,     bit25, bit26, bit27, bit28, bit29, bit30, bit31, bit32 create 4 partitions tolerate 1 failures"
+exec python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=4 --space="${SPACE}" -- \
+     "${HYPERDEX_BUILDDIR}"/test/search-stress-test --quiet -h {HOST} -p {PORT} -k string
diff --git a/test/sh/search.subspace.keytype=int,daemons=1.fault-tolerance=0.sh b/test/sh/search.subspace.keytype=int,daemons=1.fault-tolerance=0.sh
new file mode 100755
index 000000000..349f01899
--- /dev/null
+++ b/test/sh/search.subspace.keytype=int,daemons=1.fault-tolerance=0.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+SPACE="space search key int number attributes     bit01, bit02, bit03, bit04, bit05, bit06, bit07, bit08,     bit09, bit10, bit11, bit12, bit13, bit14, bit15, bit16,     bit17, bit18, bit19, bit20, bit21, bit22, bit23, bit24,     bit25, bit26, bit27, bit28, bit29, bit30, bit31, bit32     subspace bit01, bit02, bit03, bit04, bit05, bit06, bit07, bit08     subspace bit09, bit10, bit11, bit12, bit13, bit14, bit15, bit16     subspace bit17, bit18, bit19, bit20, bit21, bit22, bit23, bit24     subspace bit25, bit26, bit27, bit28, bit29, bit30, bit31, bit32 create 1 partitions tolerate 0 failures"
+exec python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=1 --space="${SPACE}" -- \
+     "${HYPERDEX_BUILDDIR}"/test/search-stress-test --quiet -h {HOST} -p {PORT} -k int
diff --git a/test/sh/search.subspace.keytype=int,daemons=4.fault-tolerance=0.sh b/test/sh/search.subspace.keytype=int,daemons=4.fault-tolerance=0.sh
new file mode 100755
index 000000000..5c75ab2d8
--- /dev/null
+++ b/test/sh/search.subspace.keytype=int,daemons=4.fault-tolerance=0.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+SPACE="space search key int number attributes     bit01, bit02, bit03, bit04, bit05, bit06, bit07, bit08,     bit09, bit10, bit11, bit12, bit13, bit14, bit15, bit16,     bit17, bit18, bit19, bit20, bit21, bit22, bit23, bit24,     bit25, bit26, bit27, bit28, bit29, bit30, bit31, bit32     subspace bit01, bit02, bit03, bit04, bit05, bit06, bit07, bit08     subspace bit09, bit10, bit11, bit12, bit13, bit14, bit15, bit16     subspace bit17, bit18, bit19, bit20, bit21, bit22, bit23, bit24     subspace bit25, bit26, bit27, bit28, bit29, bit30, bit31, bit32 create 4 partitions tolerate 0 failures"
+exec python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=4 --space="${SPACE}" -- \
+     "${HYPERDEX_BUILDDIR}"/test/search-stress-test --quiet -h {HOST} -p {PORT} -k int
diff --git a/test/sh/search.subspace.keytype=int,daemons=4.fault-tolerance=1.sh b/test/sh/search.subspace.keytype=int,daemons=4.fault-tolerance=1.sh
new file mode 100755
index 000000000..918567ad4
--- /dev/null
+++ b/test/sh/search.subspace.keytype=int,daemons=4.fault-tolerance=1.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+SPACE="space search key int number attributes     bit01, bit02, bit03, bit04, bit05, bit06, bit07, bit08,     bit09, bit10, bit11, bit12, bit13, bit14, bit15, bit16,     bit17, bit18, bit19, bit20, bit21, bit22, bit23, bit24,     bit25, bit26, bit27, bit28, bit29, bit30, bit31, bit32     subspace bit01, bit02, bit03, bit04, bit05, bit06, bit07, bit08     subspace bit09, bit10, bit11, bit12, bit13, bit14, bit15, bit16     subspace bit17, bit18, bit19, bit20, bit21, bit22, bit23, bit24     subspace bit25, bit26, bit27, bit28, bit29, bit30, bit31, bit32 create 4 partitions tolerate 1 failures"
+exec python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=4 --space="${SPACE}" -- \
+     "${HYPERDEX_BUILDDIR}"/test/search-stress-test --quiet -h {HOST} -p {PORT} -k int
diff --git a/test/sh/search.subspace.keytype=string,daemons=1.fault-tolerance=0.sh b/test/sh/search.subspace.keytype=string,daemons=1.fault-tolerance=0.sh
new file mode 100755
index 000000000..c75097565
--- /dev/null
+++ b/test/sh/search.subspace.keytype=string,daemons=1.fault-tolerance=0.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+SPACE="space search key string number attributes     bit01, bit02, bit03, bit04, bit05, bit06, bit07, bit08,     bit09, bit10, bit11, bit12, bit13, bit14, bit15, bit16,     bit17, bit18, bit19, bit20, bit21, bit22, bit23, bit24,     bit25, bit26, bit27, bit28, bit29, bit30, bit31, bit32     subspace bit01, bit02, bit03, bit04, bit05, bit06, bit07, bit08     subspace bit09, bit10, bit11, bit12, bit13, bit14, bit15, bit16     subspace bit17, bit18, bit19, bit20, bit21, bit22, bit23, bit24     subspace bit25, bit26, bit27, bit28, bit29, bit30, bit31, bit32 create 1 partitions tolerate 0 failures"
+exec python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=1 --space="${SPACE}" -- \
+     "${HYPERDEX_BUILDDIR}"/test/search-stress-test --quiet -h {HOST} -p {PORT} -k string
diff --git a/test/sh/search.subspace.keytype=string,daemons=4.fault-tolerance=0.sh b/test/sh/search.subspace.keytype=string,daemons=4.fault-tolerance=0.sh
new file mode 100755
index 000000000..7b48f8204
--- /dev/null
+++ b/test/sh/search.subspace.keytype=string,daemons=4.fault-tolerance=0.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+SPACE="space search key string number attributes     bit01, bit02, bit03, bit04, bit05, bit06, bit07, bit08,     bit09, bit10, bit11, bit12, bit13, bit14, bit15, bit16,     bit17, bit18, bit19, bit20, bit21, bit22, bit23, bit24,     bit25, bit26, bit27, bit28, bit29, bit30, bit31, bit32     subspace bit01, bit02, bit03, bit04, bit05, bit06, bit07, bit08     subspace bit09, bit10, bit11, bit12, bit13, bit14, bit15, bit16     subspace bit17, bit18, bit19, bit20, bit21, bit22, bit23, bit24     subspace bit25, bit26, bit27, bit28, bit29, bit30, bit31, bit32 create 4 partitions tolerate 0 failures"
+exec python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=4 --space="${SPACE}" -- \
+     "${HYPERDEX_BUILDDIR}"/test/search-stress-test --quiet -h {HOST} -p {PORT} -k string
diff --git a/test/sh/search.subspace.keytype=string,daemons=4.fault-tolerance=1.sh b/test/sh/search.subspace.keytype=string,daemons=4.fault-tolerance=1.sh
new file mode 100755
index 000000000..6011ed191
--- /dev/null
+++ b/test/sh/search.subspace.keytype=string,daemons=4.fault-tolerance=1.sh
@@ -0,0 +1,4 @@
+#!/bin/sh
+SPACE="space search key string number attributes     bit01, bit02, bit03, bit04, bit05, bit06, bit07, bit08,     bit09, bit10, bit11, bit12, bit13, bit14, bit15, bit16,     bit17, bit18, bit19, bit20, bit21, bit22, bit23, bit24,     bit25, bit26, bit27, bit28, bit29, bit30, bit31, bit32     subspace bit01, bit02, bit03, bit04, bit05, bit06, bit07, bit08     subspace bit09, bit10, bit11, bit12, bit13, bit14, bit15, bit16     subspace bit17, bit18, bit19, bit20, bit21, bit22, bit23, bit24     subspace bit25, bit26, bit27, bit28, bit29, bit30, bit31, bit32 create 4 partitions tolerate 1 failures"
+exec python2 "${HYPERDEX_SRCDIR}"/test/runner.py --daemons=4 --space="${SPACE}" -- \
+     "${HYPERDEX_BUILDDIR}"/test/search-stress-test --quiet -h {HOST} -p {PORT} -k string
diff --git a/test/simple-consistency-stress-test.cc b/test/simple-consistency-stress-test.cc
index 84b34143e..645104513 100644
--- a/test/simple-consistency-stress-test.cc
+++ b/test/simple-consistency-stress-test.cc
@@ -64,8 +64,8 @@
 static long window = 128;
 static long repetitions = 1024;
 static int64_t threads = 16;
-static const char* space = "consistency";
-static const char* host = "127.0.0.1";
+static const char *space = "consistency";
+static const char *host = "127.0.0.1";
 static po6::net::ipaddr coord(host);
 static long port = 1982;
 static std::auto_ptr<po6::threads::barrier> barrier;
@@ -80,28 +80,40 @@ static uint64_t inconsistencies = 0;
 extern "C"
 {
 
-static struct poptOption popts[] = {
-    POPT_AUTOHELP
-    {"window-size", 'w', POPT_ARG_LONG, &window, 'w',
-        "the number of sequential keys which will be used for the test",
-        "keys"},
-    {"repetitiions", 'r', POPT_ARG_LONG, &repetitions, 'r',
-        "the number of tests which will be run before exiting",
-        "number"},
-    {"threads", 't', POPT_ARG_LONG, &threads, 't',
-        "the number of threads which will check for inconsistencies",
-        "number"},
-    {"space", 's', POPT_ARG_STRING, &space, 's',
-        "the HyperDex space to use",
-        "space"},
-    {"host", 'h', POPT_ARG_STRING, &host, 'h',
-        "the IP address of the coordinator",
-        "IP"},
-    {"port", 'p', POPT_ARG_LONG, &port, 'p',
-        "the port number of the coordinator",
-        "port"},
-    POPT_TABLEEND
-};
+	static struct poptOption popts[] =
+	{
+		POPT_AUTOHELP
+		{
+			"window-size", 'w', POPT_ARG_LONG, &window, 'w',
+			"the number of sequential keys which will be used for the test",
+			"keys"},
+		{
+			"repetitiions", 'r', POPT_ARG_LONG, &repetitions, 'r',
+			"the number of tests which will be run before exiting",
+			"number"
+		},
+		{
+			"threads", 't', POPT_ARG_LONG, &threads, 't',
+			"the number of threads which will check for inconsistencies",
+			"number"
+		},
+		{
+			"space", 's', POPT_ARG_STRING, &space, 's',
+			"the HyperDex space to use",
+			"space"
+		},
+		{
+			"host", 'h', POPT_ARG_STRING, &host, 'h',
+			"the IP address of the coordinator",
+			"IP"
+		},
+		{
+			"port", 'p', POPT_ARG_LONG, &port, 'p',
+			"the port number of the coordinator",
+			"port"
+		},
+		POPT_TABLEEND
+	};
 
 } // extern "C"
 
@@ -111,347 +123,288 @@ static void
 reader_thread();
 
 int
-main(int argc, const char* argv[])
+main(int argc, const char *argv[])
 {
-    poptContext poptcon;
-    poptcon = poptGetContext(NULL, argc, argv, popts, POPT_CONTEXT_POSIXMEHARDER);
-    e::guard g = e::makeguard(poptFreeContext, poptcon);
-    g.use_variable();
-    int rc;
-
-    while ((rc = poptGetNextOpt(poptcon)) != -1)
-    {
-        switch (rc)
-        {
-            case 'w':
-                if (window < 0)
-                {
-                    std::cerr << "window-size must be >= 0" << std::endl;
-                    return EXIT_FAILURE;
-                }
-
-                break;
-            case 'r':
-                if (repetitions < 0)
-                {
-                    std::cerr << "repetitions must be >= 0" << std::endl;
-                    return EXIT_FAILURE;
-                }
-
-                break;
-            case 't':
-                if (threads < 0)
-                {
-                    std::cerr << "threads must be >= 0" << std::endl;
-                    return EXIT_FAILURE;
-                }
-
-                break;
-            case 's':
-                break;
-            case 'h':
-                try
-                {
-                    coord = po6::net::ipaddr(host);
-                }
-                catch (std::invalid_argument& e)
-                {
-                    std::cerr << "cannot parse coordinator address" << std::endl;
-                    return EXIT_FAILURE;
-                }
-
-                break;
-            case 'p':
-                if (port >= (1 << 16))
-                {
-                    std::cerr << "port number out of range for TCP" << std::endl;
-                    return EXIT_FAILURE;
-                }
-
-                break;
-            case POPT_ERROR_NOARG:
-            case POPT_ERROR_BADOPT:
-            case POPT_ERROR_BADNUMBER:
-            case POPT_ERROR_OVERFLOW:
-                std::cerr << poptStrerror(rc) << " " << poptBadOption(poptcon, 0) << std::endl;
-                return EXIT_FAILURE;
-            case POPT_ERROR_OPTSTOODEEP:
-            case POPT_ERROR_BADQUOTE:
-            case POPT_ERROR_ERRNO:
-            default:
-                std::cerr << "logic error in argument parsing" << std::endl;
-                return EXIT_FAILURE;
-        }
-    }
-
-    barrier.reset(new po6::threads::barrier(threads + 1));
-    po6::threads::thread writer(writer_thread);
-    writer.start();
-    std::vector<e::compat::shared_ptr<po6::threads::thread> > readers;
-
-    for (int64_t i = 0; i < threads; ++i)
-    {
-        e::compat::shared_ptr<po6::threads::thread> tptr(new po6::threads::thread(reader_thread));
-        readers.push_back(tptr);
-        tptr->start();
-    }
-
-    writer.join();
-
-    bool success = __sync_bool_compare_and_swap(&done, 0, 1);
-    assert(success);
-
-    for (int64_t i = 0; i < threads; ++i)
-    {
-        readers[i]->join();
-    }
-
-    po6::threads::mutex::hold hold(&results_lock);
-    typedef std::map<hyperdex_client_returncode, uint64_t>::iterator result_iter_t;
-    std::cout << "Failed puts:" << std::endl;
-
-    for (result_iter_t o = failed_puts.begin(); o != failed_puts.end(); ++o)
-    {
-        std::cout << o->first << "\t" << o->second << std::endl;
-    }
-
-    std::cout << std::endl << "Failed loops:" << std::endl;
-
-    for (result_iter_t o = failed_loops.begin(); o != failed_loops.end(); ++o)
-    {
-        std::cout << o->first << "\t" << o->second << std::endl;
-    }
-
-    std::cout << std::endl << "Normal ops:" << std::endl;
-
-    for (result_iter_t o = ops.begin(); o != ops.end(); ++o)
-    {
-        std::cout << o->first << "\t" << o->second << std::endl;
-    }
-
-    std::cout << std::endl << "failed writes:  " << failed_writes << std::endl
-              << "Inconsistencies:  " << inconsistencies << std::endl;
-    return EXIT_SUCCESS;
+	poptContext poptcon;
+	poptcon = poptGetContext(NULL, argc, argv, popts, POPT_CONTEXT_POSIXMEHARDER);
+	e::guard g = e::makeguard(poptFreeContext, poptcon);
+	g.use_variable();
+	int rc;
+	while ((rc = poptGetNextOpt(poptcon)) != -1)
+	{
+		switch (rc)
+		{
+		case 'w':
+			if (window < 0)
+			{
+				std::cerr << "window-size must be >= 0" << std::endl;
+				return EXIT_FAILURE;
+			}
+			break;
+		case 'r':
+			if (repetitions < 0)
+			{
+				std::cerr << "repetitions must be >= 0" << std::endl;
+				return EXIT_FAILURE;
+			}
+			break;
+		case 't':
+			if (threads < 0)
+			{
+				std::cerr << "threads must be >= 0" << std::endl;
+				return EXIT_FAILURE;
+			}
+			break;
+		case 's':
+			break;
+		case 'h':
+			try
+			{
+				coord = po6::net::ipaddr(host);
+			}
+			catch (std::invalid_argument &e)
+			{
+				std::cerr << "cannot parse coordinator address" << std::endl;
+				return EXIT_FAILURE;
+			}
+			break;
+		case 'p':
+			if (port >= (1 << 16))
+			{
+				std::cerr << "port number out of range for TCP" << std::endl;
+				return EXIT_FAILURE;
+			}
+			break;
+		case POPT_ERROR_NOARG:
+		case POPT_ERROR_BADOPT:
+		case POPT_ERROR_BADNUMBER:
+		case POPT_ERROR_OVERFLOW:
+			std::cerr << poptStrerror(rc) << " " << poptBadOption(poptcon, 0) << std::endl;
+			return EXIT_FAILURE;
+		case POPT_ERROR_OPTSTOODEEP:
+		case POPT_ERROR_BADQUOTE:
+		case POPT_ERROR_ERRNO:
+		default:
+			std::cerr << "logic error in argument parsing" << std::endl;
+			return EXIT_FAILURE;
+		}
+	}
+	barrier.reset(new po6::threads::barrier(threads + 1));
+	po6::threads::thread writer(writer_thread);
+	writer.start();
+	std::vector<e::compat::shared_ptr<po6::threads::thread> > readers;
+	for (int64_t i = 0; i < threads; ++i)
+	{
+		e::compat::shared_ptr<po6::threads::thread> tptr(new po6::threads::thread(reader_thread));
+		readers.push_back(tptr);
+		tptr->start();
+	}
+	writer.join();
+	bool success = __sync_bool_compare_and_swap(&done, 0, 1);
+	assert(success);
+	for (int64_t i = 0; i < threads; ++i)
+	{
+		readers[i]->join();
+	}
+	po6::threads::mutex::hold hold(&results_lock);
+	typedef std::map<hyperdex_client_returncode, uint64_t>::iterator result_iter_t;
+	std::cout << "Failed puts:" << std::endl;
+	for (result_iter_t o = failed_puts.begin(); o != failed_puts.end(); ++o)
+	{
+		std::cout << o->first << "\t" << o->second << std::endl;
+	}
+	std::cout << std::endl << "Failed loops:" << std::endl;
+	for (result_iter_t o = failed_loops.begin(); o != failed_loops.end(); ++o)
+	{
+		std::cout << o->first << "\t" << o->second << std::endl;
+	}
+	std::cout << std::endl << "Normal ops:" << std::endl;
+	for (result_iter_t o = ops.begin(); o != ops.end(); ++o)
+	{
+		std::cout << o->first << "\t" << o->second << std::endl;
+	}
+	std::cout << std::endl << "failed writes:  " << failed_writes << std::endl
+	          << "Inconsistencies:  " << inconsistencies << std::endl;
+	return EXIT_SUCCESS;
 }
 
 static void
 writer_thread()
 {
-    std::map<hyperdex_client_returncode, uint64_t> lfailed_puts;
-    std::map<hyperdex_client_returncode, uint64_t> lfailed_loops;
-    std::map<hyperdex_client_returncode, uint64_t> lops;
-    uint64_t lfailed_writes = 0;
-    hyperdex::Client cl(host, port);
-    bool fail = false;
-
-    for (int64_t i = 0; i < window; ++i)
-    {
-        int64_t key = i;
-        int64_t did;
-        hyperdex_client_returncode dstatus;
-
-        const char* keystr = reinterpret_cast<const char*>(&key);
-        did = cl.del(space, keystr, sizeof(key), &dstatus);
-
-        if (did < 0)
-        {
-            std::cerr << "delete failed with " << dstatus << std::endl;
-            fail = true;
-            break;
-        }
-
-        int64_t lid;
-        hyperdex_client_returncode lstatus;
-        lid = cl.loop(-1, &lstatus);
-
-        if (lid < 0)
-        {
-            std::cerr << "loop failed with " << lstatus << std::endl;
-            fail = true;
-            break;
-        }
-
-        assert(lid == did);
-
-        if (dstatus != HYPERDEX_CLIENT_SUCCESS && dstatus != HYPERDEX_CLIENT_NOTFOUND)
-        {
-            std::cerr << "delete returned " << dstatus << std::endl;
-            fail = true;
-            break;
-        }
-    }
-
-    barrier->wait();
-
-    if (fail)
-    {
-        std::cerr << "the above errors are fatal" << std::endl;
-        return;
-    }
-
-    std::cout << "starting the consistency stress test" << std::endl;
-
-    for (int64_t r = 0; r < repetitions; ++r)
-    {
-        for (int64_t i = 0; i < window; ++i)
-        {
-            uint64_t count = 0;
-
-            for (count = 0; count < 65536; ++count)
-            {
-                int64_t key = i;
-                int64_t val = r;
-                int64_t pid;
-                hyperdex_client_attribute attr;
-                hyperdex_client_returncode pstatus;
-
-                const char* keystr = reinterpret_cast<const char*>(&key);
-                attr.attr = "repetition";
-                attr.value = reinterpret_cast<const char*>(&val);
-                attr.value_sz = sizeof(val);
-                attr.datatype = HYPERDATATYPE_STRING;
-                pid = cl.put(space, keystr, sizeof(key), &attr, 1, &pstatus);
-
-                if (pid < 0)
-                {
-                    ++lfailed_puts[pstatus];
-                    continue;
-                }
-
-                int64_t lid;
-                hyperdex_client_returncode lstatus;
-                lid = cl.loop(-1, &lstatus);
-
-                if (lid < 0)
-                {
-                    ++lfailed_loops[lstatus];
-                    continue;
-                }
-
-                assert(lid == pid);
-                ++lops[pstatus];
-                break;
-            }
-
-            if (count == 65536)
-            {
-                ++lfailed_writes;
-            }
-        }
-
-        std::cout << "done " << r << "/" << repetitions << std::endl;
-    }
-
-    po6::threads::mutex::hold hold(&results_lock);
-    typedef std::map<hyperdex_client_returncode, uint64_t>::iterator result_iter_t;
-
-    for (result_iter_t o = lfailed_puts.begin(); o != lfailed_puts.end(); ++o)
-    {
-        failed_puts[o->first] += o->second;
-    }
-
-    for (result_iter_t o = lfailed_loops.begin(); o != lfailed_loops.end(); ++o)
-    {
-        failed_loops[o->first] += o->second;
-    }
-
-    for (result_iter_t o = lops.begin(); o != lops.end(); ++o)
-    {
-        ops[o->first] += o->second;
-    }
-
-    failed_writes = lfailed_writes;
+	std::map<hyperdex_client_returncode, uint64_t> lfailed_puts;
+	std::map<hyperdex_client_returncode, uint64_t> lfailed_loops;
+	std::map<hyperdex_client_returncode, uint64_t> lops;
+	uint64_t lfailed_writes = 0;
+	hyperdex::Client cl(host, port);
+	bool fail = false;
+	for (int64_t i = 0; i < window; ++i)
+	{
+		int64_t key = i;
+		int64_t did;
+		hyperdex_client_returncode dstatus;
+		const char *keystr = reinterpret_cast<const char *>(&key);
+		did = cl.del(space, keystr, sizeof(key), &dstatus);
+		if (did < 0)
+		{
+			std::cerr << "delete failed with " << dstatus << std::endl;
+			fail = true;
+			break;
+		}
+		int64_t lid;
+		hyperdex_client_returncode lstatus;
+		lid = cl.loop(-1, &lstatus);
+		if (lid < 0)
+		{
+			std::cerr << "loop failed with " << lstatus << std::endl;
+			fail = true;
+			break;
+		}
+		assert(lid == did);
+		if (dstatus != HYPERDEX_CLIENT_SUCCESS && dstatus != HYPERDEX_CLIENT_NOTFOUND)
+		{
+			std::cerr << "delete returned " << dstatus << std::endl;
+			fail = true;
+			break;
+		}
+	}
+	barrier->wait();
+	if (fail)
+	{
+		std::cerr << "the above errors are fatal" << std::endl;
+		return;
+	}
+	std::cout << "starting the consistency stress test" << std::endl;
+	for (int64_t r = 0; r < repetitions; ++r)
+	{
+		for (int64_t i = 0; i < window; ++i)
+		{
+			uint64_t count = 0;
+			for (count = 0; count < 65536; ++count)
+			{
+				int64_t key = i;
+				int64_t val = r;
+				int64_t pid;
+				hyperdex_client_attribute attr;
+				hyperdex_client_returncode pstatus;
+				const char *keystr = reinterpret_cast<const char *>(&key);
+				attr.attr = "repetition";
+				attr.value = reinterpret_cast<const char *>(&val);
+				attr.value_sz = sizeof(val);
+				attr.datatype = HYPERDATATYPE_STRING;
+				pid = cl.put(space, keystr, sizeof(key), &attr, 1, &pstatus);
+				if (pid < 0)
+				{
+					++lfailed_puts[pstatus];
+					continue;
+				}
+				int64_t lid;
+				hyperdex_client_returncode lstatus;
+				lid = cl.loop(-1, &lstatus);
+				if (lid < 0)
+				{
+					++lfailed_loops[lstatus];
+					continue;
+				}
+				assert(lid == pid);
+				++lops[pstatus];
+				break;
+			}
+			if (count == 65536)
+			{
+				++lfailed_writes;
+			}
+		}
+		std::cout << "done " << r << "/" << repetitions << std::endl;
+	}
+	po6::threads::mutex::hold hold(&results_lock);
+	typedef std::map<hyperdex_client_returncode, uint64_t>::iterator result_iter_t;
+	for (result_iter_t o = lfailed_puts.begin(); o != lfailed_puts.end(); ++o)
+	{
+		failed_puts[o->first] += o->second;
+	}
+	for (result_iter_t o = lfailed_loops.begin(); o != lfailed_loops.end(); ++o)
+	{
+		failed_loops[o->first] += o->second;
+	}
+	for (result_iter_t o = lops.begin(); o != lops.end(); ++o)
+	{
+		ops[o->first] += o->second;
+	}
+	failed_writes = lfailed_writes;
 }
 
 static void
 reader_thread()
 {
-    std::map<hyperdex_client_returncode, uint64_t> lfailed_puts;
-    std::map<hyperdex_client_returncode, uint64_t> lfailed_loops;
-    std::map<hyperdex_client_returncode, uint64_t> lops;
-    uint64_t linconsistencies = 0;
-    hyperdex::Client cl(host, port);
-    barrier->wait();
-
-    while (!__sync_bool_compare_and_swap(&done, 1, 1))
-    {
-        for (int64_t i = window - 1; i >= 0; --i)
-        {
-            int64_t oldval = 0;
-
-            while (true)
-            {
-                int64_t key = i;
-                int64_t gid;
-                const hyperdex_client_attribute* attrs = NULL;
-                size_t attrs_sz = 0;
-                hyperdex_client_returncode gstatus;
-
-                const char* keystr = reinterpret_cast<const char*>(&key);
-                gid = cl.get(space, keystr, sizeof(key), &gstatus, &attrs, &attrs_sz);
-
-                if (gid < 0)
-                {
-                    ++lfailed_puts[gstatus];
-                    continue;
-                }
-
-                int64_t lid;
-                hyperdex_client_returncode lstatus;
-                lid = cl.loop(-1, &lstatus);
-
-                if (lid < 0)
-                {
-                    ++lfailed_loops[lstatus];
-                    continue;
-                }
-
-                assert(lid == gid);
-                ++lops[gstatus];
-
-                if (gstatus == HYPERDEX_CLIENT_SUCCESS)
-                {
-                    assert(attrs_sz == 1);
-                    assert(strcmp(attrs[0].attr, "repetition") == 0);
-                    int64_t val = 0;
-                    memmove(&val, attrs[0].value, attrs[0].value_sz);
-                    assert(attrs[0].datatype == HYPERDATATYPE_STRING);
-
-                    if (val < oldval)
-                    {
-                        ++inconsistencies;
-                    }
-
-                    oldval = val;
-                }
-
-                if (attrs)
-                {
-                    hyperdex_client_destroy_attrs(attrs, attrs_sz);
-                }
-
-                break;
-            }
-        }
-    }
-
-    po6::threads::mutex::hold hold(&results_lock);
-    typedef std::map<hyperdex_client_returncode, uint64_t>::iterator result_iter_t;
-
-    for (result_iter_t o = lfailed_puts.begin(); o != lfailed_puts.end(); ++o)
-    {
-        failed_puts[o->first] += o->second;
-    }
-
-    for (result_iter_t o = lfailed_loops.begin(); o != lfailed_loops.end(); ++o)
-    {
-        failed_loops[o->first] += o->second;
-    }
-
-    for (result_iter_t o = lops.begin(); o != lops.end(); ++o)
-    {
-        ops[o->first] += o->second;
-    }
-
-    inconsistencies += linconsistencies;
+	std::map<hyperdex_client_returncode, uint64_t> lfailed_puts;
+	std::map<hyperdex_client_returncode, uint64_t> lfailed_loops;
+	std::map<hyperdex_client_returncode, uint64_t> lops;
+	uint64_t linconsistencies = 0;
+	hyperdex::Client cl(host, port);
+	barrier->wait();
+	while (!__sync_bool_compare_and_swap(&done, 1, 1))
+	{
+		for (int64_t i = window - 1; i >= 0; --i)
+		{
+			int64_t oldval = 0;
+			while (true)
+			{
+				int64_t key = i;
+				int64_t gid;
+				const hyperdex_client_attribute *attrs = NULL;
+				size_t attrs_sz = 0;
+				hyperdex_client_returncode gstatus;
+				const char *keystr = reinterpret_cast<const char *>(&key);
+				gid = cl.get(space, keystr, sizeof(key), &gstatus, &attrs, &attrs_sz);
+				if (gid < 0)
+				{
+					++lfailed_puts[gstatus];
+					continue;
+				}
+				int64_t lid;
+				hyperdex_client_returncode lstatus;
+				lid = cl.loop(-1, &lstatus);
+				if (lid < 0)
+				{
+					++lfailed_loops[lstatus];
+					continue;
+				}
+				assert(lid == gid);
+				++lops[gstatus];
+				if (gstatus == HYPERDEX_CLIENT_SUCCESS)
+				{
+					assert(attrs_sz == 1);
+					assert(strcmp(attrs[0].attr, "repetition") == 0);
+					int64_t val = 0;
+					memmove(&val, attrs[0].value, attrs[0].value_sz);
+					assert(attrs[0].datatype == HYPERDATATYPE_STRING);
+					if (val < oldval)
+					{
+						++inconsistencies;
+					}
+					oldval = val;
+				}
+				if (attrs)
+				{
+					hyperdex_client_destroy_attrs(attrs, attrs_sz);
+				}
+				break;
+			}
+		}
+	}
+	po6::threads::mutex::hold hold(&results_lock);
+	typedef std::map<hyperdex_client_returncode, uint64_t>::iterator result_iter_t;
+	for (result_iter_t o = lfailed_puts.begin(); o != lfailed_puts.end(); ++o)
+	{
+		failed_puts[o->first] += o->second;
+	}
+	for (result_iter_t o = lfailed_loops.begin(); o != lfailed_loops.end(); ++o)
+	{
+		failed_loops[o->first] += o->second;
+	}
+	for (result_iter_t o = lops.begin(); o != lops.end(); ++o)
+	{
+		ops[o->first] += o->second;
+	}
+	inconsistencies += linconsistencies;
 }
diff --git a/test/th.cc b/test/th.cc
index 3f4c20e66..7847300e4 100644
--- a/test/th.cc
+++ b/test/th.cc
@@ -38,173 +38,159 @@
 // th
 #include "th.h"
 
-static std::vector<th::test_base*>* _th_tests = NULL;
+static std::vector<th::test_base *> *_th_tests = NULL;
 
 class escape_from_test_failure
 {
-    public:
-        escape_from_test_failure() {}
+public:
+	escape_from_test_failure() {}
 };
 
-th :: test_base :: test_base(const char* group,
-                             const char* name,
-                             const char* file,
+th :: test_base :: test_base(const char *group,
+                             const char *name,
+                             const char *file,
                              size_t line)
-    : m_group(group)
-    , m_name(name)
-    , m_file(file)
-    , m_line(line)
+	: m_group(group)
+	, m_name(name)
+	, m_file(file)
+	, m_line(line)
 {
-    if (_th_tests == NULL)
-    {
-        _th_tests = new std::vector<th::test_base*>();
-    }
-
-    _th_tests->push_back(this);
+	if (_th_tests == NULL)
+	{
+		_th_tests = new std::vector<th::test_base *>();
+	}
+	_th_tests->push_back(this);
 }
 
 void
-th :: test_base :: run(bool quiet, bool* failed)
+th :: test_base :: run(bool quiet, bool *failed)
 {
-    if (!quiet) std::cerr << "===== Test " << m_group << "::" << m_name << " @ " << m_file << ":" << m_line << std::endl;
-
-    try
-    {
-        this->_run();
-        *failed = false;
-    }
-    catch (escape_from_test_failure& ttotf)
-    {
-        *failed = true;
-    }
+	if (!quiet) std::cerr << "===== Test " << m_group << "::" << m_name << " @ " << m_file << ":" << m_line << std::endl;
+	try
+	{
+		this->_run();
+		*failed = false;
+	}
+	catch (escape_from_test_failure &ttotf)
+	{
+		*failed = true;
+	}
 }
 
 bool
-th :: test_base :: operator < (const test_base& rhs) const
+th :: test_base :: operator < (const test_base &rhs) const
 {
-    return compare(rhs) < 0;
+	return compare(rhs) < 0;
 }
 
 int
-th :: test_base :: compare(const test_base& rhs) const
+th :: test_base :: compare(const test_base &rhs) const
 {
-    const test_base& lhs(*this);
-    int cmp;
-
-    // Compare file
-    cmp = strcmp(lhs.m_file, rhs.m_file);
-
-    if (cmp < 0)
-    {
-        return -1;
-    }
-    if (cmp > 0)
-    {
-        return 1;
-    }
-
-    // Compare line
-    if (lhs.m_line < rhs.m_line)
-    {
-        return -1;
-    }
-    if (lhs.m_line > rhs.m_line)
-    {
-        return 1;
-    }
-
-    // Compare group
-    cmp = strcmp(lhs.m_group, rhs.m_group);
-
-    if (cmp < 0)
-    {
-        return -1;
-    }
-    if (cmp > 0)
-    {
-        return 1;
-    }
-
-    // Compare name
-    cmp = strcmp(lhs.m_name, rhs.m_name);
-
-    if (cmp < 0)
-    {
-        return -1;
-    }
-    if (cmp > 0)
-    {
-        return 1;
-    }
-
-    return 0;
+	const test_base &lhs(*this);
+	int cmp;
+	// Compare file
+	cmp = strcmp(lhs.m_file, rhs.m_file);
+	if (cmp < 0)
+	{
+		return -1;
+	}
+	if (cmp > 0)
+	{
+		return 1;
+	}
+	// Compare line
+	if (lhs.m_line < rhs.m_line)
+	{
+		return -1;
+	}
+	if (lhs.m_line > rhs.m_line)
+	{
+		return 1;
+	}
+	// Compare group
+	cmp = strcmp(lhs.m_group, rhs.m_group);
+	if (cmp < 0)
+	{
+		return -1;
+	}
+	if (cmp > 0)
+	{
+		return 1;
+	}
+	// Compare name
+	cmp = strcmp(lhs.m_name, rhs.m_name);
+	if (cmp < 0)
+	{
+		return -1;
+	}
+	if (cmp > 0)
+	{
+		return 1;
+	}
+	return 0;
 }
 
-th :: predicate :: predicate(const char* file, size_t line, const char* a, const char* b)
-    : m_file(file)
-    , m_line(line)
-    , m_a(a)
-    , m_b(b)
+th :: predicate :: predicate(const char *file, size_t line, const char *a, const char *b)
+	: m_file(file)
+	, m_line(line)
+	, m_a(a)
+	, m_b(b)
 {
 }
 
 void
 th :: predicate :: assert_true(bool T)
 {
-    if (!T)
-    {
-        std::cerr << "FAIL @ " << m_file << ":" << m_line << ": tested " << m_a << "; expected true, but got false" << std::endl;
-        th::fail();
-    }
+	if (!T)
+	{
+		std::cerr << "FAIL @ " << m_file << ":" << m_line << ": tested " << m_a << "; expected true, but got false" << std::endl;
+		th::fail();
+	}
 }
 
 void
 th :: predicate :: assert_false(bool F)
 {
-    if (F)
-    {
-        std::cerr << "FAIL @ " << m_file << ":" << m_line << ": tested " << m_a << "; expected false, but got true" << std::endl;
-        th::fail();
-    }
+	if (F)
+	{
+		std::cerr << "FAIL @ " << m_file << ":" << m_line << ": tested " << m_a << "; expected false, but got true" << std::endl;
+		th::fail();
+	}
 }
 
 void
 th :: predicate :: fail()
 {
-    std::cerr << "FAIL @ " << m_file << ":" << m_line << ": forced fail" << std::endl;
-    th::fail();
+	std::cerr << "FAIL @ " << m_file << ":" << m_line << ": forced fail" << std::endl;
+	th::fail();
 }
 
 static bool
-compare_test_base_ptrs(const th::test_base* lhs, const th::test_base* rhs)
+compare_test_base_ptrs(const th::test_base *lhs, const th::test_base *rhs)
 {
-    return *lhs < *rhs;
+	return *lhs < *rhs;
 }
 
 int
 th :: run_tests(bool quiet)
 {
-    if (!_th_tests)
-    {
-        return 0;
-    }
-
-    std::sort(_th_tests->begin(), _th_tests->end(), compare_test_base_ptrs);
-    const std::vector<th::test_base*>& th_tests(*_th_tests);
-    int failures = 0;
-
-    for (size_t i = 0; i < th_tests.size(); ++i)
-    {
-        bool fail = false;
-        th_tests[i]->run(quiet, &fail);
-
-        if (fail)
-        {
-            ++failures;
-        }
-    }
-
-    return failures;
+	if (!_th_tests)
+	{
+		return 0;
+	}
+	std::sort(_th_tests->begin(), _th_tests->end(), compare_test_base_ptrs);
+	const std::vector<th::test_base *> &th_tests(*_th_tests);
+	int failures = 0;
+	for (size_t i = 0; i < th_tests.size(); ++i)
+	{
+		bool fail = false;
+		th_tests[i]->run(quiet, &fail);
+		if (fail)
+		{
+			++failures;
+		}
+	}
+	return failures;
 }
 
 #pragma GCC diagnostic ignored "-Wsuggest-attribute=noreturn"
@@ -212,6 +198,6 @@ th :: run_tests(bool quiet)
 void
 th :: fail()
 {
-    escape_from_test_failure eftf;
-    throw eftf;
+	escape_from_test_failure eftf;
+	throw eftf;
 }
diff --git a/test/th.h b/test/th.h
index dca6ef724..15888fb04 100644
--- a/test/th.h
+++ b/test/th.h
@@ -50,68 +50,68 @@ fail();
 
 class test_base
 {
-    public:
-        test_base(const char* group,
-             const char* name,
-             const char* file,
-             size_t line);
-        virtual ~test_base() throw () {}
-
-    public:
-        void run(bool quiet, bool* failed);
-
-    public:
-        bool operator < (const test_base& rhs) const;
-
-    private:
-        virtual void _run() = 0;
-        int compare(const test_base& rhs) const;
-
-    private:
-        test_base(const test_base&);
-        test_base& operator = (const test_base&);
-
-    private:
-        const char* m_group;
-        const char* m_name;
-        const char* m_file;
-        size_t m_line;
+public:
+	test_base(const char *group,
+	          const char *name,
+	          const char *file,
+	          size_t line);
+	virtual ~test_base() throw () {}
+
+public:
+	void run(bool quiet, bool *failed);
+
+public:
+	bool operator < (const test_base &rhs) const;
+
+private:
+	virtual void _run() = 0;
+	int compare(const test_base &rhs) const;
+
+private:
+	test_base(const test_base &);
+	test_base &operator = (const test_base &);
+
+private:
+	const char *m_group;
+	const char *m_name;
+	const char *m_file;
+	size_t m_line;
 };
 
 #define BINARY_PREDICATE(english, compiler) \
-    template <typename A, typename B> \
-    void \
-    assert_ ## english(const A& a, const B& b) \
-    { \
-        if (!(a compiler b)) \
-        { \
-            std::cerr << "FAIL @ " << m_file << ":" << m_line << ": tested " << m_a << " " TH_XSTR(compiler) " " << m_b << "; got " << a << " " TH_XSTR(compiler) " " << b << std::endl; \
-            th::fail(); \
-        } \
-    }
+	template <typename A, typename B> \
+	void \
+	assert_ ## english(const A& a, const B& b) \
+	{ \
+		if (!(a compiler b)) \
+		{ \
+			std::cerr << "FAIL @ " << m_file << ":" << m_line << ": tested " << m_a << " " TH_XSTR(compiler) " " << m_b << "; got " << a << " " TH_XSTR(compiler) " " << b << std::endl; \
+			th::fail(); \
+		} \
+	}
 
 class predicate
 {
-    public:
-        predicate(const char* file,
-                  size_t line,
-                  const char* a,
-                  const char* b);
-        void assert_true(bool T);
-        void assert_false(bool F);
-        BINARY_PREDICATE(lt, <)
-        BINARY_PREDICATE(le, <=)
-        BINARY_PREDICATE(eq, ==)
-        BINARY_PREDICATE(ne, !=)
-        BINARY_PREDICATE(ge, >=)
-        BINARY_PREDICATE(gt, >)
-        void fail();
-
-    private:
-        const char* m_file;
-        size_t m_line;
-        const char* m_a;
-        const char* m_b;
+public:
+	predicate(const char *file,
+	          size_t line,
+	          const char *a,
+	          const char *b);
+	void assert_true(bool T);
+	void assert_false(bool F);
+	BINARY_PREDICATE(lt, < )
+	BINARY_PREDICATE(le, <= )
+	BINARY_PREDICATE(eq, == )
+	BINARY_PREDICATE(ne, != )
+	BINARY_PREDICATE(ge, >= )
+	BINARY_PREDICATE(gt, > )
+	void fail();
+
+private:
+	const char *m_file;
+	size_t m_line;
+	const char *m_a;
+	const char *m_b;
 };
 
 #undef BINARY_PREDICATE
@@ -119,17 +119,17 @@ class predicate
 } // namespace th
 
 #define TEST(GROUP, NAME) \
-    class TH_CONCAT(GROUP, TH_CONCAT(_, TH_CONCAT(NAME, TH_CONCAT(_, __LINE__)))) : public th::test_base \
-    { \
-        public: \
-            TH_CONCAT(GROUP, TH_CONCAT(_, TH_CONCAT(NAME, TH_CONCAT(_, __LINE__))))() \
-                : test_base(TH_STR(GROUP), TH_STR(NAME), __FILE__, __LINE__) {} \
-        protected: \
-            virtual void _run(); \
-    }; \
-    TH_CONCAT(GROUP, TH_CONCAT(_, TH_CONCAT(NAME, TH_CONCAT(_, __LINE__)))) \
-        TH_CONCAT(_test_instance_, TH_CONCAT(GROUP, TH_CONCAT(_, TH_CONCAT(NAME, TH_CONCAT(_, __LINE__))))); \
-    void TH_CONCAT(GROUP, TH_CONCAT(_, TH_CONCAT(NAME, TH_CONCAT(_, __LINE__)))) :: _run()
+	class TH_CONCAT(GROUP, TH_CONCAT(_, TH_CONCAT(NAME, TH_CONCAT(_, __LINE__)))) : public th::test_base \
+	{ \
+	public: \
+		TH_CONCAT(GROUP, TH_CONCAT(_, TH_CONCAT(NAME, TH_CONCAT(_, __LINE__))))() \
+			: test_base(TH_STR(GROUP), TH_STR(NAME), __FILE__, __LINE__) {} \
+	protected: \
+		virtual void _run(); \
+	}; \
+	TH_CONCAT(GROUP, TH_CONCAT(_, TH_CONCAT(NAME, TH_CONCAT(_, __LINE__)))) \
+	TH_CONCAT(_test_instance_, TH_CONCAT(GROUP, TH_CONCAT(_, TH_CONCAT(NAME, TH_CONCAT(_, __LINE__))))); \
+	void TH_CONCAT(GROUP, TH_CONCAT(_, TH_CONCAT(NAME, TH_CONCAT(_, __LINE__)))) :: _run()
 
 #define ASSERT_TRUE(P)  th::predicate(__FILE__, __LINE__, TH_STR(P), NULL).assert_true(P)
 #define ASSERT_FALSE(P) th::predicate(__FILE__, __LINE__, TH_STR(P), NULL).assert_false(P)
diff --git a/test/th_main.cc b/test/th_main.cc
index df15ad215..980c30b12 100644
--- a/test/th_main.cc
+++ b/test/th_main.cc
@@ -32,14 +32,12 @@
 #include "th.h"
 
 int
-main(int argc, char* argv[])
+main(int argc, char *argv[])
 {
-    bool quiet = false;
-
-    for (int i = 1; i < argc; ++i)
-    {
-        quiet = quiet || strcmp(argv[i], "--quiet") == 0;
-    }
-
-    return th::run_tests(quiet);
+	bool quiet = false;
+	for (int i = 1; i < argc; ++i)
+	{
+		quiet = quiet || strcmp(argv[i], "--quiet") == 0;
+	}
+	return th::run_tests(quiet);
 }
diff --git a/tools/add-index.cc b/tools/add-index.cc
index ebc6f94ff..0626fdf43 100644
--- a/tools/add-index.cc
+++ b/tools/add-index.cc
@@ -33,66 +33,56 @@
 #include "tools/common.h"
 
 int
-main(int argc, const char* argv[])
+main(int argc, const char *argv[])
 {
-    hyperdex::connect_opts conn;
-    e::argparser ap;
-    ap.autohelp();
-    ap.add("Connect to a cluster:", conn.parser());
-
-    if (!ap.parse(argc, argv))
-    {
-        return EXIT_FAILURE;
-    }
-
-    if (ap.args_sz() != 2)
-    {
-        std::cerr << "please specify the space and attribute to index\n" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    if (!conn.validate())
-    {
-        std::cerr << "invalid host:port specification\n" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    try
-    {
-        hyperdex::Admin h(conn.host(), conn.port());
-        hyperdex_admin_returncode rrc;
-        int64_t rid = h.add_index(ap.args()[0], ap.args()[1], &rrc);
-
-        if (rid < 0)
-        {
-            std::cerr << "could not add index: " << rrc << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        hyperdex_admin_returncode lrc;
-        int64_t lid = h.loop(-1, &lrc);
-
-        if (lid < 0)
-        {
-            std::cerr << "could not add index: " << lrc << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        assert(rid == lid);
-
-        if (rrc != HYPERDEX_ADMIN_SUCCESS)
-        {
-            std::cerr << "could not add index: " << rrc << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        return EXIT_SUCCESS;
-    }
-    catch (std::exception& e)
-    {
-        std::cerr << "error: " << e.what() << std::endl;
-        return EXIT_FAILURE;
-    }
+	hyperdex::connect_opts conn;
+	e::argparser ap;
+	ap.autohelp();
+	ap.add("Connect to a cluster:", conn.parser());
+	if (!ap.parse(argc, argv))
+	{
+		return EXIT_FAILURE;
+	}
+	if (ap.args_sz() != 2)
+	{
+		std::cerr << "please specify the space and attribute to index\n" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	if (!conn.validate())
+	{
+		std::cerr << "invalid host:port specification\n" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	try
+	{
+		hyperdex::Admin h(conn.host(), conn.port());
+		hyperdex_admin_returncode rrc;
+		int64_t rid = h.add_index(ap.args()[0], ap.args()[1], &rrc);
+		if (rid < 0)
+		{
+			std::cerr << "could not add index: " << rrc << std::endl;
+			return EXIT_FAILURE;
+		}
+		hyperdex_admin_returncode lrc;
+		int64_t lid = h.loop(-1, &lrc);
+		if (lid < 0)
+		{
+			std::cerr << "could not add index: " << lrc << std::endl;
+			return EXIT_FAILURE;
+		}
+		assert(rid == lid);
+		if (rrc != HYPERDEX_ADMIN_SUCCESS)
+		{
+			std::cerr << "could not add index: " << rrc << std::endl;
+			return EXIT_FAILURE;
+		}
+		return EXIT_SUCCESS;
+	}
+	catch (std::exception &e)
+	{
+		std::cerr << "error: " << e.what() << std::endl;
+		return EXIT_FAILURE;
+	}
 }
diff --git a/tools/add-space.cc b/tools/add-space.cc
index 15e8dfcc6..130143466 100644
--- a/tools/add-space.cc
+++ b/tools/add-space.cc
@@ -33,81 +33,69 @@
 #include "tools/common.h"
 
 int
-main(int argc, const char* argv[])
+main(int argc, const char *argv[])
 {
-    hyperdex::connect_opts conn;
-    e::argparser ap;
-    ap.autohelp();
-    ap.add("Connect to a cluster:", conn.parser());
-
-    if (!ap.parse(argc, argv))
-    {
-        return EXIT_FAILURE;
-    }
-
-    if (!conn.validate())
-    {
-        std::cerr << "invalid host:port specification\n" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    if (ap.args_sz() != 0)
-    {
-        std::cerr << "command takes no arguments" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    std::string description;
-    std::string s;
-
-    while (std::cin >> s)
-    {
-        if (!description.empty())
-        {
-            description += " " + s;
-        }
-        else
-        {
-            description += s;
-        }
-    }
-
-    try
-    {
-        hyperdex::Admin h(conn.host(), conn.port());
-        hyperdex_admin_returncode rrc;
-        int64_t rid = h.add_space(description.c_str(), &rrc);
-
-        if (rid < 0)
-        {
-            std::cerr << "could not add space: " << h.error_message() << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        hyperdex_admin_returncode lrc;
-        int64_t lid = h.loop(-1, &lrc);
-
-        if (lid < 0)
-        {
-            std::cerr << "could not add space: " << h.error_message() << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        assert(rid == lid);
-
-        if (rrc != HYPERDEX_ADMIN_SUCCESS)
-        {
-            std::cerr << "could not add space: " << h.error_message() << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        return EXIT_SUCCESS;
-    }
-    catch (std::exception& e)
-    {
-        std::cerr << "error: " << e.what() << std::endl;
-        return EXIT_FAILURE;
-    }
+	hyperdex::connect_opts conn;
+	e::argparser ap;
+	ap.autohelp();
+	ap.add("Connect to a cluster:", conn.parser());
+	if (!ap.parse(argc, argv))
+	{
+		return EXIT_FAILURE;
+	}
+	if (!conn.validate())
+	{
+		std::cerr << "invalid host:port specification\n" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	if (ap.args_sz() != 0)
+	{
+		std::cerr << "command takes no arguments" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	std::string description;
+	std::string s;
+	while (std::cin >> s)
+	{
+		if (!description.empty())
+		{
+			description += " " + s;
+		}
+		else
+		{
+			description += s;
+		}
+	}
+	try
+	{
+		hyperdex::Admin h(conn.host(), conn.port());
+		hyperdex_admin_returncode rrc;
+		int64_t rid = h.add_space(description.c_str(), &rrc);
+		if (rid < 0)
+		{
+			std::cerr << "could not add space: " << h.error_message() << std::endl;
+			return EXIT_FAILURE;
+		}
+		hyperdex_admin_returncode lrc;
+		int64_t lid = h.loop(-1, &lrc);
+		if (lid < 0)
+		{
+			std::cerr << "could not add space: " << h.error_message() << std::endl;
+			return EXIT_FAILURE;
+		}
+		assert(rid == lid);
+		if (rrc != HYPERDEX_ADMIN_SUCCESS)
+		{
+			std::cerr << "could not add space: " << h.error_message() << std::endl;
+			return EXIT_FAILURE;
+		}
+		return EXIT_SUCCESS;
+	}
+	catch (std::exception &e)
+	{
+		std::cerr << "error: " << e.what() << std::endl;
+		return EXIT_FAILURE;
+	}
 }
diff --git a/tools/backup-manager.cc b/tools/backup-manager.cc
index c30fa8a60..570d7c9dd 100644
--- a/tools/backup-manager.cc
+++ b/tools/backup-manager.cc
@@ -47,399 +47,341 @@ using hyperdex::connect_opts;
 
 struct daemon_backup
 {
-    daemon_backup() : sid(), addr(), path() {}
-    daemon_backup(uint64_t s,
-                  const std::string& a,
-                  const std::string& p)
-        : sid(s), addr(a), path(p) {}
-    ~daemon_backup() {}
-    uint64_t sid;
-    std::string addr;
-    std::string path;
+	daemon_backup() : sid(), addr(), path() {}
+	daemon_backup(uint64_t s,
+	              const std::string &a,
+	              const std::string &p)
+		: sid(s), addr(a), path(p) {}
+	~daemon_backup() {}
+	uint64_t sid;
+	std::string addr;
+	std::string path;
 };
 
 static bool
-get_time(std::string* now)
+get_time(std::string *now)
 {
-    time_t tmp_t;
-    struct tm* tmp_tm;
-
-    tmp_t = time(NULL);
-    tmp_tm = localtime(&tmp_t);
-
-    if (tmp_tm == NULL)
-    {
-        perror("could not read time");
-        return false;
-    }
-
-    char tmp[1024];
-
-    if (strftime(tmp, 1024, "%Y-%m-%dT%H:%M:%S", tmp_tm) == 0)
-    {
-        std::cerr << "could not read time" << std::endl;
-        return false;
-    }
-
-    *now = std::string(tmp);
-    return true;
+	time_t tmp_t;
+	struct tm *tmp_tm;
+	tmp_t = time(NULL);
+	tmp_tm = localtime(&tmp_t);
+	if (tmp_tm == NULL)
+	{
+		perror("could not read time");
+		return false;
+	}
+	char tmp[1024];
+	if (strftime(tmp, 1024, "%Y-%m-%dT%H:%M:%S", tmp_tm) == 0)
+	{
+		std::cerr << "could not read time" << std::endl;
+		return false;
+	}
+	*now = std::string(tmp);
+	return true;
 }
 
 static bool
-take_backup(const connect_opts& conn,
-            const char* name,
-            std::vector<daemon_backup>* daemons)
+take_backup(const connect_opts &conn,
+            const char *name,
+            std::vector<daemon_backup> *daemons)
 {
-    hyperdex::Admin h(conn.host(), conn.port());
-    hyperdex_admin_returncode rrc;
-    const char* backups = NULL;
-    int64_t rid = h.backup(name, &rrc, &backups);
-
-    if (rid < 0)
-    {
-        std::cerr << "Backup failed.\n"
-                  << "Please read the above messages for the cause and potential solutions\n";
-        return false;
-    }
-
-    hyperdex_admin_returncode lrc;
-    int64_t lid = h.loop(-1, &lrc);
-
-    if (lid < 0)
-    {
-        std::cerr << "Backup failed.\n"
-                  << "Please read the above messages for the cause and potential solutions\n";
-        return false;
-    }
-
-    assert(rid == lid);
-
-    if (rrc != HYPERDEX_ADMIN_SUCCESS)
-    {
-        std::cerr << "backup failed: " << h.error_message() << std::endl;
-        return false;
-    }
-
-    if (!backups)
-    {
-        return true;
-    }
-
-    const char* ptr = backups;
-    const char* end = ptr + strlen(ptr);
-
-    while (ptr < end)
-    {
-        const char* eol = strchr(ptr, '\n');
-        eol = eol ? eol : end;
-        std::string line(ptr, eol);
-        ptr = eol + 1;
-        long long unsigned int num;
-        std::vector<char> loc_buf(line.size());
-        std::vector<char> path_buf(line.size());
-
-        if (sscanf(line.c_str(), "%llu %s %[^\t\n]", 
-                   &num, &loc_buf[0], &path_buf[0]) < 3)
-        {
-            std::cerr << "could not parse backup information for daemons:\n"
-                      << backups << std::flush;
-            return false;
-        }
-
-        daemons->push_back(daemon_backup(num,
-                                         std::string(&loc_buf[0]),
-                                         std::string(&path_buf[0])));
-    }
-
-    return true;
+	hyperdex::Admin h(conn.host(), conn.port());
+	hyperdex_admin_returncode rrc;
+	const char *backups = NULL;
+	int64_t rid = h.backup(name, &rrc, &backups);
+	if (rid < 0)
+	{
+		std::cerr << "Backup failed.\n"
+		          << "Please read the above messages for the cause and potential solutions\n";
+		return false;
+	}
+	hyperdex_admin_returncode lrc;
+	int64_t lid = h.loop(-1, &lrc);
+	if (lid < 0)
+	{
+		std::cerr << "Backup failed.\n"
+		          << "Please read the above messages for the cause and potential solutions\n";
+		return false;
+	}
+	assert(rid == lid);
+	if (rrc != HYPERDEX_ADMIN_SUCCESS)
+	{
+		std::cerr << "backup failed: " << h.error_message() << std::endl;
+		return false;
+	}
+	if (!backups)
+	{
+		return true;
+	}
+	const char *ptr = backups;
+	const char *end = ptr + strlen(ptr);
+	while (ptr < end)
+	{
+		const char *eol = strchr(ptr, '\n');
+		eol = eol ? eol : end;
+		std::string line(ptr, eol);
+		ptr = eol + 1;
+		long long unsigned int num;
+		std::vector<char> loc_buf(line.size());
+		std::vector<char> path_buf(line.size());
+		if (sscanf(line.c_str(), "%llu %s %[^\t\n]",
+		           &num, &loc_buf[0], &path_buf[0]) < 3)
+		{
+			std::cerr << "could not parse backup information for daemons:\n"
+			          << backups << std::flush;
+			return false;
+		}
+		daemons->push_back(daemon_backup(num,
+		                                 std::string(&loc_buf[0]),
+		                                 std::string(&path_buf[0])));
+	}
+	return true;
 }
 
 static bool
-read_latest(const std::string& base, bool* has_previous, std::string* previous)
+read_latest(const std::string &base, bool *has_previous, std::string *previous)
 {
-    std::string latest_path = po6::path::join(base, "LATEST");
-    po6::io::fd latest(open(latest_path.c_str(), O_RDONLY));
-
-    if (latest.get() < 0 && errno == ENOENT)
-    {
-        *has_previous = false;
-        return true;
-    }
-    else if (latest.get() < 0)
-    {
-        return false;
-    }
-
-    std::vector<char> buf(PATH_MAX);
-    ssize_t amt = latest.xread(&buf[0], buf.size());
-
-    if (amt < 0)
-    {
-        std::cerr << "could not read the LATEST backup: "
-                  << strerror(errno) << std::endl;
-        return false;
-    }
-
-    buf.resize(amt);
-    *has_previous = true;
-    *previous = po6::path::join(base, std::string(buf.begin(), buf.end()));
-    return true;
+	std::string latest_path = po6::path::join(base, "LATEST");
+	po6::io::fd latest(open(latest_path.c_str(), O_RDONLY));
+	if (latest.get() < 0 && errno == ENOENT)
+	{
+		*has_previous = false;
+		return true;
+	}
+	else if (latest.get() < 0)
+	{
+		return false;
+	}
+	std::vector<char> buf(PATH_MAX);
+	ssize_t amt = latest.xread(&buf[0], buf.size());
+	if (amt < 0)
+	{
+		std::cerr << "could not read the LATEST backup: "
+		          << strerror(errno) << std::endl;
+		return false;
+	}
+	buf.resize(amt);
+	*has_previous = true;
+	*previous = po6::path::join(base, std::string(buf.begin(), buf.end()));
+	return true;
 }
 
 static bool
-record_latest(const std::string& base, const std::string& now)
+record_latest(const std::string &base, const std::string &now)
 {
-    std::string latest_path = po6::path::join(base, "LATEST");
-    po6::io::fd latest(open(latest_path.c_str(), O_WRONLY|O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR));
-
-    if (latest.get() < 0)
-    {
-        std::cerr << "could not record the backup in LATEST: "
-                  << strerror(errno) << std::endl;
-        return false;
-    }
-
-    if (latest.xwrite(now.c_str(), now.size()) < static_cast<ssize_t>(now.size()))
-    {
-        std::cerr << "could not record the backup in LATEST: "
-                  << strerror(errno) << std::endl;
-        return false;
-    }
-
-    latest.close();
-    return true;
+	std::string latest_path = po6::path::join(base, "LATEST");
+	po6::io::fd latest(open(latest_path.c_str(), O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR));
+	if (latest.get() < 0)
+	{
+		std::cerr << "could not record the backup in LATEST: "
+		          << strerror(errno) << std::endl;
+		return false;
+	}
+	if (latest.xwrite(now.c_str(), now.size()) < static_cast<ssize_t>(now.size()))
+	{
+		std::cerr << "could not record the backup in LATEST: "
+		          << strerror(errno) << std::endl;
+		return false;
+	}
+	latest.close();
+	return true;
 }
 
 static bool
-fork_exec_wait(const std::vector<std::string>& args)
+fork_exec_wait(const std::vector<std::string> &args)
 {
-    pid_t child = fork();
-
-    if (child > 0)
-    {
-        int status = 0;
-
-        if (waitpid(child, &status, 0) < 0)
-        {
-            std::cerr << "could not wait for child: " << strerror(errno) << std::endl;
-            return false;
-        }
-
-        if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
-        {
-            std::cerr << "child process failed" << std::endl;
-            return false;
-        }
-
-        return true;
-    }
-    else if (child == 0)
-    {
-        std::vector<const char*> arg_ptrs;
-        arg_ptrs.reserve(args.size() + 1);
-
-        for (size_t i = 0; i < args.size(); ++i)
-        {
-            arg_ptrs.push_back(args[i].c_str());
-        }
-
-        arg_ptrs.push_back(NULL);
-        execvp(arg_ptrs[0], const_cast<char* const*>(&arg_ptrs[0]));
-        std::cerr << "could not exec: " << strerror(errno) << std::endl;
-        exit(EXIT_FAILURE);
-    }
-    else
-    {
-        std::cerr << "could not fork: " << strerror(errno) << std::endl;
-        return false;
-    }
+	pid_t child = fork();
+	if (child > 0)
+	{
+		int status = 0;
+		if (waitpid(child, &status, 0) < 0)
+		{
+			std::cerr << "could not wait for child: " << strerror(errno) << std::endl;
+			return false;
+		}
+		if (!WIFEXITED(status) || WEXITSTATUS(status) != 0)
+		{
+			std::cerr << "child process failed" << std::endl;
+			return false;
+		}
+		return true;
+	}
+	else if (child == 0)
+	{
+		std::vector<const char *> arg_ptrs;
+		arg_ptrs.reserve(args.size() + 1);
+		for (size_t i = 0; i < args.size(); ++i)
+		{
+			arg_ptrs.push_back(args[i].c_str());
+		}
+		arg_ptrs.push_back(NULL);
+		execvp(arg_ptrs[0], const_cast<char *const *>(&arg_ptrs[0]));
+		std::cerr << "could not exec: " << strerror(errno) << std::endl;
+		exit(EXIT_FAILURE);
+	}
+	else
+	{
+		std::cerr << "could not fork: " << strerror(errno) << std::endl;
+		return false;
+	}
 }
 
 int
-main(int argc, const char* argv[])
+main(int argc, const char *argv[])
 {
-    bool _cleanup = true;
-    const char* _data = ".";
-    const char* _user = NULL;
-    connect_opts conn;
-    e::argparser ap;
-    ap.autohelp();
-    ap.add("Connect to a cluster:", conn.parser());
-    ap.arg().name('b', "backup-dir")
-            .description("store backups in this directory (default: .)")
-            .metavar("dir").as_string(&_data);
-    ap.arg().name('u', "user")
-            .description("username to use for ssh connections (default: this user)")
-            .metavar("user").as_string(&_user);
-
-    if (!ap.parse(argc, argv))
-    {
-        return EXIT_FAILURE;
-    }
-
-    if (!conn.validate())
-    {
-        std::cerr << "invalid host:port specification\n" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    using po6::path::join;
-
-    try
-    {
-        bool success = true;
-        std::string base(_data);
-
-        if (!po6::path::realpath(base, &base))
-        {
-            std::cerr << "error: " << po6::strerror(errno) << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        if (chdir(base.c_str()) < 0)
-        {
-            std::cerr << "could not change directory to: " << _data << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        std::string now;
-        std::vector<daemon_backup> daemons;
-
-        if (!get_time(&now))
-        {
-            return EXIT_FAILURE;
-        }
-
-        if (!take_backup(conn, now.c_str(), &daemons))
-        {
-            return EXIT_FAILURE;
-        }
-
-        bool has_previous = false;
-        std::string previous;
-
-        if (!read_latest(base, &has_previous, &previous))
-        {
-            return EXIT_FAILURE;
-        }
-
-        std::string backupdir(join(base, now));
-
-        if (mkdir(backupdir.c_str(), S_IRWXU) < 0)
-        {
-            std::cerr << "could not make local directory for the backup: "
-                      << strerror(errno) << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        if (rename(join(base, now + ".coordinator.bin").c_str(),
-                   join(backupdir, "coordinator.bin").c_str()) < 0)
-        {
-            std::cerr << "could not rename coordinator backup: "
-                      << strerror(errno) << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        for (size_t i = 0; i < daemons.size(); ++i)
-        {
-            char buf[21];
-            sprintf(buf, "%lu", daemons[i].sid);
-            std::string daemon_dir(join(base, now, buf));
-            bool prev = false;
-            std::string link_dest;
-
-            if (has_previous)
-            {
-                struct stat stbuf;
-                std::string daemon_prev(join(previous, buf));
-                int status = stat(daemon_prev.c_str(), &stbuf);
-
-                if (status < 0 && errno == ENOENT)
-                {
-                    prev = false;
-                }
-                else if (status < 0)
-                {
-                    prev = false;
-                    std::cerr << "could not stat prev backup for " << daemons[i].sid << ": "
-                              << strerror(errno) << std::endl;
-                    success = false;
-                }
-                else
-                {
-                    prev = true;
-                    link_dest  = "--link-dest=";
-                    link_dest += daemon_prev.c_str();
-                }
-            }
-
-            std::vector<std::string> args;
-            args.push_back("rsync");
-            args.push_back("-a");
-            args.push_back("--delete");
-
-            if (prev)
-            {
-                args.push_back(link_dest);
-            }
-
-            args.push_back("--");
-            std::string rsync_url = daemons[i].addr + ":" + daemons[i].path + "/";
-
-            if (_user)
-            {
-                args.push_back(std::string(_user) + "@" + rsync_url);
-            }
-            else
-            {
-                args.push_back(rsync_url);
-            }
-
-            args.push_back(daemon_dir.c_str());
-
-            if (!fork_exec_wait(args))
-            {
-                success = false;
-            }
-        }
-
-        if (success && _cleanup)
-        {
-            for (size_t i = 0; i < daemons.size(); ++i)
-            {
-                std::vector<std::string> args;
-                args.push_back("ssh");
-
-                if (_user)
-                {
-                    args.push_back("-l");
-                    args.push_back(_user);
-                }
-
-                args.push_back(daemons[i].addr);
-                args.push_back("rm");
-                args.push_back("-r");
-                args.push_back("--");
-                args.push_back(daemons[i].path);
-
-                if (!fork_exec_wait(args))
-                {
-                    success = false;
-                }
-            }
-        }
-
-        if (success && !record_latest(base, now))
-        {
-            success = false;
-        }
-
-        return success ? EXIT_SUCCESS : EXIT_FAILURE;
-    }
-    catch (std::exception& e)
-    {
-        std::cerr << "error: " << e.what() << std::endl;
-        return EXIT_FAILURE;
-    }
+	bool _cleanup = true;
+	const char *_data = ".";
+	const char *_user = NULL;
+	connect_opts conn;
+	e::argparser ap;
+	ap.autohelp();
+	ap.add("Connect to a cluster:", conn.parser());
+	ap.arg().name('b', "backup-dir")
+	.description("store backups in this directory (default: .)")
+	.metavar("dir").as_string(&_data);
+	ap.arg().name('u', "user")
+	.description("username to use for ssh connections (default: this user)")
+	.metavar("user").as_string(&_user);
+	if (!ap.parse(argc, argv))
+	{
+		return EXIT_FAILURE;
+	}
+	if (!conn.validate())
+	{
+		std::cerr << "invalid host:port specification\n" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	using po6::path::join;
+	try
+	{
+		bool success = true;
+		std::string base(_data);
+		if (!po6::path::realpath(base, &base))
+		{
+			std::cerr << "error: " << po6::strerror(errno) << std::endl;
+			return EXIT_FAILURE;
+		}
+		if (chdir(base.c_str()) < 0)
+		{
+			std::cerr << "could not change directory to: " << _data << std::endl;
+			return EXIT_FAILURE;
+		}
+		std::string now;
+		std::vector<daemon_backup> daemons;
+		if (!get_time(&now))
+		{
+			return EXIT_FAILURE;
+		}
+		if (!take_backup(conn, now.c_str(), &daemons))
+		{
+			return EXIT_FAILURE;
+		}
+		bool has_previous = false;
+		std::string previous;
+		if (!read_latest(base, &has_previous, &previous))
+		{
+			return EXIT_FAILURE;
+		}
+		std::string backupdir(join(base, now));
+		if (mkdir(backupdir.c_str(), S_IRWXU) < 0)
+		{
+			std::cerr << "could not make local directory for the backup: "
+			          << strerror(errno) << std::endl;
+			return EXIT_FAILURE;
+		}
+		if (rename(join(base, now + ".coordinator.bin").c_str(),
+		           join(backupdir, "coordinator.bin").c_str()) < 0)
+		{
+			std::cerr << "could not rename coordinator backup: "
+			          << strerror(errno) << std::endl;
+			return EXIT_FAILURE;
+		}
+		for (size_t i = 0; i < daemons.size(); ++i)
+		{
+			char buf[21];
+			sprintf(buf, "%lu", daemons[i].sid);
+			std::string daemon_dir(join(base, now, buf));
+			bool prev = false;
+			std::string link_dest;
+			if (has_previous)
+			{
+				struct stat stbuf;
+				std::string daemon_prev(join(previous, buf));
+				int status = stat(daemon_prev.c_str(), &stbuf);
+				if (status < 0 && errno == ENOENT)
+				{
+					prev = false;
+				}
+				else if (status < 0)
+				{
+					prev = false;
+					std::cerr << "could not stat prev backup for " << daemons[i].sid << ": "
+					          << strerror(errno) << std::endl;
+					success = false;
+				}
+				else
+				{
+					prev = true;
+					link_dest  = "--link-dest=";
+					link_dest += daemon_prev.c_str();
+				}
+			}
+			std::vector<std::string> args;
+			args.push_back("rsync");
+			args.push_back("-a");
+			args.push_back("--delete");
+			if (prev)
+			{
+				args.push_back(link_dest);
+			}
+			args.push_back("--");
+			std::string rsync_url = daemons[i].addr + ":" + daemons[i].path + "/";
+			if (_user)
+			{
+				args.push_back(std::string(_user) + "@" + rsync_url);
+			}
+			else
+			{
+				args.push_back(rsync_url);
+			}
+			args.push_back(daemon_dir.c_str());
+			if (!fork_exec_wait(args))
+			{
+				success = false;
+			}
+		}
+		if (success && _cleanup)
+		{
+			for (size_t i = 0; i < daemons.size(); ++i)
+			{
+				std::vector<std::string> args;
+				args.push_back("ssh");
+				if (_user)
+				{
+					args.push_back("-l");
+					args.push_back(_user);
+				}
+				args.push_back(daemons[i].addr);
+				args.push_back("rm");
+				args.push_back("-r");
+				args.push_back("--");
+				args.push_back(daemons[i].path);
+				if (!fork_exec_wait(args))
+				{
+					success = false;
+				}
+			}
+		}
+		if (success && !record_latest(base, now))
+		{
+			success = false;
+		}
+		return success ? EXIT_SUCCESS : EXIT_FAILURE;
+	}
+	catch (std::exception &e)
+	{
+		std::cerr << "error: " << e.what() << std::endl;
+		return EXIT_FAILURE;
+	}
 }
diff --git a/tools/backup.cc b/tools/backup.cc
index 62ca3c438..ce790ff0c 100644
--- a/tools/backup.cc
+++ b/tools/backup.cc
@@ -33,74 +33,63 @@
 #include "tools/common.h"
 
 int
-main(int argc, const char* argv[])
+main(int argc, const char *argv[])
 {
-    hyperdex::connect_opts conn;
-    e::argparser ap;
-    ap.autohelp();
-    ap.add("Connect to a cluster:", conn.parser());
-
-    if (!ap.parse(argc, argv))
-    {
-        return EXIT_FAILURE;
-    }
-
-    if (!conn.validate())
-    {
-        std::cerr << "invalid host:port specification\n" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    if (ap.args_sz() != 1)
-    {
-        std::cerr << "please specify the backup name" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    try
-    {
-        hyperdex::Admin h(conn.host(), conn.port());
-        hyperdex_admin_returncode rrc;
-        const char* backups = NULL;
-        int64_t rid = h.backup(ap.args()[0], &rrc, &backups);
-
-        if (rid < 0)
-        {
-            std::cerr << "Backup failed.\n"
-                      << "Please read the above messages for the cause and potential solutions\n";
-            return EXIT_FAILURE;
-        }
-
-        hyperdex_admin_returncode lrc;
-        int64_t lid = h.loop(-1, &lrc);
-
-        if (lid < 0)
-        {
-            std::cerr << "Backup failed.\n"
-                      << "Please read the above messages for the cause and potential solutions\n";
-            return EXIT_FAILURE;
-        }
-
-        assert(rid == lid);
-
-        if (rrc != HYPERDEX_ADMIN_SUCCESS)
-        {
-            std::cerr << "backup failed: " << h.error_message() << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        if (backups)
-        {
-            std::cout << backups;
-        }
-
-        return EXIT_SUCCESS;
-    }
-    catch (std::exception& e)
-    {
-        std::cerr << "error: " << e.what() << std::endl;
-        return EXIT_FAILURE;
-    }
+	hyperdex::connect_opts conn;
+	e::argparser ap;
+	ap.autohelp();
+	ap.add("Connect to a cluster:", conn.parser());
+	if (!ap.parse(argc, argv))
+	{
+		return EXIT_FAILURE;
+	}
+	if (!conn.validate())
+	{
+		std::cerr << "invalid host:port specification\n" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	if (ap.args_sz() != 1)
+	{
+		std::cerr << "please specify the backup name" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	try
+	{
+		hyperdex::Admin h(conn.host(), conn.port());
+		hyperdex_admin_returncode rrc;
+		const char *backups = NULL;
+		int64_t rid = h.backup(ap.args()[0], &rrc, &backups);
+		if (rid < 0)
+		{
+			std::cerr << "Backup failed.\n"
+			          << "Please read the above messages for the cause and potential solutions\n";
+			return EXIT_FAILURE;
+		}
+		hyperdex_admin_returncode lrc;
+		int64_t lid = h.loop(-1, &lrc);
+		if (lid < 0)
+		{
+			std::cerr << "Backup failed.\n"
+			          << "Please read the above messages for the cause and potential solutions\n";
+			return EXIT_FAILURE;
+		}
+		assert(rid == lid);
+		if (rrc != HYPERDEX_ADMIN_SUCCESS)
+		{
+			std::cerr << "backup failed: " << h.error_message() << std::endl;
+			return EXIT_FAILURE;
+		}
+		if (backups)
+		{
+			std::cout << backups;
+		}
+		return EXIT_SUCCESS;
+	}
+	catch (std::exception &e)
+	{
+		std::cerr << "error: " << e.what() << std::endl;
+		return EXIT_FAILURE;
+	}
 }
diff --git a/tools/common.h b/tools/common.h
index 337dac7da..837a03fd0 100644
--- a/tools/common.h
+++ b/tools/common.h
@@ -48,42 +48,41 @@ BEGIN_HYPERDEX_NAMESPACE
 
 class connect_opts
 {
-    public:
-        connect_opts()
-            : m_ap() , m_host("127.0.0.1") , m_port(1982)
-        {
-            m_ap.arg().name('h', "host")
-                      .description("connect to the coordinator on an IP address or hostname (default: 127.0.0.1)")
-                      .metavar("addr").as_string(&m_host);
-            m_ap.arg().name('p', "port")
-                      .description("connect to the coordinator on an alternative port (default: 1982)")
-                      .metavar("port").as_long(&m_port);
-        }
-        ~connect_opts() throw () {}
-
-    public:
-        const e::argparser& parser() { return m_ap; }
-        const char* host() const { return m_host; }
-        uint16_t port() const { return m_port; }
-        bool validate()
-        {
-            if (m_port <= 0 || m_port >= (1 << 16))
-            {
-                std::cerr << "port number to connect to is out of range" << std::endl;
-                return false;
-            }
-
-            return true;
-        }
-
-        private:
-            connect_opts(const connect_opts&);
-            connect_opts& operator = (const connect_opts&);
-
-    private:
-        e::argparser m_ap;
-        const char* m_host;
-        long m_port;
+public:
+	connect_opts()
+		: m_ap() , m_host("127.0.0.1") , m_port(1982)
+	{
+		m_ap.arg().name('h', "host")
+		.description("connect to the coordinator on an IP address or hostname (default: 127.0.0.1)")
+		.metavar("addr").as_string(&m_host);
+		m_ap.arg().name('p', "port")
+		.description("connect to the coordinator on an alternative port (default: 1982)")
+		.metavar("port").as_long(&m_port);
+	}
+	~connect_opts() throw () {}
+
+public:
+	const e::argparser &parser() { return m_ap; }
+	const char *host() const { return m_host; }
+	uint16_t port() const { return m_port; }
+	bool validate()
+	{
+		if (m_port <= 0 || m_port >= (1 << 16))
+		{
+			std::cerr << "port number to connect to is out of range" << std::endl;
+			return false;
+		}
+		return true;
+	}
+
+private:
+	connect_opts(const connect_opts &);
+	connect_opts &operator = (const connect_opts &);
+
+private:
+	e::argparser m_ap;
+	const char *m_host;
+	long m_port;
 };
 
 #ifdef HYPERDEX_EXEC_DIR
@@ -91,69 +90,58 @@ class connect_opts
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wlarger-than="
 bool
-locate_coordinator_lib(const char* argv0, std::string* path)
+locate_coordinator_lib(const char *argv0, std::string *path)
 {
-    // find the right library
-    std::vector<std::string> paths;
-    const char* env = getenv("HYPERDEX_COORD_LIB");
-    static const char* exts[] = { "", ".so.0.0.0", ".so.0", ".so", ".dylib", 0 };
-
-    for (size_t i = 0; exts[i]; ++i)
-    {
-        std::string base(HYPERDEX_LIB_NAME);
-        base += exts[i];
-        paths.push_back(po6::path::join(HYPERDEX_EXEC_DIR, base));
-        paths.push_back(po6::path::join(po6::path::dirname(argv0), ".libs", base));
-
-        if (env)
-        {
-            std::string envlib(env);
-            envlib += exts[i];
-            paths.push_back(envlib);
-        }
-    }
-
-    // maybe we're running out of Git.  make it "just work"
-    char selfbuf[PATH_MAX + 1];
-    memset(selfbuf, 0, sizeof(selfbuf));
-
-    if (readlink("/proc/self/exe", selfbuf, PATH_MAX) >= 0)
-    {
-        std::string workdir(selfbuf);
-        workdir = po6::path::dirname(workdir);
-        std::string gitdir(po6::path::join(workdir, ".git"));
-        struct stat buf;
-
-        if (stat(gitdir.c_str(), &buf) == 0 &&
-            S_ISDIR(buf.st_mode))
-        {
-            std::string libdir(po6::path::join(workdir, ".libs"));
-
-            for (size_t i = 0; exts[i]; ++i)
-            {
-                std::string libname(HYPERDEX_LIB_NAME);
-                libname += exts[i];
-                paths.push_back(po6::path::join(libdir, libname));
-            }
-        }
-    }
-
-    size_t idx = 0;
-
-    while (idx < paths.size())
-    {
-        struct stat buf;
-
-        if (stat(paths[idx].c_str(), &buf) == 0)
-        {
-            *path = paths[idx];
-            return true;
-        }
-
-        ++idx;
-    }
-
-    return false;
+	// find the right library
+	std::vector<std::string> paths;
+	const char *env = getenv("HYPERDEX_COORD_LIB");
+	static const char *exts[] = { "", ".so.0.0.0", ".so.0", ".so", ".dylib", 0 };
+	for (size_t i = 0; exts[i]; ++i)
+	{
+		std::string base(HYPERDEX_LIB_NAME);
+		base += exts[i];
+		paths.push_back(po6::path::join(HYPERDEX_EXEC_DIR, base));
+		paths.push_back(po6::path::join(po6::path::dirname(argv0), ".libs", base));
+		if (env)
+		{
+			std::string envlib(env);
+			envlib += exts[i];
+			paths.push_back(envlib);
+		}
+	}
+	// maybe we're running out of Git.  make it "just work"
+	char selfbuf[PATH_MAX + 1];
+	memset(selfbuf, 0, sizeof(selfbuf));
+	if (readlink("/proc/self/exe", selfbuf, PATH_MAX) >= 0)
+	{
+		std::string workdir(selfbuf);
+		workdir = po6::path::dirname(workdir);
+		std::string gitdir(po6::path::join(workdir, ".git"));
+		struct stat buf;
+		if (stat(gitdir.c_str(), &buf) == 0 &&
+		    S_ISDIR(buf.st_mode))
+		{
+			std::string libdir(po6::path::join(workdir, ".libs"));
+			for (size_t i = 0; exts[i]; ++i)
+			{
+				std::string libname(HYPERDEX_LIB_NAME);
+				libname += exts[i];
+				paths.push_back(po6::path::join(libdir, libname));
+			}
+		}
+	}
+	size_t idx = 0;
+	while (idx < paths.size())
+	{
+		struct stat buf;
+		if (stat(paths[idx].c_str(), &buf) == 0)
+		{
+			*path = paths[idx];
+			return true;
+		}
+		++idx;
+	}
+	return false;
 }
 #pragma GCC diagnostic pop
 #undef HYPERDEX_LIB_NAME
diff --git a/tools/coordinator.cc b/tools/coordinator.cc
index 15497254b..4a88a6f30 100644
--- a/tools/coordinator.cc
+++ b/tools/coordinator.cc
@@ -39,60 +39,50 @@
 #include "tools/common.h"
 
 int
-main(int argc, const char* argv[])
+main(int argc, const char *argv[])
 {
-    std::string libpath;
-
-    if (!hyperdex::locate_coordinator_lib(argv[0], &libpath))
-    {
-        std::cerr << "cannot locate the HyperDex coordinator library" << std::endl;
-        return EXIT_FAILURE;
-    }
-
-    // setup the environment
-    if (setenv("REPLICANT_WRAP", "hyperdex-coordinator", 1) < 0)
-    {
-        std::cerr << "could not setup the environment: " << strerror(errno) << std::endl;
-        return EXIT_FAILURE;
-    }
-
-    // generate a random token
-    uint64_t token;
-    po6::io::fd sysrand(open("/dev/urandom", O_RDONLY));
-
-    if (sysrand.get() < 0 ||
-        sysrand.read(&token, sizeof(token)) != sizeof(token))
-    {
-        std::cerr << "could not generate random token for cluster" << std::endl;
-        return EXIT_FAILURE;
-    }
-
-    char token_buf[21];
-    snprintf(token_buf, 21, "%lu", (unsigned long) token);
-
-    // exec replicant daemon
-    std::vector<const char*> args;
-    args.push_back("replicant");
-    args.push_back("daemon");
-
-    for (int i = 1; i < argc; ++i)
-    {
-        args.push_back(argv[i]);
-    }
-
-    args.push_back("--object");
-    args.push_back("hyperdex");
-    args.push_back("--library");
-    args.push_back(libpath.c_str());
-    args.push_back("--init-string");
-    args.push_back(token_buf);
-    args.push_back(NULL);
-
-    if (execvp("replicant", const_cast<char*const*>(&args[0])) < 0)
-    {
-        perror("could not exec replicant");
-        return EXIT_FAILURE;
-    }
-
-    abort();
+	std::string libpath;
+	if (!hyperdex::locate_coordinator_lib(argv[0], &libpath))
+	{
+		std::cerr << "cannot locate the HyperDex coordinator library" << std::endl;
+		return EXIT_FAILURE;
+	}
+	// setup the environment
+	if (setenv("REPLICANT_WRAP", "hyperdex-coordinator", 1) < 0)
+	{
+		std::cerr << "could not setup the environment: " << strerror(errno) << std::endl;
+		return EXIT_FAILURE;
+	}
+	// generate a random token
+	uint64_t token;
+	po6::io::fd sysrand(open("/dev/urandom", O_RDONLY));
+	if (sysrand.get() < 0 ||
+	    sysrand.read(&token, sizeof(token)) != sizeof(token))
+	{
+		std::cerr << "could not generate random token for cluster" << std::endl;
+		return EXIT_FAILURE;
+	}
+	char token_buf[21];
+	snprintf(token_buf, 21, "%lu", (unsigned long) token);
+	// exec replicant daemon
+	std::vector<const char *> args;
+	args.push_back("replicant");
+	args.push_back("daemon");
+	for (int i = 1; i < argc; ++i)
+	{
+		args.push_back(argv[i]);
+	}
+	args.push_back("--object");
+	args.push_back("hyperdex");
+	args.push_back("--library");
+	args.push_back(libpath.c_str());
+	args.push_back("--init-string");
+	args.push_back(token_buf);
+	args.push_back(NULL);
+	if (execvp("replicant", const_cast<char *const *>(&args[0])) < 0)
+	{
+		perror("could not exec replicant");
+		return EXIT_FAILURE;
+	}
+	abort();
 }
diff --git a/tools/list-spaces.cc b/tools/list-spaces.cc
index 08b1f7a9b..b66353115 100644
--- a/tools/list-spaces.cc
+++ b/tools/list-spaces.cc
@@ -34,68 +34,59 @@
 #include "tools/common.h"
 
 int
-main(int argc, const char* argv[])
+main(int argc, const char *argv[])
 {
-    hyperdex::connect_opts conn;
-    e::argparser ap;
-    ap.autohelp();
-    ap.add("Connect to a cluster:", conn.parser());
-
-    if (!ap.parse(argc, argv))
-    {
-        return EXIT_FAILURE;
-    }
-
-    if (!conn.validate())
-    {
-        std::cerr << "invalid host:port specification\n" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    try
-    {
-        hyperdex::Admin h(conn.host(), conn.port());
-        hyperdex_admin_returncode rrc;
-        const char* spaces;
-        int64_t rid = h.list_spaces(&rrc, &spaces);
-
-        if (rid < 0)
-        {
-            std::cerr << "could not list spaces: " << h.error_message() << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        hyperdex_admin_returncode lrc;
-        int64_t lid = h.loop(-1, &lrc);
-
-        if (lid < 0)
-        {
-            std::cerr << "could not list spaces: " << h.error_message() << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        assert(rid == lid);
-
-        if (rrc != HYPERDEX_ADMIN_SUCCESS)
-        {
-            std::cerr << "could not list spaces: " << h.error_message() << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        if (strcmp(spaces, "") == 0)
-        {
-            std::cout << "No spaces are found." << std::endl;
-        }
-        else
-        {
-            std::cout << spaces;
-            return EXIT_SUCCESS;
-        }
-    }
-    catch (std::exception& e)
-    {
-        std::cerr << "error: " << e.what() << std::endl;
-        return EXIT_FAILURE;
-    }
+	hyperdex::connect_opts conn;
+	e::argparser ap;
+	ap.autohelp();
+	ap.add("Connect to a cluster:", conn.parser());
+	if (!ap.parse(argc, argv))
+	{
+		return EXIT_FAILURE;
+	}
+	if (!conn.validate())
+	{
+		std::cerr << "invalid host:port specification\n" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	try
+	{
+		hyperdex::Admin h(conn.host(), conn.port());
+		hyperdex_admin_returncode rrc;
+		const char *spaces;
+		int64_t rid = h.list_spaces(&rrc, &spaces);
+		if (rid < 0)
+		{
+			std::cerr << "could not list spaces: " << h.error_message() << std::endl;
+			return EXIT_FAILURE;
+		}
+		hyperdex_admin_returncode lrc;
+		int64_t lid = h.loop(-1, &lrc);
+		if (lid < 0)
+		{
+			std::cerr << "could not list spaces: " << h.error_message() << std::endl;
+			return EXIT_FAILURE;
+		}
+		assert(rid == lid);
+		if (rrc != HYPERDEX_ADMIN_SUCCESS)
+		{
+			std::cerr << "could not list spaces: " << h.error_message() << std::endl;
+			return EXIT_FAILURE;
+		}
+		if (strcmp(spaces, "") == 0)
+		{
+			std::cout << "No spaces are found." << std::endl;
+		}
+		else
+		{
+			std::cout << spaces;
+			return EXIT_SUCCESS;
+		}
+	}
+	catch (std::exception &e)
+	{
+		std::cerr << "error: " << e.what() << std::endl;
+		return EXIT_FAILURE;
+	}
 }
diff --git a/tools/mv-space.cc b/tools/mv-space.cc
index 864fe89be..783586bf7 100644
--- a/tools/mv-space.cc
+++ b/tools/mv-space.cc
@@ -33,67 +33,57 @@
 #include "tools/common.h"
 
 int
-main(int argc, const char* argv[])
+main(int argc, const char *argv[])
 {
-    hyperdex::connect_opts conn;
-    e::argparser ap;
-    ap.autohelp();
-    ap.option_string("[OPTIONS] <source> <target>");
-    ap.add("Connect to a cluster:", conn.parser());
-
-    if (!ap.parse(argc, argv))
-    {
-        return EXIT_FAILURE;
-    }
-
-    if (!conn.validate())
-    {
-        std::cerr << "invalid host:port specification\n" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    if (ap.args_sz() != 2)
-    {
-        std::cerr << "please specify the source and target space names\n" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    try
-    {
-        hyperdex::Admin h(conn.host(), conn.port());
-        hyperdex_admin_returncode rrc;
-        int64_t rid = h.mv_space(ap.args()[0], ap.args()[1], &rrc);
-
-        if (rid < 0)
-        {
-            std::cerr << "could not rename space: " << rrc << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        hyperdex_admin_returncode lrc;
-        int64_t lid = h.loop(-1, &lrc);
-
-        if (lid < 0)
-        {
-            std::cerr << "could not rename space: " << lrc << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        assert(rid == lid);
-
-        if (rrc != HYPERDEX_ADMIN_SUCCESS)
-        {
-            std::cerr << "could not rename space: " << rrc << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        return EXIT_SUCCESS;
-    }
-    catch (std::exception& e)
-    {
-        std::cerr << "error: " << e.what() << std::endl;
-        return EXIT_FAILURE;
-    }
+	hyperdex::connect_opts conn;
+	e::argparser ap;
+	ap.autohelp();
+	ap.option_string("[OPTIONS] <source> <target>");
+	ap.add("Connect to a cluster:", conn.parser());
+	if (!ap.parse(argc, argv))
+	{
+		return EXIT_FAILURE;
+	}
+	if (!conn.validate())
+	{
+		std::cerr << "invalid host:port specification\n" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	if (ap.args_sz() != 2)
+	{
+		std::cerr << "please specify the source and target space names\n" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	try
+	{
+		hyperdex::Admin h(conn.host(), conn.port());
+		hyperdex_admin_returncode rrc;
+		int64_t rid = h.mv_space(ap.args()[0], ap.args()[1], &rrc);
+		if (rid < 0)
+		{
+			std::cerr << "could not rename space: " << rrc << std::endl;
+			return EXIT_FAILURE;
+		}
+		hyperdex_admin_returncode lrc;
+		int64_t lid = h.loop(-1, &lrc);
+		if (lid < 0)
+		{
+			std::cerr << "could not rename space: " << lrc << std::endl;
+			return EXIT_FAILURE;
+		}
+		assert(rid == lid);
+		if (rrc != HYPERDEX_ADMIN_SUCCESS)
+		{
+			std::cerr << "could not rename space: " << rrc << std::endl;
+			return EXIT_FAILURE;
+		}
+		return EXIT_SUCCESS;
+	}
+	catch (std::exception &e)
+	{
+		std::cerr << "error: " << e.what() << std::endl;
+		return EXIT_FAILURE;
+	}
 }
diff --git a/tools/perf-counters.cc b/tools/perf-counters.cc
index 570799c19..c9140fbc7 100644
--- a/tools/perf-counters.cc
+++ b/tools/perf-counters.cc
@@ -36,60 +36,52 @@
 #include "tools/common.h"
 
 int
-main(int argc, const char* argv[])
+main(int argc, const char *argv[])
 {
-    hyperdex::connect_opts conn;
-    e::argparser ap;
-    ap.autohelp();
-    ap.add("Connect to a cluster:", conn.parser());
-
-    if (!ap.parse(argc, argv))
-    {
-        return EXIT_FAILURE;
-    }
-
-    if (!conn.validate())
-    {
-        std::cerr << "invalid host:port specification\n" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    if (ap.args_sz() != 0)
-    {
-        std::cerr << "command takes no arguments" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    try
-    {
-        hyperdex::Admin h(conn.host(), conn.port());
-        hyperdex_admin_returncode prc;
-        hyperdex_admin_perf_counter pc;
-        int64_t pid = h.enable_perf_counters(&prc, &pc);
-        assert(pid>=0);
-
-        while(true)
-        {
-            hyperdex_admin_returncode lrc;
-            int64_t lid = h.loop(-1, &lrc);
-
-            if (lid != pid)
-            {
-                continue;
-            }
-
-            assert(lid==pid);
-            assert(prc == HYPERDEX_ADMIN_SUCCESS);
-            std::cout << pc.id << " " << pc.time << " " << pc.property << " = " << pc.measurement << std::endl;
-        }
-
-        return EXIT_SUCCESS;
-    }
-    catch (std::exception& e)
-    {
-        std::cerr << "error: " << e.what() << std::endl;
-        return EXIT_FAILURE;
-    }
+	hyperdex::connect_opts conn;
+	e::argparser ap;
+	ap.autohelp();
+	ap.add("Connect to a cluster:", conn.parser());
+	if (!ap.parse(argc, argv))
+	{
+		return EXIT_FAILURE;
+	}
+	if (!conn.validate())
+	{
+		std::cerr << "invalid host:port specification\n" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	if (ap.args_sz() != 0)
+	{
+		std::cerr << "command takes no arguments" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	try
+	{
+		hyperdex::Admin h(conn.host(), conn.port());
+		hyperdex_admin_returncode prc;
+		hyperdex_admin_perf_counter pc;
+		int64_t pid = h.enable_perf_counters(&prc, &pc);
+		assert(pid >= 0);
+		while (true)
+		{
+			hyperdex_admin_returncode lrc;
+			int64_t lid = h.loop(-1, &lrc);
+			if (lid != pid)
+			{
+				continue;
+			}
+			assert(lid == pid);
+			assert(prc == HYPERDEX_ADMIN_SUCCESS);
+			std::cout << pc.id << " " << pc.time << " " << pc.property << " = " << pc.measurement << std::endl;
+		}
+		return EXIT_SUCCESS;
+	}
+	catch (std::exception &e)
+	{
+		std::cerr << "error: " << e.what() << std::endl;
+		return EXIT_FAILURE;
+	}
 }
diff --git a/tools/raw-backup.cc b/tools/raw-backup.cc
index e306ce700..a2b01fa9d 100644
--- a/tools/raw-backup.cc
+++ b/tools/raw-backup.cc
@@ -36,89 +36,81 @@
 
 class connect_opts
 {
-    public:
-        connect_opts()
-            : m_ap() , m_host("127.0.0.1") , m_port(2012)
-        {
-            m_ap.arg().name('h', "host")
-                      .description("connect to the daemon on an IP address or hostname (default: 127.0.0.1)")
-                      .metavar("addr").as_string(&m_host);
-            m_ap.arg().name('p', "port")
-                      .description("connect to the daemon on an alternative port (default: 2012)")
-                      .metavar("port").as_long(&m_port);
-        }
-        ~connect_opts() throw () {}
-
-    public:
-        const e::argparser& parser() { return m_ap; }
-        const char* host() { return m_host; }
-        uint16_t port() { return m_port; }
-        bool validate()
-        {
-            if (m_port <= 0 || m_port >= (1 << 16))
-            {
-                std::cerr << "port number to connect to is out of range" << std::endl;
-                return false;
-            }
-
-            return true;
-        }
-
-        private:
-            connect_opts(const connect_opts&);
-            connect_opts& operator = (const connect_opts&);
-
-    private:
-        e::argparser m_ap;
-        const char* m_host;
-        long m_port;
+public:
+	connect_opts()
+		: m_ap() , m_host("127.0.0.1") , m_port(2012)
+	{
+		m_ap.arg().name('h', "host")
+		.description("connect to the daemon on an IP address or hostname (default: 127.0.0.1)")
+		.metavar("addr").as_string(&m_host);
+		m_ap.arg().name('p', "port")
+		.description("connect to the daemon on an alternative port (default: 2012)")
+		.metavar("port").as_long(&m_port);
+	}
+	~connect_opts() throw () {}
+
+public:
+	const e::argparser &parser() { return m_ap; }
+	const char *host() { return m_host; }
+	uint16_t port() { return m_port; }
+	bool validate()
+	{
+		if (m_port <= 0 || m_port >= (1 << 16))
+		{
+			std::cerr << "port number to connect to is out of range" << std::endl;
+			return false;
+		}
+		return true;
+	}
+
+private:
+	connect_opts(const connect_opts &);
+	connect_opts &operator = (const connect_opts &);
+
+private:
+	e::argparser m_ap;
+	const char *m_host;
+	long m_port;
 };
 
 int
-main(int argc, const char* argv[])
+main(int argc, const char *argv[])
 {
-    connect_opts conn;
-    e::argparser ap;
-    ap.autohelp();
-    ap.option_string("[OPTIONS] <backup-name>");
-    ap.add("Connect to a daemon:", conn.parser());
-
-    if (!ap.parse(argc, argv))
-    {
-        return EXIT_FAILURE;
-    }
-
-    if (!conn.validate())
-    {
-        std::cerr << "invalid host:port specification\n" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    if (ap.args_sz() != 1)
-    {
-        std::cerr << "please specify a name for the backup" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    const char* name = ap.args()[0];
-
-    try
-    {
-        hyperdex_admin_returncode rc;
-
-        if (hyperdex_admin_raw_backup(conn.host(), conn.port(), name, &rc) < 0)
-        {
-            std::cerr << "could not take raw backup: " << rc << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        return EXIT_SUCCESS;
-    }
-    catch (std::exception& e)
-    {
-        std::cerr << "error: " << e.what() << std::endl;
-        return EXIT_FAILURE;
-    }
+	connect_opts conn;
+	e::argparser ap;
+	ap.autohelp();
+	ap.option_string("[OPTIONS] <backup-name>");
+	ap.add("Connect to a daemon:", conn.parser());
+	if (!ap.parse(argc, argv))
+	{
+		return EXIT_FAILURE;
+	}
+	if (!conn.validate())
+	{
+		std::cerr << "invalid host:port specification\n" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	if (ap.args_sz() != 1)
+	{
+		std::cerr << "please specify a name for the backup" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	const char *name = ap.args()[0];
+	try
+	{
+		hyperdex_admin_returncode rc;
+		if (hyperdex_admin_raw_backup(conn.host(), conn.port(), name, &rc) < 0)
+		{
+			std::cerr << "could not take raw backup: " << rc << std::endl;
+			return EXIT_FAILURE;
+		}
+		return EXIT_SUCCESS;
+	}
+	catch (std::exception &e)
+	{
+		std::cerr << "error: " << e.what() << std::endl;
+		return EXIT_FAILURE;
+	}
 }
diff --git a/tools/rm-index.cc b/tools/rm-index.cc
index 049853b89..729893f9d 100644
--- a/tools/rm-index.cc
+++ b/tools/rm-index.cc
@@ -33,76 +33,64 @@
 #include "tools/common.h"
 
 int
-main(int argc, const char* argv[])
+main(int argc, const char *argv[])
 {
-    hyperdex::connect_opts conn;
-    e::argparser ap;
-    ap.autohelp();
-    ap.add("Connect to a cluster:", conn.parser());
-
-    if (!ap.parse(argc, argv))
-    {
-        return EXIT_FAILURE;
-    }
-
-    if (ap.args_sz() != 1)
-    {
-        std::cerr << "please specify the id of the index to remove\n" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    if (!conn.validate())
-    {
-        std::cerr << "invalid host:port specification\n" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    char* endptr = NULL;
-    uint64_t id = strtoull(ap.args()[0], &endptr, 10);
-
-    if (id == 0 || *endptr != '\0')
-    {
-        std::cerr << "invalid index id\n" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    try
-    {
-        hyperdex::Admin h(conn.host(), conn.port());
-        hyperdex_admin_returncode rrc;
-        int64_t rid = h.rm_index(id, &rrc);
-
-        if (rid < 0)
-        {
-            std::cerr << "could not rm index: " << rrc << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        hyperdex_admin_returncode lrc;
-        int64_t lid = h.loop(-1, &lrc);
-
-        if (lid < 0)
-        {
-            std::cerr << "could not rm index: " << lrc << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        assert(rid == lid);
-
-        if (rrc != HYPERDEX_ADMIN_SUCCESS)
-        {
-            std::cerr << "could not rm index: " << rrc << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        return EXIT_SUCCESS;
-    }
-    catch (std::exception& e)
-    {
-        std::cerr << "error: " << e.what() << std::endl;
-        return EXIT_FAILURE;
-    }
+	hyperdex::connect_opts conn;
+	e::argparser ap;
+	ap.autohelp();
+	ap.add("Connect to a cluster:", conn.parser());
+	if (!ap.parse(argc, argv))
+	{
+		return EXIT_FAILURE;
+	}
+	if (ap.args_sz() != 1)
+	{
+		std::cerr << "please specify the id of the index to remove\n" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	if (!conn.validate())
+	{
+		std::cerr << "invalid host:port specification\n" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	char *endptr = NULL;
+	uint64_t id = strtoull(ap.args()[0], &endptr, 10);
+	if (id == 0 || *endptr != '\0')
+	{
+		std::cerr << "invalid index id\n" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	try
+	{
+		hyperdex::Admin h(conn.host(), conn.port());
+		hyperdex_admin_returncode rrc;
+		int64_t rid = h.rm_index(id, &rrc);
+		if (rid < 0)
+		{
+			std::cerr << "could not rm index: " << rrc << std::endl;
+			return EXIT_FAILURE;
+		}
+		hyperdex_admin_returncode lrc;
+		int64_t lid = h.loop(-1, &lrc);
+		if (lid < 0)
+		{
+			std::cerr << "could not rm index: " << lrc << std::endl;
+			return EXIT_FAILURE;
+		}
+		assert(rid == lid);
+		if (rrc != HYPERDEX_ADMIN_SUCCESS)
+		{
+			std::cerr << "could not rm index: " << rrc << std::endl;
+			return EXIT_FAILURE;
+		}
+		return EXIT_SUCCESS;
+	}
+	catch (std::exception &e)
+	{
+		std::cerr << "error: " << e.what() << std::endl;
+		return EXIT_FAILURE;
+	}
 }
diff --git a/tools/rm-space.cc b/tools/rm-space.cc
index 456fd23d0..2fd5a3486 100644
--- a/tools/rm-space.cc
+++ b/tools/rm-space.cc
@@ -33,67 +33,57 @@
 #include "tools/common.h"
 
 int
-main(int argc, const char* argv[])
+main(int argc, const char *argv[])
 {
-    hyperdex::connect_opts conn;
-    e::argparser ap;
-    ap.autohelp();
-    ap.add("Connect to a cluster:", conn.parser());
-
-    if (!ap.parse(argc, argv))
-    {
-        return EXIT_FAILURE;
-    }
-
-    if (!conn.validate())
-    {
-        std::cerr << "invalid host:port specification\n" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    try
-    {
-        hyperdex::Admin h(conn.host(), conn.port());
-        bool failure = false;
-
-        for (size_t i = 0; i < ap.args_sz(); ++i)
-        {
-            hyperdex_admin_returncode rrc;
-            int64_t rid = h.rm_space(ap.args()[i], &rrc);
-
-            if (rid < 0)
-            {
-                std::cerr << "could not rm space: " << h.error_message() << std::endl;
-                failure = true;
-                continue;
-            }
-
-            hyperdex_admin_returncode lrc;
-            int64_t lid = h.loop(-1, &lrc);
-
-            if (lid < 0)
-            {
-                std::cerr << "could not rm space: " << h.error_message() << std::endl;
-                failure = true;
-                continue;
-            }
-
-            assert(rid == lid);
-
-            if (rrc != HYPERDEX_ADMIN_SUCCESS)
-            {
-                std::cerr << "could not rm space: " << h.error_message() << std::endl;
-                failure = true;
-                continue;
-            }
-        }
-
-        return failure ? EXIT_FAILURE : EXIT_SUCCESS;
-    }
-    catch (std::exception& e)
-    {
-        std::cerr << "error: " << e.what() << std::endl;
-        return EXIT_FAILURE;
-    }
+	hyperdex::connect_opts conn;
+	e::argparser ap;
+	ap.autohelp();
+	ap.add("Connect to a cluster:", conn.parser());
+	if (!ap.parse(argc, argv))
+	{
+		return EXIT_FAILURE;
+	}
+	if (!conn.validate())
+	{
+		std::cerr << "invalid host:port specification\n" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	try
+	{
+		hyperdex::Admin h(conn.host(), conn.port());
+		bool failure = false;
+		for (size_t i = 0; i < ap.args_sz(); ++i)
+		{
+			hyperdex_admin_returncode rrc;
+			int64_t rid = h.rm_space(ap.args()[i], &rrc);
+			if (rid < 0)
+			{
+				std::cerr << "could not rm space: " << h.error_message() << std::endl;
+				failure = true;
+				continue;
+			}
+			hyperdex_admin_returncode lrc;
+			int64_t lid = h.loop(-1, &lrc);
+			if (lid < 0)
+			{
+				std::cerr << "could not rm space: " << h.error_message() << std::endl;
+				failure = true;
+				continue;
+			}
+			assert(rid == lid);
+			if (rrc != HYPERDEX_ADMIN_SUCCESS)
+			{
+				std::cerr << "could not rm space: " << h.error_message() << std::endl;
+				failure = true;
+				continue;
+			}
+		}
+		return failure ? EXIT_FAILURE : EXIT_SUCCESS;
+	}
+	catch (std::exception &e)
+	{
+		std::cerr << "error: " << e.what() << std::endl;
+		return EXIT_FAILURE;
+	}
 }
diff --git a/tools/server-forget.cc b/tools/server-forget.cc
index 146cd59ff..0f35d87a3 100644
--- a/tools/server-forget.cc
+++ b/tools/server-forget.cc
@@ -33,77 +33,65 @@
 #include "tools/common.h"
 
 int
-main(int argc, const char* argv[])
+main(int argc, const char *argv[])
 {
-    hyperdex::connect_opts conn;
-    e::argparser ap;
-    ap.autohelp();
-    ap.option_string("[OPTIONS] <server-id>");
-    ap.add("Connect to a cluster:", conn.parser());
-
-    if (!ap.parse(argc, argv))
-    {
-        return EXIT_FAILURE;
-    }
-
-    if (!conn.validate())
-    {
-        std::cerr << "invalid host:port specification\n" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    if (ap.args_sz() != 1)
-    {
-        std::cerr << "please specify the server id" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    char* end = NULL;
-    uint64_t token = strtoull(ap.args()[0], &end, 0);
-
-    if (*end != '\0' || ap.args()[0] == end)
-    {
-        std::cerr << "server id must be a number" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    try
-    {
-        hyperdex::Admin h(conn.host(), conn.port());
-        hyperdex_admin_returncode rrc;
-        int64_t rid = h.server_forget(token, &rrc);
-
-        if (rid < 0)
-        {
-            std::cerr << "could not forget server: " << rrc << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        hyperdex_admin_returncode lrc;
-        int64_t lid = h.loop(-1, &lrc);
-
-        if (lid < 0)
-        {
-            std::cerr << "could not forget server: " << lrc << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        assert(rid == lid);
-
-        if (rrc != HYPERDEX_ADMIN_SUCCESS)
-        {
-            std::cerr << "could not forget server: " << rrc << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        return EXIT_SUCCESS;
-    }
-    catch (std::exception& e)
-    {
-        std::cerr << "error: " << e.what() << std::endl;
-        return EXIT_FAILURE;
-    }
+	hyperdex::connect_opts conn;
+	e::argparser ap;
+	ap.autohelp();
+	ap.option_string("[OPTIONS] <server-id>");
+	ap.add("Connect to a cluster:", conn.parser());
+	if (!ap.parse(argc, argv))
+	{
+		return EXIT_FAILURE;
+	}
+	if (!conn.validate())
+	{
+		std::cerr << "invalid host:port specification\n" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	if (ap.args_sz() != 1)
+	{
+		std::cerr << "please specify the server id" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	char *end = NULL;
+	uint64_t token = strtoull(ap.args()[0], &end, 0);
+	if (*end != '\0' || ap.args()[0] == end)
+	{
+		std::cerr << "server id must be a number" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	try
+	{
+		hyperdex::Admin h(conn.host(), conn.port());
+		hyperdex_admin_returncode rrc;
+		int64_t rid = h.server_forget(token, &rrc);
+		if (rid < 0)
+		{
+			std::cerr << "could not forget server: " << rrc << std::endl;
+			return EXIT_FAILURE;
+		}
+		hyperdex_admin_returncode lrc;
+		int64_t lid = h.loop(-1, &lrc);
+		if (lid < 0)
+		{
+			std::cerr << "could not forget server: " << lrc << std::endl;
+			return EXIT_FAILURE;
+		}
+		assert(rid == lid);
+		if (rrc != HYPERDEX_ADMIN_SUCCESS)
+		{
+			std::cerr << "could not forget server: " << rrc << std::endl;
+			return EXIT_FAILURE;
+		}
+		return EXIT_SUCCESS;
+	}
+	catch (std::exception &e)
+	{
+		std::cerr << "error: " << e.what() << std::endl;
+		return EXIT_FAILURE;
+	}
 }
diff --git a/tools/server-kill.cc b/tools/server-kill.cc
index 9683ff866..8fcf5f30f 100644
--- a/tools/server-kill.cc
+++ b/tools/server-kill.cc
@@ -33,77 +33,65 @@
 #include "tools/common.h"
 
 int
-main(int argc, const char* argv[])
+main(int argc, const char *argv[])
 {
-    hyperdex::connect_opts conn;
-    e::argparser ap;
-    ap.autohelp();
-    ap.option_string("[OPTIONS] <server-id>");
-    ap.add("Connect to a cluster:", conn.parser());
-
-    if (!ap.parse(argc, argv))
-    {
-        return EXIT_FAILURE;
-    }
-
-    if (!conn.validate())
-    {
-        std::cerr << "invalid host:port specification\n" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    if (ap.args_sz() != 1)
-    {
-        std::cerr << "please specify the server id" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    char* end = NULL;
-    uint64_t token = strtoull(ap.args()[0], &end, 0);
-
-    if (*end != '\0' || ap.args()[0] == end)
-    {
-        std::cerr << "server id must be a number" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    try
-    {
-        hyperdex::Admin h(conn.host(), conn.port());
-        hyperdex_admin_returncode rrc;
-        int64_t rid = h.server_kill(token, &rrc);
-
-        if (rid < 0)
-        {
-            std::cerr << "could not kill server: " << rrc << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        hyperdex_admin_returncode lrc;
-        int64_t lid = h.loop(-1, &lrc);
-
-        if (lid < 0)
-        {
-            std::cerr << "could not kill server: " << lrc << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        assert(rid == lid);
-
-        if (rrc != HYPERDEX_ADMIN_SUCCESS)
-        {
-            std::cerr << "could not kill server: " << rrc << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        return EXIT_SUCCESS;
-    }
-    catch (std::exception& e)
-    {
-        std::cerr << "error: " << e.what() << std::endl;
-        return EXIT_FAILURE;
-    }
+	hyperdex::connect_opts conn;
+	e::argparser ap;
+	ap.autohelp();
+	ap.option_string("[OPTIONS] <server-id>");
+	ap.add("Connect to a cluster:", conn.parser());
+	if (!ap.parse(argc, argv))
+	{
+		return EXIT_FAILURE;
+	}
+	if (!conn.validate())
+	{
+		std::cerr << "invalid host:port specification\n" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	if (ap.args_sz() != 1)
+	{
+		std::cerr << "please specify the server id" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	char *end = NULL;
+	uint64_t token = strtoull(ap.args()[0], &end, 0);
+	if (*end != '\0' || ap.args()[0] == end)
+	{
+		std::cerr << "server id must be a number" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	try
+	{
+		hyperdex::Admin h(conn.host(), conn.port());
+		hyperdex_admin_returncode rrc;
+		int64_t rid = h.server_kill(token, &rrc);
+		if (rid < 0)
+		{
+			std::cerr << "could not kill server: " << rrc << std::endl;
+			return EXIT_FAILURE;
+		}
+		hyperdex_admin_returncode lrc;
+		int64_t lid = h.loop(-1, &lrc);
+		if (lid < 0)
+		{
+			std::cerr << "could not kill server: " << lrc << std::endl;
+			return EXIT_FAILURE;
+		}
+		assert(rid == lid);
+		if (rrc != HYPERDEX_ADMIN_SUCCESS)
+		{
+			std::cerr << "could not kill server: " << rrc << std::endl;
+			return EXIT_FAILURE;
+		}
+		return EXIT_SUCCESS;
+	}
+	catch (std::exception &e)
+	{
+		std::cerr << "error: " << e.what() << std::endl;
+		return EXIT_FAILURE;
+	}
 }
diff --git a/tools/server-offline.cc b/tools/server-offline.cc
index 0f23415e1..df7ffa761 100644
--- a/tools/server-offline.cc
+++ b/tools/server-offline.cc
@@ -33,77 +33,65 @@
 #include "tools/common.h"
 
 int
-main(int argc, const char* argv[])
+main(int argc, const char *argv[])
 {
-    hyperdex::connect_opts conn;
-    e::argparser ap;
-    ap.autohelp();
-    ap.option_string("[OPTIONS] <server-id>");
-    ap.add("Connect to a cluster:", conn.parser());
-
-    if (!ap.parse(argc, argv))
-    {
-        return EXIT_FAILURE;
-    }
-
-    if (!conn.validate())
-    {
-        std::cerr << "invalid host:port specification\n" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    if (ap.args_sz() != 1)
-    {
-        std::cerr << "please specify the server id" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    char* end = NULL;
-    uint64_t token = strtoull(ap.args()[0], &end, 0);
-
-    if (*end != '\0' || ap.args()[0] == end)
-    {
-        std::cerr << "server id must be a number" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    try
-    {
-        hyperdex::Admin h(conn.host(), conn.port());
-        hyperdex_admin_returncode rrc;
-        int64_t rid = h.server_offline(token, &rrc);
-
-        if (rid < 0)
-        {
-            std::cerr << "could not mark server unavailable: " << rrc << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        hyperdex_admin_returncode lrc;
-        int64_t lid = h.loop(-1, &lrc);
-
-        if (lid < 0)
-        {
-            std::cerr << "could not mark server unavailable: " << lrc << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        assert(rid == lid);
-
-        if (rrc != HYPERDEX_ADMIN_SUCCESS)
-        {
-            std::cerr << "could not mark server unavailable: " << rrc << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        return EXIT_SUCCESS;
-    }
-    catch (std::exception& e)
-    {
-        std::cerr << "error: " << e.what() << std::endl;
-        return EXIT_FAILURE;
-    }
+	hyperdex::connect_opts conn;
+	e::argparser ap;
+	ap.autohelp();
+	ap.option_string("[OPTIONS] <server-id>");
+	ap.add("Connect to a cluster:", conn.parser());
+	if (!ap.parse(argc, argv))
+	{
+		return EXIT_FAILURE;
+	}
+	if (!conn.validate())
+	{
+		std::cerr << "invalid host:port specification\n" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	if (ap.args_sz() != 1)
+	{
+		std::cerr << "please specify the server id" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	char *end = NULL;
+	uint64_t token = strtoull(ap.args()[0], &end, 0);
+	if (*end != '\0' || ap.args()[0] == end)
+	{
+		std::cerr << "server id must be a number" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	try
+	{
+		hyperdex::Admin h(conn.host(), conn.port());
+		hyperdex_admin_returncode rrc;
+		int64_t rid = h.server_offline(token, &rrc);
+		if (rid < 0)
+		{
+			std::cerr << "could not mark server unavailable: " << rrc << std::endl;
+			return EXIT_FAILURE;
+		}
+		hyperdex_admin_returncode lrc;
+		int64_t lid = h.loop(-1, &lrc);
+		if (lid < 0)
+		{
+			std::cerr << "could not mark server unavailable: " << lrc << std::endl;
+			return EXIT_FAILURE;
+		}
+		assert(rid == lid);
+		if (rrc != HYPERDEX_ADMIN_SUCCESS)
+		{
+			std::cerr << "could not mark server unavailable: " << rrc << std::endl;
+			return EXIT_FAILURE;
+		}
+		return EXIT_SUCCESS;
+	}
+	catch (std::exception &e)
+	{
+		std::cerr << "error: " << e.what() << std::endl;
+		return EXIT_FAILURE;
+	}
 }
diff --git a/tools/server-online.cc b/tools/server-online.cc
index beb0a0f6d..7080d1e7e 100644
--- a/tools/server-online.cc
+++ b/tools/server-online.cc
@@ -33,77 +33,65 @@
 #include "tools/common.h"
 
 int
-main(int argc, const char* argv[])
+main(int argc, const char *argv[])
 {
-    hyperdex::connect_opts conn;
-    e::argparser ap;
-    ap.autohelp();
-    ap.option_string("[OPTIONS] <server-id>");
-    ap.add("Connect to a cluster:", conn.parser());
-
-    if (!ap.parse(argc, argv))
-    {
-        return EXIT_FAILURE;
-    }
-
-    if (!conn.validate())
-    {
-        std::cerr << "invalid host:port specification\n" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    if (ap.args_sz() != 1)
-    {
-        std::cerr << "please specify the server id" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    char* end = NULL;
-    uint64_t token = strtoull(ap.args()[0], &end, 0);
-
-    if (*end != '\0' || ap.args()[0] == end)
-    {
-        std::cerr << "server id must be a number" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    try
-    {
-        hyperdex::Admin h(conn.host(), conn.port());
-        hyperdex_admin_returncode rrc;
-        int64_t rid = h.server_online(token, &rrc);
-
-        if (rid < 0)
-        {
-            std::cerr << "could not bring server online: " << rrc << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        hyperdex_admin_returncode lrc;
-        int64_t lid = h.loop(-1, &lrc);
-
-        if (lid < 0)
-        {
-            std::cerr << "could not bring server online: " << lrc << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        assert(rid == lid);
-
-        if (rrc != HYPERDEX_ADMIN_SUCCESS)
-        {
-            std::cerr << "could not bring server online: " << rrc << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        return EXIT_SUCCESS;
-    }
-    catch (std::exception& e)
-    {
-        std::cerr << "error: " << e.what() << std::endl;
-        return EXIT_FAILURE;
-    }
+	hyperdex::connect_opts conn;
+	e::argparser ap;
+	ap.autohelp();
+	ap.option_string("[OPTIONS] <server-id>");
+	ap.add("Connect to a cluster:", conn.parser());
+	if (!ap.parse(argc, argv))
+	{
+		return EXIT_FAILURE;
+	}
+	if (!conn.validate())
+	{
+		std::cerr << "invalid host:port specification\n" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	if (ap.args_sz() != 1)
+	{
+		std::cerr << "please specify the server id" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	char *end = NULL;
+	uint64_t token = strtoull(ap.args()[0], &end, 0);
+	if (*end != '\0' || ap.args()[0] == end)
+	{
+		std::cerr << "server id must be a number" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	try
+	{
+		hyperdex::Admin h(conn.host(), conn.port());
+		hyperdex_admin_returncode rrc;
+		int64_t rid = h.server_online(token, &rrc);
+		if (rid < 0)
+		{
+			std::cerr << "could not bring server online: " << rrc << std::endl;
+			return EXIT_FAILURE;
+		}
+		hyperdex_admin_returncode lrc;
+		int64_t lid = h.loop(-1, &lrc);
+		if (lid < 0)
+		{
+			std::cerr << "could not bring server online: " << lrc << std::endl;
+			return EXIT_FAILURE;
+		}
+		assert(rid == lid);
+		if (rrc != HYPERDEX_ADMIN_SUCCESS)
+		{
+			std::cerr << "could not bring server online: " << rrc << std::endl;
+			return EXIT_FAILURE;
+		}
+		return EXIT_SUCCESS;
+	}
+	catch (std::exception &e)
+	{
+		std::cerr << "error: " << e.what() << std::endl;
+		return EXIT_FAILURE;
+	}
 }
diff --git a/tools/server-register.cc b/tools/server-register.cc
index 0db89950a..91fa310ef 100644
--- a/tools/server-register.cc
+++ b/tools/server-register.cc
@@ -33,77 +33,65 @@
 #include "tools/common.h"
 
 int
-main(int argc, const char* argv[])
+main(int argc, const char *argv[])
 {
-    hyperdex::connect_opts conn;
-    e::argparser ap;
-    ap.autohelp();
-    ap.option_string("[OPTIONS] <server-id> <address:port>");
-    ap.add("Connect to a cluster:", conn.parser());
-
-    if (!ap.parse(argc, argv))
-    {
-        return EXIT_FAILURE;
-    }
-
-    if (!conn.validate())
-    {
-        std::cerr << "invalid host:port specification\n" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    if (ap.args_sz() != 2)
-    {
-        std::cerr << "please specify the server id and address:port" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    char* end = NULL;
-    uint64_t token = strtoull(ap.args()[0], &end, 0);
-
-    if (*end != '\0' || ap.args()[0] == end)
-    {
-        std::cerr << "server id must be a number" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    try
-    {
-        hyperdex::Admin h(conn.host(), conn.port());
-        hyperdex_admin_returncode rrc;
-        int64_t rid = h.server_register(token, ap.args()[1], &rrc);
-
-        if (rid < 0)
-        {
-            std::cerr << "could not register server: " << rrc << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        hyperdex_admin_returncode lrc;
-        int64_t lid = h.loop(-1, &lrc);
-
-        if (lid < 0)
-        {
-            std::cerr << "could not register server: " << lrc << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        assert(rid == lid);
-
-        if (rrc != HYPERDEX_ADMIN_SUCCESS)
-        {
-            std::cerr << "could not register server: " << rrc << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        return EXIT_SUCCESS;
-    }
-    catch (std::exception& e)
-    {
-        std::cerr << "error: " << e.what() << std::endl;
-        return EXIT_FAILURE;
-    }
+	hyperdex::connect_opts conn;
+	e::argparser ap;
+	ap.autohelp();
+	ap.option_string("[OPTIONS] <server-id> <address:port>");
+	ap.add("Connect to a cluster:", conn.parser());
+	if (!ap.parse(argc, argv))
+	{
+		return EXIT_FAILURE;
+	}
+	if (!conn.validate())
+	{
+		std::cerr << "invalid host:port specification\n" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	if (ap.args_sz() != 2)
+	{
+		std::cerr << "please specify the server id and address:port" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	char *end = NULL;
+	uint64_t token = strtoull(ap.args()[0], &end, 0);
+	if (*end != '\0' || ap.args()[0] == end)
+	{
+		std::cerr << "server id must be a number" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	try
+	{
+		hyperdex::Admin h(conn.host(), conn.port());
+		hyperdex_admin_returncode rrc;
+		int64_t rid = h.server_register(token, ap.args()[1], &rrc);
+		if (rid < 0)
+		{
+			std::cerr << "could not register server: " << rrc << std::endl;
+			return EXIT_FAILURE;
+		}
+		hyperdex_admin_returncode lrc;
+		int64_t lid = h.loop(-1, &lrc);
+		if (lid < 0)
+		{
+			std::cerr << "could not register server: " << lrc << std::endl;
+			return EXIT_FAILURE;
+		}
+		assert(rid == lid);
+		if (rrc != HYPERDEX_ADMIN_SUCCESS)
+		{
+			std::cerr << "could not register server: " << rrc << std::endl;
+			return EXIT_FAILURE;
+		}
+		return EXIT_SUCCESS;
+	}
+	catch (std::exception &e)
+	{
+		std::cerr << "error: " << e.what() << std::endl;
+		return EXIT_FAILURE;
+	}
 }
diff --git a/tools/set-fault-tolerance.cc b/tools/set-fault-tolerance.cc
index 85f94ddc5..400415f9e 100644
--- a/tools/set-fault-tolerance.cc
+++ b/tools/set-fault-tolerance.cc
@@ -33,77 +33,65 @@
 #include "tools/common.h"
 
 int
-main(int argc, const char* argv[])
+main(int argc, const char *argv[])
 {
-    hyperdex::connect_opts conn;
-    e::argparser ap;
-    ap.autohelp();
-    ap.option_string("[OPTIONS] <space> <ft>");
-    ap.add("Connect to a cluster:", conn.parser());
-
-    if (!ap.parse(argc, argv))
-    {
-        return EXIT_FAILURE;
-    }
-
-    if (!conn.validate())
-    {
-        std::cerr << "invalid host:port specification\n" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    if (ap.args_sz() != 2)
-    {
-        std::cerr << "specify the space and fault tolerance level" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    char* end = NULL;
-    long ft = strtol(ap.args()[1], &end, 0);
-
-    if (*end != '\0' || ap.args()[1] == end || ft < 0)
-    {
-        std::cerr << "fault tolerance must be a number greater than 0" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    try
-    {
-        hyperdex::Admin h(conn.host(), conn.port());
-        hyperdex_admin_returncode rrc;
-        int64_t rid = h.fault_tolerance(ap.args()[0], ft, &rrc);
-
-        if (rid < 0)
-        {
-            std::cerr << "could not set fault tolerance: " << rrc << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        hyperdex_admin_returncode lrc;
-        int64_t lid = h.loop(-1, &lrc);
-
-        if (lid < 0)
-        {
-            std::cerr << "could not set fault tolerance: " << lrc << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        assert(rid == lid);
-
-        if (rrc != HYPERDEX_ADMIN_SUCCESS)
-        {
-            std::cerr << "could not set fault tolerance: " << rrc << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        return EXIT_SUCCESS;
-    }
-    catch (std::exception& e)
-    {
-        std::cerr << "error: " << e.what() << std::endl;
-        return EXIT_FAILURE;
-    }
+	hyperdex::connect_opts conn;
+	e::argparser ap;
+	ap.autohelp();
+	ap.option_string("[OPTIONS] <space> <ft>");
+	ap.add("Connect to a cluster:", conn.parser());
+	if (!ap.parse(argc, argv))
+	{
+		return EXIT_FAILURE;
+	}
+	if (!conn.validate())
+	{
+		std::cerr << "invalid host:port specification\n" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	if (ap.args_sz() != 2)
+	{
+		std::cerr << "specify the space and fault tolerance level" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	char *end = NULL;
+	long ft = strtol(ap.args()[1], &end, 0);
+	if (*end != '\0' || ap.args()[1] == end || ft < 0)
+	{
+		std::cerr << "fault tolerance must be a number greater than 0" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	try
+	{
+		hyperdex::Admin h(conn.host(), conn.port());
+		hyperdex_admin_returncode rrc;
+		int64_t rid = h.fault_tolerance(ap.args()[0], ft, &rrc);
+		if (rid < 0)
+		{
+			std::cerr << "could not set fault tolerance: " << rrc << std::endl;
+			return EXIT_FAILURE;
+		}
+		hyperdex_admin_returncode lrc;
+		int64_t lid = h.loop(-1, &lrc);
+		if (lid < 0)
+		{
+			std::cerr << "could not set fault tolerance: " << lrc << std::endl;
+			return EXIT_FAILURE;
+		}
+		assert(rid == lid);
+		if (rrc != HYPERDEX_ADMIN_SUCCESS)
+		{
+			std::cerr << "could not set fault tolerance: " << rrc << std::endl;
+			return EXIT_FAILURE;
+		}
+		return EXIT_SUCCESS;
+	}
+	catch (std::exception &e)
+	{
+		std::cerr << "error: " << e.what() << std::endl;
+		return EXIT_FAILURE;
+	}
 }
diff --git a/tools/set-read-only.cc b/tools/set-read-only.cc
index bc4548fbc..18cb8e551 100644
--- a/tools/set-read-only.cc
+++ b/tools/set-read-only.cc
@@ -33,67 +33,57 @@
 #include "tools/common.h"
 
 int
-main(int argc, const char* argv[])
+main(int argc, const char *argv[])
 {
-    hyperdex::connect_opts conn;
-    e::argparser ap;
-    ap.autohelp();
-    ap.option_string("[OPTIONS] <server-id>");
-    ap.add("Connect to a cluster:", conn.parser());
-
-    if (!ap.parse(argc, argv))
-    {
-        return EXIT_FAILURE;
-    }
-
-    if (!conn.validate())
-    {
-        std::cerr << "invalid host:port specification\n" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    if (ap.args_sz() != 0)
-    {
-        std::cerr << "command takes no arguments" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    try
-    {
-        hyperdex::Admin h(conn.host(), conn.port());
-        hyperdex_admin_returncode rrc;
-        int64_t rid = h.read_only(true, &rrc);
-
-        if (rid < 0)
-        {
-            std::cerr << "could not make cluster read-only: " << rrc << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        hyperdex_admin_returncode lrc;
-        int64_t lid = h.loop(-1, &lrc);
-
-        if (lid < 0)
-        {
-            std::cerr << "could not make cluster read-only: " << lrc << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        assert(rid == lid);
-
-        if (rrc != HYPERDEX_ADMIN_SUCCESS)
-        {
-            std::cerr << "could not make cluster read-only: " << rrc << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        return EXIT_SUCCESS;
-    }
-    catch (std::exception& e)
-    {
-        std::cerr << "error: " << e.what() << std::endl;
-        return EXIT_FAILURE;
-    }
+	hyperdex::connect_opts conn;
+	e::argparser ap;
+	ap.autohelp();
+	ap.option_string("[OPTIONS] <server-id>");
+	ap.add("Connect to a cluster:", conn.parser());
+	if (!ap.parse(argc, argv))
+	{
+		return EXIT_FAILURE;
+	}
+	if (!conn.validate())
+	{
+		std::cerr << "invalid host:port specification\n" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	if (ap.args_sz() != 0)
+	{
+		std::cerr << "command takes no arguments" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	try
+	{
+		hyperdex::Admin h(conn.host(), conn.port());
+		hyperdex_admin_returncode rrc;
+		int64_t rid = h.read_only(true, &rrc);
+		if (rid < 0)
+		{
+			std::cerr << "could not make cluster read-only: " << rrc << std::endl;
+			return EXIT_FAILURE;
+		}
+		hyperdex_admin_returncode lrc;
+		int64_t lid = h.loop(-1, &lrc);
+		if (lid < 0)
+		{
+			std::cerr << "could not make cluster read-only: " << lrc << std::endl;
+			return EXIT_FAILURE;
+		}
+		assert(rid == lid);
+		if (rrc != HYPERDEX_ADMIN_SUCCESS)
+		{
+			std::cerr << "could not make cluster read-only: " << rrc << std::endl;
+			return EXIT_FAILURE;
+		}
+		return EXIT_SUCCESS;
+	}
+	catch (std::exception &e)
+	{
+		std::cerr << "error: " << e.what() << std::endl;
+		return EXIT_FAILURE;
+	}
 }
diff --git a/tools/set-read-write.cc b/tools/set-read-write.cc
index febdc9832..e266fdc92 100644
--- a/tools/set-read-write.cc
+++ b/tools/set-read-write.cc
@@ -33,67 +33,57 @@
 #include "tools/common.h"
 
 int
-main(int argc, const char* argv[])
+main(int argc, const char *argv[])
 {
-    hyperdex::connect_opts conn;
-    e::argparser ap;
-    ap.autohelp();
-    ap.option_string("[OPTIONS] <server-id>");
-    ap.add("Connect to a cluster:", conn.parser());
-
-    if (!ap.parse(argc, argv))
-    {
-        return EXIT_FAILURE;
-    }
-
-    if (!conn.validate())
-    {
-        std::cerr << "invalid host:port specification\n" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    if (ap.args_sz() != 0)
-    {
-        std::cerr << "command takes no arguments" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    try
-    {
-        hyperdex::Admin h(conn.host(), conn.port());
-        hyperdex_admin_returncode rrc;
-        int64_t rid = h.read_only(false, &rrc);
-
-        if (rid < 0)
-        {
-            std::cerr << "could not make cluster read-write: " << rrc << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        hyperdex_admin_returncode lrc;
-        int64_t lid = h.loop(-1, &lrc);
-
-        if (lid < 0)
-        {
-            std::cerr << "could not make cluster read-write: " << lrc << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        assert(rid == lid);
-
-        if (rrc != HYPERDEX_ADMIN_SUCCESS)
-        {
-            std::cerr << "could not make cluster read-write: " << rrc << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        return EXIT_SUCCESS;
-    }
-    catch (std::exception& e)
-    {
-        std::cerr << "error: " << e.what() << std::endl;
-        return EXIT_FAILURE;
-    }
+	hyperdex::connect_opts conn;
+	e::argparser ap;
+	ap.autohelp();
+	ap.option_string("[OPTIONS] <server-id>");
+	ap.add("Connect to a cluster:", conn.parser());
+	if (!ap.parse(argc, argv))
+	{
+		return EXIT_FAILURE;
+	}
+	if (!conn.validate())
+	{
+		std::cerr << "invalid host:port specification\n" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	if (ap.args_sz() != 0)
+	{
+		std::cerr << "command takes no arguments" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	try
+	{
+		hyperdex::Admin h(conn.host(), conn.port());
+		hyperdex_admin_returncode rrc;
+		int64_t rid = h.read_only(false, &rrc);
+		if (rid < 0)
+		{
+			std::cerr << "could not make cluster read-write: " << rrc << std::endl;
+			return EXIT_FAILURE;
+		}
+		hyperdex_admin_returncode lrc;
+		int64_t lid = h.loop(-1, &lrc);
+		if (lid < 0)
+		{
+			std::cerr << "could not make cluster read-write: " << lrc << std::endl;
+			return EXIT_FAILURE;
+		}
+		assert(rid == lid);
+		if (rrc != HYPERDEX_ADMIN_SUCCESS)
+		{
+			std::cerr << "could not make cluster read-write: " << rrc << std::endl;
+			return EXIT_FAILURE;
+		}
+		return EXIT_SUCCESS;
+	}
+	catch (std::exception &e)
+	{
+		std::cerr << "error: " << e.what() << std::endl;
+		return EXIT_FAILURE;
+	}
 }
diff --git a/tools/show-config.cc b/tools/show-config.cc
index 0fe9f8686..73f7d6548 100644
--- a/tools/show-config.cc
+++ b/tools/show-config.cc
@@ -33,68 +33,58 @@
 #include "tools/common.h"
 
 int
-main(int argc, const char* argv[])
+main(int argc, const char *argv[])
 {
-    hyperdex::connect_opts conn;
-    e::argparser ap;
-    ap.autohelp();
-    ap.add("Connect to a cluster:", conn.parser());
-
-    if (!ap.parse(argc, argv))
-    {
-        return EXIT_FAILURE;
-    }
-
-    if (!conn.validate())
-    {
-        std::cerr << "invalid host:port specification\n" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    if (ap.args_sz() != 0)
-    {
-        std::cerr << "command takes no positional arguments" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    try
-    {
-        hyperdex::Admin h(conn.host(), conn.port());
-        hyperdex_admin_returncode rrc;
-        const char* config = NULL;
-        int64_t rid = h.dump_config(&rrc, &config);
-
-        if (rid < 0)
-        {
-            std::cerr << "could not show config: " << h.error_message() << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        hyperdex_admin_returncode lrc;
-        int64_t lid = h.loop(-1, &lrc);
-
-        if (lid < 0)
-        {
-            std::cerr << "could not show config: " << h.error_message() << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        assert(rid == lid);
-
-        if (rrc != HYPERDEX_ADMIN_SUCCESS)
-        {
-            std::cerr << "could not show config: " << h.error_message() << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        std::cout << config;
-        return EXIT_SUCCESS;
-    }
-    catch (std::exception& e)
-    {
-        std::cerr << "error: " << e.what() << std::endl;
-        return EXIT_FAILURE;
-    }
+	hyperdex::connect_opts conn;
+	e::argparser ap;
+	ap.autohelp();
+	ap.add("Connect to a cluster:", conn.parser());
+	if (!ap.parse(argc, argv))
+	{
+		return EXIT_FAILURE;
+	}
+	if (!conn.validate())
+	{
+		std::cerr << "invalid host:port specification\n" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	if (ap.args_sz() != 0)
+	{
+		std::cerr << "command takes no positional arguments" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	try
+	{
+		hyperdex::Admin h(conn.host(), conn.port());
+		hyperdex_admin_returncode rrc;
+		const char *config = NULL;
+		int64_t rid = h.dump_config(&rrc, &config);
+		if (rid < 0)
+		{
+			std::cerr << "could not show config: " << h.error_message() << std::endl;
+			return EXIT_FAILURE;
+		}
+		hyperdex_admin_returncode lrc;
+		int64_t lid = h.loop(-1, &lrc);
+		if (lid < 0)
+		{
+			std::cerr << "could not show config: " << h.error_message() << std::endl;
+			return EXIT_FAILURE;
+		}
+		assert(rid == lid);
+		if (rrc != HYPERDEX_ADMIN_SUCCESS)
+		{
+			std::cerr << "could not show config: " << h.error_message() << std::endl;
+			return EXIT_FAILURE;
+		}
+		std::cout << config;
+		return EXIT_SUCCESS;
+	}
+	catch (std::exception &e)
+	{
+		std::cerr << "error: " << e.what() << std::endl;
+		return EXIT_FAILURE;
+	}
 }
diff --git a/tools/validate-space.cc b/tools/validate-space.cc
index 148be1d06..df49d33cc 100644
--- a/tools/validate-space.cc
+++ b/tools/validate-space.cc
@@ -38,52 +38,43 @@
 #include <hyperdex/hyperspace_builder.h>
 
 int
-main(int argc, const char* argv[])
+main(int argc, const char *argv[])
 {
-    e::argparser ap;
-    ap.autohelp();
-
-    if (!ap.parse(argc, argv))
-    {
-        return EXIT_FAILURE;
-    }
-
-    if (ap.args_sz() != 0)
-    {
-        std::cerr << "command takes no arguments" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    std::string description;
-    std::string s;
-
-    while (std::cin >> s)
-    {
-        if (!description.empty())
-        {
-            description += " " + s;
-        }
-        else
-        {
-            description += s;
-        }
-    }
-
-    struct hyperspace* space = hyperspace_parse(description.c_str());
-
-    if (hyperspace_error(space))
-    {
-        std::cerr << "invalid hyperspace: " << hyperspace_error(space) << std::endl;
-
-        if (space)
-        {
-            hyperspace_destroy(space);
-        }
-
-        return EXIT_FAILURE;
-    }
-
-    hyperspace_destroy(space);
-    return EXIT_SUCCESS;
+	e::argparser ap;
+	ap.autohelp();
+	if (!ap.parse(argc, argv))
+	{
+		return EXIT_FAILURE;
+	}
+	if (ap.args_sz() != 0)
+	{
+		std::cerr << "command takes no arguments" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	std::string description;
+	std::string s;
+	while (std::cin >> s)
+	{
+		if (!description.empty())
+		{
+			description += " " + s;
+		}
+		else
+		{
+			description += s;
+		}
+	}
+	struct hyperspace *space = hyperspace_parse(description.c_str());
+	if (hyperspace_error(space))
+	{
+		std::cerr << "invalid hyperspace: " << hyperspace_error(space) << std::endl;
+		if (space)
+		{
+			hyperspace_destroy(space);
+		}
+		return EXIT_FAILURE;
+	}
+	hyperspace_destroy(space);
+	return EXIT_SUCCESS;
 }
diff --git a/tools/wait-until-stable.cc b/tools/wait-until-stable.cc
index 6ed5b02fe..75df5706e 100644
--- a/tools/wait-until-stable.cc
+++ b/tools/wait-until-stable.cc
@@ -33,66 +33,56 @@
 #include "tools/common.h"
 
 int
-main(int argc, const char* argv[])
+main(int argc, const char *argv[])
 {
-    hyperdex::connect_opts conn;
-    e::argparser ap;
-    ap.autohelp();
-    ap.add("Connect to a cluster:", conn.parser());
-
-    if (!ap.parse(argc, argv))
-    {
-        return EXIT_FAILURE;
-    }
-
-    if (!conn.validate())
-    {
-        std::cerr << "invalid host:port specification\n" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    if (ap.args_sz() != 0)
-    {
-        std::cerr << "command takes no arguments" << std::endl;
-        ap.usage();
-        return EXIT_FAILURE;
-    }
-
-    try
-    {
-        hyperdex::Admin h(conn.host(), conn.port());
-        hyperdex_admin_returncode rrc;
-        int64_t rid = h.wait_until_stable(&rrc);
-
-        if (rid < 0)
-        {
-            std::cerr << "could not wait until stable: " << h.error_message() << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        hyperdex_admin_returncode lrc;
-        int64_t lid = h.loop(-1, &lrc);
-
-        if (lid < 0)
-        {
-            std::cerr << "could not wait until stable: " << h.error_message() << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        assert(rid == lid);
-
-        if (rrc != HYPERDEX_ADMIN_SUCCESS)
-        {
-            std::cerr << "could not wait until stable: " << h.error_message() << std::endl;
-            return EXIT_FAILURE;
-        }
-
-        return EXIT_SUCCESS;
-    }
-    catch (std::exception& e)
-    {
-        std::cerr << "error: " << e.what() << std::endl;
-        return EXIT_FAILURE;
-    }
+	hyperdex::connect_opts conn;
+	e::argparser ap;
+	ap.autohelp();
+	ap.add("Connect to a cluster:", conn.parser());
+	if (!ap.parse(argc, argv))
+	{
+		return EXIT_FAILURE;
+	}
+	if (!conn.validate())
+	{
+		std::cerr << "invalid host:port specification\n" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	if (ap.args_sz() != 0)
+	{
+		std::cerr << "command takes no arguments" << std::endl;
+		ap.usage();
+		return EXIT_FAILURE;
+	}
+	try
+	{
+		hyperdex::Admin h(conn.host(), conn.port());
+		hyperdex_admin_returncode rrc;
+		int64_t rid = h.wait_until_stable(&rrc);
+		if (rid < 0)
+		{
+			std::cerr << "could not wait until stable: " << h.error_message() << std::endl;
+			return EXIT_FAILURE;
+		}
+		hyperdex_admin_returncode lrc;
+		int64_t lid = h.loop(-1, &lrc);
+		if (lid < 0)
+		{
+			std::cerr << "could not wait until stable: " << h.error_message() << std::endl;
+			return EXIT_FAILURE;
+		}
+		assert(rid == lid);
+		if (rrc != HYPERDEX_ADMIN_SUCCESS)
+		{
+			std::cerr << "could not wait until stable: " << h.error_message() << std::endl;
+			return EXIT_FAILURE;
+		}
+		return EXIT_SUCCESS;
+	}
+	catch (std::exception &e)
+	{
+		std::cerr << "error: " << e.what() << std::endl;
+		return EXIT_FAILURE;
+	}
 }
diff --git a/windows/hyperclientclr.cpp b/windows/hyperclientclr.cpp
index 0e9e9446b..4ba48bdad 100644
--- a/windows/hyperclientclr.cpp
+++ b/windows/hyperclientclr.cpp
@@ -1,959 +1,898 @@
-// This is the main DLL file.
-
-#include <hyperclientclr.h>
-#include <client/hyperclient.h>
-#include <stdlib.h>
-#include <string.h>
-#include <msclr/marshal.h>
-#include <cliext/utility>
-#include <marshal.h>
-#include <e/endian.h>
-
-using namespace msclr::interop;
-using namespace cliext;
-using namespace System;
-using namespace System::Collections::Generic;
-
-#define THROW_EXCEPTION(x) \
-    do{ \
-        HyperClientException^ ex = gcnew HyperClientException(); \
-        ex->return_code = static_cast<HyperClientReturnCode>(x); \
-        throw ex; \
-    } while (0)
-
-namespace
-HyperDex
-{    
-
-    Int64 unpack_int64(const char* val)
-    {
-        int64_t out;
-        e::unpack64le(val, &out);
-        return out;
-    }
-
-    Double unpack_float(const char* val)
-    {
-        double out;
-        e::unpack64le(val, (int64_t*)&out);
-        return out;
-    }
-
-    String^ unpack_string(const char* str, size_t sz)
-    {
-        char* tmp = (char*)malloc(sz + 1);
-        memcpy(tmp, str, sz);
-        tmp[sz] = '\0';
-        String^ output = marshal_as<String^>(tmp);
-        free(tmp);
-        return output;
-    }
-
-    Dictionary<String^, String^>^
-        unpack_map_string_string(const char* pos, size_t rem)
-        {
-            Dictionary<String^, String^>^ dict = gcnew Dictionary<String^, String^>();
-
-            while(rem >= 4)
-            {
-                uint32_t sz;
-                e::unpack32le(pos, &sz);
-                pos += 4;
-                rem -= 4;
-
-                String^ key = unpack_string(pos, sz);
-                pos += sz;
-                rem -= sz;
-
-                e::unpack32le(pos, &sz);
-                pos += 4;
-                rem -= 4;
-
-                String^ val = unpack_string(pos, sz);
-                pos += sz;
-                rem -= sz;
-
-                dict->Add(key, val);
-            }
-            return dict;
-        }
-
-    Dictionary<String^, Int64>^
-        unpack_map_string_int64(const char* pos, size_t rem)
-        {
-            Dictionary<String^, Int64>^ dict = gcnew Dictionary<String^, Int64>();
-
-            while(rem >= 4)
-            {
-                uint32_t sz;
-                e::unpack32le(pos, &sz);
-                pos += 4;
-                rem -= 4;
-
-                String^ key = unpack_string(pos, sz);
-                pos += sz;
-                rem -= sz;
-
-                Int64 val = unpack_int64(pos);
-                pos += 8;
-                rem -= 8;
-
-                dict->Add(key, val);
-            }
-            return dict;
-        } 
-
-    Dictionary<String^, Double>^
-        unpack_map_string_float(const char* pos, size_t rem)
-        {
-            Dictionary<String^, Double>^ dict = gcnew Dictionary<String^, Double>();
-
-            while(rem >= 4)
-            {
-                uint32_t sz;
-                e::unpack32le(pos, &sz);
-                pos += 4;
-                rem -= 4;
-
-                String^ key = unpack_string(pos, sz);
-                pos += sz;
-                rem -= sz;
-
-                Double val = unpack_float(pos);
-                pos += 8;
-                rem -= 8;
-
-                dict->Add(key, val);
-            }
-            return dict;
-        } 
-
-    Dictionary<Int64, Double>^
-        unpack_map_int64_float(const char* pos, size_t rem)
-        {
-            Dictionary<Int64, Double>^ dict = gcnew Dictionary<Int64, Double>();
-
-            while(rem >= 8)
-            {
-                Int64 key = unpack_int64(pos);
-                pos += 8;
-                rem -= 8;
-
-                Double val = unpack_float(pos);
-                pos += 8;
-                rem -= 8;
-
-                dict->Add(key, val);
-            }
-            return dict;
-        } 
-
-    Dictionary<Int64, Int64>^
-        unpack_map_int64_int64(const char* pos, size_t rem)
-        {
-            Dictionary<Int64, Int64>^ dict = gcnew Dictionary<Int64, Int64>();
-
-            while(rem >= 8)
-            {
-                Int64 key = unpack_int64(pos);
-                pos += 8;
-                rem -= 8;
-
-                Int64 val = unpack_int64(pos);
-                pos += 8;
-                rem -= 8;
-
-                dict->Add(key, val);
-            }
-            return dict;
-        } 
-
-
-    Dictionary<Int64, String^>^
-        unpack_map_int64_string(const char* pos, size_t rem)
-        {
-            Dictionary<Int64, String^>^ dict = gcnew Dictionary<Int64, String^>();
-
-            while(rem >= 8)
-            {
-                Int64 key = unpack_int64(pos);
-                pos += 8;
-                rem -= 8;
-
-                uint32_t sz;
-                e::unpack32le(pos, &sz);
-                pos += 4;
-                rem -= 4;
-
-                String^ val = unpack_string(pos, sz);
-                pos += sz;
-                rem -= sz;
-
-                dict->Add(key, val);
-            }
-            return dict;
-        } 
-
-    Dictionary<Double, Double>^
-        unpack_map_float_float(const char* pos, size_t rem)
-        {
-            Dictionary<Double, Double>^ dict = gcnew Dictionary<Double, Double>();
-
-            while(rem >= 8)
-            {
-                Double key = unpack_float(pos);
-                pos += 8;
-                rem -= 8;
-
-                Double val = unpack_float(pos);
-                pos += 8;
-                rem -= 8;
-
-                dict->Add(key, val);
-            }
-            return dict;
-        } 
-
-    Dictionary<Double, Int64>^
-        unpack_map_float_int64(const char* pos, size_t rem)
-        {
-            Dictionary<Double, Int64>^ dict = gcnew Dictionary<Double, Int64>();
-
-            while(rem >= 8)
-            {
-                Double key = unpack_float(pos);
-                pos += 8;
-                rem -= 8;
-
-                Int64 val = unpack_int64(pos);
-                pos += 8;
-                rem -= 8;
-
-                dict->Add(key, val);
-            }
-            return dict;
-        } 
-
-
-    Dictionary<Double, String^>^
-        unpack_map_float_string(const char* pos, size_t rem)
-        {
-            Dictionary<Double, String^>^ dict = gcnew Dictionary<Double, String^>();
-
-            while(rem >= 8)
-            {
-                Double key = unpack_float(pos);
-                pos += 8;
-                rem -= 8;
-
-                uint32_t sz;
-                e::unpack32le(pos, &sz);
-                pos += 4;
-                rem -= 4;
-
-                String^ val = unpack_string(pos, sz);
-                pos += sz;
-                rem -= sz;
-
-                dict->Add(key, val);
-            }
-            return dict;
-        } 
-
-
-    SortedSet<String^>^
-        unpack_set_string(const char* pos, size_t rem)
-        {
-            SortedSet<String^>^ lst = gcnew SortedSet<String^>();
-
-            while(rem >= 4)
-            {
-                uint32_t sz;
-                e::unpack32le(pos, &sz);
-                pos += 4;
-                rem -= 4;
-                lst->Add(unpack_string(pos, sz));
-                pos += sz;
-                rem -= sz;
-            }
-            return lst;
-        }
-
-    SortedSet<Double>^ 
-        unpack_set_float(const char* pos, size_t rem)
-        {
-            SortedSet<Double>^ lst = gcnew SortedSet<Double>();
-
-            while(rem >= 8)
-            {
-                lst->Add(unpack_float(pos));
-                pos += 8;
-                rem -= 8;
-            }
-            return lst;
-        }
-
-    SortedSet<Int64>^ 
-        unpack_set_int64(const char* pos, size_t rem)
-        {
-            SortedSet<Int64>^ lst = gcnew SortedSet<Int64>();
-
-            while(rem >= 8)
-            {
-                lst->Add(unpack_int64(pos));
-                pos += 8;
-                rem -= 8;
-            }
-            return lst;
-        }
-
-
-    List<String^>^
-        unpack_list_string(const char* pos, size_t rem)
-        {
-            List<String^>^ lst = gcnew List<String^>();
-
-            while(rem >= 4)
-            {
-                uint32_t sz;
-                e::unpack32le(pos, &sz);
-                pos += 4;
-                rem -= 4;
-                lst->Add(unpack_string(pos, sz));
-                pos += sz;
-                rem -= sz;
-            }
-            return lst;
-        }
-
-    List<Double>^ 
-        unpack_list_float(const char* pos, size_t rem)
-        {
-            List<Double>^ lst = gcnew List<Double>();
-
-            while(rem >= 8)
-            {
-                lst->Add(unpack_float(pos));
-                pos += 8;
-                rem -= 8;
-            }
-            return lst;
-        }
-
-    List<Int64>^ 
-        unpack_list_int64(const char* pos, size_t rem)
-        {
-            List<Int64>^ lst = gcnew List<Int64>();
-
-            while(rem >= 8)
-            {
-                lst->Add(unpack_int64(pos));
-                pos += 8;
-                rem -= 8;
-            }
-            return lst;
-        }
-
-
-    HyperClient::HyperClient(String^ coordinator, uint16_t port)
-    {
-        WSADATA wsa;
-        if(WSAStartup(MAKEWORD(2,2), &wsa))
-            abort();
-        const char* coord;
-        mc = gcnew marshal_context();
-        coord = mc->marshal_as<const char*>( coordinator );
-        _hc = new hyperclient(coord, port);
-    }
-
-    HyperClient::~HyperClient()
-    {
-        this->!HyperClient();
-    }
-
-    HyperClient::!HyperClient()
-    {
-        delete _hc;
-        _hc = nullptr;
-    }
-
-    Dictionary<String ^, Object ^> ^
-        HyperClient::get(String ^space, String ^key)
-        { 
-            Dictionary<String ^, Object ^> ^output = gcnew Dictionary<String ^, Object ^>;
-            marshal_context context;
-
-            hyperclient_returncode st;
-            hyperclient_attribute *attrs;
-            size_t attrs_sz;
-            int64_t ret = _hc->get(context.marshal_as<const char*>(space), 
-                    context.marshal_as<const char*>(key), 
-                    key->Length, &st, &attrs, &attrs_sz); 
-            if(ret < 0)
-            {
-                THROW_EXCEPTION(st);
-            }
-
-            while(1)
-            {
-                hyperclient_returncode rc;
-                int64_t lret = _hc->loop(-1, &rc);
-                if(lret == ret)
-                {
-                    if(rc == HYPERCLIENT_SUCCESS)
-                    {
-                        for(int i = 0; i < attrs_sz; ++i)
-                        {
-                            if(attrs[i].value_sz == 0)
-                            {
-                                continue;
-                            }
-                            switch(attrs[i].datatype)
-                            {
-
-                                case HYPERDATATYPE_STRING:
-                                    {
-                                        output->Add(marshal_as<String^>(attrs[i].attr), 
-                                                unpack_string(attrs[i].value, attrs[i].value_sz)); 
-                                        break;
-                                    }
-                                case HYPERDATATYPE_INT64:
-                                    output->Add(marshal_as<String^>(attrs[i].attr),
-                                            unpack_int64(attrs[i].value));
-                                    break;
-                                case HYPERDATATYPE_FLOAT:
-                                    output->Add(marshal_as<String^>(attrs[i].attr),
-                                            unpack_float(attrs[i].value));
-                                    break;
-                                case HYPERDATATYPE_SET_STRING:
-                                    {
-                                        output->Add(marshal_as<String^>(attrs[i].attr), 
-                                                unpack_set_string(attrs[i].value, attrs[i].value_sz));
-                                        break;
-                                    }
-                                case HYPERDATATYPE_LIST_STRING:
-                                    {
-                                        output->Add(marshal_as<String^>(attrs[i].attr), 
-                                                unpack_list_string(attrs[i].value, attrs[i].value_sz));
-                                        break;
-                                    }
-                                case HYPERDATATYPE_SET_INT64:
-                                    {
-                                        output->Add(marshal_as<String^>(attrs[i].attr), 
-                                                unpack_set_int64(attrs[i].value, attrs[i].value_sz));
-                                        break;         
-                                    }
-                                case HYPERDATATYPE_LIST_INT64:
-                                    {
-                                        output->Add(marshal_as<String^>(attrs[i].attr), 
-                                                unpack_list_int64(attrs[i].value, attrs[i].value_sz));
-                                        break;         
-                                    }
-                                case HYPERDATATYPE_SET_FLOAT:
-                                    {
-                                        output->Add(marshal_as<String^>(attrs[i].attr), 
-                                                unpack_set_float(attrs[i].value, attrs[i].value_sz));
-                                        break;         
-                                    }
-                                case HYPERDATATYPE_LIST_FLOAT:
-                                    {
-                                        output->Add(marshal_as<String^>(attrs[i].attr), 
-                                                unpack_list_float(attrs[i].value, attrs[i].value_sz));
-                                        break;         
-                                    }
-                                case HYPERDATATYPE_MAP_STRING_STRING:
-                                    {
-                                        output->Add(marshal_as<String^>(attrs[i].attr),
-                                                unpack_map_string_string(attrs[i].value, attrs[i].value_sz));
-                                        break;
-                                    }
-                                case HYPERDATATYPE_MAP_STRING_INT64:
-                                    {
-                                        output->Add(marshal_as<String^>(attrs[i].attr),
-                                                unpack_map_string_int64(attrs[i].value, attrs[i].value_sz));
-                                        break;
-                                    }
-                                case HYPERDATATYPE_MAP_STRING_FLOAT:
-                                    {
-                                        output->Add(marshal_as<String^>(attrs[i].attr),
-                                                unpack_map_string_float(attrs[i].value, attrs[i].value_sz));
-                                        break;
-                                    }
-                                case HYPERDATATYPE_MAP_INT64_STRING:
-                                    {
-                                        output->Add(marshal_as<String^>(attrs[i].attr),
-                                                unpack_map_int64_string(attrs[i].value, attrs[i].value_sz));
-                                        break;
-                                    }
-                                case HYPERDATATYPE_MAP_INT64_INT64:
-                                    {
-                                        output->Add(marshal_as<String^>(attrs[i].attr),
-                                                unpack_map_int64_int64(attrs[i].value, attrs[i].value_sz));
-                                        break;
-                                    }
-                                case HYPERDATATYPE_MAP_INT64_FLOAT:
-                                    {
-                                        output->Add(marshal_as<String^>(attrs[i].attr),
-                                                unpack_map_int64_float(attrs[i].value, attrs[i].value_sz));
-                                        break;
-                                    }
-                                case HYPERDATATYPE_MAP_FLOAT_STRING:
-                                    {
-                                        output->Add(marshal_as<String^>(attrs[i].attr),
-                                                unpack_map_float_string(attrs[i].value, attrs[i].value_sz));
-                                        break;
-                                    }
-                                case HYPERDATATYPE_MAP_FLOAT_INT64:
-                                    {
-                                        output->Add(marshal_as<String^>(attrs[i].attr),
-                                                unpack_map_float_int64(attrs[i].value, attrs[i].value_sz));
-                                        break;
-                                    }
-                                case HYPERDATATYPE_MAP_FLOAT_FLOAT:
-                                    {
-                                        output->Add(marshal_as<String^>(attrs[i].attr),
-                                                unpack_map_float_float(attrs[i].value, attrs[i].value_sz));
-                                        break;
-                                    }
-                                case HYPERDATATYPE_MAP_STRING_KEYONLY:
-                                default:
-                                    THROW_EXCEPTION(HYPERCLIENT_WRONGTYPE);
-                                    break;
-                            }
-                        }
-                    }
-                    else
-                    {
-                        THROW_EXCEPTION(rc);
-                    }
-                    break;
-                }
-            }
-
-            return output;
-        }
-
-#define WAIT_FOR_STATUS \
-    while(1) \
-    { \
-        hyperclient_returncode rc; \
-        int64_t lret = _hc->loop(-1, &rc); \
-        if(lret == ret) \
-        { \
-            if(rc == HYPERCLIENT_SUCCESS) \
-            { \
-                return true; \
-            } \
-            \
-            THROW_EXCEPTION(rc); \
-        } \
-    } \
-    \
-    return false; \
-
-#define HYPERCLIENT_CLRDEF(OPNAME) \
-    bool \
-    HyperClient:: ## OPNAME(String ^space, String ^key, Dictionary<String ^, Object ^> ^ attrs) \
-    { \
-        size_t size; \
-        for each(KeyValuePair<String ^, Object ^> kvp in attrs) \
-        { \
-            if (kvp.Value->GetType()->IsGenericType \
-                    && kvp.Value->GetType()->GetGenericTypeDefinition() == List::typeid) \
-            { \
-                if(kvp.Value->GetType() == String::typeid) \
-                size += 1 + ((List<String ^>^)kvp.Value)->Count; \
-                if(kvp.Value->GetType() == Int64::typeid) \
-                size += 1 + ((List<Int64>^)kvp.Value)->Count; \
-                if(kvp.Value->GetType() == Double::typeid) \
-                size += 1 + ((List<Double>^)kvp.Value)->Count; \
-            } \
-            else if (kvp.Value->GetType()->IsGenericType \
-                    && kvp.Value->GetType()->GetGenericTypeDefinition() == SortedSet::typeid) \
-            { \
-                if(kvp.Value->GetType() == String::typeid) \
-                size += 1 + ((SortedSet<String ^>^)kvp.Value)->Count; \
-                if(kvp.Value->GetType() == Int64::typeid) \
-                size += 1 + ((SortedSet<Int64>^)kvp.Value)->Count; \
-                if(kvp.Value->GetType() == Double::typeid) \
-                size += 1 + ((SortedSet<Double>^)kvp.Value)->Count; \
-            } \
-            else \
-            { \
-                size ++; \
-            } \
-        } \
-        marshal_context context; \
-        hyperclient_returncode st; \
-        int64_t ret = _hc->OPNAME(context.marshal_as<const char*>(space), \
-                context.marshal_as<const char*>(key), \
-                key->Length, \
-                context.marshal_as<hyperclient_attribute*>(attrs), \
-                size, &st); \
-        if(ret < 0) \
-        { \
-            THROW_EXCEPTION(st); \
-        } \
-        WAIT_FOR_STATUS \
-    }
-
-    HYPERCLIENT_CLRDEF(put)
-        HYPERCLIENT_CLRDEF(put_if_not_exist)
-        HYPERCLIENT_CLRDEF(atomic_add)
-        HYPERCLIENT_CLRDEF(atomic_sub)
-        HYPERCLIENT_CLRDEF(atomic_mul)
-        HYPERCLIENT_CLRDEF(atomic_div)
-        HYPERCLIENT_CLRDEF(atomic_mod)
-        HYPERCLIENT_CLRDEF(atomic_and)
-        HYPERCLIENT_CLRDEF(atomic_or)
-        HYPERCLIENT_CLRDEF(atomic_xor)
-        HYPERCLIENT_CLRDEF(string_prepend)
-        HYPERCLIENT_CLRDEF(string_append)
-        HYPERCLIENT_CLRDEF(list_lpush)
-        HYPERCLIENT_CLRDEF(list_rpush)
-        HYPERCLIENT_CLRDEF(set_add)
-        HYPERCLIENT_CLRDEF(set_remove)
-        HYPERCLIENT_CLRDEF(set_intersect)
-        HYPERCLIENT_CLRDEF(set_union)
-
-#define HYPERCLIENT_MAP_CLRDEF(OPNAME) \
-        bool \
-        HyperClient:: map_ ## OPNAME(String ^space, String ^key, Dictionary<String ^, Dictionary<Object^, Object ^>^ > ^ attrs) \
-        { \
-            marshal_context context; \
-            hyperclient_returncode st; \
-            size_t size = 0; \
-            for each(KeyValuePair<String ^, Dictionary<Object ^, Object ^>^ > attrkvp in attrs) \
-            { \
-                size += attrkvp.Value->Count; \
-            } \
-            int64_t ret = _hc->map_ ## OPNAME(context.marshal_as<const char*>(space), \
-                    context.marshal_as<const char*>(key), \
-                    key->Length, \
-                    context.marshal_as<hyperclient_map_attribute*>(attrs), \
-                    size, &st); \
-            if(ret < 0) \
-            { \
-                THROW_EXCEPTION(st); \
-            } \
-            WAIT_FOR_STATUS \
-        }
-
-        HYPERCLIENT_MAP_CLRDEF(add)
-        HYPERCLIENT_MAP_CLRDEF(remove)
-        HYPERCLIENT_MAP_CLRDEF(atomic_add)
-        HYPERCLIENT_MAP_CLRDEF(atomic_sub)
-        HYPERCLIENT_MAP_CLRDEF(atomic_mul)
-        HYPERCLIENT_MAP_CLRDEF(atomic_div)
-        HYPERCLIENT_MAP_CLRDEF(atomic_mod)
-        HYPERCLIENT_MAP_CLRDEF(atomic_and)
-        HYPERCLIENT_MAP_CLRDEF(atomic_or)
-        HYPERCLIENT_MAP_CLRDEF(atomic_xor)
-        HYPERCLIENT_MAP_CLRDEF(string_prepend)
-        HYPERCLIENT_MAP_CLRDEF(string_append)
-
-        List<Dictionary<String ^, Object^>^ >^ 
-        HyperClient::search(String^ space, Dictionary<String ^, Object^>^ checks)
-        {
-            List<Dictionary<String ^, Object ^>^ > ^toValue = gcnew List<Dictionary<String ^, Object ^>^ >();
-
-            marshal_context context;
-            hyperclient_returncode st;
-            struct hyperclient_attribute* attrs;
-            size_t attrs_sz;
-            size_t checks_sz;
-
-            for each(KeyValuePair<String ^, Object ^> kvp in checks)
-            {
-                if (kvp.Value->GetType()->IsGenericType 
-                        && kvp.Value->GetType()->GetGenericTypeDefinition() == KeyValuePair::typeid)
-                {
-                    ++checks_sz;
-                }
-                ++checks_sz;
-            }
-
-            int64_t ret = _hc->search(context.marshal_as<const char*>(space),
-                    context.marshal_as<struct hyperclient_attribute_check*>(checks),
-                    checks_sz, &st, &attrs, &attrs_sz);
-            if(ret < 0)
-            {
-                THROW_EXCEPTION(st);
-            }
-
-            while(1)
-            {
-                hyperclient_returncode rc;
-                int64_t lret = _hc->loop(-1, &rc);
-                if(lret < 0)
-                {
-                    THROW_EXCEPTION(rc);
-                }
-                else if(lret == ret)
-                {
-                    Dictionary<String ^, Object ^>^ output = gcnew Dictionary<String ^, Object ^>();
-                    for(int i = 0; i < attrs_sz; ++i)
-                    {
-                        switch(attrs[i].datatype)
-                        {
-
-                            case HYPERDATATYPE_STRING:
-                                {
-                                    output->Add(marshal_as<String^>(attrs[i].attr), 
-                                            unpack_string(attrs[i].value, attrs[i].value_sz)); 
-                                    break;
-                                }
-                            case HYPERDATATYPE_INT64:
-                                output->Add(marshal_as<String^>(attrs[i].attr),
-                                        unpack_int64(attrs[i].value));
-                                break;
-                            case HYPERDATATYPE_FLOAT:
-                                output->Add(marshal_as<String^>(attrs[i].attr),
-                                        unpack_float(attrs[i].value));
-                                break;
-                            case HYPERDATATYPE_SET_STRING:
-                                {
-                                    output->Add(marshal_as<String^>(attrs[i].attr), 
-                                            unpack_set_string(attrs[i].value, attrs[i].value_sz));
-                                    break;
-                                }
-                            case HYPERDATATYPE_LIST_STRING:
-                                {
-                                    output->Add(marshal_as<String^>(attrs[i].attr), 
-                                            unpack_list_string(attrs[i].value, attrs[i].value_sz));
-                                    break;
-                                }
-                            case HYPERDATATYPE_SET_INT64:
-                                {
-                                    output->Add(marshal_as<String^>(attrs[i].attr), 
-                                            unpack_set_int64(attrs[i].value, attrs[i].value_sz));
-                                    break;         
-                                }
-                            case HYPERDATATYPE_LIST_INT64:
-                                {
-                                    output->Add(marshal_as<String^>(attrs[i].attr), 
-                                            unpack_list_int64(attrs[i].value, attrs[i].value_sz));
-                                    break;         
-                                }
-                            case HYPERDATATYPE_SET_FLOAT:
-                                {
-                                    output->Add(marshal_as<String^>(attrs[i].attr), 
-                                            unpack_set_float(attrs[i].value, attrs[i].value_sz));
-                                    break;         
-                                }
-                            case HYPERDATATYPE_LIST_FLOAT:
-                                {
-                                    output->Add(marshal_as<String^>(attrs[i].attr), 
-                                            unpack_list_float(attrs[i].value, attrs[i].value_sz));
-                                    break;         
-                                }
-                            case HYPERDATATYPE_MAP_STRING_STRING:
-                                {
-                                    output->Add(marshal_as<String^>(attrs[i].attr),
-                                            unpack_map_string_string(attrs[i].value, attrs[i].value_sz));
-                                    break;
-                                }
-                            case HYPERDATATYPE_MAP_STRING_INT64:
-                                {
-                                    output->Add(marshal_as<String^>(attrs[i].attr),
-                                            unpack_map_string_int64(attrs[i].value, attrs[i].value_sz));
-                                    break;
-                                }
-                            case HYPERDATATYPE_MAP_STRING_FLOAT:
-                                {
-                                    output->Add(marshal_as<String^>(attrs[i].attr),
-                                            unpack_map_string_float(attrs[i].value, attrs[i].value_sz));
-                                    break;
-                                }
-                            case HYPERDATATYPE_MAP_INT64_STRING:
-                                {
-                                    output->Add(marshal_as<String^>(attrs[i].attr),
-                                            unpack_map_int64_string(attrs[i].value, attrs[i].value_sz));
-                                    break;
-                                }
-                            case HYPERDATATYPE_MAP_INT64_INT64:
-                                {
-                                    output->Add(marshal_as<String^>(attrs[i].attr),
-                                            unpack_map_int64_int64(attrs[i].value, attrs[i].value_sz));
-                                    break;
-                                }
-                            case HYPERDATATYPE_MAP_INT64_FLOAT:
-                                {
-                                    output->Add(marshal_as<String^>(attrs[i].attr),
-                                            unpack_map_int64_float(attrs[i].value, attrs[i].value_sz));
-                                    break;
-                                }
-                            case HYPERDATATYPE_MAP_FLOAT_STRING:
-                                {
-                                    output->Add(marshal_as<String^>(attrs[i].attr),
-                                            unpack_map_float_string(attrs[i].value, attrs[i].value_sz));
-                                    break;
-                                }
-                            case HYPERDATATYPE_MAP_FLOAT_INT64:
-                                {
-                                    output->Add(marshal_as<String^>(attrs[i].attr),
-                                            unpack_map_float_int64(attrs[i].value, attrs[i].value_sz));
-                                    break;
-                                }
-                            case HYPERDATATYPE_MAP_FLOAT_FLOAT:
-                                {
-                                    output->Add(marshal_as<String^>(attrs[i].attr),
-                                            unpack_map_float_float(attrs[i].value, attrs[i].value_sz));
-                                    break;
-                                }
-                            case HYPERDATATYPE_MAP_STRING_KEYONLY:
-                            default:
-                                THROW_EXCEPTION(HYPERCLIENT_WRONGTYPE);
-                                break;
-                        }
-                    }
-
-                    toValue->Add(output);
-
-                    if(rc == HYPERCLIENT_SEARCHDONE)
-                    {
-                        break;
-                    }
-                }
-            }
-            return toValue;
-        }
-
-    List<Dictionary<String ^, Object^>^ >^ 
-        HyperClient::sorted_search(String^ space, String ^sortby, 
-                UInt64 limit, bool maximize, Dictionary<String ^, Object^>^ checks)
-        {
-            List<Dictionary<String ^, Object ^>^ > ^toValue = gcnew List<Dictionary<String ^, Object ^>^ >();
-
-            marshal_context context;
-            hyperclient_returncode st;
-            struct hyperclient_attribute* attrs;
-            size_t attrs_sz;
-            size_t checks_sz;
-
-            for each(KeyValuePair<String ^, Object ^> kvp in checks)
-            {
-                if (kvp.Value->GetType()->IsGenericType 
-                        && kvp.Value->GetType()->GetGenericTypeDefinition() == KeyValuePair::typeid)
-                {
-                    ++checks_sz;
-                }
-                ++checks_sz;
-            }
-
-            int64_t ret = _hc->sorted_search(context.marshal_as<const char*>(space),
-                    context.marshal_as<struct hyperclient_attribute_check*>(checks),
-                    checks_sz, context.marshal_as<const char*>(sortby), limit, maximize,
-                    &st, &attrs, &attrs_sz);
-
-            if(ret < 0)
-            {
-                THROW_EXCEPTION(st);
-            }
-
-            while(1)
-            {
-                hyperclient_returncode rc;
-                int64_t lret = _hc->loop(-1, &rc);
-                if(lret < 0)
-                {
-                    THROW_EXCEPTION(rc);
-                }
-                else if(lret == ret)
-                {
-                    Dictionary<String ^, Object ^>^ output = gcnew Dictionary<String ^, Object ^>();
-                    for(int i = 0; i < attrs_sz; ++i)
-                    {
-                        switch(attrs[i].datatype)
-                        {
-                            case HYPERDATATYPE_STRING:
-                                output->Add(marshal_as<String^>(attrs[i].attr), 
-                                        marshal_as<String^>(attrs[i].value));
-                                break;
-                            case HYPERDATATYPE_INT64:
-                                output->Add(marshal_as<String^>(attrs[i].attr),
-                                        *(int64_t*)attrs[i].value);
-                                break;
-                            case HYPERDATATYPE_FLOAT:
-                                output->Add(marshal_as<String^>(attrs[i].attr),
-                                        *(double*)attrs[i].value);
-                                break;
-                            default:
-                                break;
-                        }
-                    }
-
-                    toValue->Add(output);
-
-                    if(rc == HYPERCLIENT_SEARCHDONE)
-                    {
-                        break;
-                    }
-                }
-            }
-            return toValue;
-        }
-
-
-    UInt64 
-        HyperClient::count(String^ space, Dictionary<String ^, Object^>^ checks)
-        {
-            marshal_context context;
-            hyperclient_returncode st;
-            size_t checks_sz;
-            uint64_t result;
-
-            for each(KeyValuePair<String ^, Object ^> kvp in checks)
-            {
-                if (kvp.Value->GetType()->IsGenericType 
-                        && kvp.Value->GetType()->GetGenericTypeDefinition() == KeyValuePair::typeid)
-                {
-                    ++checks_sz;
-                }
-                ++checks_sz;
-            }
-
-            int64_t ret = _hc->count(context.marshal_as<const char*>(space),
-                    context.marshal_as<struct hyperclient_attribute_check*>(checks),
-                    checks_sz, &st, &result);
-            if(ret < 0)
-            {
-                THROW_EXCEPTION(st);
-            }
-
-            while(1)
-            {
-                hyperclient_returncode rc;
-                int64_t lret = _hc->loop(-1, &rc);
-                if(lret < 0)
-                {
-                    THROW_EXCEPTION(rc);
-                }
-                else if(lret == ret)
-                {
-                    if(rc == HYPERCLIENT_SUCCESS)
-                    {
-                        return result;
-                    }
-                    THROW_EXCEPTION(rc);
-                }
-            }
-        }
-
-
-    bool
-        HyperClient::del(String^ space, String^ key)
-        {
-            marshal_context context;
-            hyperclient_returncode st;
-            int64_t ret = _hc->del(context.marshal_as<const char*>(space),
-                    context.marshal_as<const char*>(key),
-                    key->Length, &st);
-
-            if(ret < 0)
-            {
-                THROW_EXCEPTION(st);
-            }
-            WAIT_FOR_STATUS
-        }
-}
+// This is the main DLL file.
+
+#include <hyperclientclr.h>
+#include <client/hyperclient.h>
+#include <stdlib.h>
+#include <string.h>
+#include <msclr/marshal.h>
+#include <cliext/utility>
+#include <marshal.h>
+#include <e/endian.h>
+
+using namespace msclr::interop;
+using namespace cliext;
+using namespace System;
+using namespace System::Collections::Generic;
+
+#define THROW_EXCEPTION(x) \
+	do{ \
+		HyperClientException^ ex = gcnew HyperClientException(); \
+		ex->return_code = static_cast<HyperClientReturnCode>(x); \
+		throw ex; \
+	} while (0)
+
+namespace
+	HyperDex
+{
+
+Int64 unpack_int64(const char *val)
+{
+	int64_t out;
+	e::unpack64le(val, &out);
+	return out;
+}
+
+Double unpack_float(const char *val)
+{
+	double out;
+	e::unpack64le(val, (int64_t *)&out);
+	return out;
+}
+
+String ^unpack_string(const char *str, size_t sz)
+{
+	char *tmp = (char *)malloc(sz + 1);
+	memcpy(tmp, str, sz);
+	tmp[sz] = '\0';
+	String ^output = marshal_as<String ^>(tmp);
+	free(tmp);
+	return output;
+}
+
+Dictionary<String ^, String ^> ^
+unpack_map_string_string(const char *pos, size_t rem)
+{
+	Dictionary<String ^, String ^> ^dict = gcnew Dictionary<String ^, String ^>();
+	while (rem >= 4)
+	{
+		uint32_t sz;
+		e::unpack32le(pos, &sz);
+		pos += 4;
+		rem -= 4;
+		String ^key = unpack_string(pos, sz);
+		pos += sz;
+		rem -= sz;
+		e::unpack32le(pos, &sz);
+		pos += 4;
+		rem -= 4;
+		String ^val = unpack_string(pos, sz);
+		pos += sz;
+		rem -= sz;
+		dict->Add(key, val);
+	}
+	return dict;
+}
+
+Dictionary<String ^, Int64> ^
+unpack_map_string_int64(const char *pos, size_t rem)
+{
+	Dictionary<String ^, Int64> ^dict = gcnew Dictionary<String ^, Int64>();
+	while (rem >= 4)
+	{
+		uint32_t sz;
+		e::unpack32le(pos, &sz);
+		pos += 4;
+		rem -= 4;
+		String ^key = unpack_string(pos, sz);
+		pos += sz;
+		rem -= sz;
+		Int64 val = unpack_int64(pos);
+		pos += 8;
+		rem -= 8;
+		dict->Add(key, val);
+	}
+	return dict;
+}
+
+Dictionary<String ^, Double> ^
+unpack_map_string_float(const char *pos, size_t rem)
+{
+	Dictionary<String ^, Double> ^dict = gcnew Dictionary<String ^, Double>();
+	while (rem >= 4)
+	{
+		uint32_t sz;
+		e::unpack32le(pos, &sz);
+		pos += 4;
+		rem -= 4;
+		String ^key = unpack_string(pos, sz);
+		pos += sz;
+		rem -= sz;
+		Double val = unpack_float(pos);
+		pos += 8;
+		rem -= 8;
+		dict->Add(key, val);
+	}
+	return dict;
+}
+
+Dictionary<Int64, Double> ^
+unpack_map_int64_float(const char *pos, size_t rem)
+{
+	Dictionary<Int64, Double> ^dict = gcnew Dictionary<Int64, Double>();
+	while (rem >= 8)
+	{
+		Int64 key = unpack_int64(pos);
+		pos += 8;
+		rem -= 8;
+		Double val = unpack_float(pos);
+		pos += 8;
+		rem -= 8;
+		dict->Add(key, val);
+	}
+	return dict;
+}
+
+Dictionary<Int64, Int64> ^
+unpack_map_int64_int64(const char *pos, size_t rem)
+{
+	Dictionary<Int64, Int64> ^dict = gcnew Dictionary<Int64, Int64>();
+	while (rem >= 8)
+	{
+		Int64 key = unpack_int64(pos);
+		pos += 8;
+		rem -= 8;
+		Int64 val = unpack_int64(pos);
+		pos += 8;
+		rem -= 8;
+		dict->Add(key, val);
+	}
+	return dict;
+}
+
+
+Dictionary<Int64, String ^> ^
+unpack_map_int64_string(const char *pos, size_t rem)
+{
+	Dictionary<Int64, String ^> ^dict = gcnew Dictionary<Int64, String ^>();
+	while (rem >= 8)
+	{
+		Int64 key = unpack_int64(pos);
+		pos += 8;
+		rem -= 8;
+		uint32_t sz;
+		e::unpack32le(pos, &sz);
+		pos += 4;
+		rem -= 4;
+		String ^val = unpack_string(pos, sz);
+		pos += sz;
+		rem -= sz;
+		dict->Add(key, val);
+	}
+	return dict;
+}
+
+Dictionary<Double, Double> ^
+unpack_map_float_float(const char *pos, size_t rem)
+{
+	Dictionary<Double, Double> ^dict = gcnew Dictionary<Double, Double>();
+	while (rem >= 8)
+	{
+		Double key = unpack_float(pos);
+		pos += 8;
+		rem -= 8;
+		Double val = unpack_float(pos);
+		pos += 8;
+		rem -= 8;
+		dict->Add(key, val);
+	}
+	return dict;
+}
+
+Dictionary<Double, Int64> ^
+unpack_map_float_int64(const char *pos, size_t rem)
+{
+	Dictionary<Double, Int64> ^dict = gcnew Dictionary<Double, Int64>();
+	while (rem >= 8)
+	{
+		Double key = unpack_float(pos);
+		pos += 8;
+		rem -= 8;
+		Int64 val = unpack_int64(pos);
+		pos += 8;
+		rem -= 8;
+		dict->Add(key, val);
+	}
+	return dict;
+}
+
+
+Dictionary<Double, String ^> ^
+unpack_map_float_string(const char *pos, size_t rem)
+{
+	Dictionary<Double, String ^> ^dict = gcnew Dictionary<Double, String ^>();
+	while (rem >= 8)
+	{
+		Double key = unpack_float(pos);
+		pos += 8;
+		rem -= 8;
+		uint32_t sz;
+		e::unpack32le(pos, &sz);
+		pos += 4;
+		rem -= 4;
+		String ^val = unpack_string(pos, sz);
+		pos += sz;
+		rem -= sz;
+		dict->Add(key, val);
+	}
+	return dict;
+}
+
+
+SortedSet<String ^> ^
+unpack_set_string(const char *pos, size_t rem)
+{
+	SortedSet<String ^> ^lst = gcnew SortedSet<String ^>();
+	while (rem >= 4)
+	{
+		uint32_t sz;
+		e::unpack32le(pos, &sz);
+		pos += 4;
+		rem -= 4;
+		lst->Add(unpack_string(pos, sz));
+		pos += sz;
+		rem -= sz;
+	}
+	return lst;
+}
+
+SortedSet<Double> ^
+unpack_set_float(const char *pos, size_t rem)
+{
+	SortedSet<Double> ^lst = gcnew SortedSet<Double>();
+	while (rem >= 8)
+	{
+		lst->Add(unpack_float(pos));
+		pos += 8;
+		rem -= 8;
+	}
+	return lst;
+}
+
+SortedSet<Int64> ^
+unpack_set_int64(const char *pos, size_t rem)
+{
+	SortedSet<Int64> ^lst = gcnew SortedSet<Int64>();
+	while (rem >= 8)
+	{
+		lst->Add(unpack_int64(pos));
+		pos += 8;
+		rem -= 8;
+	}
+	return lst;
+}
+
+
+List<String ^> ^
+unpack_list_string(const char *pos, size_t rem)
+{
+	List<String ^> ^lst = gcnew List<String ^>();
+	while (rem >= 4)
+	{
+		uint32_t sz;
+		e::unpack32le(pos, &sz);
+		pos += 4;
+		rem -= 4;
+		lst->Add(unpack_string(pos, sz));
+		pos += sz;
+		rem -= sz;
+	}
+	return lst;
+}
+
+List<Double> ^
+unpack_list_float(const char *pos, size_t rem)
+{
+	List<Double> ^lst = gcnew List<Double>();
+	while (rem >= 8)
+	{
+		lst->Add(unpack_float(pos));
+		pos += 8;
+		rem -= 8;
+	}
+	return lst;
+}
+
+List<Int64> ^
+unpack_list_int64(const char *pos, size_t rem)
+{
+	List<Int64> ^lst = gcnew List<Int64>();
+	while (rem >= 8)
+	{
+		lst->Add(unpack_int64(pos));
+		pos += 8;
+		rem -= 8;
+	}
+	return lst;
+}
+
+
+HyperClient::HyperClient(String ^coordinator, uint16_t port)
+{
+	WSADATA wsa;
+	if (WSAStartup(MAKEWORD(2, 2), &wsa))
+		abort();
+	const char *coord;
+	mc = gcnew marshal_context();
+	coord = mc->marshal_as<const char *>( coordinator );
+	_hc = new hyperclient(coord, port);
+}
+
+HyperClient::~HyperClient()
+{
+	this->!HyperClient();
+}
+
+HyperClient::!HyperClient()
+{
+	delete _hc;
+	_hc = nullptr;
+}
+
+Dictionary<String ^, Object ^> ^
+HyperClient::get(String ^space, String ^key)
+{
+	Dictionary<String ^, Object ^> ^output = gcnew Dictionary<String ^, Object ^>;
+	marshal_context context;
+	hyperclient_returncode st;
+	hyperclient_attribute *attrs;
+	size_t attrs_sz;
+	int64_t ret = _hc->get(context.marshal_as<const char *>(space),
+	                       context.marshal_as<const char *>(key),
+	                       key->Length, &st, &attrs, &attrs_sz);
+	if (ret < 0)
+	{
+		THROW_EXCEPTION(st);
+	}
+	while (1)
+	{
+		hyperclient_returncode rc;
+		int64_t lret = _hc->loop(-1, &rc);
+		if (lret == ret)
+		{
+			if (rc == HYPERCLIENT_SUCCESS)
+			{
+				for (int i = 0; i < attrs_sz; ++i)
+				{
+					if (attrs[i].value_sz == 0)
+					{
+						continue;
+					}
+					switch (attrs[i].datatype)
+					{
+					case HYPERDATATYPE_STRING:
+					{
+						output->Add(marshal_as<String ^>(attrs[i].attr),
+						            unpack_string(attrs[i].value, attrs[i].value_sz));
+						break;
+					}
+					case HYPERDATATYPE_INT64:
+						output->Add(marshal_as<String ^>(attrs[i].attr),
+						            unpack_int64(attrs[i].value));
+						break;
+					case HYPERDATATYPE_FLOAT:
+						output->Add(marshal_as<String ^>(attrs[i].attr),
+						            unpack_float(attrs[i].value));
+						break;
+					case HYPERDATATYPE_SET_STRING:
+					{
+						output->Add(marshal_as<String ^>(attrs[i].attr),
+						            unpack_set_string(attrs[i].value, attrs[i].value_sz));
+						break;
+					}
+					case HYPERDATATYPE_LIST_STRING:
+					{
+						output->Add(marshal_as<String ^>(attrs[i].attr),
+						            unpack_list_string(attrs[i].value, attrs[i].value_sz));
+						break;
+					}
+					case HYPERDATATYPE_SET_INT64:
+					{
+						output->Add(marshal_as<String ^>(attrs[i].attr),
+						            unpack_set_int64(attrs[i].value, attrs[i].value_sz));
+						break;
+					}
+					case HYPERDATATYPE_LIST_INT64:
+					{
+						output->Add(marshal_as<String ^>(attrs[i].attr),
+						            unpack_list_int64(attrs[i].value, attrs[i].value_sz));
+						break;
+					}
+					case HYPERDATATYPE_SET_FLOAT:
+					{
+						output->Add(marshal_as<String ^>(attrs[i].attr),
+						            unpack_set_float(attrs[i].value, attrs[i].value_sz));
+						break;
+					}
+					case HYPERDATATYPE_LIST_FLOAT:
+					{
+						output->Add(marshal_as<String ^>(attrs[i].attr),
+						            unpack_list_float(attrs[i].value, attrs[i].value_sz));
+						break;
+					}
+					case HYPERDATATYPE_MAP_STRING_STRING:
+					{
+						output->Add(marshal_as<String ^>(attrs[i].attr),
+						            unpack_map_string_string(attrs[i].value, attrs[i].value_sz));
+						break;
+					}
+					case HYPERDATATYPE_MAP_STRING_INT64:
+					{
+						output->Add(marshal_as<String ^>(attrs[i].attr),
+						            unpack_map_string_int64(attrs[i].value, attrs[i].value_sz));
+						break;
+					}
+					case HYPERDATATYPE_MAP_STRING_FLOAT:
+					{
+						output->Add(marshal_as<String ^>(attrs[i].attr),
+						            unpack_map_string_float(attrs[i].value, attrs[i].value_sz));
+						break;
+					}
+					case HYPERDATATYPE_MAP_INT64_STRING:
+					{
+						output->Add(marshal_as<String ^>(attrs[i].attr),
+						            unpack_map_int64_string(attrs[i].value, attrs[i].value_sz));
+						break;
+					}
+					case HYPERDATATYPE_MAP_INT64_INT64:
+					{
+						output->Add(marshal_as<String ^>(attrs[i].attr),
+						            unpack_map_int64_int64(attrs[i].value, attrs[i].value_sz));
+						break;
+					}
+					case HYPERDATATYPE_MAP_INT64_FLOAT:
+					{
+						output->Add(marshal_as<String ^>(attrs[i].attr),
+						            unpack_map_int64_float(attrs[i].value, attrs[i].value_sz));
+						break;
+					}
+					case HYPERDATATYPE_MAP_FLOAT_STRING:
+					{
+						output->Add(marshal_as<String ^>(attrs[i].attr),
+						            unpack_map_float_string(attrs[i].value, attrs[i].value_sz));
+						break;
+					}
+					case HYPERDATATYPE_MAP_FLOAT_INT64:
+					{
+						output->Add(marshal_as<String ^>(attrs[i].attr),
+						            unpack_map_float_int64(attrs[i].value, attrs[i].value_sz));
+						break;
+					}
+					case HYPERDATATYPE_MAP_FLOAT_FLOAT:
+					{
+						output->Add(marshal_as<String ^>(attrs[i].attr),
+						            unpack_map_float_float(attrs[i].value, attrs[i].value_sz));
+						break;
+					}
+					case HYPERDATATYPE_MAP_STRING_KEYONLY:
+					default:
+						THROW_EXCEPTION(HYPERCLIENT_WRONGTYPE);
+						break;
+					}
+				}
+			}
+			else
+			{
+				THROW_EXCEPTION(rc);
+			}
+			break;
+		}
+	}
+	return output;
+}
+
+#define WAIT_FOR_STATUS \
+	while(1) \
+	{ \
+		hyperclient_returncode rc; \
+		int64_t lret = _hc->loop(-1, &rc); \
+		if(lret == ret) \
+		{ \
+			if(rc == HYPERCLIENT_SUCCESS) \
+			{ \
+				return true; \
+			} \
+			\
+			THROW_EXCEPTION(rc); \
+		} \
+	} \
+	\
+	return false; \
+
+#define HYPERCLIENT_CLRDEF(OPNAME) \
+	bool \
+	HyperClient:: ## OPNAME(String ^space, String ^key, Dictionary<String ^, Object ^> ^ attrs) \
+	{ \
+		size_t size; \
+		for each(KeyValuePair<String ^, Object ^> kvp in attrs) \
+		{ \
+			if (kvp.Value->GetType()->IsGenericType \
+			    && kvp.Value->GetType()->GetGenericTypeDefinition() == List::typeid) \
+			{ \
+				if(kvp.Value->GetType() == String::typeid) \
+					size += 1 + ((List<String ^>^)kvp.Value)->Count; \
+				if(kvp.Value->GetType() == Int64::typeid) \
+					size += 1 + ((List<Int64>^)kvp.Value)->Count; \
+				if(kvp.Value->GetType() == Double::typeid) \
+					size += 1 + ((List<Double>^)kvp.Value)->Count; \
+			} \
+			else if (kvp.Value->GetType()->IsGenericType \
+			         && kvp.Value->GetType()->GetGenericTypeDefinition() == SortedSet::typeid) \
+			{ \
+				if(kvp.Value->GetType() == String::typeid) \
+					size += 1 + ((SortedSet<String ^>^)kvp.Value)->Count; \
+				if(kvp.Value->GetType() == Int64::typeid) \
+					size += 1 + ((SortedSet<Int64>^)kvp.Value)->Count; \
+				if(kvp.Value->GetType() == Double::typeid) \
+					size += 1 + ((SortedSet<Double>^)kvp.Value)->Count; \
+			} \
+			else \
+			{ \
+				size ++; \
+			} \
+		} \
+		marshal_context context; \
+		hyperclient_returncode st; \
+		int64_t ret = _hc->OPNAME(context.marshal_as<const char*>(space), \
+		                          context.marshal_as<const char*>(key), \
+		                          key->Length, \
+		                          context.marshal_as<hyperclient_attribute*>(attrs), \
+		                          size, &st); \
+		if(ret < 0) \
+		{ \
+			THROW_EXCEPTION(st); \
+		} \
+		WAIT_FOR_STATUS \
+	}
+
+	HYPERCLIENT_CLRDEF(put)
+	HYPERCLIENT_CLRDEF(put_if_not_exist)
+	HYPERCLIENT_CLRDEF(atomic_add)
+	HYPERCLIENT_CLRDEF(atomic_sub)
+	HYPERCLIENT_CLRDEF(atomic_mul)
+	HYPERCLIENT_CLRDEF(atomic_div)
+	HYPERCLIENT_CLRDEF(atomic_mod)
+	HYPERCLIENT_CLRDEF(atomic_and)
+	HYPERCLIENT_CLRDEF(atomic_or)
+	HYPERCLIENT_CLRDEF(atomic_xor)
+	HYPERCLIENT_CLRDEF(string_prepend)
+	HYPERCLIENT_CLRDEF(string_append)
+	HYPERCLIENT_CLRDEF(list_lpush)
+	HYPERCLIENT_CLRDEF(list_rpush)
+	HYPERCLIENT_CLRDEF(set_add)
+	HYPERCLIENT_CLRDEF(set_remove)
+	HYPERCLIENT_CLRDEF(set_intersect)
+	HYPERCLIENT_CLRDEF(set_union)
+
+#define HYPERCLIENT_MAP_CLRDEF(OPNAME) \
+	bool \
+	HyperClient:: map_ ## OPNAME(String ^space, String ^key, Dictionary<String ^, Dictionary<Object^, Object ^>^ > ^ attrs) \
+	{ \
+		marshal_context context; \
+		hyperclient_returncode st; \
+		size_t size = 0; \
+		for each(KeyValuePair<String ^, Dictionary<Object ^, Object ^>^ > attrkvp in attrs) \
+		{ \
+			size += attrkvp.Value->Count; \
+		} \
+		int64_t ret = _hc->map_ ## OPNAME(context.marshal_as<const char*>(space), \
+		                                  context.marshal_as<const char*>(key), \
+		                                  key->Length, \
+		                                  context.marshal_as<hyperclient_map_attribute*>(attrs), \
+		                                  size, &st); \
+		if(ret < 0) \
+		{ \
+			THROW_EXCEPTION(st); \
+		} \
+		WAIT_FOR_STATUS \
+	}
+
+	HYPERCLIENT_MAP_CLRDEF(add)
+	HYPERCLIENT_MAP_CLRDEF(remove)
+	HYPERCLIENT_MAP_CLRDEF(atomic_add)
+	HYPERCLIENT_MAP_CLRDEF(atomic_sub)
+	HYPERCLIENT_MAP_CLRDEF(atomic_mul)
+	HYPERCLIENT_MAP_CLRDEF(atomic_div)
+	HYPERCLIENT_MAP_CLRDEF(atomic_mod)
+	HYPERCLIENT_MAP_CLRDEF(atomic_and)
+	HYPERCLIENT_MAP_CLRDEF(atomic_or)
+	HYPERCLIENT_MAP_CLRDEF(atomic_xor)
+	HYPERCLIENT_MAP_CLRDEF(string_prepend)
+	HYPERCLIENT_MAP_CLRDEF(string_append)
+
+	List<Dictionary<String ^, Object ^>^ > ^
+	HyperClient::search(String ^space, Dictionary<String ^, Object ^> ^checks)
+	{
+		List<Dictionary<String ^, Object ^>^ > ^toValue = gcnew List<Dictionary<String ^, Object ^>^ >();
+		marshal_context context;
+		hyperclient_returncode st;
+		struct hyperclient_attribute *attrs;
+		size_t attrs_sz;
+		size_t checks_sz;
+		for each(KeyValuePair<String ^, Object ^> kvp in checks)
+		{
+			if (kvp.Value->GetType()->IsGenericType
+			    && kvp.Value->GetType()->GetGenericTypeDefinition() == KeyValuePair::typeid)
+			{
+				++checks_sz;
+			}
+			++checks_sz;
+		}
+		int64_t ret = _hc->search(context.marshal_as<const char *>(space),
+		                          context.marshal_as<struct hyperclient_attribute_check *>(checks),
+		                          checks_sz, &st, &attrs, &attrs_sz);
+		if (ret < 0)
+		{
+			THROW_EXCEPTION(st);
+		}
+		while (1)
+		{
+			hyperclient_returncode rc;
+			int64_t lret = _hc->loop(-1, &rc);
+			if (lret < 0)
+			{
+				THROW_EXCEPTION(rc);
+			}
+			else if (lret == ret)
+			{
+				Dictionary<String ^, Object ^> ^output = gcnew Dictionary<String ^, Object ^>();
+				for (int i = 0; i < attrs_sz; ++i)
+				{
+					switch (attrs[i].datatype)
+					{
+					case HYPERDATATYPE_STRING:
+					{
+						output->Add(marshal_as<String ^>(attrs[i].attr),
+						            unpack_string(attrs[i].value, attrs[i].value_sz));
+						break;
+					}
+					case HYPERDATATYPE_INT64:
+						output->Add(marshal_as<String ^>(attrs[i].attr),
+						            unpack_int64(attrs[i].value));
+						break;
+					case HYPERDATATYPE_FLOAT:
+						output->Add(marshal_as<String ^>(attrs[i].attr),
+						            unpack_float(attrs[i].value));
+						break;
+					case HYPERDATATYPE_SET_STRING:
+					{
+						output->Add(marshal_as<String ^>(attrs[i].attr),
+						            unpack_set_string(attrs[i].value, attrs[i].value_sz));
+						break;
+					}
+					case HYPERDATATYPE_LIST_STRING:
+					{
+						output->Add(marshal_as<String ^>(attrs[i].attr),
+						            unpack_list_string(attrs[i].value, attrs[i].value_sz));
+						break;
+					}
+					case HYPERDATATYPE_SET_INT64:
+					{
+						output->Add(marshal_as<String ^>(attrs[i].attr),
+						            unpack_set_int64(attrs[i].value, attrs[i].value_sz));
+						break;
+					}
+					case HYPERDATATYPE_LIST_INT64:
+					{
+						output->Add(marshal_as<String ^>(attrs[i].attr),
+						            unpack_list_int64(attrs[i].value, attrs[i].value_sz));
+						break;
+					}
+					case HYPERDATATYPE_SET_FLOAT:
+					{
+						output->Add(marshal_as<String ^>(attrs[i].attr),
+						            unpack_set_float(attrs[i].value, attrs[i].value_sz));
+						break;
+					}
+					case HYPERDATATYPE_LIST_FLOAT:
+					{
+						output->Add(marshal_as<String ^>(attrs[i].attr),
+						            unpack_list_float(attrs[i].value, attrs[i].value_sz));
+						break;
+					}
+					case HYPERDATATYPE_MAP_STRING_STRING:
+					{
+						output->Add(marshal_as<String ^>(attrs[i].attr),
+						            unpack_map_string_string(attrs[i].value, attrs[i].value_sz));
+						break;
+					}
+					case HYPERDATATYPE_MAP_STRING_INT64:
+					{
+						output->Add(marshal_as<String ^>(attrs[i].attr),
+						            unpack_map_string_int64(attrs[i].value, attrs[i].value_sz));
+						break;
+					}
+					case HYPERDATATYPE_MAP_STRING_FLOAT:
+					{
+						output->Add(marshal_as<String ^>(attrs[i].attr),
+						            unpack_map_string_float(attrs[i].value, attrs[i].value_sz));
+						break;
+					}
+					case HYPERDATATYPE_MAP_INT64_STRING:
+					{
+						output->Add(marshal_as<String ^>(attrs[i].attr),
+						            unpack_map_int64_string(attrs[i].value, attrs[i].value_sz));
+						break;
+					}
+					case HYPERDATATYPE_MAP_INT64_INT64:
+					{
+						output->Add(marshal_as<String ^>(attrs[i].attr),
+						            unpack_map_int64_int64(attrs[i].value, attrs[i].value_sz));
+						break;
+					}
+					case HYPERDATATYPE_MAP_INT64_FLOAT:
+					{
+						output->Add(marshal_as<String ^>(attrs[i].attr),
+						            unpack_map_int64_float(attrs[i].value, attrs[i].value_sz));
+						break;
+					}
+					case HYPERDATATYPE_MAP_FLOAT_STRING:
+					{
+						output->Add(marshal_as<String ^>(attrs[i].attr),
+						            unpack_map_float_string(attrs[i].value, attrs[i].value_sz));
+						break;
+					}
+					case HYPERDATATYPE_MAP_FLOAT_INT64:
+					{
+						output->Add(marshal_as<String ^>(attrs[i].attr),
+						            unpack_map_float_int64(attrs[i].value, attrs[i].value_sz));
+						break;
+					}
+					case HYPERDATATYPE_MAP_FLOAT_FLOAT:
+					{
+						output->Add(marshal_as<String ^>(attrs[i].attr),
+						            unpack_map_float_float(attrs[i].value, attrs[i].value_sz));
+						break;
+					}
+					case HYPERDATATYPE_MAP_STRING_KEYONLY:
+					default:
+						THROW_EXCEPTION(HYPERCLIENT_WRONGTYPE);
+						break;
+					}
+				}
+				toValue->Add(output);
+				if (rc == HYPERCLIENT_SEARCHDONE)
+				{
+					break;
+				}
+			}
+		}
+		return toValue;
+	}
+
+	List<Dictionary<String ^, Object ^>^ > ^
+	HyperClient::sorted_search(String ^space, String ^sortby,
+	                           UInt64 limit, bool maximize, Dictionary<String ^, Object ^> ^checks)
+	{
+		List<Dictionary<String ^, Object ^>^ > ^toValue = gcnew List<Dictionary<String ^, Object ^>^ >();
+		marshal_context context;
+		hyperclient_returncode st;
+		struct hyperclient_attribute *attrs;
+		size_t attrs_sz;
+		size_t checks_sz;
+		for each(KeyValuePair<String ^, Object ^> kvp in checks)
+		{
+			if (kvp.Value->GetType()->IsGenericType
+			    && kvp.Value->GetType()->GetGenericTypeDefinition() == KeyValuePair::typeid)
+			{
+				++checks_sz;
+			}
+			++checks_sz;
+		}
+		int64_t ret = _hc->sorted_search(context.marshal_as<const char *>(space),
+		                                 context.marshal_as<struct hyperclient_attribute_check *>(checks),
+		                                 checks_sz, context.marshal_as<const char *>(sortby), limit, maximize,
+		                                 &st, &attrs, &attrs_sz);
+		if (ret < 0)
+		{
+			THROW_EXCEPTION(st);
+		}
+		while (1)
+		{
+			hyperclient_returncode rc;
+			int64_t lret = _hc->loop(-1, &rc);
+			if (lret < 0)
+			{
+				THROW_EXCEPTION(rc);
+			}
+			else if (lret == ret)
+			{
+				Dictionary<String ^, Object ^> ^output = gcnew Dictionary<String ^, Object ^>();
+				for (int i = 0; i < attrs_sz; ++i)
+				{
+					switch (attrs[i].datatype)
+					{
+					case HYPERDATATYPE_STRING:
+						output->Add(marshal_as<String ^>(attrs[i].attr),
+						            marshal_as<String ^>(attrs[i].value));
+						break;
+					case HYPERDATATYPE_INT64:
+						output->Add(marshal_as<String ^>(attrs[i].attr),
+						            *(int64_t *)attrs[i].value);
+						break;
+					case HYPERDATATYPE_FLOAT:
+						output->Add(marshal_as<String ^>(attrs[i].attr),
+						            *(double *)attrs[i].value);
+						break;
+					default:
+						break;
+					}
+				}
+				toValue->Add(output);
+				if (rc == HYPERCLIENT_SEARCHDONE)
+				{
+					break;
+				}
+			}
+		}
+		return toValue;
+	}
+
+
+	UInt64
+	HyperClient::count(String ^space, Dictionary<String ^, Object ^> ^checks)
+	{
+		marshal_context context;
+		hyperclient_returncode st;
+		size_t checks_sz;
+		uint64_t result;
+		for each(KeyValuePair<String ^, Object ^> kvp in checks)
+		{
+			if (kvp.Value->GetType()->IsGenericType
+			    && kvp.Value->GetType()->GetGenericTypeDefinition() == KeyValuePair::typeid)
+			{
+				++checks_sz;
+			}
+			++checks_sz;
+		}
+		int64_t ret = _hc->count(context.marshal_as<const char *>(space),
+		                         context.marshal_as<struct hyperclient_attribute_check *>(checks),
+		                         checks_sz, &st, &result);
+		if (ret < 0)
+		{
+			THROW_EXCEPTION(st);
+		}
+		while (1)
+		{
+			hyperclient_returncode rc;
+			int64_t lret = _hc->loop(-1, &rc);
+			if (lret < 0)
+			{
+				THROW_EXCEPTION(rc);
+			}
+			else if (lret == ret)
+			{
+				if (rc == HYPERCLIENT_SUCCESS)
+				{
+					return result;
+				}
+				THROW_EXCEPTION(rc);
+			}
+		}
+	}
+
+
+	bool
+	HyperClient::del(String ^space, String ^key)
+	{
+		marshal_context context;
+		hyperclient_returncode st;
+		int64_t ret = _hc->del(context.marshal_as<const char *>(space),
+		                       context.marshal_as<const char *>(key),
+		                       key->Length, &st);
+		if (ret < 0)
+		{
+			THROW_EXCEPTION(st);
+		}
+		WAIT_FOR_STATUS
+	}
+	}
diff --git a/windows/hyperclientclr.h b/windows/hyperclientclr.h
index a59af0a61..4f4559971 100644
--- a/windows/hyperclientclr.h
+++ b/windows/hyperclientclr.h
@@ -12,123 +12,123 @@ using namespace System;
 using namespace System::Collections::Generic;
 
 #define THROW_EXCEPTION(x) \
-    do{ \
-        HyperClientException^ ex = gcnew HyperClientException(); \
-        ex->return_code = static_cast<HyperClientReturnCode>(x); \
-        throw ex; \
-    } while (0)
+	do{ \
+		HyperClientException^ ex = gcnew HyperClientException(); \
+		ex->return_code = static_cast<HyperClientReturnCode>(x); \
+		throw ex; \
+	} while (0)
 
 namespace
-HyperDex
+	HyperDex
 {
-    public enum class HyperClientReturnCode
-    {
-        HYPERDEX_CLIENT_SUCCESS      = 8448,
-                                 HYPERDEX_CLIENT_NOTFOUND     = 8449,
-                                 HYPERDEX_CLIENT_SEARCHDONE   = 8450,
-                                 HYPERDEX_CLIENT_CMPFAIL      = 8451,
-                                 HYPERDEX_CLIENT_READONLY     = 8452,
-
-                                 /* Error conditions */
-                                 HYPERDEX_CLIENT_UNKNOWNSPACE = 8512,
-                                 HYPERDEX_CLIENT_COORDFAIL    = 8513,
-                                 HYPERDEX_CLIENT_SERVERERROR  = 8514,
-                                 HYPERDEX_CLIENT_POLLFAILED   = 8515,
-                                 HYPERDEX_CLIENT_OVERFLOW     = 8516,
-                                 HYPERDEX_CLIENT_RECONFIGURE  = 8517,
-                                 HYPERDEX_CLIENT_TIMEOUT      = 8519,
-                                 HYPERDEX_CLIENT_UNKNOWNATTR  = 8520,
-                                 HYPERDEX_CLIENT_DUPEATTR     = 8521,
-                                 HYPERDEX_CLIENT_NONEPENDING  = 8523,
-                                 HYPERDEX_CLIENT_DONTUSEKEY   = 8524,
-                                 HYPERDEX_CLIENT_WRONGTYPE    = 8525,
-                                 HYPERDEX_CLIENT_NOMEM        = 8526,
-                                 HYPERDEX_CLIENT_BADCONFIG    = 8527,
-                                 HYPERDEX_CLIENT_BADSPACE     = 8528,
-                                 HYPERDEX_CLIENT_DUPLICATE    = 8529,
-                                 HYPERDEX_CLIENT_INTERRUPTED  = 8530,
-                                 HYPERDEX_CLIENT_CLUSTER_JUMP = 8531,
-                                 HYPERDEX_CLIENT_COORD_LOGGED = 8532,
-
-                                 /* This should never happen.  It indicates a bug */
-                                 HYPERDEX_CLIENT_INTERNAL     = 8573,
-                                 HYPERDEX_CLIENT_EXCEPTION    = 8574,
-                                 HYPERDEX_CLIENT_GARBAGE      = 8575
-    };
-
-    public ref struct HyperClientException : public System::Exception
-    {
-        public:
-            HyperClientReturnCode^ return_code;
-    };
-
-    public ref class HyperClient
-    {
-
-        hyperclient* _hc;
-        marshal_context^ mc;
-
-        public:
-        HyperClient(String^ coordinator, uint16_t port);
-        ~HyperClient();
-
-        protected:
-        !HyperClient();
-
-        public:
-        Dictionary<String ^, Object ^> ^get(String ^space, String ^key);
+public enum class HyperClientReturnCode
+{
+	HYPERDEX_CLIENT_SUCCESS      = 8448,
+	HYPERDEX_CLIENT_NOTFOUND     = 8449,
+	HYPERDEX_CLIENT_SEARCHDONE   = 8450,
+	HYPERDEX_CLIENT_CMPFAIL      = 8451,
+	HYPERDEX_CLIENT_READONLY     = 8452,
+
+	/* Error conditions */
+	HYPERDEX_CLIENT_UNKNOWNSPACE = 8512,
+	HYPERDEX_CLIENT_COORDFAIL    = 8513,
+	HYPERDEX_CLIENT_SERVERERROR  = 8514,
+	HYPERDEX_CLIENT_POLLFAILED   = 8515,
+	HYPERDEX_CLIENT_OVERFLOW     = 8516,
+	HYPERDEX_CLIENT_RECONFIGURE  = 8517,
+	HYPERDEX_CLIENT_TIMEOUT      = 8519,
+	HYPERDEX_CLIENT_UNKNOWNATTR  = 8520,
+	HYPERDEX_CLIENT_DUPEATTR     = 8521,
+	HYPERDEX_CLIENT_NONEPENDING  = 8523,
+	HYPERDEX_CLIENT_DONTUSEKEY   = 8524,
+	HYPERDEX_CLIENT_WRONGTYPE    = 8525,
+	HYPERDEX_CLIENT_NOMEM        = 8526,
+	HYPERDEX_CLIENT_BADCONFIG    = 8527,
+	HYPERDEX_CLIENT_BADSPACE     = 8528,
+	HYPERDEX_CLIENT_DUPLICATE    = 8529,
+	HYPERDEX_CLIENT_INTERRUPTED  = 8530,
+	HYPERDEX_CLIENT_CLUSTER_JUMP = 8531,
+	HYPERDEX_CLIENT_COORD_LOGGED = 8532,
+
+	/* This should never happen.  It indicates a bug */
+	HYPERDEX_CLIENT_INTERNAL     = 8573,
+	HYPERDEX_CLIENT_EXCEPTION    = 8574,
+	HYPERDEX_CLIENT_GARBAGE      = 8575
+};
+
+public ref struct HyperClientException : public System::Exception
+{
+public:
+	HyperClientReturnCode ^return_code;
+};
+
+public ref class HyperClient
+{
+
+	hyperclient *_hc;
+	marshal_context ^mc;
+
+public:
+	HyperClient(String ^coordinator, uint16_t port);
+	~HyperClient();
+
+protected:
+	!HyperClient();
+
+public:
+	Dictionary<String ^, Object ^> ^get(String ^space, String ^key);
 
 #define HYPERDEX_CLIENT_CLRDEC(OPNAME) \
-        bool OPNAME(String ^space, String ^key, Dictionary<String ^, Object ^> ^ attrs);
-
-        HYPERDEX_CLIENT_CLRDEC(put)
-            HYPERDEX_CLIENT_CLRDEC(put_if_not_exist)
-            HYPERDEX_CLIENT_CLRDEC(atomic_add)
-            HYPERDEX_CLIENT_CLRDEC(atomic_sub)
-            HYPERDEX_CLIENT_CLRDEC(atomic_mul)
-            HYPERDEX_CLIENT_CLRDEC(atomic_div)
-            HYPERDEX_CLIENT_CLRDEC(atomic_mod)
-            HYPERDEX_CLIENT_CLRDEC(atomic_and)
-            HYPERDEX_CLIENT_CLRDEC(atomic_or)
-            HYPERDEX_CLIENT_CLRDEC(atomic_xor)
-            HYPERDEX_CLIENT_CLRDEC(string_prepend)
-            HYPERDEX_CLIENT_CLRDEC(string_append)
-            HYPERDEX_CLIENT_CLRDEC(list_lpush)
-            HYPERDEX_CLIENT_CLRDEC(list_rpush)
-            HYPERDEX_CLIENT_CLRDEC(set_add)
-            HYPERDEX_CLIENT_CLRDEC(set_remove)
-            HYPERDEX_CLIENT_CLRDEC(set_intersect)
-            HYPERDEX_CLIENT_CLRDEC(set_union)
+	bool OPNAME(String ^space, String ^key, Dictionary<String ^, Object ^> ^ attrs);
+
+	HYPERDEX_CLIENT_CLRDEC(put)
+	HYPERDEX_CLIENT_CLRDEC(put_if_not_exist)
+	HYPERDEX_CLIENT_CLRDEC(atomic_add)
+	HYPERDEX_CLIENT_CLRDEC(atomic_sub)
+	HYPERDEX_CLIENT_CLRDEC(atomic_mul)
+	HYPERDEX_CLIENT_CLRDEC(atomic_div)
+	HYPERDEX_CLIENT_CLRDEC(atomic_mod)
+	HYPERDEX_CLIENT_CLRDEC(atomic_and)
+	HYPERDEX_CLIENT_CLRDEC(atomic_or)
+	HYPERDEX_CLIENT_CLRDEC(atomic_xor)
+	HYPERDEX_CLIENT_CLRDEC(string_prepend)
+	HYPERDEX_CLIENT_CLRDEC(string_append)
+	HYPERDEX_CLIENT_CLRDEC(list_lpush)
+	HYPERDEX_CLIENT_CLRDEC(list_rpush)
+	HYPERDEX_CLIENT_CLRDEC(set_add)
+	HYPERDEX_CLIENT_CLRDEC(set_remove)
+	HYPERDEX_CLIENT_CLRDEC(set_intersect)
+	HYPERDEX_CLIENT_CLRDEC(set_union)
 
 #define HYPERDEX_CLIENT_MAP_CLRDEC(OPNAME) \
-            bool map_ ## OPNAME(String ^space, String ^key, Dictionary<String ^, Dictionary<Object^, Object ^>^ > ^ attrs);
+	bool map_ ## OPNAME(String ^space, String ^key, Dictionary<String ^, Dictionary<Object^, Object ^>^ > ^ attrs);
 
-            HYPERDEX_CLIENT_MAP_CLRDEC(add)
-            HYPERDEX_CLIENT_MAP_CLRDEC(remove)
-            HYPERDEX_CLIENT_MAP_CLRDEC(atomic_add)
-            HYPERDEX_CLIENT_MAP_CLRDEC(atomic_sub)
-            HYPERDEX_CLIENT_MAP_CLRDEC(atomic_mul)
-            HYPERDEX_CLIENT_MAP_CLRDEC(atomic_div)
-            HYPERDEX_CLIENT_MAP_CLRDEC(atomic_mod)
-            HYPERDEX_CLIENT_MAP_CLRDEC(atomic_and)
-            HYPERDEX_CLIENT_MAP_CLRDEC(atomic_or)
-            HYPERDEX_CLIENT_MAP_CLRDEC(atomic_xor)
-            HYPERDEX_CLIENT_MAP_CLRDEC(string_prepend)
-            HYPERDEX_CLIENT_MAP_CLRDEC(string_append)
+	HYPERDEX_CLIENT_MAP_CLRDEC(add)
+	HYPERDEX_CLIENT_MAP_CLRDEC(remove)
+	HYPERDEX_CLIENT_MAP_CLRDEC(atomic_add)
+	HYPERDEX_CLIENT_MAP_CLRDEC(atomic_sub)
+	HYPERDEX_CLIENT_MAP_CLRDEC(atomic_mul)
+	HYPERDEX_CLIENT_MAP_CLRDEC(atomic_div)
+	HYPERDEX_CLIENT_MAP_CLRDEC(atomic_mod)
+	HYPERDEX_CLIENT_MAP_CLRDEC(atomic_and)
+	HYPERDEX_CLIENT_MAP_CLRDEC(atomic_or)
+	HYPERDEX_CLIENT_MAP_CLRDEC(atomic_xor)
+	HYPERDEX_CLIENT_MAP_CLRDEC(string_prepend)
+	HYPERDEX_CLIENT_MAP_CLRDEC(string_append)
 
-            List<Dictionary<String ^, Object^>^ >^
-            search(String^ space, Dictionary<String ^, Object^>^ checks);
+	List<Dictionary<String ^, Object ^>^ > ^
+	search(String ^space, Dictionary<String ^, Object ^> ^checks);
 
-        List<Dictionary<String ^, Object^>^ >^
-            sorted_search(String^ space, String ^sortby,
-                    UInt64 limit, bool maximize, Dictionary<String ^, Object^>^ checks);
+	List<Dictionary<String ^, Object ^>^ > ^
+	sorted_search(String ^space, String ^sortby,
+	              UInt64 limit, bool maximize, Dictionary<String ^, Object ^> ^checks);
 
 
-        UInt64
-            count(String^ space, Dictionary<String ^, Object^>^ checks);
+	UInt64
+	count(String ^space, Dictionary<String ^, Object ^> ^checks);
 
 
-        bool
-            del(String^ space, String^ key);
-    };
+	bool
+	del(String ^space, String ^key);
+};
 }
diff --git a/windows/ieee754.h b/windows/ieee754.h
index 20ba54d88..1d1e9b89b 100644
--- a/windows/ieee754.h
+++ b/windows/ieee754.h
@@ -8,171 +8,171 @@
 #include <float.h>
 
 union ieee754_float
-  {
-    float f;
+{
+	float f;
 
-    /* This is the IEEE 754 single-precision format.  */
-    struct
-      {
+	/* This is the IEEE 754 single-precision format.  */
+	struct
+	{
 #if	__BYTE_ORDER == __BIG_ENDIAN
-	unsigned int negative:1;
-	unsigned int exponent:8;
-	unsigned int mantissa:23;
+		unsigned int negative: 1;
+		unsigned int exponent: 8;
+		unsigned int mantissa: 23;
 #endif				/* Big endian.  */
 #if	__BYTE_ORDER == __LITTLE_ENDIAN
-	unsigned int mantissa:23;
-	unsigned int exponent:8;
-	unsigned int negative:1;
+		unsigned int mantissa: 23;
+		unsigned int exponent: 8;
+		unsigned int negative: 1;
 #endif				/* Little endian.  */
-      } ieee;
+	} ieee;
 
-    /* This format makes it easier to see if a NaN is a signalling NaN.  */
-    struct
-      {
+	/* This format makes it easier to see if a NaN is a signalling NaN.  */
+	struct
+	{
 #if	__BYTE_ORDER == __BIG_ENDIAN
-	unsigned int negative:1;
-	unsigned int exponent:8;
-	unsigned int quiet_nan:1;
-	unsigned int mantissa:22;
+		unsigned int negative: 1;
+		unsigned int exponent: 8;
+		unsigned int quiet_nan: 1;
+		unsigned int mantissa: 22;
 #endif				/* Big endian.  */
 #if	__BYTE_ORDER == __LITTLE_ENDIAN
-	unsigned int mantissa:22;
-	unsigned int quiet_nan:1;
-	unsigned int exponent:8;
-	unsigned int negative:1;
+		unsigned int mantissa: 22;
+		unsigned int quiet_nan: 1;
+		unsigned int exponent: 8;
+		unsigned int negative: 1;
 #endif				/* Little endian.  */
-      } ieee_nan;
-  };
+	} ieee_nan;
+};
 
 #define IEEE754_FLOAT_BIAS	0x7f /* Added to exponent.  */
 
 
 union ieee754_double
-  {
-    double d;
+{
+	double d;
 
-    /* This is the IEEE 754 double-precision format.  */
-    struct
-      {
+	/* This is the IEEE 754 double-precision format.  */
+	struct
+	{
 #if	__BYTE_ORDER == __BIG_ENDIAN
-	unsigned int negative:1;
-	unsigned int exponent:11;
-	/* Together these comprise the mantissa.  */
-	unsigned int mantissa0:20;
-	unsigned int mantissa1:32;
+		unsigned int negative: 1;
+		unsigned int exponent: 11;
+		/* Together these comprise the mantissa.  */
+		unsigned int mantissa0: 20;
+		unsigned int mantissa1: 32;
 #endif				/* Big endian.  */
 #if	__BYTE_ORDER == __LITTLE_ENDIAN
 # if	__FLOAT_WORD_ORDER == BIG_ENDIAN
-	unsigned int mantissa0:20;
-	unsigned int exponent:11;
-	unsigned int negative:1;
-	unsigned int mantissa1:32;
+		unsigned int mantissa0: 20;
+		unsigned int exponent: 11;
+		unsigned int negative: 1;
+		unsigned int mantissa1: 32;
 # else
-	/* Together these comprise the mantissa.  */
-	unsigned int mantissa1:32;
-	unsigned int mantissa0:20;
-	unsigned int exponent:11;
-	unsigned int negative:1;
+		/* Together these comprise the mantissa.  */
+		unsigned int mantissa1: 32;
+		unsigned int mantissa0: 20;
+		unsigned int exponent: 11;
+		unsigned int negative: 1;
 # endif
 #endif				/* Little endian.  */
-      } ieee;
+	} ieee;
 
-    /* This format makes it easier to see if a NaN is a signalling NaN.  */
-    struct
-      {
+	/* This format makes it easier to see if a NaN is a signalling NaN.  */
+	struct
+	{
 #if	__BYTE_ORDER == __BIG_ENDIAN
-	unsigned int negative:1;
-	unsigned int exponent:11;
-	unsigned int quiet_nan:1;
-	/* Together these comprise the mantissa.  */
-	unsigned int mantissa0:19;
-	unsigned int mantissa1:32;
+		unsigned int negative: 1;
+		unsigned int exponent: 11;
+		unsigned int quiet_nan: 1;
+		/* Together these comprise the mantissa.  */
+		unsigned int mantissa0: 19;
+		unsigned int mantissa1: 32;
 #else
 # if	__FLOAT_WORD_ORDER == BIG_ENDIAN
-	unsigned int mantissa0:19;
-	unsigned int quiet_nan:1;
-	unsigned int exponent:11;
-	unsigned int negative:1;
-	unsigned int mantissa1:32;
+		unsigned int mantissa0: 19;
+		unsigned int quiet_nan: 1;
+		unsigned int exponent: 11;
+		unsigned int negative: 1;
+		unsigned int mantissa1: 32;
 # else
-	/* Together these comprise the mantissa.  */
-	unsigned int mantissa1:32;
-	unsigned int mantissa0:19;
-	unsigned int quiet_nan:1;
-	unsigned int exponent:11;
-	unsigned int negative:1;
+		/* Together these comprise the mantissa.  */
+		unsigned int mantissa1: 32;
+		unsigned int mantissa0: 19;
+		unsigned int quiet_nan: 1;
+		unsigned int exponent: 11;
+		unsigned int negative: 1;
 # endif
 #endif
-      } ieee_nan;
-  };
+	} ieee_nan;
+};
 
 #define IEEE754_DOUBLE_BIAS	0x3ff /* Added to exponent.  */
 
 
 union ieee854_long_double
-  {
-    long double d;
+{
+	long double d;
 
-    /* This is the IEEE 854 double-extended-precision format.  */
-    struct
-      {
+	/* This is the IEEE 854 double-extended-precision format.  */
+	struct
+	{
 #if	__BYTE_ORDER == __BIG_ENDIAN
-	unsigned int negative:1;
-	unsigned int exponent:15;
-	unsigned int empty:16;
-	unsigned int mantissa0:32;
-	unsigned int mantissa1:32;
+		unsigned int negative: 1;
+		unsigned int exponent: 15;
+		unsigned int empty: 16;
+		unsigned int mantissa0: 32;
+		unsigned int mantissa1: 32;
 #endif
 #if	__BYTE_ORDER == __LITTLE_ENDIAN
 # if	__FLOAT_WORD_ORDER == BIG_ENDIAN
-	unsigned int exponent:15;
-	unsigned int negative:1;
-	unsigned int empty:16;
-	unsigned int mantissa0:32;
-	unsigned int mantissa1:32;
+		unsigned int exponent: 15;
+		unsigned int negative: 1;
+		unsigned int empty: 16;
+		unsigned int mantissa0: 32;
+		unsigned int mantissa1: 32;
 # else
-	unsigned int mantissa1:32;
-	unsigned int mantissa0:32;
-	unsigned int exponent:15;
-	unsigned int negative:1;
-	unsigned int empty:16;
+		unsigned int mantissa1: 32;
+		unsigned int mantissa0: 32;
+		unsigned int exponent: 15;
+		unsigned int negative: 1;
+		unsigned int empty: 16;
 # endif
 #endif
-      } ieee;
+	} ieee;
 
-    /* This is for NaNs in the IEEE 854 double-extended-precision format.  */
-    struct
-      {
+	/* This is for NaNs in the IEEE 854 double-extended-precision format.  */
+	struct
+	{
 #if	__BYTE_ORDER == __BIG_ENDIAN
-	unsigned int negative:1;
-	unsigned int exponent:15;
-	unsigned int empty:16;
-	unsigned int one:1;
-	unsigned int quiet_nan:1;
-	unsigned int mantissa0:30;
-	unsigned int mantissa1:32;
+		unsigned int negative: 1;
+		unsigned int exponent: 15;
+		unsigned int empty: 16;
+		unsigned int one: 1;
+		unsigned int quiet_nan: 1;
+		unsigned int mantissa0: 30;
+		unsigned int mantissa1: 32;
 #endif
 #if	__BYTE_ORDER == __LITTLE_ENDIAN
 # if	__FLOAT_WORD_ORDER == BIG_ENDIAN
-	unsigned int exponent:15;
-	unsigned int negative:1;
-	unsigned int empty:16;
-	unsigned int mantissa0:30;
-	unsigned int quiet_nan:1;
-	unsigned int one:1;
-	unsigned int mantissa1:32;
+		unsigned int exponent: 15;
+		unsigned int negative: 1;
+		unsigned int empty: 16;
+		unsigned int mantissa0: 30;
+		unsigned int quiet_nan: 1;
+		unsigned int one: 1;
+		unsigned int mantissa1: 32;
 # else
-	unsigned int mantissa1:32;
-	unsigned int mantissa0:30;
-	unsigned int quiet_nan:1;
-	unsigned int one:1;
-	unsigned int exponent:15;
-	unsigned int negative:1;
-	unsigned int empty:16;
+		unsigned int mantissa1: 32;
+		unsigned int mantissa0: 30;
+		unsigned int quiet_nan: 1;
+		unsigned int one: 1;
+		unsigned int exponent: 15;
+		unsigned int negative: 1;
+		unsigned int empty: 16;
 # endif
 #endif
-      } ieee_nan;
-  };
+	} ieee_nan;
+};
 
 #define IEEE854_LONG_DOUBLE_BIAS 0x3fff
 
diff --git a/windows/marshal.cpp b/windows/marshal.cpp
index 234f6e25c..5895d2341 100644
--- a/windows/marshal.cpp
+++ b/windows/marshal.cpp
@@ -15,443 +15,405 @@ using namespace cliext;
 using namespace System::Collections::Generic;
 
 #define THROW_EXCEPTION(x) \
-    do{ \
-        HyperClientException^ ex = gcnew HyperClientException(); \
-        ex->return_code = static_cast<HyperClientReturnCode>(x); \
-        throw ex; \
-    } while (0)
+	do{ \
+		HyperClientException^ ex = gcnew HyperClientException(); \
+		ex->return_code = static_cast<HyperClientReturnCode>(x); \
+		throw ex; \
+	} while (0)
 
 
-msclr::interop::context_node<const char*, Double ^>::context_node(const char*& toObject, Double ^fromObject)
+msclr::interop::context_node<const char *, Double ^>::context_node(const char *&toObject, Double ^fromObject)
 {
-    toPtr = NULL;
-    toPtr = (const char*)(new double(*fromObject));
-    toObject = toPtr;
+	toPtr = NULL;
+	toPtr = (const char *)(new double(*fromObject));
+	toObject = toPtr;
 }
 
-msclr::interop::context_node<const char*, Double ^>::~context_node()
+msclr::interop::context_node<const char *, Double ^>::~context_node()
 {
-    this->!context_node();
+	this->!context_node();
 }
 
-msclr::interop::context_node<const char*, Double ^>::!context_node()
+msclr::interop::context_node<const char *, Double ^>::!context_node()
 {
-    if (toPtr != NULL) {
-        delete toPtr;
-        toPtr = NULL;
-    }
+	if (toPtr != NULL)
+	{
+		delete toPtr;
+		toPtr = NULL;
+	}
 }
-msclr::interop::context_node<const char*, Int64 ^>::context_node(const char*& toObject, Int64 ^fromObject)
+msclr::interop::context_node<const char *, Int64 ^>::context_node(const char *&toObject, Int64 ^fromObject)
 {
-    toPtr = NULL;
-    toPtr = (const char*)(new int64_t(*fromObject));
-    toObject = toPtr;
+	toPtr = NULL;
+	toPtr = (const char *)(new int64_t(*fromObject));
+	toObject = toPtr;
 }
 
-msclr::interop::context_node<const char*, Int64 ^>::~context_node()
+msclr::interop::context_node<const char *, Int64 ^>::~context_node()
 {
-    this->!context_node();
+	this->!context_node();
 }
 
-msclr::interop::context_node<const char*, Int64 ^>::!context_node()
+msclr::interop::context_node<const char *, Int64 ^>::!context_node()
 {
-    if (toPtr != NULL) {
-        delete toPtr;
-        toPtr = NULL;
-    }
+	if (toPtr != NULL)
+	{
+		delete toPtr;
+		toPtr = NULL;
+	}
 }
 
-msclr::interop::context_node<hyperclient_attribute*, Dictionary<String^, Object^>^ >::context_node(hyperclient_attribute*& toObject, Dictionary<String^, Object^>^ fromObject)
+msclr::interop::context_node<hyperclient_attribute *, Dictionary<String ^, Object ^>^ >::context_node(hyperclient_attribute *&toObject, Dictionary<String ^, Object ^> ^fromObject)
 {
-    size = fromObject->Count;
-
-    toPtr = new hyperclient_attribute[size]();
-
-    int i = 0;
-    for each(KeyValuePair<String ^, Object ^> kvp in fromObject)
-    {
-        if(kvp.Value->GetType() == String::typeid)
-        {
-            toPtr[i].value = context.marshal_as<const char*>((String ^)kvp.Value);
-            toPtr[i].attr = context.marshal_as<const char*>((String ^)kvp.Key);
-            toPtr[i].datatype = HYPERDATATYPE_STRING;
-            toPtr[i].value_sz = strlen(toPtr[i].value);
-        }
-        else if(kvp.Value->GetType() == Int64::typeid)
-        {
-            toPtr[i].value = context.marshal_as<const char*>((Int64 ^)kvp.Value);
-            toPtr[i].attr = context.marshal_as<const char*>((String ^)kvp.Key);
-            toPtr[i].datatype = HYPERDATATYPE_INT64;
-            toPtr[i].value_sz = sizeof(int64_t);
-        }
-        else if(kvp.Value->GetType() == Double::typeid)
-        {
-            toPtr[i].value = context.marshal_as<const char*>((Double^)kvp.Value);
-            toPtr[i].attr = context.marshal_as<const char*>((String ^)kvp.Key);
-            toPtr[i].datatype = HYPERDATATYPE_FLOAT;
-            toPtr[i].value_sz = sizeof(double);
-        }
-        else if (kvp.Value->GetType()->IsGenericType 
-                && kvp.Value->GetType()->GetGenericTypeDefinition() == List::typeid)
-        {
-            if(kvp.Value->GetType()->GetGenericArguments()[0] == String::typeid)
-            {
-                toPtr[i].datatype = HYPERDATATYPE_LIST_STRING;
-                toPtr[i].attr = context.marshal_as<const char*>((String^)kvp.Key);
-
-                for each(String ^ s in (List<String^>^)kvp.Value)
-                {
-                    const char* str = context.marshal_as<const char*>(s);
-                    uint32_t len = s->Length;
-                    char * val = (char*)malloc(len + sizeof(uint32_t));
-
-                    memcpy(val,&len,sizeof(uint32_t));
-                    memcpy(val + sizeof(uint32_t), str, len);
-                    toPtr[i].value = val;
-
-                    toPtr[i].value_sz = len + sizeof(uint32_t);
-                }
-            }
-            else if(kvp.Value->GetType()->GetGenericArguments()[0] == Int64::typeid)
-            {
-                toPtr[i].datatype = HYPERDATATYPE_LIST_INT64;
-                toPtr[i].attr = context.marshal_as<const char*>((String^)kvp.Key);
-
-                uint32_t len = ((List<Int64>^)kvp.Value)->Count * 8;
-
-                char * val = (char*)malloc(len);
-
-                for each(Int64 s in (List<Int64>^)kvp.Value)
-                {
-                    int64_t str = s;
-                    memcpy(val, &str, sizeof(int64_t));
-                    val += sizeof(int64_t);
-                }
-                    
-                toPtr[i].value = val - len;
-                toPtr[i].value_sz = len;
-            }
-            else if(kvp.Value->GetType()->GetGenericArguments()[0] == Double::typeid)
-            {
-                toPtr[i].datatype = HYPERDATATYPE_LIST_FLOAT;
-                toPtr[i].attr = context.marshal_as<const char*>((String^)kvp.Key);
-
-                uint32_t len = ((List<Double>^)kvp.Value)->Count * 8;
-
-                char * val = (char*)malloc(len);
-
-                for each(Double s in (List<Double>^)kvp.Value)
-                {
-                    double str = s;
-                    memcpy(val, &str, sizeof(double));
-                    val += sizeof(double);
-                }
-                    
-                toPtr[i].value = val - len;
-                toPtr[i].value_sz = len;
-            }        
-        }
-        else if (kvp.Value->GetType()->IsGenericType 
-                && kvp.Value->GetType()->GetGenericTypeDefinition() == SortedSet::typeid)
-        {
-            if(kvp.Value->GetType()->GetGenericArguments()[0] == String::typeid)
-            {
-                toPtr[i].datatype = HYPERDATATYPE_SET_STRING;
-                toPtr[i].attr = context.marshal_as<const char*>((String^)kvp.Key);
-
-                uint32_t len = 0;
-                for each(String ^ s in (SortedSet<String^>^)kvp.Value)
-                {
-                    len += sizeof(uint32_t) + s->Length;
-                }
-
-                char * val = (char*)malloc(len);
-
-                for each(String ^ s in (SortedSet<String^>^)kvp.Value)
-                {
-                    const char* str = context.marshal_as<const char*>(s);
-                    uint32_t sz = s->Length;
-
-                    memcpy(val,&sz,sizeof(uint32_t));
-                    val += sizeof(uint32_t);
-
-                    memcpy(val, str, sz);
-                    val += sz;
-                }
-                    
-                toPtr[i].value = val - len;
-                toPtr[i].value_sz = len;
-            }
-            else if(kvp.Value->GetType()->GetGenericArguments()[0] == Int64::typeid)
-            {
-                toPtr[i].datatype = HYPERDATATYPE_SET_INT64;
-                toPtr[i].attr = context.marshal_as<const char*>((String^)kvp.Key);
-
-                uint32_t len = ((SortedSet<Int64>^)kvp.Value)->Count * 8;
-
-                char * val = (char*)malloc(len);
-
-                for each(Int64 s in (SortedSet<Int64>^)kvp.Value)
-                {
-                    int64_t str = s;
-                    memcpy(val, &str, sizeof(int64_t));
-                    val += sizeof(int64_t);
-                }
-                    
-                toPtr[i].value = val - len;
-                toPtr[i].value_sz = len;
-            }
-            else if(kvp.Value->GetType()->GetGenericArguments()[0] == Double::typeid)
-            {
-                toPtr[i].datatype = HYPERDATATYPE_SET_FLOAT;
-                toPtr[i].attr = context.marshal_as<const char*>((String^)kvp.Key);
-
-                uint32_t len = ((SortedSet<Double>^)kvp.Value)->Count * 8;
-
-                char * val = (char*)malloc(len);
-
-                for each(Double s in (SortedSet<Double>^)kvp.Value)
-                {
-                    double str = s;
-                    memcpy(val, &str, sizeof(double));
-                    val += sizeof(double);
-                }
-                    
-                toPtr[i].value = val - len;
-                toPtr[i].value_sz = len;
-            }        
-        }
-        else
-        {
-            delete[] toPtr;
-            THROW_EXCEPTION(HYPERCLIENT_WRONGTYPE);
-        }
-
-        ++i;
-    }
-
-    toObject = toPtr;
+	size = fromObject->Count;
+	toPtr = new hyperclient_attribute[size]();
+	int i = 0;
+	for each(KeyValuePair<String ^, Object ^> kvp in fromObject)
+	{
+		if (kvp.Value->GetType() == String::typeid)
+		{
+			toPtr[i].value = context.marshal_as<const char *>((String ^)kvp.Value);
+			toPtr[i].attr = context.marshal_as<const char *>((String ^)kvp.Key);
+			toPtr[i].datatype = HYPERDATATYPE_STRING;
+			toPtr[i].value_sz = strlen(toPtr[i].value);
+		}
+		else if (kvp.Value->GetType() == Int64::typeid)
+		{
+			toPtr[i].value = context.marshal_as<const char *>((Int64 ^)kvp.Value);
+			toPtr[i].attr = context.marshal_as<const char *>((String ^)kvp.Key);
+			toPtr[i].datatype = HYPERDATATYPE_INT64;
+			toPtr[i].value_sz = sizeof(int64_t);
+		}
+		else if (kvp.Value->GetType() == Double::typeid)
+		{
+			toPtr[i].value = context.marshal_as<const char *>((Double ^)kvp.Value);
+			toPtr[i].attr = context.marshal_as<const char *>((String ^)kvp.Key);
+			toPtr[i].datatype = HYPERDATATYPE_FLOAT;
+			toPtr[i].value_sz = sizeof(double);
+		}
+		else if (kvp.Value->GetType()->IsGenericType
+		         && kvp.Value->GetType()->GetGenericTypeDefinition() == List::typeid)
+		{
+			if (kvp.Value->GetType()->GetGenericArguments()[0] == String::typeid)
+			{
+				toPtr[i].datatype = HYPERDATATYPE_LIST_STRING;
+				toPtr[i].attr = context.marshal_as<const char *>((String ^)kvp.Key);
+				for each(String ^ s in (List<String ^> ^)kvp.Value)
+				{
+					const char *str = context.marshal_as<const char *>(s);
+					uint32_t len = s->Length;
+					char *val = (char *)malloc(len + sizeof(uint32_t));
+					memcpy(val, &len, sizeof(uint32_t));
+					memcpy(val + sizeof(uint32_t), str, len);
+					toPtr[i].value = val;
+					toPtr[i].value_sz = len + sizeof(uint32_t);
+				}
+			}
+			else if (kvp.Value->GetType()->GetGenericArguments()[0] == Int64::typeid)
+			{
+				toPtr[i].datatype = HYPERDATATYPE_LIST_INT64;
+				toPtr[i].attr = context.marshal_as<const char *>((String ^)kvp.Key);
+				uint32_t len = ((List<Int64> ^)kvp.Value)->Count * 8;
+				char *val = (char *)malloc(len);
+				for each(Int64 s in (List<Int64> ^)kvp.Value)
+				{
+					int64_t str = s;
+					memcpy(val, &str, sizeof(int64_t));
+					val += sizeof(int64_t);
+				}
+				toPtr[i].value = val - len;
+				toPtr[i].value_sz = len;
+			}
+			else if (kvp.Value->GetType()->GetGenericArguments()[0] == Double::typeid)
+			{
+				toPtr[i].datatype = HYPERDATATYPE_LIST_FLOAT;
+				toPtr[i].attr = context.marshal_as<const char *>((String ^)kvp.Key);
+				uint32_t len = ((List<Double> ^)kvp.Value)->Count * 8;
+				char *val = (char *)malloc(len);
+				for each(Double s in (List<Double> ^)kvp.Value)
+				{
+					double str = s;
+					memcpy(val, &str, sizeof(double));
+					val += sizeof(double);
+				}
+				toPtr[i].value = val - len;
+				toPtr[i].value_sz = len;
+			}
+		}
+		else if (kvp.Value->GetType()->IsGenericType
+		         && kvp.Value->GetType()->GetGenericTypeDefinition() == SortedSet::typeid)
+		{
+			if (kvp.Value->GetType()->GetGenericArguments()[0] == String::typeid)
+			{
+				toPtr[i].datatype = HYPERDATATYPE_SET_STRING;
+				toPtr[i].attr = context.marshal_as<const char *>((String ^)kvp.Key);
+				uint32_t len = 0;
+				for each(String ^ s in (SortedSet<String ^> ^)kvp.Value)
+				{
+					len += sizeof(uint32_t) + s->Length;
+				}
+				char *val = (char *)malloc(len);
+				for each(String ^ s in (SortedSet<String ^> ^)kvp.Value)
+				{
+					const char *str = context.marshal_as<const char *>(s);
+					uint32_t sz = s->Length;
+					memcpy(val, &sz, sizeof(uint32_t));
+					val += sizeof(uint32_t);
+					memcpy(val, str, sz);
+					val += sz;
+				}
+				toPtr[i].value = val - len;
+				toPtr[i].value_sz = len;
+			}
+			else if (kvp.Value->GetType()->GetGenericArguments()[0] == Int64::typeid)
+			{
+				toPtr[i].datatype = HYPERDATATYPE_SET_INT64;
+				toPtr[i].attr = context.marshal_as<const char *>((String ^)kvp.Key);
+				uint32_t len = ((SortedSet<Int64> ^)kvp.Value)->Count * 8;
+				char *val = (char *)malloc(len);
+				for each(Int64 s in (SortedSet<Int64> ^)kvp.Value)
+				{
+					int64_t str = s;
+					memcpy(val, &str, sizeof(int64_t));
+					val += sizeof(int64_t);
+				}
+				toPtr[i].value = val - len;
+				toPtr[i].value_sz = len;
+			}
+			else if (kvp.Value->GetType()->GetGenericArguments()[0] == Double::typeid)
+			{
+				toPtr[i].datatype = HYPERDATATYPE_SET_FLOAT;
+				toPtr[i].attr = context.marshal_as<const char *>((String ^)kvp.Key);
+				uint32_t len = ((SortedSet<Double> ^)kvp.Value)->Count * 8;
+				char *val = (char *)malloc(len);
+				for each(Double s in (SortedSet<Double> ^)kvp.Value)
+				{
+					double str = s;
+					memcpy(val, &str, sizeof(double));
+					val += sizeof(double);
+				}
+				toPtr[i].value = val - len;
+				toPtr[i].value_sz = len;
+			}
+		}
+		else
+		{
+			delete[] toPtr;
+			THROW_EXCEPTION(HYPERCLIENT_WRONGTYPE);
+		}
+		++i;
+	}
+	toObject = toPtr;
 }
-msclr::interop::context_node<hyperclient_attribute*, Dictionary<String^, Object^>^ >::~context_node()
+msclr::interop::context_node<hyperclient_attribute *, Dictionary<String ^, Object ^>^ >::~context_node()
 {
-    this->!context_node();
+	this->!context_node();
 }
-msclr::interop::context_node<hyperclient_attribute*, Dictionary<String^, Object^>^ >::!context_node()
+msclr::interop::context_node<hyperclient_attribute *, Dictionary<String ^, Object ^>^ >::!context_node()
 {
-    if (toPtr != NULL) {
-        delete toPtr;
-        toPtr = NULL;
-    }
+	if (toPtr != NULL)
+	{
+		delete toPtr;
+		toPtr = NULL;
+	}
 }
 
-msclr::interop::context_node<hyperclient_map_attribute*, Dictionary<String^, Dictionary<Object^, Object^>^>^ >::context_node(hyperclient_map_attribute*& toObject, Dictionary<String^, Dictionary<Object^,Object^>^>^ fromObject)
+msclr::interop::context_node<hyperclient_map_attribute *, Dictionary<String ^, Dictionary<Object ^, Object ^>^>^ >::context_node(hyperclient_map_attribute *&toObject, Dictionary<String ^, Dictionary<Object ^, Object ^>^> ^fromObject)
 {
-    size = 0;
-    for each(KeyValuePair<String ^, Dictionary<Object ^, Object ^>^ > attrkvp in fromObject)
-    {
-        size += attrkvp.Value->Count;
-    }
-
-
-    toPtr = new hyperclient_map_attribute[size]();
-
-    int i = 0;
-    for each(KeyValuePair<String ^, Dictionary<Object ^, Object ^>^ > attrkvp in fromObject)
-    {
-        /* Map Attribute */
-        const char* name = context.marshal_as<const char*>((String ^)attrkvp.Key);
-
-        /* Map Keys */
-        for each(KeyValuePair<Object ^, Object ^> kvp in attrkvp.Value)
-        {
-            toPtr[i].attr = name;
-
-            if(kvp.Value->GetType() == String::typeid)
-            {
-                toPtr[i].value = context.marshal_as<const char*>((String ^)kvp.Value);
-                toPtr[i].value_datatype = HYPERDATATYPE_STRING;
-                toPtr[i].value_sz = strlen(toPtr[i].value);
-            }
-            else if(kvp.Value->GetType() == Int64::typeid)
-            {
-                toPtr[i].value = context.marshal_as<const char*>((Int64 ^)kvp.Value);
-                toPtr[i].value_datatype = HYPERDATATYPE_INT64;
-                toPtr[i].value_sz = sizeof(int64_t);
-            }
-            else if(kvp.Value->GetType() == Double::typeid)
-            {
-                toPtr[i].value = context.marshal_as<const char*>((Double^)kvp.Value);
-                toPtr[i].value_datatype = HYPERDATATYPE_FLOAT;
-                toPtr[i].value_sz = sizeof(double);
-            }
-            else
-            {
-                delete[] toPtr;
-                THROW_EXCEPTION(HYPERCLIENT_WRONGTYPE);
-            }
-
-            /* Map Value */
-            if(kvp.Key->GetType() == String::typeid)
-            {
-                toPtr[i].map_key = context.marshal_as<const char*>((String ^)kvp.Key);
-                toPtr[i].map_key_datatype = HYPERDATATYPE_STRING;
-                toPtr[i].map_key_sz = strlen(toPtr[i].map_key);
-            }
-            else if(kvp.Key->GetType() == Int64::typeid)
-            {
-                toPtr[i].map_key = context.marshal_as<const char*>((Int64 ^)kvp.Key);
-                toPtr[i].map_key_datatype = HYPERDATATYPE_INT64;
-                toPtr[i].map_key_sz = sizeof(int64_t);
-            }
-            else if(kvp.Key->GetType() == Double::typeid)
-            {
-                toPtr[i].map_key = context.marshal_as<const char*>((Double ^)kvp.Key);
-                toPtr[i].map_key_datatype = HYPERDATATYPE_FLOAT;
-                toPtr[i].map_key_sz = sizeof(double);
-            }
-            else
-            {
-                delete[] toPtr;
-                THROW_EXCEPTION(HYPERCLIENT_WRONGTYPE);
-            }
-
-            ++i;
-        }
-
-        ++i;
-    }
-
-    toObject = toPtr;
+	size = 0;
+	for each(KeyValuePair<String ^, Dictionary<Object ^, Object ^>^ > attrkvp in fromObject)
+	{
+		size += attrkvp.Value->Count;
+	}
+	toPtr = new hyperclient_map_attribute[size]();
+	int i = 0;
+	for each(KeyValuePair<String ^, Dictionary<Object ^, Object ^>^ > attrkvp in fromObject)
+	{
+		/* Map Attribute */
+		const char *name = context.marshal_as<const char *>((String ^)attrkvp.Key);
+		/* Map Keys */
+		for each(KeyValuePair<Object ^, Object ^> kvp in attrkvp.Value)
+		{
+			toPtr[i].attr = name;
+			if (kvp.Value->GetType() == String::typeid)
+			{
+				toPtr[i].value = context.marshal_as<const char *>((String ^)kvp.Value);
+				toPtr[i].value_datatype = HYPERDATATYPE_STRING;
+				toPtr[i].value_sz = strlen(toPtr[i].value);
+			}
+			else if (kvp.Value->GetType() == Int64::typeid)
+			{
+				toPtr[i].value = context.marshal_as<const char *>((Int64 ^)kvp.Value);
+				toPtr[i].value_datatype = HYPERDATATYPE_INT64;
+				toPtr[i].value_sz = sizeof(int64_t);
+			}
+			else if (kvp.Value->GetType() == Double::typeid)
+			{
+				toPtr[i].value = context.marshal_as<const char *>((Double ^)kvp.Value);
+				toPtr[i].value_datatype = HYPERDATATYPE_FLOAT;
+				toPtr[i].value_sz = sizeof(double);
+			}
+			else
+			{
+				delete[] toPtr;
+				THROW_EXCEPTION(HYPERCLIENT_WRONGTYPE);
+			}
+			/* Map Value */
+			if (kvp.Key->GetType() == String::typeid)
+			{
+				toPtr[i].map_key = context.marshal_as<const char *>((String ^)kvp.Key);
+				toPtr[i].map_key_datatype = HYPERDATATYPE_STRING;
+				toPtr[i].map_key_sz = strlen(toPtr[i].map_key);
+			}
+			else if (kvp.Key->GetType() == Int64::typeid)
+			{
+				toPtr[i].map_key = context.marshal_as<const char *>((Int64 ^)kvp.Key);
+				toPtr[i].map_key_datatype = HYPERDATATYPE_INT64;
+				toPtr[i].map_key_sz = sizeof(int64_t);
+			}
+			else if (kvp.Key->GetType() == Double::typeid)
+			{
+				toPtr[i].map_key = context.marshal_as<const char *>((Double ^)kvp.Key);
+				toPtr[i].map_key_datatype = HYPERDATATYPE_FLOAT;
+				toPtr[i].map_key_sz = sizeof(double);
+			}
+			else
+			{
+				delete[] toPtr;
+				THROW_EXCEPTION(HYPERCLIENT_WRONGTYPE);
+			}
+			++i;
+		}
+		++i;
+	}
+	toObject = toPtr;
 }
 
-msclr::interop::context_node<hyperclient_map_attribute*, Dictionary<String^, Dictionary<Object^, Object^>^ >^ >::~context_node()
+msclr::interop::context_node<hyperclient_map_attribute *, Dictionary<String ^, Dictionary<Object ^, Object ^>^ >^ >::~context_node()
 {
-    this->!context_node();
+	this->!context_node();
 }
-msclr::interop::context_node<hyperclient_map_attribute*, Dictionary<String^, Dictionary<Object^, Object^>^ >^ >::!context_node()
+msclr::interop::context_node<hyperclient_map_attribute *, Dictionary<String ^, Dictionary<Object ^, Object ^>^ >^ >::!context_node()
 {
-    if (toPtr != NULL) {
-        delete toPtr;
-        toPtr = NULL;
-    }
+	if (toPtr != NULL)
+	{
+		delete toPtr;
+		toPtr = NULL;
+	}
 }
 
-msclr::interop::context_node<hyperclient_attribute_check*, Dictionary<String^, Object^>^ >::context_node(hyperclient_attribute_check*& toObject, Dictionary<String^, Object^>^ fromObject)
+msclr::interop::context_node<hyperclient_attribute_check *, Dictionary<String ^, Object ^>^ >::context_node(hyperclient_attribute_check *&toObject, Dictionary<String ^, Object ^> ^fromObject)
 {
-    //Waste a bit of memory but we don't have to cycle the dictionary twice to find out
-    //how many of the checks are pairs.
-    size = fromObject->Count * 2;
-
-    toPtr = new hyperclient_attribute_check[size]();
-
-    int i = 0;
-    for each(KeyValuePair<String ^, Object ^> kvp in fromObject)
-    {
-        if(kvp.Value->GetType() == String::typeid)
-        {
-            toPtr[i].value = context.marshal_as<const char*>((String ^)kvp.Value);
-            toPtr[i].attr = context.marshal_as<const char*>((String ^)kvp.Key);
-            toPtr[i].datatype = HYPERDATATYPE_STRING;
-            toPtr[i].value_sz = strlen(toPtr[i].value);
-            toPtr[i].predicate = HYPERPREDICATE_EQUALS;
-        }
-        else if(kvp.Value->GetType() == Int64::typeid)
-        {
-            toPtr[i].value = context.marshal_as<const char*>((Int64 ^)kvp.Value);
-            toPtr[i].attr = context.marshal_as<const char*>((String ^)kvp.Key);
-            toPtr[i].datatype = HYPERDATATYPE_INT64;
-            toPtr[i].value_sz = sizeof(int64_t);
-            toPtr[i].predicate = HYPERPREDICATE_EQUALS;
-        }
-        else if(kvp.Value->GetType() == Double::typeid)
-        {
-            toPtr[i].value = context.marshal_as<const char*>((Double^)kvp.Value);
-            toPtr[i].attr = context.marshal_as<const char*>((String ^)kvp.Key);
-            toPtr[i].datatype = HYPERDATATYPE_FLOAT;
-            toPtr[i].value_sz = sizeof(double);
-            toPtr[i].predicate = HYPERPREDICATE_EQUALS;
-        }
-        else if (kvp.Value->GetType()->IsGenericType 
-                && kvp.Value->GetType()->GetGenericTypeDefinition() == KeyValuePair::typeid)
-        {
-            int j = i;
-            do
-            {
-                if(kvp.Value->GetType() == String::typeid)
-                {
-                    toPtr[i].value = context.marshal_as<const char*>((String ^)kvp.Value);
-                    toPtr[i].attr = context.marshal_as<const char*>((String ^)kvp.Key);
-                    toPtr[i].datatype = HYPERDATATYPE_STRING;
-                    toPtr[i].value_sz = strlen(toPtr[i].value);
-                    if(j == i)
-                    {
-                        /* First argument is always the lower bound. */
-                        toPtr[i].predicate = HYPERPREDICATE_GREATER_EQUAL;
-                    }
-                    else
-                    {
-                        /* Second argument is always the lower bound. */
-                        toPtr[i].predicate = HYPERPREDICATE_LESS_EQUAL;
-                    }
-                }
-                else if(kvp.Value->GetType() == Int64::typeid)
-                {
-                    toPtr[i].value = context.marshal_as<const char*>((Int64 ^)kvp.Value);
-                    toPtr[i].attr = context.marshal_as<const char*>((String ^)kvp.Key);
-                    toPtr[i].datatype = HYPERDATATYPE_INT64;
-                    toPtr[i].value_sz = sizeof(int64_t);
-                    if(j == i)
-                    {
-                        toPtr[i].predicate = HYPERPREDICATE_GREATER_EQUAL;
-                    }
-                    else
-                    {
-                        toPtr[i].predicate = HYPERPREDICATE_LESS_EQUAL;
-                    }
-                }
-                else if(kvp.Value->GetType() == Double::typeid)
-                {
-                    toPtr[i].value = context.marshal_as<const char*>((Double^)kvp.Value);
-                    toPtr[i].attr = context.marshal_as<const char*>((String ^)kvp.Key);
-                    toPtr[i].datatype = HYPERDATATYPE_FLOAT;
-                    toPtr[i].value_sz = sizeof(double);
-                    if(j == i)
-                    {
-                        toPtr[i].predicate = HYPERPREDICATE_GREATER_EQUAL;
-                    }
-                    else
-                    {
-                        toPtr[i].predicate = HYPERPREDICATE_LESS_EQUAL;
-                    }
-                }
-                else
-                {
-                    delete[] toPtr;
-                    THROW_EXCEPTION(HYPERCLIENT_WRONGTYPE);
-                }
-            }
-            while(i < j + 1 && ++i);
-        }
-
-        else
-        {
-            delete[] toPtr;
-            THROW_EXCEPTION(HYPERCLIENT_WRONGTYPE);
-        }
-
-        ++i;
-    }
-
-    toObject = toPtr;
+	//Waste a bit of memory but we don't have to cycle the dictionary twice to find out
+	//how many of the checks are pairs.
+	size = fromObject->Count * 2;
+	toPtr = new hyperclient_attribute_check[size]();
+	int i = 0;
+	for each(KeyValuePair<String ^, Object ^> kvp in fromObject)
+	{
+		if (kvp.Value->GetType() == String::typeid)
+		{
+			toPtr[i].value = context.marshal_as<const char *>((String ^)kvp.Value);
+			toPtr[i].attr = context.marshal_as<const char *>((String ^)kvp.Key);
+			toPtr[i].datatype = HYPERDATATYPE_STRING;
+			toPtr[i].value_sz = strlen(toPtr[i].value);
+			toPtr[i].predicate = HYPERPREDICATE_EQUALS;
+		}
+		else if (kvp.Value->GetType() == Int64::typeid)
+		{
+			toPtr[i].value = context.marshal_as<const char *>((Int64 ^)kvp.Value);
+			toPtr[i].attr = context.marshal_as<const char *>((String ^)kvp.Key);
+			toPtr[i].datatype = HYPERDATATYPE_INT64;
+			toPtr[i].value_sz = sizeof(int64_t);
+			toPtr[i].predicate = HYPERPREDICATE_EQUALS;
+		}
+		else if (kvp.Value->GetType() == Double::typeid)
+		{
+			toPtr[i].value = context.marshal_as<const char *>((Double ^)kvp.Value);
+			toPtr[i].attr = context.marshal_as<const char *>((String ^)kvp.Key);
+			toPtr[i].datatype = HYPERDATATYPE_FLOAT;
+			toPtr[i].value_sz = sizeof(double);
+			toPtr[i].predicate = HYPERPREDICATE_EQUALS;
+		}
+		else if (kvp.Value->GetType()->IsGenericType
+		         && kvp.Value->GetType()->GetGenericTypeDefinition() == KeyValuePair::typeid)
+		{
+			int j = i;
+			do
+			{
+				if (kvp.Value->GetType() == String::typeid)
+				{
+					toPtr[i].value = context.marshal_as<const char *>((String ^)kvp.Value);
+					toPtr[i].attr = context.marshal_as<const char *>((String ^)kvp.Key);
+					toPtr[i].datatype = HYPERDATATYPE_STRING;
+					toPtr[i].value_sz = strlen(toPtr[i].value);
+					if (j == i)
+					{
+						/* First argument is always the lower bound. */
+						toPtr[i].predicate = HYPERPREDICATE_GREATER_EQUAL;
+					}
+					else
+					{
+						/* Second argument is always the lower bound. */
+						toPtr[i].predicate = HYPERPREDICATE_LESS_EQUAL;
+					}
+				}
+				else if (kvp.Value->GetType() == Int64::typeid)
+				{
+					toPtr[i].value = context.marshal_as<const char *>((Int64 ^)kvp.Value);
+					toPtr[i].attr = context.marshal_as<const char *>((String ^)kvp.Key);
+					toPtr[i].datatype = HYPERDATATYPE_INT64;
+					toPtr[i].value_sz = sizeof(int64_t);
+					if (j == i)
+					{
+						toPtr[i].predicate = HYPERPREDICATE_GREATER_EQUAL;
+					}
+					else
+					{
+						toPtr[i].predicate = HYPERPREDICATE_LESS_EQUAL;
+					}
+				}
+				else if (kvp.Value->GetType() == Double::typeid)
+				{
+					toPtr[i].value = context.marshal_as<const char *>((Double ^)kvp.Value);
+					toPtr[i].attr = context.marshal_as<const char *>((String ^)kvp.Key);
+					toPtr[i].datatype = HYPERDATATYPE_FLOAT;
+					toPtr[i].value_sz = sizeof(double);
+					if (j == i)
+					{
+						toPtr[i].predicate = HYPERPREDICATE_GREATER_EQUAL;
+					}
+					else
+					{
+						toPtr[i].predicate = HYPERPREDICATE_LESS_EQUAL;
+					}
+				}
+				else
+				{
+					delete[] toPtr;
+					THROW_EXCEPTION(HYPERCLIENT_WRONGTYPE);
+				}
+			}
+			while (i < j + 1 && ++i);
+		}
+		else
+		{
+			delete[] toPtr;
+			THROW_EXCEPTION(HYPERCLIENT_WRONGTYPE);
+		}
+		++i;
+	}
+	toObject = toPtr;
 }
-msclr::interop::context_node<hyperclient_attribute_check*, Dictionary<String^, Object^>^ >::~context_node()
+msclr::interop::context_node<hyperclient_attribute_check *, Dictionary<String ^, Object ^>^ >::~context_node()
 {
-    this->!context_node();
+	this->!context_node();
 }
-msclr::interop::context_node<hyperclient_attribute_check*, Dictionary<String^, Object^>^ >::!context_node()
+msclr::interop::context_node<hyperclient_attribute_check *, Dictionary<String ^, Object ^>^ >::!context_node()
 {
-    if (toPtr != NULL) {
-        delete toPtr;
-        toPtr = NULL;
-    }
+	if (toPtr != NULL)
+	{
+		delete toPtr;
+		toPtr = NULL;
+	}
 }
diff --git a/windows/marshal.h b/windows/marshal.h
index 939b0c501..3f7c2cb39 100644
--- a/windows/marshal.h
+++ b/windows/marshal.h
@@ -14,85 +14,87 @@ using namespace cliext;
 using namespace System::Collections::Generic;
 
 #define THROW_EXCEPTION(x) \
-    do{ \
-    HyperClientException^ ex = gcnew HyperClientException(); \
-    ex->return_code = static_cast<HyperClientReturnCode>(x); \
-    throw ex; \
-    } while (0)
+	do{ \
+		HyperClientException^ ex = gcnew HyperClientException(); \
+		ex->return_code = static_cast<HyperClientReturnCode>(x); \
+		throw ex; \
+	} while (0)
 
 
-namespace msclr {
-    namespace interop {
-        template<>
-            ref class context_node<const char*, Double ^> : public context_node_base
-            {
-                private:
-                    const char* toPtr;
-                    marshal_context context;
+namespace msclr
+{
+namespace interop
+{
+template<>
+ref class context_node<const char *, Double ^> : public context_node_base
+{
+private:
+	const char *toPtr;
+	marshal_context context;
 
-                public:
-                    context_node(const char*& toObject, Double ^fromObject);
-                    ~context_node();
+public:
+	context_node(const char *&toObject, Double ^fromObject);
+	~context_node();
 
-                protected:
-                    !context_node();
-            };
+protected:
+	!context_node();
+};
 
-        template<>
-            ref class context_node<const char*, Int64 ^> : public context_node_base
-            {
-                private:
-                    const char* toPtr;
-                    marshal_context context;
+template<>
+ref class context_node<const char *, Int64 ^> : public context_node_base
+{
+private:
+	const char *toPtr;
+	marshal_context context;
 
-                public:
-                    context_node(const char*& toObject, Int64 ^fromObject);
-                    ~context_node();
+public:
+	context_node(const char *&toObject, Int64 ^fromObject);
+	~context_node();
 
-                protected:
-                    !context_node();
-            };
+protected:
+	!context_node();
+};
 
-        template<>
-            ref class context_node<hyperclient_attribute*, Dictionary<String^, Object^>^ > : public context_node_base
-            {
-                private:
-                    hyperclient_attribute* toPtr;
-                    int size;
-                    marshal_context context;
-                public:
-                    context_node(hyperclient_attribute*& toObject, Dictionary<String^, Object^>^ fromObject);
-                    ~context_node();
-                protected:
-                    !context_node();
-            };
+template<>
+ref class context_node<hyperclient_attribute *, Dictionary<String ^, Object ^>^ > : public context_node_base
+{
+private:
+	hyperclient_attribute *toPtr;
+	int size;
+	marshal_context context;
+public:
+	context_node(hyperclient_attribute *&toObject, Dictionary<String ^, Object ^> ^fromObject);
+	~context_node();
+protected:
+	!context_node();
+};
 
-        template<>
-            ref class context_node<hyperclient_map_attribute*, Dictionary<String^, Dictionary<Object^, Object^>^ >^ > : public context_node_base
-            {
-                private:
-                    hyperclient_map_attribute* toPtr;
-                    int size;
-                    marshal_context context;
-                public:
-                    context_node(hyperclient_map_attribute*& toObject,Dictionary<String^, Dictionary<Object^, Object^>^ >^ fromObject);
-                    ~context_node();
-                protected:
-                    !context_node();
-            };
+template<>
+ref class context_node<hyperclient_map_attribute *, Dictionary<String ^, Dictionary<Object ^, Object ^>^ >^ > : public context_node_base
+{
+private:
+	hyperclient_map_attribute *toPtr;
+	int size;
+	marshal_context context;
+public:
+	context_node(hyperclient_map_attribute *&toObject, Dictionary<String ^, Dictionary<Object ^, Object ^>^ > ^fromObject);
+	~context_node();
+protected:
+	!context_node();
+};
 
-        template<>
-            ref class context_node<hyperclient_attribute_check*, Dictionary<String^, Object^>^ > : public context_node_base
-            {
-                private:
-                    hyperclient_attribute_check* toPtr;
-                    int size;
-                    marshal_context context;
-                public:
-                    context_node(hyperclient_attribute_check*& toObject, Dictionary<String^, Object^>^ fromObject);
-                    ~context_node();
-                protected:
-                    !context_node();
-            };
-    }
+template<>
+ref class context_node<hyperclient_attribute_check *, Dictionary<String ^, Object ^>^ > : public context_node_base
+{
+private:
+	hyperclient_attribute_check *toPtr;
+	int size;
+	marshal_context context;
+public:
+	context_node(hyperclient_attribute_check *&toObject, Dictionary<String ^, Object ^> ^fromObject);
+	~context_node();
+protected:
+	!context_node();
+};
+}
 }
diff --git a/windows/unistd.h b/windows/unistd.h
index 651758a39..908b5f60f 100644
--- a/windows/unistd.h
+++ b/windows/unistd.h
@@ -1,6 +1,6 @@
-#ifdef _MSC_VER
-#  include <io.h>
-#  include <process.h>
-#else
-#  include <unistd.h>
-#endif
+#ifdef _MSC_VER
+#  include <io.h>
+#  include <process.h>
+#else
+#  include <unistd.h>
+#endif