+#define vec_meta(A) (((vector_t*)(A)) - 1)
+#define vec_free(A) ((void)((A) ? (mem_d((void*)vec_meta(A)), (A) = NULL) : 0))
+#define vec_push(A,V) (GMQCC_VEC_WILLGROW((A),1), (A)[vec_meta(A)->used++] = (V))
+#define vec_size(A) ((A) ? vec_meta(A)->used : 0)
+#define vec_add(A,N) (GMQCC_VEC_WILLGROW((A),(N)), vec_meta(A)->used += (N), &(A)[vec_meta(A)->used-(N)])
+#define vec_last(A) ((A)[vec_meta(A)->used - 1])
+#define vec_pop(A) ((void)(vec_meta(A)->used -= 1))
+#define vec_shrinkto(A,N) ((void)(vec_meta(A)->used = (N)))
+#define vec_shrinkby(A,N) ((void)(vec_meta(A)->used -= (N)))
+#define vec_append(A,N,S) ((void)(memcpy(vec_add((A), (N)), (S), (N) * sizeof(*(S)))))
+#define vec_upload(X,Y,S) ((void)(memcpy(vec_add((X), (S) * sizeof(*(Y))), (Y), (S) * sizeof(*(Y)))))
+#define vec_remove(A,I,N) ((void)(memmove((A)+(I),(A)+((I)+(N)),sizeof(*(A))*(vec_meta(A)->used-(I)-(N))),vec_meta(A)->used-=(N)))
+
+typedef struct trie_s {
+ void *value;
+ struct trie_s *entries;
+} correct_trie_t;
+
+correct_trie_t* correct_trie_new();
+
+typedef struct hash_table_t {
+ size_t size;
+ struct hash_node_t **table;
+} hash_table_t, *ht;
+
+typedef struct hash_set_t {
+ size_t bits;
+ size_t mask;
+ size_t capacity;
+ size_t *items;
+ size_t total;
+} hash_set_t, *hs;
+
+/*
+ * hashtable implementation:
+ *
+ * Note:
+ * This was designed for pointers: you manage the life of the object yourself
+ * if you do use this for non-pointers please be warned that the object may not
+ * be valid if the duration of it exceeds (i.e on stack). So you need to allocate
+ * yourself, or put those in global scope to ensure duration is for the whole
+ * runtime.
+ *
+ * util_htnew(size) -- to make a new hashtable
+ * util_htset(table, key, value, sizeof(value)) -- to set something in the table
+ * util_htget(table, key) -- to get something from the table
+ * util_htdel(table) -- to delete the table
+ *
+ * example of use:
+ *
+ * ht foo = util_htnew(1024);
+ * int data = 100;
+ * char *test = "hello world\n";
+ * util_htset(foo, "foo", (void*)&data);
+ * util_gtset(foo, "bar", (void*)test);
+ *
+ * printf("foo: %d, bar %s",
+ * *((int *)util_htget(foo, "foo")),
+ * ((char*)util_htget(foo, "bar"))
+ * );
+ *
+ * util_htdel(foo);
+ */
+hash_table_t *util_htnew (size_t size);
+void util_htset (hash_table_t *ht, const char *key, void *value);
+void util_htdel (hash_table_t *ht);
+size_t util_hthash(hash_table_t *ht, const char *key);
+void util_htseth(hash_table_t *ht, const char *key, size_t hash, void *value);
+
+void *util_htget (hash_table_t *ht, const char *key);
+void *util_htgeth(hash_table_t *ht, const char *key, size_t hash);
+
+/*
+ * hashset implementation:
+ * This was designed for pointers: you manage the life of the object yourself
+ * if you do use this for non-pointers please be warned that the object may not
+ * be valid if the duration of it exceeds (i.e on stack). So you need to allocate
+ * yourself, or put those in global scope to ensure duration is for the whole
+ * runtime.
+ *
+ * util_hsnew() -- to make a new hashset
+ * util_hsadd(set, key) -- to add something in the set
+ * util_hshas(set, key) -- to check if something is in the set
+ * util_hsrem(set, key) -- to remove something in the set
+ * util_hsdel(set) -- to delete the set
+ *
+ * example of use:
+ *
+ * hs foo = util_hsnew();
+ * char *bar = "hello blub\n";
+ * char *baz = "hello dale\n";
+ *
+ * util_hsadd(foo, bar);
+ * util_hsadd(foo, baz);
+ * util_hsrem(foo, baz);
+ *
+ * printf("bar %d | baz %d\n",
+ * util_hshas(foo, bar),
+ * util_hshad(foo, baz)
+ * );
+ *
+ * util_hsdel(foo);
+ */
+
+hash_set_t *util_hsnew(void);
+int util_hsadd(hash_set_t *, void *);
+int util_hshas(hash_set_t *, void *);
+int util_hsrem(hash_set_t *, void *);
+void util_hsdel(hash_set_t *);
+
+/*===================================================================*/
+/*============================ file.c ===============================*/
+/*===================================================================*/
+/* file handling */
+void fs_file_close (FILE *);
+int fs_file_error (FILE *);
+int fs_file_getc (FILE *);
+int fs_file_flush (FILE *);
+int fs_file_printf (FILE *, const char *, ...);
+int fs_file_puts (FILE *, const char *);
+int fs_file_putc (FILE *, int);
+int fs_file_seek (FILE *, long int, int);
+long int fs_file_tell (FILE *);
+
+size_t fs_file_read (void *, size_t, size_t, FILE *);
+size_t fs_file_write (const void *, size_t, size_t, FILE *);
+
+FILE *fs_file_open (const char *, const char *);
+int fs_file_getline(char **, size_t *, FILE *);
+
+/* directory handling */
+DIR *fs_dir_open (const char *);
+int fs_dir_close (DIR *);
+struct dirent *fs_dir_read (DIR *);
+int fs_dir_make (const char *);
+int fs_dir_change (const char *);
+
+
+/*===================================================================*/
+/*=========================== correct.c =============================*/
+/*===================================================================*/
+typedef struct {
+ char ***edits;
+ size_t **lens;
+} correction_t;
+
+void correct_del (correct_trie_t*, size_t **);
+void correct_add (correct_trie_t*, size_t ***, const char *);
+char *correct_str (correction_t *, correct_trie_t*, const char *);
+void correct_init(correction_t *);
+void correct_free(correction_t *);