rw.WriteHeader(http.StatusOK)

	conn, brw, err := hj.Hijack()
	if err != nil {
		h.t.Logf("Failed to hijack client connection, host=%s: %v", req.Host, err)
		return
	}
	defer conn.Close()

	if err := brw.Flush(); err != nil {
		h.t.Logf("Failed to flush pending writes to client, host=%s: %v", req.Host, err)
		return
	}
	if _, err := io.Copy(sconn, io.LimitReader(brw, int64(brw.Reader.Buffered()))); err != nil {

	res.Header = rw.Header()
	res.Body = nil // so res.Write only writes the headers; we have res.Body in backConn above
	if err := res.Write(brw); err != nil {
		p.getErrorHandler()(rw, req, fmt.Errorf("response write: %v", err))
		return
	}
	if err := brw.Flush(); err != nil {
		p.getErrorHandler()(rw, req, fmt.Errorf("response flush: %v", err))
		return
	}
	errc := make(chan error, 1)

// POWER10/ISA 3.1.

#include "../../../../../runtime/textflag.h"

TEXT asmtest(SB), DUPOK|NOSPLIT, $0
	BRD R1, R2                              // 7c220176
	BRH R1, R2                              // 7c2201b6
	BRW R1, R2                              // 7c220136
	CFUGED R1, R2, R3                       // 7c2311b8
	CNTLZDM R2, R3, R1                      // 7c411876
	CNTTZDM R2, R3, R1                      // 7c411c76

	// ppc64x/power10: "BRD"
	return bits.ReverseBytes64(n)
}

func ReverseBytes32(n uint32) uint32 {
	// amd64:"BSWAPL"
	// 386:"BSWAPL"
	// s390x:"MOVWBR"
	// arm64:"REVW"
	// ppc64x/power10: "BRW"
	return bits.ReverseBytes32(n)
}

func ReverseBytes16(n uint16) uint16 {
	// amd64:"ROLW"
	// arm64:"REV16W",-"UBFX",-"ORR"
	// arm/5:"SLL","SRL","ORR"
	// arm/6:"REV16"
	// arm/7:"REV16"

	"MTVSRDM",
	"MTVSRBMI",
	"MTVSRBM",
	"LXVRWX",
	"LXVRHX",
	"LXVRDX",
	"LXVRBX",
	"LXVPX",
	"LXVP",
	"LXVKQ",
	"DCTFIXQQ",
	"DCFFIXQQ",
	"CNTTZDM",
	"CNTLZDM",
	"CFUGED",
	"BRW",
	"BRH",
	"BRD",
	"HASHSTP",
	"HASHST",
	"HASHCHKP",
	"HASHCHK",
	"XXSPLTIW",
	"XXSPLTIDP",
	"XXSPLTI32DX",
	"XXPERMX",
	"XXEVAL",
	"XXBLENDVW",
	"XXBLENDVH",
	"XXBLENDVD",

		{name: "BRD", argLength: 1, reg: gp11, asm: "BRD"},                                              // reversebytes64(arg0)
		{name: "BRW", argLength: 1, reg: gp11, asm: "BRW"},                                              // reversebytes32(arg0)
		{name: "BRH", argLength: 1, reg: gp11, asm: "BRH"},                                              // reversebytes16(arg0)

			w.WriteHeader(500)
			return
		}
		nc, brw, err := w.(Hijacker).Hijack()
		if err != nil {
			t.Error(err)
			return
		}
		defer nc.Close()
		nc.Write([]byte("HTTP/1.1 200 OK\r\n\r\n"))
		// Switch to a little protocol that capitalize its input lines:
		for {
			line, err := brw.ReadString('\n')
			if err != nil {
				if err != io.EOF {
					t.Error(err)

var opstr = [...]string{
	HASHCHK:        "hashchk",
	HASHCHKP:       "hashchkp",
	HASHST:         "hashst",
	HASHSTP:        "hashstp",
	BRD:            "brd",
	BRH:            "brh",
	BRW:            "brw",
	CFUGED:         "cfuged",
	CNTLZDM:        "cntlzdm",
	CNTTZDM:        "cnttzdm",
	DCFFIXQQ:       "dcffixqq",
	DCTFIXQQ:       "dctfixqq",
	LXVKQ:          "lxvkq",
	LXVP:           "lxvp",

	return false
}
func rewriteValuePPC64_OpBswap32(v *Value) bool {
	v_0 := v.Args[0]
	b := v.Block
	typ := &b.Func.Config.Types
	// match: (Bswap32 x)
	// cond: buildcfg.GOPPC64>=10
	// result: (BRW x)
	for {
		x := v_0
		if !(buildcfg.GOPPC64 >= 10) {
			break
		}
		v.reset(OpPPC64BRW)
		v.AddArg(x)
		return true
	}
	// match: (Bswap32 x:(MOVWZload [off] {sym} ptr mem))

			},
			outputs: []outputInfo{
				{0, 1073733624}, // R3 R4 R5 R6 R7 R8 R9 R10 R11 R12 R14 R15 R16 R17 R18 R19 R20 R21 R22 R23 R24 R25 R26 R27 R28 R29
			},
		},
	},
	{
		name:   "BRW",
		argLen: 1,
		asm:    ppc64.ABRW,
		reg: regInfo{
			inputs: []inputInfo{
				{0, 1073733630}, // SP SB R3 R4 R5 R6 R7 R8 R9 R10 R11 R12 R14 R15 R16 R17 R18 R19 R20 R21 R22 R23 R24 R25 R26 R27 R28 R29