b := dst.AvailableBuffer()
	b, err := appendCompact(b, src, false)
	dst.Write(b)
	return err
}

func appendCompact(dst, src []byte, escape bool) ([]byte, error) {
	origLen := len(dst)
	scan := newScanner()
	defer freeScanner(scan)
	start := 0
	for i, c := range src {
		if escape && (c == '<' || c == '>' || c == '&') {
			if start < i {
				dst = append(dst, src[start:i]...)
			}

	cpuMHz := ""

	// The 512-byte buffer is enough to hold the contents of CPU0
	buf := make([]byte, 512)
	err := readLinuxProcCPUInfo(buf)
	if err != nil {
		return ""
	}

	scanner := bufio.NewScanner(bytes.NewReader(buf))
	for scanner.Scan() {
		key, value, found := strings.Cut(scanner.Text(), ": ")
		if !found {
			continue
		}
		switch strings.TrimSpace(key) {
		case "Model Name", "model name":

	if err != nil {
		log.Fatal(err)
	}
	fd, err := os.Create(*output)
	if err != nil {
		log.Fatal(err)
	}
	out := bufio.NewWriter(fd)
	defer out.Flush()
	var on = false
	s := bufio.NewScanner(in)
	first := true
	for s.Scan() {
		line := s.Text()
		if !on {
			// First relevant line contains "= obj.ABase".
			// If we find it, delete the = so we don't stop immediately.
			const prefix = "= obj.ABase"

}

// FromSerialized parses a profile from serialization output of Profile.WriteTo.
func FromSerialized(r io.Reader) (*Profile, error) {
	d := emptyProfile()

	scanner := bufio.NewScanner(r)
	scanner.Split(bufio.ScanLines)

	if !scanner.Scan() {
		if err := scanner.Err(); err != nil {
			return nil, fmt.Errorf("error reading preprocessed profile: %w", err)
		}

	// We are either getting iptables rules as a `stdin` blob in `iptables-save` format (if this is a restore)
	if stdin != nil {
		buf := bufio.NewScanner(stdin)
		for buf.Scan() {
			stdincmd := buf.Text()
			s.ExecutedAll = append(s.ExecutedAll, stdincmd)
			s.ExecutedStdin = append(s.ExecutedStdin, stdincmd)
		}
	} else {
		// ...or as discrete individual commands

	}
	return nil
}

// ParseExpectation parses the serialized form of an Expectation.
func ParseExpectation(data []byte) (*Expectation, error) {
	exp := new(Expectation)
	s := bufio.NewScanner(bytes.NewReader(data))
	if s.Scan() {
		c := strings.SplitN(s.Text(), " ", 2)
		switch c[0] {
		case "SUCCESS":
		case "FAILURE":
			exp.failure = true
			if len(c) != 2 {

	}

	bf := bytes.Buffer{}

	save := func(s string) {
		bf.WriteString(s + "\n")
	}
	reset := func() {
		bf.Reset()
	}

	ret := make(map[time.Duration][]string)

	s := bufio.NewScanner(f)
	s.Split(bufio.ScanLines)

	var (
		t            time.Duration
		skip, record bool
	)

	for s.Scan() {
		line := s.Text()
		switch {
		case skip && line != "":
		case skip && line == "":

	// this is an inlining reporting test, not an optimization test.  -N makes it less fragile
	dumpBytes := compileAndDump(t, file, function, "-N")
	dump := bufio.NewScanner(bytes.NewReader(dumpBytes))
	dumpLineNum := 0
	var gotStmts []int
	var gotStacks [][]int
	for dump.Scan() {
		line := dump.Text()
		dumpLineNum++
		matches := inlineLine.FindStringSubmatch(line)

	regSkip := regexp.MustCompile(patternSkip)

	fileInput, err := os.ReadFile(e2eFile)
	if err != nil {
		return fmt.Errorf("Failed to read file %s: %w", e2eFile, err)
	}
	scanner := bufio.NewScanner(bytes.NewReader(fileInput))
	scanner.Split(bufio.ScanLines)

	for scanner.Scan() {
		line := scanner.Text()
		if regStartConformance.MatchString(line) {
			if inConformanceCode {

	names map[string]event.Type
	s     *bufio.Scanner
}

// NewTextReader creates a new reader for the trace text format.
func NewTextReader(r io.Reader) (*TextReader, error) {
	tr := &TextReader{s: bufio.NewScanner(r)}
	line, err := tr.nextLine()
	if err != nil {
		return nil, err
	}
	trace, line := readToken(line)
	if trace != "Trace" {
		return nil, fmt.Errorf("failed to parse header")
	}