padding-left: 1em
}

.toc-inlined {
    padding-bottom: 1em
}

.toc-inlined .directory {
    border-left: 0
}

.toc-inlined .directory li {
    font-size: 1rem
}

.toc-inlined .directory ul {
    list-style-type: none !important;
    padding-left: 0;
    padding-bottom: 0;
    margin: 0
}

.toc-inlined .directory ul ul {
    padding-left: 1em
}

    const LayoutOptimizationPipelineOptions& options);

struct StandardPipelineOptions
    : public PassPipelineOptions<StandardPipelineOptions> {
  Option<bool> enable_inliner{*this, "enable-inliner",
                              llvm::cl::desc("Enable inliner."),
                              llvm::cl::init(false)};
  Option<bool> form_clusters{*this, "form-clusters",
                             llvm::cl::desc("Enable Cluster Formation pass."),

	return ok
}

// InlineData returns true if object contents are inlined alongside its metadata.
func (fi FileInfo) InlineData() bool {
	_, ok := fi.Metadata[ReservedMetadataPrefixLower+"inline-data"]
	// Earlier MinIO versions didn't reset "x-minio-internal-inline-data"
	// from fi.Metadata when the object was tiered. So, tiered objects

}

type Text struct {
	Position
	Inline []Inline
	raw    string
}

func (b *Text) PrintHTML(buf *bytes.Buffer) {
	for _, x := range b.Inline {
		x.PrintHTML(buf)
	}
}

func (b *Text) printMarkdown(buf *bytes.Buffer, s mdState) {
	if s.prefix1 != "" {
		buf.WriteString(s.prefix1)
	} else {
		buf.WriteString(s.prefix)
	}
	var prev Inline
	for _, x := range b.Inline {

	ls := s.(*LSym)
	return ls.Size
}

// Here "from" is a symbol corresponding to an inlined or concrete
// function, "to" is the symbol for the corresponding abstract
// function, and "dclIdx" is the index of the symbol of interest with
// respect to the Dcl slice of the original pre-optimization version
// of the inlined function.
func (c dwCtxt) RecordDclReference(from dwarf.Sym, to dwarf.Sym, dclIdx int, inlIndex int) {

online.help.name.relatedquery=relatedquery
online.help.name.relatedcontent=relatedcontent
online.help.name.wizard=wizard
online.help.name.badword=badword
online.help.name.pathmap=pathmap
online.help.name.boostdoc=boostdoc
online.help.name.dataconfig=dataconfig
online.help.name.systeminfo=systeminfo
online.help.name.user=user
online.help.name.group=group
online.help.name.design=design
online.help.name.dashboard=dashboard

				name, ok := originDIE.Val(dwarf.AttrName).(string)
				if !ok {
					t.Fatalf("no name attr for inlined subroutine at offset %v", child.Offset)
				}
				if name != "main.inlined" {
					t.Fatalf("expected inlined routine %s got %s", "main.cand", name)
				}

				// Verify that the call_file attribute for the inlined
				// instance is ok. In this case it should match the file

			e.Residual = true
		}
		if !inline {
			e.Inline = false
		}
		return
	}

	info := &Edge{Src: n, Dest: to, WeightDiv: dv, Weight: v, Residual: residual, Inline: inline}
	n.Out.Add(info)
	to.In.Add(info)
}

// NodeInfo contains the attributes for a node.
type NodeInfo struct {
	Name              string
	Address           uint64
	StartLine, Lineno int
}

			// Note: entry is not modified. It always refers to a real frame, not an inlined one.
			// File/line from funcline1 below are already correct.
			f = nil

			// When CallersFrame is invoked using the PC list returned by Callers,
			// the PC list includes virtual PCs corresponding to each outer frame
			// around an innermost real inlined PC.
			// We also want to support code passing in a PC list extracted from a

// value indicates whether the append occurred.
func (h *nextHist) add(file, line, text string) bool {
	// Only record source code in testdata unless the inlines flag is set
	if !*inlines && !strings.Contains(file, "/testdata/") {
		return false
	}
	fi := h.f2i[file]
	if fi == 0 {
		h.fs = append(h.fs, file)
		fi = uint8(len(h.fs))
		h.f2i[file] = fi
	}