var nw JSONSchemaPropsOrBool
	switch {
	case len(data) == 0:
	case data[0] == '{':
		var sch JSONSchemaProps
		if err := json.Unmarshal(data, &sch); err != nil {
			return err
		}
		nw.Allows = true
		nw.Schema = &sch
	case len(data) == 4 && string(data) == "true":
		nw.Allows = true
	case len(data) == 5 && string(data) == "false":
		nw.Allows = false
	default:

	var nw JSONSchemaPropsOrBool
	switch {
	case len(data) == 0:
	case data[0] == '{':
		var sch JSONSchemaProps
		if err := json.Unmarshal(data, &sch); err != nil {
			return err
		}
		nw.Allows = true
		nw.Schema = &sch
	case len(data) == 4 && string(data) == "true":
		nw.Allows = true
	case len(data) == 5 && string(data) == "false":
		nw.Allows = false
	default:

				addressFunc     func(nw string) string
				targetPortFunc  func(nw string) int
				networkNameFunc func(nw string) string
			}{
				{
					name:            "with gateway address",
					addressFunc:     func(nw string) string { return gatewayAddresses[nw].ip },
					targetPortFunc:  func(nw string) int { return gatewayAddresses[nw].port },
					networkNameFunc: func(nw string) string { return "" },
				},
				{

const (
	north direction = iota
	ne
	east
	se
	south
	sw
	west
	nw
	up
	down
)

func (dir direction) String() string {
	strs := map[direction]string{
		north: "north",
		ne:    "ne",
		east:  "east",
		se:    "se",
		south: "south",
		sw:    "sw",
		west:  "west",
		nw:    "nw",
		up:    "up",
		down:  "down",
	}
	if str, ok := strs[dir]; ok {
		return str

		o.qty = uint32(chunkSize)
		o.o.Offset = uint32(curpos)
		o.o.OffsetHigh = uint32(curpos >> 32)

		nw, err := execIO(o, func(o *operation) error {
			return syscall.TransmitFile(o.fd.Sysfd, o.handle, o.qty, 0, &o.o, nil, syscall.TF_WRITE_BEHIND)
		})
		if err != nil {
			return written, err
		}

		curpos += int64(nw)

		// Some versions of Windows (Windows 10 1803) do not set
		// file position after TransmitFile completes.

// io.Writer.
func (stw *Writer) Write(w io.Writer) error {
	wr128 := func(v uint) error {
		stw.tmp = stw.tmp[:0]
		stw.tmp = uleb128.AppendUleb128(stw.tmp, v)
		if nw, err := w.Write(stw.tmp); err != nil {
			return fmt.Errorf("writing string table: %v", err)
		} else if nw != len(stw.tmp) {
			return fmt.Errorf("short write emitting stringtab uleb")
		}
		return nil
	}
	if err := wr128(uint(len(stw.strs))); err != nil {
		return err

			}
		}
	}

	wf := func(t *testing.T, ws *WriteSeeker, p []byte) {
		t.Helper()
		nw, werr := ws.Write(p)
		if werr != nil {
			t.Fatalf("unexpected write error: %v", werr)
		}
		if nw != len(p) {
			t.Fatalf("wrong amount written want %d got %d", len(p), nw)
		}
	}

	rf := func(t *testing.T, ws *WriteSeeker, p []byte) {
		t.Helper()
		b := make([]byte, len(p))

	sz := len(ws.BytesWritten())
	zeros := []byte{0, 0, 0, 0}
	rem := uint32(sz) % 4
	if rem != 0 {
		pad := zeros[:(4 - rem)]
		if nw, err := ws.Write(pad); err != nil {
			return err
		} else if nw != len(pad) {
			return fmt.Errorf("error: short write")
		}
	}
	return nil
}

func (cfw *CoverageDataWriter) patchSegmentHeader(ws *slicewriter.WriteSeeker) error {

func (npa *NodePortAddresses) GetNodeIPs(nw NetworkInterfacer) ([]net.IP, error) {
	addrs, err := nw.InterfaceAddrs()
	if err != nil {
		return nil, fmt.Errorf("error listing all interfaceAddrs from host, error: %v", err)
	}

	// Use a map to dedup matches
	addresses := make(map[string]net.IP)
	for _, cidr := range npa.cidrs {
		for _, addr := range addrs {
			var ip net.IP

		return 0, p.writeCloseError()
	default:
		p.wrMu.Lock()
		defer p.wrMu.Unlock()
	}

	for once := true; once || len(b) > 0; once = false {
		select {
		case p.wrCh <- b:
			nw := <-p.rdCh
			b = b[nw:]
			n += nw
		case <-p.done:
			return n, p.writeCloseError()
		}
	}
	return n, nil
}

func (p *pipe) closeWrite(err error) error {
	if err == nil {
		err = EOF
	}
	p.werr.Store(err)