}
static void
change_decode_encoding_noenc(struct bincode *bc, char **encoding)
{
	(void)bc;
	*encoding = xstrdup("UTF-8");

	void (*fn_change_decode_encoding)(struct bincode *, char **);
	fn_change_decode_encoding = &change_decode_encoding;
	if (hashed->version == VERSION_NOENC)
		fn_change_decode_encoding = change_decode_encoding_noenc;

			change_decode_encoding(bc, &bhunk->edit.encoding);

			fn_change_decode_encoding(bc, &bhunk->edit.encoding);

			change_decode_encoding(bc, &bhunk->replacement.encoding);

			fn_change_decode_encoding(
				bc, &bhunk->replacement.encoding
			);

			change_decode_encoding(bc, &bhunk->fileadd.encoding);

			fn_change_decode_encoding(bc, &bhunk->fileadd.encoding);

			change_decode_encoding(bc, &bhunk->filedel.encoding);

			fn_change_decode_encoding(bc, &bhunk->filedel.encoding);

			change_decode_encoding(bc, &bhunk->fileundel.encoding);

			fn_change_decode_encoding(
				bc, &bhunk->fileundel.encoding
			);

			change_decode_encoding(

			fn_change_decode_encoding(

	}
}
void
change_decode_author(struct bincode *bc, struct author *author)
{
	size_t len, i;
	len = bincode_getu64(bc);
	author->len = len;
	author->entries = xmalloc(sizeof(struct authorentry) * len);
	for (i = 0; i < author->len; i++) {
		len = bincode_getu64(bc);
		author->entries[i].key = xmalloc(len + 1);
		bincode_getstr(bc, author->entries[i].key, len);
		len = bincode_getu64(bc);
		author->entries[i].value = xmalloc(len + 1);
		bincode_getstr(bc, author->entries[i].value, len);

void
change_decode_author_noenc(struct bincode *bc, struct author *author)
{
	size_t len, i;
	char *name, *full_name, *email;

	i = 1;
	full_name = email = NULL;
	len = bincode_getu64(bc);
	name = xmalloc(len + 1);
	bincode_getstr(bc, name, len);
	if (bincode_getu8(bc)) {
		i++;
		len = bincode_getu64(bc);
		full_name = xmalloc(len + 1);
		bincode_getstr(bc, full_name, len);
	}
	if (bincode_getu8(bc)) {
		i++;
		len = bincode_getu64(bc);
		email = xmalloc(len + 1);
		bincode_getstr(bc, email, len);
	}
	author->len = i;
	author->entries = xmalloc(sizeof(struct authorentry) * i);
	i = 0;
	author->entries[i].key = xstrdup("name");
	author->entries[i].value = name;
	if (full_name) {
		i++;
		author->entries[i].key = xstrdup("full_name");
		author->entries[i].value = full_name;
	}
	if (email) {
		i++;
		author->entries[i].key = xstrdup("email");
		author->entries[i].value = email;
	}
}

	void (*fn_change_decode_author)(struct bincode *, struct author *);

	fn_change_decode_author = change_decode_author;
	if (hashed->version == VERSION_NOENC)
		fn_change_decode_author = change_decode_author_noenc;

		size_t j;
		len = bincode_getu64(&bc);
		hashed->header.authors.map[i].entries =
			xmalloc(sizeof(struct author) * len);
		hashed->header.authors.map[i].len = len;
		for (j = 0; j < hashed->header.authors.map[i].len; j++) {
			// In VERSION_NOENC, the authors are a struct { name: str, full_name: maybe str, email: maybe str } instead of a more generic map
			// TODO switch on offsets.version to figure
			// out how to decode the authors here
			len = bincode_getu64(&bc);
			hashed->header.authors.map[i].entries[j].key =
				xmalloc(len + 1);
			bincode_getstr(
				&bc,
				hashed->header.authors.map[i].entries[j].key,
				len
			);
			len = bincode_getu64(&bc);
			hashed->header.authors.map[i].entries[j].value =
				xmalloc(len + 1);
			bincode_getstr(
				&bc,
				hashed->header.authors.map[i].entries[j].value,
				len
			);
		}

		fn_change_decode_author(&bc, &hashed->header.authors.map[i]);

/**
 * In the VERSION_NOENC file metadata (for file additions), the
 * filemetadata contains *only* the inodemetadata directly followed by
 * the basename. The basename is not bincode-encoded, so we assume the
 * length of the string is the given content length minus 2 (for the
 * first two bytes used by the inodemetadata).
 */
static void
read_filemetadata_noenc(
	struct filemetadata *m, uint8_t *contents, size_t contents_len
)
{
	size_t len;
	struct bincode bc = { .avail = contents_len, .buf = contents };
	m->inodemetadata = bincode_getu16(&bc);
	len = contents_len - 2;
	m->basename = xmalloc(len + 1);
	memcpy(m->basename, &contents[2], len);
	m->basename[len] = '\0';
}

	void (*fn_read_filemetadata)(struct filemetadata *, uint8_t *, size_t);

	fn_read_filemetadata = read_filemetadata;
	if (hashed->version == VERSION_NOENC)
		fn_read_filemetadata = read_filemetadata_noenc;

	printf("[[authors]]\n");

		printf("[[authors]]\n");

		printf("\n");

	printf("\n");

				read_filemetadata(

				fn_read_filemetadata(

			read_filemetadata(

			fn_read_filemetadata(

	if (off->version != VERSION) {
		if (off->version == VERSION_NOENC) {
			printf("The NOENC version (%lu) is not yet supported, sorry (but it's planned)\n",
			       off->version);
		} else {
			printf("Version %lu is not yet supported, sorry.\n",
			       off->version);
		}

	if (off->version != VERSION && off->version != VERSION_NOENC) {
		printf("Version %lu is not yet supported, sorry.\n",
		       off->version);
		err = off->version;

	size_t i, x;

	size_t x;