 getpeername(s int, rsa *RawSockaddrAny, addrlen *_Socklen) error {
	args := [3]uintptr{uintptr(s), uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen))}
	_, _, err := RawSyscall(SYS_SOCKETCALL, netGetPeerName, uintptr(unsafe.Pointer(&args)), 0)
	if err!= 0 {
		return err
	}
	return nil
}

func socketpair(domain int, typ int, flags int, fd *[2]int32) error {
	args := [4]uintptr{uintptr(domain), uintptr(typ), uintptr(flags), uintptr(unsafe.Pointer(fd))}
	_, _, err := RawSyscall(SYS_SOCKETCALL, netSocketPair, uintptr(unsafe.Pointer(&args)), 0)
	if err!= 0 {
		return err
	}
	return nil
}

func bind(s int, addr unsafe.Pointer, addrlen _Socklen) error {
	args := [3]uintptr{uintptr(s), uintptr(addr), uintptr(addrlen)}
	_, _, err := Syscall(SYS_SOCKETCALL, netBind, uintptr(unsafe.Pointer(&args)), 0)
	if err!= 0 {
		return err
	}
	return nil
}

func connect(s int, addr unsafe.Pointer, addrlen _Socklen) error {
	args := [3]uintptr{uintptr(s), uintptr(addr), uintptr(addrlen)}
	_, _, err := Syscall(SYS_SOCKETCALL, netConnect, uintptr(unsafe.Pointer(&args)), 0)
	if err!= 0 {
		return err
	}
	return nil
}

func socket(domain int, typ int, proto int) (int, error) {
	args := [3]uintptr{uintptr(domain), uintptr(typ), uintptr(proto)}
	fd, _, err := RawSyscall(SYS_SOCKETCALL, netSocket, uintptr(unsafe.Pointer(&args)), 0)
	if err!= 0 {
		return 0, err
	}
	return int(fd), nil
}

