diff --git a/ds.c b/ds.c
index 53ef37b..661b482 100644
--- a/ds.c
+++ b/ds.c
@@ -6,13 +6,13 @@
 ds_sll_t
 *ds_sll_init(void)
 {
-	return ds_sll_new_node(NULL);
+  return ds_sll_new_node(NULL);
 }
 
 ds_dll_t
 *ds_dll_init(void)
 {
-	return ds_dll_new_node(NULL);
+  return ds_dll_new_node(NULL);
 }
 
 ds_sll_t
@@ -42,165 +42,165 @@ ds_dll_t
 int
 ds_sll_insert(ds_sll_t *ll, void *data)
 {
-	if (!ll || !data) {
-		return -1;
-	}
+  if (!ll || !data) {
+    return -1;
+  }
 
-	ds_ll_foreach(ds_sll_t, ll) {
-		if (!cur->data) {
-			cur->data = data;
-			return 0;
-		} else if (!cur->next) {
-			cur->next = ds_sll_new_node(data);
-			return 0;
-		}
-	}
+  ds_ll_foreach(ds_sll_t, ll) {
+    if (!cur->data) {
+      cur->data = data;
+      return 0;
+    } else if (!cur->next) {
+      cur->next = ds_sll_new_node(data);
+      return 0;
+    }
+  }
 
-	return -1;
+  return -1;
 }
 
 int
 ds_dll_insert(ds_dll_t *ll, void *data)
 {
-	if (!ll || !data) {
-		return -1;
-	}
+  if (!ll || !data) {
+    return -1;
+  }
 
-	ds_ll_foreach(ds_dll_t, ll) {
-		if (!cur->data) {
-			cur->data = data;
-			return 0;
-		} else if (!cur->next) {
-			cur->next = ds_dll_new_node(data);
-			cur->next->prev = cur;
-			return 0;
-		}
-	}
+  ds_ll_foreach(ds_dll_t, ll) {
+    if (!cur->data) {
+      cur->data = data;
+      return 0;
+    } else if (!cur->next) {
+      cur->next = ds_dll_new_node(data);
+      cur->next->prev = cur;
+      return 0;
+    }
+  }
 
-	return -1;
+  return -1;
 }
 
 void
 *ds_sll_remove(ds_sll_t **ll, unsigned idx)
 {
-	int i;
-	void *data;
-	ds_sll_t *cur, *rm;
+  int i;
+  void *data;
+  ds_sll_t *cur, *rm;
 
-	rm = NULL;
-	if (!ll || !*ll) {
-		return NULL;
-	}
+  rm = NULL;
+  if (!ll || !*ll) {
+    return NULL;
+  }
 
-	if (idx == 0) {
-		rm = *ll;
-		*ll = rm->next;
-	} else {
-		for (i = -1, cur = *ll; cur; i++, cur = cur->next) {
-			if (idx == i + 1) {
-				rm = cur->next;
-				break;
-			}
-		}
+  if (idx == 0) {
+    rm = *ll;
+    *ll = rm->next;
+  } else {
+    for (i = -1, cur = *ll; cur; i++, cur = cur->next) {
+      if (idx == i + 1) {
+        rm = cur->next;
+        break;
+      }
+    }
 
-		if (!rm) {
-			return NULL;
-		}
+    if (!rm) {
+      return NULL;
+    }
 
-		cur->next = rm->next;
-	}
+    cur->next = rm->next;
+  }
 
-	data = rm->data;
-	free(rm);
-	return data;
+  data = rm->data;
+  free(rm);
+  return data;
 }
 
 void
 *ds_dll_remove(ds_dll_t **ll, unsigned idx)
 {
-	int i;
-	void *data;
-	ds_dll_t *cur, *rm;
+  int i;
+  void *data;
+  ds_dll_t *cur, *rm;
 
-	rm = NULL;
-	if (!ll || !*ll) {
-		return NULL;
-	}
+  rm = NULL;
+  if (!ll || !*ll) {
+    return NULL;
+  }
 
-	if (idx == 0) {
-		rm = *ll;
-		*ll = rm->next;
-		if (rm->next) {
-			rm->next->prev = NULL;
-		}
-	} else {
-		for (i = 0, cur = *ll; cur; i++, cur = cur->next) {
-			if (i == idx) {
-				rm = cur;
-				break;
-			}
-		}
+  if (idx == 0) {
+    rm = *ll;
+    *ll = rm->next;
+    if (rm->next) {
+      rm->next->prev = NULL;
+    }
+  } else {
+    for (i = 0, cur = *ll; cur; i++, cur = cur->next) {
+      if (i == idx) {
+        rm = cur;
+        break;
+      }
+    }
 
-		if (!rm) {
-			return NULL;
-		}
+    if (!rm) {
+      return NULL;
+    }
 
-		rm->prev->next = rm->next;
-		if (rm->next) {
-			rm->next->prev = rm->prev;
-		}
-	}
+    rm->prev->next = rm->next;
+    if (rm->next) {
+      rm->next->prev = rm->prev;
+    }
+  }
 
-	data = rm->data;
-	free(rm);
-	return data;
+  data = rm->data;
+  free(rm);
+  return data;
 }
 
 ds_hmp_t
 *ds_hmp_init(int data_len)
 {
-	ds_hmp_t *hmp;
+  ds_hmp_t *hmp;
 
-	if (!data_len) {
-		return NULL;
-	}
+  if (!data_len) {
+    return NULL;
+  }
 
-	hmp = calloc(1, sizeof(ds_hmp_t));
-	hmp->data_len = data_len;
-	hmp->data = calloc(data_len, sizeof(ds_sll_t **));
+  hmp = calloc(1, sizeof(ds_hmp_t));
+  hmp->data_len = data_len;
+  hmp->data = calloc(data_len, sizeof(ds_sll_t **));
 
-	return hmp;
+  return hmp;
 }
 
 int
 ds_hmp_free(ds_hmp_t **hmp, void kv_callback(_ds_hmp_kv_t *kv))
 {
-	int i;
-	_ds_hmp_kv_t *kv;
-	ds_sll_t *ll;
+  int i;
+  _ds_hmp_kv_t *kv;
+  ds_sll_t *ll;
 
-	if (!hmp || !*hmp) {
-		return -1;
-	}
+  if (!hmp || !*hmp) {
+    return -1;
+  }
 
-	for (i = 0; i < (*hmp)->data_len; i++) {
-		ll = (*hmp)->data[i];
-		while (ll && ll->data) {
-			if ((kv = ds_sll_remove(&ll, 0))) {
-				if (kv_callback) {
-					kv_callback(kv);
-				}
-				free(kv);
-			}
-		}
-		if (ll) {
-			free(ll);
-		}
-	}
-	free((*hmp)->data);
-	free(*hmp);
+  for (i = 0; i < (*hmp)->data_len; i++) {
+    ll = (*hmp)->data[i];
+    while (ll && ll->data) {
+      if ((kv = ds_sll_remove(&ll, 0))) {
+        if (kv_callback) {
+          kv_callback(kv);
+        }
+        free(kv);
+      }
+    }
+    if (ll) {
+      free(ll);
+    }
+  }
+  free((*hmp)->data);
+  free(*hmp);
 
-	return 0;
+  return 0;
 }
 
 int
