DeletedBy    []Hash

	if len(oldBlock.DeletedBy) > 0 {
		newBlock.DeletedBy = make([]Hash, len(oldBlock.DeletedBy))
		copy(newBlock.DeletedBy, oldBlock.DeletedBy)
	}

	var deletions []NewEdge

					if e.Flag&EdgeFlagsDeleted == EdgeFlagsDeleted {
						deletions = append(deletions, e)
					} else {
						err := g.putNewEdge(h, e)
						if err != nil {
							return err
						}

					err := g.putNewEdge(h, e)
					if err != nil {
						return err

	for _, e := range deletions {
		err := g.putNewEdge(h, e)
		if err != nil {
			return err
		}
	}

	source := g.blockEnding(coalesceHash(ne.From.Change, change), ne.From.Pos)
	if source == nil {
		return fmt.Errorf("not found: block ending at %v:%d", coalesceHash(ne.From.Change, change), ne.From.Pos)
	}

	}
	if target.End > ne.To.End {
		g.splitBlock(target, ne.To.End)

	found := false
	// Look for the old edge and update it if it is found.
	for _, e := range source.Edges {
		if e.Change == introducedBy && e.From == source && e.To == target {
			found = true
			e.Change = change
			e.Flag = ne.Flag

	for {
		if target.End > ne.To.End {
			g.splitBlock(target, ne.To.End)
		}
		if ne.Flag&EdgeFlagsDeleted != 0 {
			// This is a deletion, so we'll add this change to the DeletedBy list if it
			// isn't there already.
			found := false
			for _, h := range target.DeletedBy {
				if h == change {
					found = true
					break
				}
			}
			if !found {
				target.DeletedBy = append(target.DeletedBy, change)
			}
		} else {
			// This is an undeletion, so we'll remove the change that did the deletion
			// from the DeletedBy list.
			for i, h := range target.DeletedBy {
				if h == introducedBy {
					target.DeletedBy = append(target.DeletedBy[:i], target.DeletedBy[i+1:]...)
					break
				}
			}
		}
		if target.End == ne.To.End {

	}

	if !found {
		makeEdge(change, ne.Flag, source, target)

		newTarget := g.blockStarting(target.Change, target.End)
		if newTarget == nil {
			return fmt.Errorf("not found: block to follow %v:%d:%d", target.Change, target.Start, target.End)
		}
		target = newTarget

		if e.Flag&EdgeFlagsDeleted != 0 {

		if len(e.To.DeletedBy) > 0 {

			if f.Flag&EdgeFlagsDeleted != 0 {

			if len(f.To.DeletedBy) > 0 {

	deleted := make([]bool, len(blocks))

		var dead, alive int
		for _, e := range b.ReverseEdges {
			if e.Flag&EdgeFlagsBlock != 0 {
				if e.Flag&EdgeFlagsDeleted != 0 {
					dead++
				} else {
					alive++
				}
			}
		}
		if dead > 0 && alive == 0 {
			deleted[i] = true
		}

				if !deleted[j] {

				if len(blocks[j].DeletedBy) == 0 {

				if !deleted[j] {

				if len(blocks[j].DeletedBy) == 0 {

		if deleted[i] {

		if len(b.DeletedBy) > 0 {

	for j := 0; j < conflictEnd[len(blocks)]; j++ {
		fmt.Fprintf(dest, ">>>>>>>\n")
	}

		if e.Flag&EdgeFlagsDeleted != 0 {

		if len(e.To.DeletedBy) > 0 {

			if inodeEdge.Flag&EdgeFlagsDeleted != 0 {

			if len(inodeEdge.To.DeletedBy) > 0 {

		}
		if entry.Inode == nil && len(b.Edges) > 0 {
			// All the potential inodes are deleted.
			// But there has to be one.
			// So we'll just pick the first one.
			entry.Inode = b.Edges[0].To