// type parameter. Otherwise the result is nil. Errors are reported through the err parameter.
// Note: infer may fail (return nil) due to invalid args operands without reporting additional errors.
func (check *Checker) infer(posn positioner, tparams []*TypeParam, targs []Type, params *Tuple, args []*operand, reverse bool, err *error_) (inferred []Type) {
	// Don't verify result conditions if there's no error handler installed:

	{"net.inet.ipcomp.enable", []_C_int{4, 2, 108, 1}},
	{"net.inet.ipcomp.stats", []_C_int{4, 2, 108, 2}},
	{"net.inet.ipip.allow", []_C_int{4, 2, 4, 1}},
	{"net.inet.ipip.stats", []_C_int{4, 2, 4, 2}},
	{"net.inet.pfsync.stats", []_C_int{4, 2, 240, 1}},
	{"net.inet.tcp.ackonpush", []_C_int{4, 2, 6, 13}},
	{"net.inet.tcp.always_keepalive", []_C_int{4, 2, 6, 22}},
	{"net.inet.tcp.baddynamic", []_C_int{4, 2, 6, 6}},

	{"net.inet.ipcomp.enable", []_C_int{4, 2, 108, 1}},
	{"net.inet.ipcomp.stats", []_C_int{4, 2, 108, 2}},
	{"net.inet.ipip.allow", []_C_int{4, 2, 4, 1}},
	{"net.inet.ipip.stats", []_C_int{4, 2, 4, 2}},
	{"net.inet.pfsync.stats", []_C_int{4, 2, 240, 1}},
	{"net.inet.tcp.ackonpush", []_C_int{4, 2, 6, 13}},
	{"net.inet.tcp.always_keepalive", []_C_int{4, 2, 6, 22}},
	{"net.inet.tcp.baddynamic", []_C_int{4, 2, 6, 6}},

	{"net.inet.ipcomp.enable", []_C_int{4, 2, 108, 1}},
	{"net.inet.ipcomp.stats", []_C_int{4, 2, 108, 2}},
	{"net.inet.ipip.allow", []_C_int{4, 2, 4, 1}},
	{"net.inet.ipip.stats", []_C_int{4, 2, 4, 2}},
	{"net.inet.pfsync.stats", []_C_int{4, 2, 240, 1}},
	{"net.inet.tcp.ackonpush", []_C_int{4, 2, 6, 13}},
	{"net.inet.tcp.always_keepalive", []_C_int{4, 2, 6, 22}},
	{"net.inet.tcp.baddynamic", []_C_int{4, 2, 6, 6}},

	if faketime && (fd == 1 || fd == 2) {
		n = faketimeWrite(fd, p)
		if n < 0 {
			return 0, ErrorString("error")
		}
		return n, nil
	}

	return Pwrite(fd, p, -1)
}

var ioSync int64

//sys	fd2path(fd int, buf []byte) (err error)

func Fd2path(fd int) (path string, err error) {
	var buf [512]byte

	e := fd2path(fd, buf[:])
	if e != nil {
		return "", e
	}

		return err
	}

	return nil
}

func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
	if raceenabled {
		raceReleaseMerge(unsafe.Pointer(&ioSync))
	}
	return sendfile(outfd, infd, offset, count)
}

func Fstatvfs(fd int, buf *Statvfs_t) (err error) {
	return Fstatvfs1(fd, buf, ST_WAIT)
}

func Statvfs(path string, buf *Statvfs_t) (err error) {

		}
	}
	if err == nil {
		raceAcquire(unsafe.Pointer(&ioSync))
	}
}

func Writev(fd int, iovs [][]byte) (n int, err error) {
	iovecs := make([]Iovec, 0, minIovec)
	iovecs = appendBytes(iovecs, iovs)
	if raceenabled {
		raceReleaseMerge(unsafe.Pointer(&ioSync))
	}
	n, err = writev(fd, iovecs)
	writevRacedetect(iovecs, n)
	return n, err
}

	uname.Machine[unsafe.Sizeof(uname.Machine)-1] = 0

	return nil
}

func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
	if raceenabled {
		raceReleaseMerge(unsafe.Pointer(&ioSync))
	}
	return sendfile(outfd, infd, offset, count)
}

/*
 * Exposed directly
 */
//sys	Access(path string, mode uint32) (err error)
//sys	Adjtime(delta *Timeval, olddelta *Timeval) (err error)

	return
}

//sys	Getcwd(buf []byte) (n int, err error) = SYS___GETCWD

func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
	if raceenabled {
		raceReleaseMerge(unsafe.Pointer(&ioSync))
	}
	return sendfile(outfd, infd, offset, count)
}

// TODO
func sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) {
	return -1, ENOSYS
}

	err := readFile(fd, p, done, overlapped)
	if race.Enabled {
		if *done > 0 {
			race.WriteRange(unsafe.Pointer(&p[0]), int(*done))
		}
		race.Acquire(unsafe.Pointer(&ioSync))
	}
	if msan.Enabled && *done > 0 {
		msan.Write(unsafe.Pointer(&p[0]), uintptr(*done))
	}
	if asan.Enabled && *done > 0 {
		asan.Write(unsafe.Pointer(&p[0]), uintptr(*done))
	}
	return err
}