func _() {
	// An "invalid array index" compiler error signifies that the constant values have changed.
	// Re-run the stringer command to generate them again.
	var x [1]struct{}
	_ = x[Sxxx-0]
	_ = x[STEXT-1]
	_ = x[SRODATA-2]
	_ = x[SNOPTRDATA-3]
	_ = x[SDATA-4]
	_ = x[SBSS-5]
	_ = x[SNOPTRBSS-6]
	_ = x[STLSBSS-7]
	_ = x[SDWARFCUINFO-8]
	_ = x[SDWARFCONST-9]
	_ = x[SDWARFFCN-10]
	_ = x[SDWARFABSFCN-11]
	_ = x[SDWARFTYPE-12]

DATA ·pow_x433<> + 0(SB)/8, $0x4330000000000000
GLOBL ·pow_x433<> + 0(SB), RODATA, $8
DATA ·pow_x43f<> + 0(SB)/8, $0x43f0000000000000
GLOBL ·pow_x43f<> + 0(SB), RODATA, $8
DATA ·pow_xadd<> + 0(SB)/8, $0xc2f0000100003fef
GLOBL ·pow_xadd<> + 0(SB), RODATA, $8
DATA ·pow_xa<> + 0(SB)/8, $0x4019000000000000
GLOBL ·pow_xa<> + 0(SB), RODATA, $8

// Scale correction tables
DATA powiadd<> + 0(SB)/8, $0xf000000000000000

	if len(msg) > 0 {
		fmt.Fprintf(os.Stderr, "error: %s\n", msg)
	}
	fmt.Fprintf(os.Stderr, "usage: go tool covdata %s -i=dir1,dir2 -o=<dir>\n\n", s.mode)
	flag.PrintDefaults()
	fmt.Fprintf(os.Stderr, "\nExamples:\n\n")
	op := "from"
	if s.mode == intersectMode {
		op = "with"
	}
	fmt.Fprintf(os.Stderr, "  go tool covdata %s -i=dir1,dir2 -o=outdir\n\n", s.mode)
	fmt.Fprintf(os.Stderr, "  \t%ss dir2 %s dir1, writing result\n", s.mode, op)

DATA ·cbrtrodataL9<> + 48(SB)/8, $1.000244140625
DATA ·cbrtrodataL9<> + 56(SB)/8, $0.33333333333333333333E+00
DATA ·cbrtrodataL9<> + 64(SB)/8, $79228162514264337593543950336.
GLOBL ·cbrtrodataL9<> + 0(SB), RODATA, $72

// Index tables
DATA ·cbrttab32069<> + 0(SB)/8, $0x404030303020202
DATA ·cbrttab32069<> + 8(SB)/8, $0x101010101000000
DATA ·cbrttab32069<> + 16(SB)/8, $0x808070706060605

                .assertStdout(containsString(
                    "< html allowed, cdata closing token ]]> encoded!\n" +
                    "no EOL, non-asci char: ż\n" +
                    "xml entity: &amp;"
                ))
                .assertStderr(equalTo("< html allowed, cdata closing token ]]> encoded!\n"))
    }

    String lineNumberOf(String text) {
        int i = 1

		writeErrorResponseJSON(ctx, w, errorCodes.ToAPIErr(apiErrCode), r.URL)
		return
	}

	cfgData := ""
	{
		tgtSuffix := ""
		if cfgTarget != madmin.Default {
			tgtSuffix = config.SubSystemSeparator + cfgTarget
		}
		cfgData = subSys + tgtSuffix + config.KvSpaceSeparator + string(reqBytes)
	}

	cfg, err := readServerConfig(ctx, objectAPI, nil)
	if err != nil {

  <expressions>
    <expression>
      <syntax>settings.offline</syntax>
      <configuration>
        <![CDATA[
    <offline>true</offline>
    ]]></configuration>
      <description>
        <![CDATA[
      Flags the system as offline, to prevent accessing the network to resolve artifacts or execute plugins.

		nptrs := ft.PtrBytes / goarch.PtrSize
		gcdata := ft.GcSlice(0, (nptrs+7)/8)
		for i := uintptr(0); i < nptrs; i++ {
			gc = append(gc, gcdata[i/8]>>(i%8)&1)
		}
	}
	return
}

func TypeLinks() []string {
	var r []string
	sections, offset := typelinks()
	for i, offs := range offset {
		rodata := sections[i]
		for _, off := range offs {
			typ := (*rtype)(resolveTypeOff(rodata, off))
			r = append(r, typ.String())
		}

      <description>
        <![CDATA[
        The {@code <dependency>} element contains information about a dependency
        of the project.
        ]]>
      </description>
      <fields>
        <field>
          <name>groupId</name>
          <version>3.0.0+</version>
          <required>true</required>
          <description>
            <![CDATA[

package main_test

import (
	cmdcovdata "cmd/covdata"
	"flag"
	"fmt"
	"internal/coverage/pods"
	"internal/goexperiment"
	"internal/testenv"
	"log"
	"os"
	"path/filepath"
	"regexp"
	"strconv"
	"strings"
	"sync"
	"testing"
)

// testcovdata returns the path to the unit test executable to be used as
// standin for 'go tool covdata'.
func testcovdata(t testing.TB) string {