AddShapeLegalizationPasses(pm);
  pm.addNestedPass<func::FuncOp>(
      CreateConvertCustomAggregationOpToQuantStatsPass());
  pm.addPass(createQuantizeCompositeFunctionsPass(options));
  // Add an inliner pass to inline quantized StableHLO functions.
  pm.addPass(createInlinerPass());
  if (pipeline_config.unpack_quantized_types()) {
    AddStablehloQuantToIntPasses(pm);
  }
}

void AddWeightOnlyQuantizationPasses(

	startLine int32 // line number of start of function (func keyword/TEXT directive)
}

// An inlineUnwinder iterates over the stack of inlined calls at a PC by
// decoding the inline table. The last step of iteration is always the frame of
// the physical function, so there's always at least one frame.
//
// This is typically used as:
//

Xiaopeng Han <******@****.***> 1686841337 +0800

// pcBuf and dst should not overlap.
//
// fpunwindExpand checks if pcBuf contains logical frames (which include inlined
// frames) or physical frames (produced by frame pointer unwinding) using a
// sentinel value in pcBuf[0]. Logical frames are simply returned without the
// sentinel. Physical frames are turned into logical frames via inline unwinding
// and by applying the skip value that's stored in pcBuf[0].

}

type H struct {
	A A `json:"ha"`
	C `json:",inline"`
}

type I struct {
	A A `json:"ia"`
	H `json:",inline"`

	UL1 UnknownLevel1 `json:"ul1"`
}

type UnknownLevel1 struct {
	A          int64 `json:"a"`
	InlinedAA  `json:",inline"`
	InlinedAAA `json:",inline"`
}
type InlinedAA struct {
	AA int64 `json:"aa"`
}
type InlinedAAA struct {

    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) {