pos := p.pos()
	pos.EndLine = pos.StartLine + len(b.text) - 1
	return &Paragraph{
		pos,
		p.newText(pos, s),
	}
}

func newPara(p *parseState, s line) (line, bool) {
	// Process paragraph continuation text or start new paragraph.
	b := p.para()
	indented := p.lineDepth == len(p.stack)-2 // fully indented, not playing "pargraph continuation text" games
	text := s.trimSpaceString()

	if b != nil && b.table != nil {

	if c, ok := p.nextB().(*listBuilder); ok {
		list = c
	}
	if list == nil || list.bullet != rune(bullet) {
		// “When the first list item in a list interrupts a paragraph—that is,
		// when it starts on a line that would otherwise count as
		// paragraph continuation text—then (a) the lines Ls must
		// not begin with a blank line,
		// and (b) if the list item is ordered, the start number must be 1.”

			dumpNL(out, indent)
			dumpTo(out, indent, item)
		}

	case *ListItem:
		fmt.Fprintf(out, "Item Number=%q", x.Number)
		dumpTo(out, indent+1, x.Content)

	case *Paragraph:
		fmt.Fprintf(out, "Paragraph")
		dumpTo(out, indent+1, x.Text)

	case *Code:
		fmt.Fprintf(out, "Code")
		dumpTo(out, indent+1, x.Text)

	case []Text:
		for _, t := range x {
			dumpNL(out, indent)

		dumpBlock(b, depth)
	}
}

func dumpBlock(b md.Block, depth int) {
	typeName := strings.TrimPrefix(fmt.Sprintf("%T", b), "*markdown.")
	dprintf(depth, "%s\n", typeName)
	switch b := b.(type) {
	case *md.Paragraph:
		dumpInlines(b.Text.Inline, depth+1)
	case *md.Heading:
		dumpInlines(b.Text.Inline, depth+1)
	case *md.List:
		dumpBlocks(b.Items, depth+1)
	case *md.Item:
		dumpBlocks(b.Blocks, depth+1)
	default:

	return s[i+2 : j], s[:i]
}

func newSetextHeading(p *parseState, s line) (line, bool) {
	var n int
	peek := s
	if p.nextB() == p.para() && peek.trimSetext(&n) {
		p.closeBlock()
		para, ok := p.last().(*Paragraph)
		if !ok {
			return s, false
		}
		p.deleteLast()
		p.doneBlock(&Heading{Position{para.StartLine, p.lineno}, n, para.Text, ""})
		return line{}, true
	}
	return s, false
}

	case *md.Text:
		b.Inline = addSymbolLinksInlines(b.Inline, defaultPackage)
	case *md.List:
		addSymbolLinksBlocks(b.Items, defaultPackage)
	case *md.Item:
		addSymbolLinksBlocks(b.Blocks, defaultPackage)
	case *md.Paragraph:
		addSymbolLinksBlock(b.Text, defaultPackage)
	case *md.Quote:
		addSymbolLinksBlocks(b.Blocks, defaultPackage)
	// no links in these blocks
	case *md.CodeBlock:
	case *md.HTMLBlock:
	case *md.Empty:

		if !ok || decl.Body == nil {
			continue
		}
		if decl.Name.Name == "putvar" || decl.Name.Name == "putAbstractVar" {
			// construct the simplified CFG
			pvagraph, _ := pvacfgbody(t, &fset, cm, decl.Body.List)
			funcs[decl.Name.Name+"Abbrev"] = pvacfgvisit(pvagraph, abbrevs)
		}
	}
	abbrevslice := make([]string, len(abbrevs))
	for abbrev, n := range abbrevs {
		abbrevslice[n] = abbrev
	}

	buf := new(bytes.Buffer)