PLBZ 1234(R1), $0, R3                   // 06000000886104d260000000
	// Note, PLD crosses a 64B boundary, and a nop is inserted between PLBZ and PLD
	PLD 1234(R1), $0, R3                    // 04000000e46104d2
	PLFD 1234(R1), $0, F3                   // 06000000c86104d2
	PLFS 1234567890(R4), $0, F3             // 06004996c06402d2
	PLFS 1234567890(R0), $1, F3             // 06104996c06002d2

	"PMXVBF16GER2PN",
	"PMXVBF16GER2NP",
	"PMXVBF16GER2NN",
	"PMXVBF16GER2",
	"PLXVP",
	"PLXV",
	"PLXSSP",
	"PLXSD",
	"PLWZ",
	"PLWA",
	"PLQ",
	"PLHZ",
	"PLHA",
	"PLFS",
	"PLFD",
	"PLD",
	"PLBZ",
	"PADDI",
}

var GenOpcodes = [...]uint32{
	0x7c030162, // AXXSETACCZ
	0x7c010162, // AXXMTACC
	0x7c000162, // AXXMFACC
	0xf0000768, // AXXGENPCVWM

	MTVSRQM:        "mtvsrqm",
	MTVSRWM:        "mtvsrwm",
	PADDI:          "paddi",
	PDEPD:          "pdepd",
	PEXTD:          "pextd",
	PLBZ:           "plbz",
	PLD:            "pld",
	PLFD:           "plfd",
	PLFS:           "plfs",
	PLHA:           "plha",
	PLHZ:           "plhz",
	PLQ:            "plq",
	PLWA:           "plwa",
	PLWZ:           "plwz",
	PLXSD:          "plxsd",

	ld	29, -168(1)
	ld	30, -160(1)
	ld	31, -152(1)
	lfd	14, -144(1)
	lfd	15, -136(1)
	lfd	16, -128(1)
	lfd	17, -120(1)
	lfd	18, -112(1)
	lfd	19, -104(1)
	lfd	20, -96(1)
	lfd	21, -88(1)
	lfd	22, -80(1)
	lfd	23, -72(1)
	lfd	24, -64(1)
	lfd	25, -56(1)
	lfd	26, -48(1)
	lfd	27, -40(1)
	lfd	28, -32(1)
	lfd	29, -24(1)
	lfd	30, -16(1)
	lfd	31, -8(1)

	return fd.pfd.SetDeadline(t)
}

func (fd *netFD) SetReadDeadline(t time.Time) error {
	return fd.pfd.SetReadDeadline(t)
}

func (fd *netFD) SetWriteDeadline(t time.Time) error {
	return fd.pfd.SetWriteDeadline(t)

	if err != nil {
		return nil, err
	}
	net, err := fileListenNet(filetype)
	if err != nil {
		return nil, err
	}
	pfd := f.PollFD().Copy()
	fd := newPollFD(net, pfd)
	if err := fd.init(); err != nil {
		pfd.Close()
		return nil, err
	}
	return newFileListener(fd), nil
}

func fileConn(f *os.File) (Conn, error) {
	filetype, err := fd_fdstat_get_type(f.PollFD().Sysfd)

			return nil, nil
		}
		fallthrough
	default:
		return nil, os.NewSyscallError("connect", err)
	}
	if err := fd.pfd.Init(fd.net, true); err != nil {
		return nil, err
	}
	if deadline, hasDeadline := ctx.Deadline(); hasDeadline {
		fd.pfd.SetWriteDeadline(deadline)
		defer fd.pfd.SetWriteDeadline(noDeadline)
	}

	// Start the "interrupter" goroutine, if this context might be canceled.
	//

	}

	if d == 0 {
		d = defaultTCPKeepAliveIdle
	} else if d < 0 {
		return nil
	}
	// The kernel expects seconds so round to next highest second.
	secs := int(roundDurationUp(d, time.Second))
	err := fd.pfd.SetsockoptInt(syscall.IPPROTO_TCP, sysTCP_KEEPIDLE, secs)
	runtime.KeepAlive(fd)
	return wrapSyscallError("setsockopt", err)
}

func setKeepAliveInterval(fd *netFD, d time.Duration) error {

	pfd, network := getPollFDAndNetwork(w)
	// TODO(panjf2000): same as File.spliceToFile.
	if pfd == nil || !pfd.IsStream || !isUnixOrTCP(string(network)) {
		return
	}

	sc, err := f.SyscallConn()
	if err != nil {
		return
	}

	rerr := sc.Read(func(fd uintptr) (done bool) {
		written, err, handled = poll.SendFile(pfd, int(fd), 1<<63-1)
		return true
	})

	case "udp":
		laddr = new(UDPAddr)
		raddr = new(UDPAddr)
	default:
		laddr = unknownAddr{}
		raddr = unknownAddr{}
	}
	return &netFD{
		pfd:   pfd,
		net:   net,
		laddr: laddr,
		raddr: raddr,
	}
}

func (fd *netFD) init() error {
	return fd.pfd.Init(fd.net, true)
}

func (fd *netFD) name() string {
	return "unknown"
}

func (fd *netFD) accept() (netfd *netFD, err error) {