@@ -219,91 +219,91 @@ _ds_hmp_gen_hash(char *str)
 int
 ds_hmp_insert(ds_hmp_t *hmp, char *key, void *data)
 {
-	_ds_hmp_kv_t *kv;
-	ds_sll_t *ll;
-	unsigned hash_pos;
+  _ds_hmp_kv_t *kv;
+  ds_sll_t *ll;
+  unsigned hash_pos;
 
-	if (!hmp || !key || !data) {
-		return -1;
-	}
+  if (!hmp || !key || !data) {
+    return -1;
+  }
 
-	kv = malloc(sizeof(_ds_hmp_kv_t));
-	kv->key = key;
-	kv->val = data;
+  kv = malloc(sizeof(_ds_hmp_kv_t));
+  kv->key = key;
+  kv->val = data;
 
-	hash_pos = _ds_hmp_gen_hash(key) % hmp->data_len;
-	if (!hmp->data[hash_pos]) {
-		hmp->data[hash_pos] = ds_sll_init();
-		if (!hmp->data[hash_pos]) {
-			return -1;
-		}
-	}
+  hash_pos = _ds_hmp_gen_hash(key) % hmp->data_len;
+  if (!hmp->data[hash_pos]) {
+    hmp->data[hash_pos] = ds_sll_init();
+    if (!hmp->data[hash_pos]) {
+      return -1;
+    }
+  }
 
-	/* get the ll and put the data into it */
-	ll = hmp->data[hash_pos];
-	if (ds_sll_insert(ll, kv) != 0) {
-		return -1;
-	}
+  /* get the ll and put the data into it */
+  ll = hmp->data[hash_pos];
+  if (ds_sll_insert(ll, kv) != 0) {
+    return -1;
+  }
 
-	return 0;
+  return 0;
 }
 
 void
 *ds_hmp_get(ds_hmp_t *hmp, char *key)
 {
-	ds_sll_t *cur, *ll;
-	unsigned hash_pos;
+  ds_sll_t *cur, *ll;
+  unsigned hash_pos;
 
-	if (!hmp || !key) {
-		return NULL;
-	}
+  if (!hmp || !key) {
+    return NULL;
+  }
 
-	hash_pos = _ds_hmp_gen_hash(key) % hmp->data_len;
-	ll = hmp->data[hash_pos];
-	if (!ll) {
-		return NULL;
-	}
+  hash_pos = _ds_hmp_gen_hash(key) % hmp->data_len;
+  ll = hmp->data[hash_pos];
+  if (!ll) {
+    return NULL;
+  }
 
-	ds_ll_foreach(ds_sll_t, ll) {
-		if (strcmp(((_ds_hmp_kv_t *)cur->data)->key, key) == 0) {
-			return ((_ds_hmp_kv_t *)cur->data)->val;
-		}
-	}
+  ds_ll_foreach(ds_sll_t, ll) {
+    if (strcmp(((_ds_hmp_kv_t *)cur->data)->key, key) == 0) {
+      return ((_ds_hmp_kv_t *)cur->data)->val;
+    }
+  }
 
-	return NULL;
+  return NULL;
 }
 
 void
 *ds_hmp_remove(ds_hmp_t *hmp, char *key)
 {
-	int i;
-	void *data;
-	unsigned hash_pos;
-	ds_sll_t *ll, *cur;
-	_ds_hmp_kv_t *kv;
+  int i;
+  void *data;
+  unsigned hash_pos;
+  ds_sll_t *ll, *cur;
+  _ds_hmp_kv_t *kv;
 
-	if (!hmp || !key) {
-		return NULL;
-	}
+  if (!hmp || !key) {
+    return NULL;
+  }
 
-	hash_pos = _ds_hmp_gen_hash(key) % hmp->data_len;
-	ll = hmp->data[hash_pos];
-	if (!ll) {
-		return NULL;
-	}
+  hash_pos = _ds_hmp_gen_hash(key) % hmp->data_len;
+  ll = hmp->data[hash_pos];
+  if (!ll) {
+    return NULL;
+  }
 
-	for (i = 0, cur = ll; cur; i++, cur = cur->next) {
-		if (strcmp(((_ds_hmp_kv_t *)cur->data)->key, key) == 0) {
-			kv = ds_sll_remove(&ll, i);
-			hmp->data[hash_pos] = ll;
-			if (!kv) {
-				return NULL;
-			}
-			data = kv->val;
-			free(kv);
-			return data;
-		}
-	}
+  for (i = 0, cur = ll; cur; i++, cur = cur->next) {
+    if (strcmp(((_ds_hmp_kv_t *)cur->data)->key, key) == 0) {
+      kv = ds_sll_remove(&ll, i);
+      hmp->data[hash_pos] = ll;
+      if (!kv) {
+        return NULL;
+      }
+      data = kv->val;
+      free(kv);
+      return data;
+    }
+  }
 
-	return NULL;
+  return NULL;
 }