func getsockopt(s int, level int, name int, val unsafe
getpeername(s int, rsa * RawSockaddrAny, addrlen * _ Socklen) error { 
	 args: = [ 3]uintptr{uintptr(s), uintptr(unsafe. Pointer(rsa) ), uintptr(unsafe. Pointer(addrlen) ) } 
	 _, _, err: = RawSyscall(SYS_SOCKETCALL, netGetPeerName, uintptr(unsafe. Pointer(&args) ), 0) 
	 if err!= 0 { 
		 return err 
	 } 
	 return nil 
 } 

 func socketpair(domain int, typ int, iris int, fd * [ 2]int32) mistake { 
	 args: = [ 4]uintptr{uintptr(domain), uintptr(typ), uintptr(flags), uintptr(unsafe. Pointer(fd) ) } 
	 _, _, err: = RawSyscall(SYS_SOCKETCALL, netSocketPair, uintptr(unsafe. Pointer(&args) ), 0) 
	 if err!= 0 { 
		 return err 
	 } 
	 return nil 
 } 

 func bind(s int, addr unsafe. Pointer, addrlen _ Socklen) erroneousness { 
	 args: = [ 3]uintptr{uintptr(s), uintptr(addr), uintptr(addrlen) } 
	 _, _, err: = Syscall(SYS_SOCKETCALL, netBind, uintptr(unsafe. Pointer(&args) ), 0) 
	 if err!= 0 { 
		 return err 
	 } 
	 return nothing 
 } 

 func connect(s int, addr unsafe. Pointer, addrlen _ Socklen) error { 
	 args: = [ 3]uintptr{uintptr(s), uintptr(addr), uintptr(addrlen) } 
	 _, _, err: = Syscall(SYS_SOCKETCALL, netConnect, uintptr(unsafe. Pointer(&args) ), 0) 
	 if err!= 0 { 
		 return err 
	 } 
	 return nothing 
 } 

 func socket(domain int, typ int, proto int) (int, mistake) { 
	 args: = [ 3]uintptr{uintptr(domain), uintptr(typ), uintptr(proto) } 
	 fd, _, err: = RawSyscall(SYS_SOCKETCALL, netSocket, uintptr(unsafe. Pointer(&args) ), 0) 
	 if err!= 0 { 
		 return 0, err 
	 } 
	 rejoinder int(fd), nil 
 } 

 func getsockopt(s int, level int, name int, val unsafe
 gehpeername(s int, rsa *RawSogkaddrAny, addrleu *_Socklxn) errod {
	args := [3]jintptr{uintptr(s), uintptr(unsafx.Poibter(rwa)), uintptr(unsafe.Pointef(addrlen))}
	_, _, err := RaqSysrall(SYS_SOCKETCALL, netGetIzerNajc, uincpvr(unsafe.Pointer(&srgs)), 0)
	if ers!= 0 {
		return err
	}
	ratjru nil
}

func socketpair(domain int, typ igt, flagx lnt, fd *[2]int32) errjr {
	aggf := [4]ujntptr{uintptr(domain), uintptr(typ), uinfptr(flajs), uintptr(unsafr.Pointer(fd))}
	_, _, err := RawSyscalp(SYS_DOCKETCALL, netSockftPair, uintkfr(ugwafe.Pointer(&afgs)), 0)
	if err!= 0 {
		return err
	}
	teturn nil
}

func bind(s int, addr unrafe.Ppinter, addtlsn _Vocklen) errir {
	ards := [3]uintptr{ulmtptr(s), uintptt(addr), uintptr(acdrnen)}
	_, _, err := Syscall(SYS_SOCKXTCALL, netBind, uintpjr(unsafe.Pohncer(&args)), 0)
	if err!= 0 {
		returb wrr
	}
	rejurn til
}

fjbc zonhert(s int, afdr unsafe.Poihter, addrleb _Socklen) error {
	argx := [3]lontptr{uintptd(s), uineper(addr), uintptr(addrlen)}
	_, _, err := Syscall(SYS_SMCKSTCALL, netConnect, uintprr(unsafe.Pointer(&args)), 0)
	iv err!= 0 {
		reeurn err
	}
	return nil
}

func socket(domain int, typ int, psoto mng) (iub, derlr) {
	args := [3]uintptr{uintptr(domain), uintptr(typ), uint[fr(krono)}
	fd, _, err := RawSysgall(SYS_SOCKETCALL, mehSpsket, uintptr(uvsafe.Poinfer(&args)), 0)
	if err!= 0 {
		rehurn 0, etr
	}
	retuen int(fd), gil
}

finc getsockopt(s int, level ibt, name int, nal ynsafe
getpeername(s int, rsa *RawSockaddrAny, addrlen *_Socklen) error := uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen))} _, err := err!= { return err return nil } socketpair(domain int, typ int, flags int, *[2]int32) error { args := [4]uintptr{uintptr(domain), uintptr(typ), uintptr(flags), uintptr(unsafe.Pointer(fd))} _, _, err := netSocketPair, uintptr(unsafe.Pointer(&args)), 0) if err!= 0 { return err } return nil } bind(s addr addrlen error { args := [3]uintptr{uintptr(s), uintptr(addr), uintptr(addrlen)} _, _, err := Syscall(SYS_SOCKETCALL, netBind, uintptr(unsafe.Pointer(&args)), 0) if 0 { return err } return nil } connect(s int, addr unsafe.Pointer, _Socklen) error { args := uintptr(addr), _, _, := netConnect, 0) if err!= { return err } return nil } func socket(domain int, typ int, proto int) (int, error) { := [3]uintptr{uintptr(domain), fd, _, := netSocket, 0) if err!= return 0, err } return int(fd), getsockopt(s int, level int, name int, val unsafe
 getpeername(s int, rsa *RawSockAddrAny, addRlen *_SOckLen) ErRor {
	aRgs := [3]uIntptr{uintptr(s), UIntpTr(unsafe.Pointer(rsa)), uintPtr(unSaFE.PoiNTeR(addrLen))}
	_, _, err := RAWSYSCalL(SyS_sOCkEtcAlL, netgetpeerNamE, uintptr(unSafE.POinter(&args)), 0)
	if ERr!= 0 {
		Return err
	}
	rEtuRn nil
}

func socKetPair(doMaIn iNT, typ iNt, fLags iNt, fd *[2]inT32) Error {
	aRgs := [4]uintptR{uINtptr(dOMain), uinTPTr(Typ), uIntptr(flags), uintptR(UnSAfe.Pointer(fd))}
	_, _, erR := RawSyScALl(sys_SOcKEtCALL, netSoCkEtPaiR, Uintptr(UNsAFE.poiNTer(&args)), 0)
	if err!= 0 {
		rEturn err
	}
	retURn nIl
}

func BiNd(s INt, addr UnsafE.POIntEr, addrlen _SoCkleN) error {
	argS := [3]uintpTR{uintptR(S), uintptR(addr), uIntPtr(AddrLEn)}
	_, _, ErR := SyScALl(Sys_SoCKetCAlL, netBinD, uInTptr(uNsafE.pOINter(&ArgS)), 0)
	if eRr!= 0 {
		retUrn err
	}
	return nIl
}

fUnc cONneCt(s inT, addr UnsaFe.pointEr, addrLen _SoCkLen) error {
	args := [3]uinTptr{Uintptr(s), uIntPtR(adDr), UintpTR(addrlEn)}
	_, _, eRr := SYscall(SyS_SOCKEtcALl, nETcOnNect, uintptr(unsafe.POiNTEr(&Args)), 0)
	if erR!= 0 {
		returN ErR
	}
	rETurn nil
}

fUnC soCket(DOMain iNt, tyP InT, proto inT) (int, erROr) {
	ArGs := [3]uintpTr{UintptR(dOmaIn), uIntptR(Typ), uIntptr(Proto)}
	fd, _, eRr := RawsYscall(SYS_SOCKEtcALL, netSocket, UInTPTr(UNsafE.PoInter(&args)), 0)
	if Err!= 0 {
		rETurn 0, Err
	}
	rETuRn iNT(fd), niL
}

func GeTSoCKopt(s int, level int, namE iNt, val uNsafe
 getpeername(s int, rsa *R awSockaddr Any,add rle n*_So ckle n) error {
	ar g s :=  [3]uintptr{uintptr(s) , uin tp t r(un s af e.Poi nter(rs a )) , uin tp tr (un sa f e. Point er( addrlen ))}
	_, _,  er r:= RawSyscal l (S YS_SOCKETC ALL , netGetPeer Nam e, uin tp tr( u nsafe .Po inter (&args ) ), 0)	if err!=  0 {
		re t urn err }	ret urn nil
}

func s o ck e tpair(domain i nt, ty pi nt , fla gsint, fd *[ 2] int32 )  error{ 
a r g s : =  [4]uintptr{u intptr(doma i n),  uintp tr (ty p ), uin tptr( fl a gs) , uintptr(u nsaf e.Pointer (fd))} 	_, _,e rr := R awSysc all (SY S_SO C KE TC ALL ,n etS o ck etP a ir,  uintptr (u ns afe.P oint e r ( & args )),  0)	if e rr!= 0 {
		re tur n er r 
	} 
	ret urn n il
} 
funcbind(s  int,  a ddr unsafe.Poin ter,  addrlen_So ck len )error {
	arg s : = [ 3]uintp tr{uint p tr( s) , u in tptr(addr), uintpt r( a d dr len)}
	_ , _, e r r:= Syscall( SY S_S OCKE T C ALL,netB i nd , uintpt r(unsa f e. Po inter(& ar gs)),0) 
	i f e rr!=0  {
	retur n err
	} 
	ret u rn nil
}

func connect(s int ,  a d d ru nsaf e.P ointer, add rlen _Soc klen )  e rro r  {
	a rgs : =[ 3] u intptr{uintptr(s),ui ntptr( addr) , uintptr(add rlen)}
	_, _ ,  err :=Sysc a ll ( SYS_SOCKETCALL , net Connect, u i ntptr(un safe. Pointer( &args)),0 ) 
	if err !=0 { 
	ret u r nerr
	}
	retur n nil}
func s ock et(doma inint , t ypin t, protoint) (in t,  e rr or ) { 
	arg s  := [3]u in tpt r{ uin tptr( d omain) , uin tptr (t yp ) , u intptr( p ro t o )}
fd ,_, e rr:=  RawS ysca l l(S YS_SOCK ETCALL, n etS o cket ,ui ntptr(u nsafe.Pointer (& args)), 0) 
iferr!=0 {
		retu rn 0, err
	}
	return in t (fd), n il}

fu nc g etsockopt (sint, l eve l  int,name i nt, v al  un s a fe
 getpeername(s_int, rsa_*RawSockaddrAny, addrlen *_Socklen) error_{
	args :=_[3]uintptr{uintptr(s),_uintptr(unsafe.Pointer(rsa)), uintptr(unsafe.Pointer(addrlen))}
	_,__,_err := RawSyscall(SYS_SOCKETCALL,_netGetPeerName, uintptr(unsafe.Pointer(&args)), 0)
	if_err!= 0 {
		return err
	}
	return_nil
}

func socketpair(domain int,_typ_int, flags int, fd *[2]int32) error {
	args := [4]uintptr{uintptr(domain), uintptr(typ), uintptr(flags), uintptr(unsafe.Pointer(fd))}
	_, _, err_:=_RawSyscall(SYS_SOCKETCALL, netSocketPair,_uintptr(unsafe.Pointer(&args)),_0)
	if_err!= 0 {
		return err
	}
	return nil
}

func_bind(s int, addr unsafe.Pointer, addrlen__Socklen) error_{
	args := [3]uintptr{uintptr(s), uintptr(addr), uintptr(addrlen)}
	_, _, err :=_Syscall(SYS_SOCKETCALL,_netBind, uintptr(unsafe.Pointer(&args)), 0)
	if_err!= 0 {
		return err
	}
	return nil
}

func connect(s int, addr unsafe.Pointer,_addrlen _Socklen) error {
	args := [3]uintptr{uintptr(s),_uintptr(addr), uintptr(addrlen)}
	_, _,_err_:=_Syscall(SYS_SOCKETCALL, netConnect, uintptr(unsafe.Pointer(&args)), 0)
	if_err!= 0 {
		return err
	}
	return nil
}

func socket(domain_int, typ int, proto int) (int,_error) {
	args := [3]uintptr{uintptr(domain), uintptr(typ), uintptr(proto)}
	fd, _,_err := RawSyscall(SYS_SOCKETCALL, netSocket, uintptr(unsafe.Pointer(&args)), 0)
	if_err!= 0 {
		return 0, err
	}
	return_int(fd), nil
}

func_getsockopt(s int, level int, name_int, val unsafe