my $funcname = "";
	if($sysname eq "") {
		$sysname = "SYS_$func";
		$sysname =~ s/([a-z])([A-Z])/${1}_$2/g;	# turn FooBar into Foo_Bar
		$sysname =~ y/a-z/A-Z/;
		if($libc) {
			$sysname =~ y/A-Z/a-z/;
			$sysname = substr $sysname, 4;
			$funcname = "libc_$sysname";
		}
	}
	if($libc) {
		if($funcname eq "") {
			$sysname = substr $sysname, 4;
			$sysname =~ y/A-Z/a-z/;

func Version() (string, error) {
	var uts unix.Utsname
	if err := unix.Uname(&uts); err != nil {
		return "", err
	}

	sysname := unix.ByteSliceToString(uts.Sysname[:])
	release := unix.ByteSliceToString(uts.Release[:])
	version := unix.ByteSliceToString(uts.Version[:])
	machine := unix.ByteSliceToString(uts.Machine[:])

	return sysname + " " + release + " " + version + " " + machine, nil

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package os

func hostname() (name string, err error) {
	f, err := Open("#c/sysname")
	if err != nil {
		return "", err
	}
	defer f.Close()

	var buf [128]byte
	n, err := f.Read(buf[:len(buf)-1])

	if err != nil {
		return "", err
	}
	if n > 0 {
		buf[n] = 0
	}

			$modname = "libc";
		}
		$modname .= ".so";

	}

	# System call name.
	if($sysname eq "") {
		$sysname = "$func";
	}

	# System call pointer variable name.
	my $sysvarname = "libc_${sysname}";

	my $strconvfunc = "BytePtrFromString";
	my $strconvtype = "*byte";

	$sysname =~ y/A-Z/a-z/; # All libc functions are lowercase.

	# Runtime import of function to allow cross-platform builds.

	if err != nil {
		// Utsname members on Dragonfly are only 32 bytes and
		// the syscall returns ENOMEM in case the actual value
		// is longer.
		if err == ENOMEM {
			err = nil
		}
	}
	return err
}

func Uname(uname *Utsname) error {
	mib := []_C_int{CTL_KERN, KERN_OSTYPE}
	n := unsafe.Sizeof(uname.Sysname)
	if err := sysctlUname(mib, &uname.Sysname[0], &n); err != nil {
		return err
	}

	Version uint8
	Type    uint8
	Addrs   int32
	Flags   int32
	Index   uint16
	Addrlen uint8
	_       [1]byte
}

type FdSet struct {
	Bits [2048]int32
}

type Utsname struct {
	Sysname  [32]byte
	Nodename [32]byte
	Release  [32]byte
	Version  [32]byte
	Machine  [32]byte
}

type Ustat_t struct{}

type Sigset_t struct {
	Losigs uint32
	Hisigs uint32
}

package unix

import (
	"runtime"
	"sync"
	"syscall"
	"unsafe"
)

//go:linkname procUname libc_uname

var procUname uintptr

// utsname represents the fields of a struct utsname defined in <sys/utsname.h>.
type utsname struct {
	Sysname  [257]byte
	Nodename [257]byte
	Release  [257]byte
	Version  [257]byte
	Machine  [257]byte
}

// KernelVersion returns major and minor kernel version numbers

type IfMsgHdr struct {
	Msglen    uint16
	Version   uint8
	Type      uint8
	Addrs     int32
	Flags     int32
	Index     uint16
	Addrlen   uint8
	Pad_cgo_0 [1]byte
}

type Utsname struct {
	Sysname  [32]uint8
	Nodename [32]uint8
	Release  [32]uint8
	Version  [32]uint8
	Machine  [32]uint8
}

const (
	_AT_FDCWD            = -0x2
	_AT_REMOVEDIR        = 0x1

	var value Ptmget
	err := ioctlPtr(fd, req, unsafe.Pointer(&value))
	return &value, err
}

func Uname(uname *Utsname) error {
	mib := []_C_int{CTL_KERN, KERN_OSTYPE}
	n := unsafe.Sizeof(uname.Sysname)
	if err := sysctl(mib, &uname.Sysname[0], &n, nil, 0); err != nil {
		return err
	}

	mib = []_C_int{CTL_KERN, KERN_HOSTNAME}
	n = unsafe.Sizeof(uname.Nodename)

	Version uint8
	Type    uint8
	Addrs   int32
	Flags   int32
	Index   uint16
	Addrlen uint8
	_       [1]byte
}

type FdSet struct {
	Bits [1024]int64
}

type Utsname struct {
	Sysname  [32]byte
	Nodename [32]byte
	Release  [32]byte
	Version  [32]byte
	Machine  [32]byte
}

type Ustat_t struct{}

type Sigset_t struct {
	Set [4]uint64
}

const (