diff --git a/test.c b/test.c
index 919b0a4..2e99a9a 100644
--- a/test.c
+++ b/test.c
@@ -4,70 +4,70 @@
 
 #include "ds.h"
 
-#define test(name, tests) do {																				\
-		const char *_test_name = name;																		\
-		int _tests_passed = 0;																						\
-		int	_tests = 0;																										\
-		tests																															\
-		_tests_passed += _tests;																					\
-		printf("%s: %d/%d tests passed\n", name, _tests_passed, _tests);	\
-	} while (0)
+#define test(name, tests) do {                                        \
+    const char *_test_name = name;                                    \
+    int _tests_passed = 0;                                            \
+    int _tests = 0;                                                   \
+    tests                                                             \
+    _tests_passed += _tests;                                          \
+    printf("%s: %d/%d tests passed\n", name, _tests_passed, _tests);  \
+  } while (0)
 
-#define it(message, test) do {											\
-	_tests++;																					\
-	if (!(test)) {																		\
-		printf("%s %s FAILED\n", _test_name, message);	\
-		_tests_passed--;																\
-	}																									\
+#define it(message, test) do {                      \
+  _tests++;                                         \
+  if (!(test)) {                                    \
+    printf("%s %s FAILED\n", _test_name, message);  \
+    _tests_passed--;                                \
+  }                                                 \
 } while (0)
 
 typedef struct {
-	int num;
-	char *str;
+  int num;
+  char *str;
 } complex;
 
 int
 main(int argc, char *argv[])
 {
-	test("sll",
-		char *a = "one";
+  test("sll",
+    char *a = "one";
 
-		ds_sll_t *tmp;
-		it("creates a new linked list", tmp = ds_sll_init());
-		free(tmp);
+    ds_sll_t *tmp;
+    it("creates a new linked list", tmp = ds_sll_init());
+    free(tmp);
 
-		ds_sll_t *ll = ds_sll_new_node(a);
-		it("inserts an invalid item", ds_sll_insert(ll, NULL) == -1);
-		it("removes an invalid index", ds_sll_remove(&ll, 1234) == NULL);
-		it("removes an item", a == ds_sll_remove(&ll, 0));
-	);
+    ds_sll_t *ll = ds_sll_new_node(a);
+    it("inserts an invalid item", ds_sll_insert(ll, NULL) == -1);
+    it("removes an invalid index", ds_sll_remove(&ll, 1234) == NULL);
+    it("removes an item", a == ds_sll_remove(&ll, 0));
+  );
 
-	test("dll",
-		char *a = "one";
+  test("dll",
+    char *a = "one";
 
-		ds_dll_t *tmp;
-		it("creates a new linked list", tmp = ds_dll_init());
-		free(tmp);
+    ds_dll_t *tmp;
+    it("creates a new linked list", tmp = ds_dll_init());
+    free(tmp);
 
-		ds_dll_t *ll = ds_dll_new_node(a);
-		it("inserts an invalid item", ds_dll_insert(ll, NULL) == -1);
-		it("removes an invalid index", ds_dll_remove(&ll, 1234) == NULL);
-		it("removes an item", a == ds_dll_remove(&ll, 0));
-	);
+    ds_dll_t *ll = ds_dll_new_node(a);
+    it("inserts an invalid item", ds_dll_insert(ll, NULL) == -1);
+    it("removes an invalid index", ds_dll_remove(&ll, 1234) == NULL);
+    it("removes an item", a == ds_dll_remove(&ll, 0));
+  );
 
-	test("hmp",
-		complex *a = calloc(1, sizeof(complex));
-		a->num = 1;
-		a->str = "abc";
+  test("hmp",
+    complex *a = calloc(1, sizeof(complex));
+    a->num = 1;
+    a->str = "abc";
 
-		ds_hmp_t *hmp = ds_hmp_init(101);
-		it("inserts an item", ds_hmp_insert(hmp, a->str, a) == 0);
-		it("generates a hash", _ds_hmp_gen_hash("a") == 177670);
-		it("removes a non-existent item", ds_hmp_remove(hmp, "???") == NULL);
-		it("removes an invalid item", ds_hmp_remove(hmp, NULL) == NULL);
-		it("removes an item", a == ds_hmp_remove(hmp, a->str));
-		ds_hmp_free(&hmp, NULL);
+    ds_hmp_t *hmp = ds_hmp_init(101);
+    it("inserts an item", ds_hmp_insert(hmp, a->str, a) == 0);
+    it("generates a hash", _ds_hmp_gen_hash("a") == 177670);
+    it("removes a non-existent item", ds_hmp_remove(hmp, "???") == NULL);
+    it("removes an invalid item", ds_hmp_remove(hmp, NULL) == NULL);
+    it("removes an item", a == ds_hmp_remove(hmp, a->str));
+    ds_hmp_free(&hmp, NULL);
 
-		free(a);
-	);
+    free(a);
+  );
 }