g.splitBlock(blocks[i], pos)

	// Split the block.
	oldBlock := blocks[i]
	newBlock := &Block{

	return blocks[i]
}
func (g *Graph) splitBlock(oldBlock *Block, pos ChangePosition) (newBlock *Block) {
	change := oldBlock.Change
	newBlock = &Block{

	for _, e := range newBlock.Edges {
		e.From = newBlock
	}

	blocks = append(blocks, newBlock)

	blocks := append(g.Index[change], newBlock)

	return oldBlock

	return newBlock

	var deletions []NewEdge

			default:
				return fmt.Errorf("not implemented yet: %T", a)

			case EdgeMap:
				for _, e := range a.Edges {
					if e.Flag&EdgeFlagsDeleted == EdgeFlagsDeleted {
						deletions = append(deletions, e)
					} else {
						err := g.putNewEdge(h, e)
						if err != nil {
							return err
						}
					}
				}

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

func (g *Graph) putNewEdge(change Hash, ne NewEdge) error {
	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)
	}
	target := g.blockStarting(coalesceHash(ne.To.Change, change), ne.To.Start)
	if target == nil {
		return fmt.Errorf("not found: block starting at %v:%d", coalesceHash(ne.To.Change, change), ne.To.Start)
	}
	if target.End > ne.To.End {
		g.splitBlock(target, ne.To.End)
	}
	introducedBy := coalesceHash(ne.IntroducedBy, change)
	// Delete old edges from source to target.
	for i, e := range source.Edges {
		if e.Change == introducedBy && e.From == source && e.To == target {
			source.Edges = append(source.Edges[:i], source.Edges[i+1:]...)
			break
		}
	}
	for i, e := range target.ReverseEdges {
		if e.Change == introducedBy && e.From == source && e.To == target {
			target.ReverseEdges = append(target.ReverseEdges[:i], target.ReverseEdges[i+1:]...)
			break
		}
	}
	makeEdge(change, ne.Flag, source, target)
	return nil
}

	case 7:
		return replacement(data)

type Replacement struct {
	Change      Atom
	Replacement Atom
	Local       Local
	Encoding    string
}
func (r Replacement) atoms() []Atom {
	return []Atom{r.Change, r.Replacement}
}
func replacement(data []byte) ([]byte, Replacement, error) {
	var r Replacement
	data, _, err := tuple(
		assign(&r.Change, atom),
		assign(&r.Replacement, atom),
		assign(&r.Local, local),
		assign(&r.Encoding, mapValue(option(toString(lengthData(uint64LE))), func(p *string) string {
			if p == nil {
				return ""
			}
			return *p
		})),
	)(data)
	return data, r, err
}

		stroke := "black"

		style := "stroke: black"

			stroke = "royalblue"

			style = "stroke: royalblue"

			stroke = "forestgreen"

			style = "stroke: forestgreen"
		case 128, 129:
			style = "stroke: forestgreen; stroke-dash: 3"

		fmt.Fprintf(b, "%q -> %q {style.stroke: %s}\n", blockID(e.From), blockID(e.To), stroke)

		fmt.Fprintf(b, "%q -> %q {style: {%s}}\n", blockID(e.From), blockID(e.To), style)