if change == (Hash{}) {
		return g.Root
	}

	b := g.Root
	for i := 0; i < 2; i++ {
		var next *Block
		for _, e := range b.Edges {
			if e.Flag&EdgeFlagsDeleted != 0 {

	// There are two possible configurations for the directory structure:
	// The old setup had directory entries as direct children of the root.
	// The new setup has a special root inode, which is a child of an intermediate
	// vertex, which is a child of the root.
	//
	// So we need to try both possibilities.
	var possibleRoots []*Block
	var directFiles []*Block
	for _, e := range g.Root.Edges {
		if e.Flag&EdgeFlagsDeleted != 0 {
			continue
		}
		if e.Flag&EdgeFlagsFolder == 0 {
			return nil, errors.New("non-folder edge found while looking for root directory")
		}
		b := e.To
		if len(b.Content) > 0 {
			directFiles = append(directFiles, b)
			continue
		}
		for _, f := range b.Edges {
			if f.Flag&EdgeFlagsDeleted != 0 {

			if e.Flag&EdgeFlagsFolder == 0 {

			if f.Flag&EdgeFlagsFolder == 0 {

			next = e.To
			break

			if len(f.To.Content) > 0 {
				continue
			}
			possibleRoots = append(possibleRoots, f.To)

		if next == nil {
			return nil, errors.New("no root directory found")
		}
		b = next

	return b, nil

	if len(directFiles) > 0 || len(possibleRoots) == 0 {
		return g.Root, nil
	}
	if len(possibleRoots) > 1 {
		return nil, fmt.Errorf("found %d possible root directories", len(possibleRoots))
	}
	return possibleRoots[0], nil