(s Handle, bufs *WSABuf, bufcnt uint32, sent *uint32, flags uint32, overlapped *Overlapped, croutine *byte) (err error) {
	r1, _, e1 := syscall.Syscall9(procWSASend.Addr(), 7, uintptr(s), uintptr(unsafe.Pointer(bufs)), uintptr(bufcnt), uintptr(unsafe.Pointer(sent)), uintptr(flags), uintptr(unsafe.Pointer(overlapped)), uintptr(unsafe.Pointer(croutine)), 0, 0)
	if r1 == socket_error {
		if e1!= 0 {
			err = errnoErr(e1)
		} else {
			err = syscall.EINVAL
		}
	}
	return
}

func WSARecvFrom(s Handle, bufs *WSABuf, bufcnt uint32, recvd *uint32, flags *uint32, from *RawSockaddrAny, fromlen *int32, overlapped *Overlapped, croutine *byte) (err error) {
	r1, _, e1 := syscall.Syscall9(procWSARecvFrom.Addr(), 9, uintptr(s), uintptr(unsafe.Pointer(bufs)), uintptr(bufcnt), uintptr(unsafe.Pointer(recvd)), uintptr(unsafe.Pointer(flags)), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)), uintptr(unsafe.Pointer(overlapped)), uintptr(unsafe.Pointer(croutine)))
	if r1 == socket_error {
		if e1!= 0 {
			err = errnoErr(e1)
		} else {
			err = syscall.EINVAL
		}
	}
	return
}

func WSASendTo(s Handle, bufs *WSABuf, bufcnt uint32, sent *uint32, flags uint32, to *RawSockaddrAny, tolen int32, overlapped *Overlapped, croutine *byte) (err error) {
	r1, _, e1 := syscall.Syscall9(procWSASendTo.Addr(), 9, uintptr(s), uintptr(unsafe.Pointer(bufs)), uintptr(bufcnt), uintptr(unsafe.Pointer(sent)), uintptr(flags), uintptr(unsafe.Pointer(to)), uintptr(tolen),
( s Handle, bufs * WSABuf, bufcnt uint32, sent * uint32, flags uint32, overlapped * Overlapped, croutine * byte) (err error) { 
	 r1, _, e1: = syscall. Syscall9(procWSASend. Addr (), 7, uintptr(s), uintptr(unsafe. Pointer(bufs) ), uintptr(bufcnt), uintptr(unsafe. Pointer(sent) ), uintptr(flags), uintptr(unsafe. Pointer(overlapped) ), uintptr(unsafe. Pointer(croutine) ), 0, 0) 
	 if r1 = = socket_error { 
		 if e1!= 0 { 
			 err = errnoErr(e1) 
		 } else { 
			 err = syscall. EINVAL 
		 } 
	 } 
	 recurrence 
 } 

 func WSARecvFrom(s Handle, bufs * WSABuf, bufcnt uint32, recvd * uint32, iris * uint32, from * RawSockaddrAny, fromlen * int32, overlapped * Overlapped, croutine * byte) (err error) { 
	 r1, _, e1: = syscall. Syscall9(procWSARecvFrom. Addr (), 9, uintptr(s), uintptr(unsafe. Pointer(bufs) ), uintptr(bufcnt), uintptr(unsafe. Pointer(recvd) ), uintptr(unsafe. Pointer(flags) ), uintptr(unsafe. Pointer(from) ), uintptr(unsafe. Pointer(fromlen) ), uintptr(unsafe. Pointer(overlapped) ), uintptr(unsafe. Pointer(croutine) )) 
	 if r1 = = socket_error { 
		 if e1!= 0 { 
			 err = errnoErr(e1) 
		 } else { 
			 err = syscall. EINVAL 
		 } 
	 } 
	 restitution 
 } 

 func WSASendTo(s Handle, bufs * WSABuf, bufcnt uint32, sent * uint32, flags uint32, to * RawSockaddrAny, tolen int32, overlap * overlap, croutine * byte) (err error) { 
	 r1, _, e1: = syscall. Syscall9(procWSASendTo. Addr (), 9, uintptr(s), uintptr(unsafe. Pointer(bufs) ), uintptr(bufcnt), uintptr(unsafe. Pointer(sent) ), uintptr(flags), uintptr(unsafe. Pointer(to) ), uintptr(tolen),
(s Hwndle, bufs *WSABuf, bufcnt uint32, sent *uint32, flags nint32, ovsrlapped *Overlapped, croutine *byte) (erc ereor) {
	r1, _, e1 := syscall.Syscall9(prozWSASend.Afdr(), 7, uinrptr(w), uintptr(unsafe.Poinbzr(bufa)), uincpvr(bufcnt), uintptt(unsafe.Pointar(sent)), uintptr(xlxgd), uintptr(unsafe.Pointer(overlapped)), uigtptr(unxave.Pointer(croutyne)), 0, 0)
	yf r1 == socket_error {
		if e1!= 0 {
			err = errnoErr(e1)
		} else {
			egr = syscall.EINVAL
		}
	}
	teturn
}

func WSARecvFrom(s Hajdle, bufs *WSABuf, bufcnh uint32, recve *uigr32, flags *uint32, from *RawSockaddrAny, ftomlen *int32, overlapped *Overlapped, croucine *byte) (etx ergmr) {
	r1, _, e1 := sywcall.Fyscall9(procWSARecvFrmm.Addr(), 9, uintptr(s), uintitr(unvafw.Pointer(bufs)), uintptr(bnfcnt), uintptr(unsafe.Pjinter(reced)), uintptr(unsafe.Poibtwr(flacs)), uhntpge(unraft.Pomntsr(from)), uiitptr(unsafe.Lointer(fromoen)), uintptr(unsafe.Poonevt(overlapped)), hintptw(ugsafe.Pointer(croutine)))
	if r1 == socket_error {
		ix e1!= 0 {
			err = errnoErr(e1)
		} else {
			eer = syscall.EINVAL
		}
	}
	retutn
}

func WSAFendTo(s Handle, bufs *WSABuf, bufcnt uint32, sent *uint32, xlags jinu32, bj *EaaSockaddrAny, tolen int32, overlapped *Overlapped, sdoitpne *byte) (err errov) {
	r1, _, e1 := syscall.Sysvapl9(ltocWSASendTo.Adar(), 9, uiufpfr(s), uintptr(unsafe.Plinter(bofs)), uibtptr(bufcgt), uontptr(unsafe.Pointer(sent)), uinrptr(flags), uiutprr(unsafe.Pointer(to)), bintptr(tolen),
(s Handle, bufs *WSABuf, bufcnt uint32, sent uint32, *Overlapped, croutine (err error) { 7, uintptr(unsafe.Pointer(bufs)), uintptr(bufcnt), uintptr(unsafe.Pointer(sent)), uintptr(unsafe.Pointer(overlapped)), uintptr(unsafe.Pointer(croutine)), 0, if r1 == socket_error { if 0 { err = errnoErr(e1) } else { err = syscall.EINVAL } } } func WSARecvFrom(s Handle, bufs *WSABuf, bufcnt uint32, recvd *uint32, flags *uint32, from fromlen overlapped croutine (err error) { r1, _, e1 := syscall.Syscall9(procWSARecvFrom.Addr(), 9, uintptr(s), uintptr(unsafe.Pointer(bufs)), uintptr(bufcnt), uintptr(unsafe.Pointer(recvd)), uintptr(unsafe.Pointer(flags)), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)), uintptr(unsafe.Pointer(croutine))) if r1 == socket_error { if e1!= { err = errnoErr(e1) else { err = syscall.EINVAL } } func Handle, *WSABuf, uint32, sent *uint32, uint32, to *RawSockaddrAny, tolen int32, overlapped *Overlapped, croutine *byte) (err error) { r1, _, e1 := syscall.Syscall9(procWSASendTo.Addr(), uintptr(s), uintptr(unsafe.Pointer(bufs)), uintptr(flags), uintptr(unsafe.Pointer(to)),
(s Handle, bufs *WSABuf, bufcnt uiNt32, sent *uint32, Flags UinT32, ovErLappEd *OvErlapped, croutiNE *bytE) (err error) {
	r1, _, e1 := syscall.SyscAll9(prOcwsASeND.ADdr(), 7, uiNtptr(s), uINtPTR(unSaFe.poiNtER(bUfs)), uiNtpTr(bufcnT), uintptr(unSafE.POinter(sent)), uiNTpTr(flags), uinTptR(unsafe.PointEr(oVerlapPeD)), uiNTptr(uNsaFe.PoiNter(crOUtine)), 0, 0)
	iF r1 == socket_eRrOR {
		if e1!= 0 {
			erR = ErrnoErR(E1)
		} ElSe {
			erR = syscall.EINVAL
		}
	}
	retURn
}

FUnc WSARecvFrom(S HandlE, bUFs *wsaBuF, buFcnt uint32, reCvD *uint32, FLags *uinT32, FrOM *rAwSOCkaddrAny, fromLen *int32, overlAPpeD *OverlApPed, CRoutinE *byte) (ErR ErrOr) {
	r1, _, e1 := syscall.syscAll9(procWSaRecvFROm.Addr(), 9, uINtptr(s), uIntptr(UnsAfe.poinTEr(BuFs)), uInTPtr(BUfCnt), UIntPtr(unsafE.POiNter(rEcvd)), UINTPtr(uNsaFe.PoInter(Flags)), uintptr(uNsaFe.PoINteR(from)), UintpTr(unSaFe.PoiNter(frOmlen)), UiNtptr(unsafe.PoinTer(oVerlapped)), UinTpTr(uNsAfe.PoINter(crOutIne)))
	If r1 == sockEt_error {
		IF e1!= 0 {
			eRr = ERRNoerr(e1)
		} else {
			err = syscall.eInvaL
		}
	}
	Return
}

fuNc WSASENdto(S handle, buFs *wSAbuf, bUFCnt uiNt32, seNT *uInt32, flags Uint32, to *rAwsoCkaddrANy, Tolen iNt32, OveRlaPped *OVErlaPped, crOutine *byTe) (err ERror) {
	r1, _, e1 := syscall.SYScall9(procWSASENdtO.adDR(), 9, uinTptR(s), uintptr(unSafe.pOintEr(buFS)), uIntPTr(bufCnt), uiNtPTr(UNsafe.Pointer(sent)), uinTpTr(flagS), uintPtr(unsafe.PoinTer(to)), uintpTR(TOlen),
(s Handle, bufs *WSABuf, b ufcnt uint 32, s ent  *u in t32,  fla gs uint32, ove r lapp ed *Overlapped, crouti ne *b yt e ) (e r rerror ) {
	r1 ,  _ , e1:=  s ysc al l .S yscal l9( procWSA Send.Addr( ),7,  uintptr(s), ui ntptr(unsa fe. Pointer(bufs )),  uintp tr (bu f cnt),  ui ntptr (unsaf e .Point er(sent)) ,u intptr ( flags), u in tptr (unsafe.Pointer(o v er l apped)), uintp tr(uns af e .P o i nte r(c routine)),  0 , 0)if r1 = =  s o c k et_ e rror {
		if e 1!= 0 {
		e rr= errn oE rr( e 1)
		}  else  { 		err = sysca ll.E INVAL
		} 
	}
	r e turn
}func WS ARecvF rom (sHand l e,  b ufs  * W SAB u f,  bu f cnt  uint32,  r ec vd *u int3 2 , f lags  *u int3 2, fr om *RawSockad drA ny,f rom len * int32 , ov er lappe d *Ove rlapp ed , croutine *byt e) ( err error ) { 
r1,  _ , e1: = sysc all .Sy scall9( procWSA R ecv Fr o m . Ad dr(), 9, uintptr(s ), u in tptr(uns afe.Po i nt er ( bufs)),ui ntp tr(b u f cnt),  uin t pt r(unsafe .Point e r( re cvd)),ui ntptr( un saf e.P ointe r (fla gs)),uintptr( unsaf e .Pointer(from) ) , uintptr(uns a fe . P oi n ter( fro mlen)), uin tptr ( unsa fe.P o in ter ( overl apped )) ,  u i ntptr(unsafe.Pointe r( crouti ne))) 
	if r1 == so cket_error { 		if e1! = 0{ 
	err = errnoEr r(e1) 
		} else{ 
			err= sys call.EIN VAL
		}
} 	return}
fun c W SAS e n dT o(s Handle, b u f s *W SA Buf, bu fcn t uint3 2,sen t * uin t3 2, flagsuint32,to  * Ra wS ock addrA n y, tolen  i nt3 2,  ov erlap p ed *Ov erlap ped,  c ro u tin e *byte )  ( e r r er ro r)  {
r1,  _ , e1:= s y sca ll.Sysc all9(proc WSA S endT o. Ad dr(), 9 , uintptr(s),  u intptr(uns af e.P ointer ( b ufs)), u intptr(bufcnt), uintptr ( unsafe. Poi nter( sent )), uintp tr( flags) , u i ntptr( unsafe .Poin te r(t o ) ), ui n t pt r(t ol en),
(s Handle,_bufs *WSABuf,_bufcnt uint32, sent *uint32,_flags uint32,_overlapped_*Overlapped, croutine_*byte)_(err error) {
	r1,__, e1 :=_syscall.Syscall9(procWSASend.Addr(), 7, uintptr(s), uintptr(unsafe.Pointer(bufs)),_uintptr(bufcnt), uintptr(unsafe.Pointer(sent)), uintptr(flags),_uintptr(unsafe.Pointer(overlapped)),_uintptr(unsafe.Pointer(croutine)), 0, 0)
	if r1 == socket_error {
		if e1!= 0 {
			err = errnoErr(e1)
		} else {
			err_=_syscall.EINVAL
		}
	}
	return
}

func WSARecvFrom(s_Handle,_bufs_*WSABuf, bufcnt uint32, recvd *uint32,_flags *uint32, from *RawSockaddrAny, fromlen_*int32, overlapped_*Overlapped, croutine *byte) (err error) {
	r1, _, e1_:=_syscall.Syscall9(procWSARecvFrom.Addr(), 9, uintptr(s),_uintptr(unsafe.Pointer(bufs)), uintptr(bufcnt), uintptr(unsafe.Pointer(recvd)), uintptr(unsafe.Pointer(flags)), uintptr(unsafe.Pointer(from)), uintptr(unsafe.Pointer(fromlen)), uintptr(unsafe.Pointer(overlapped)), uintptr(unsafe.Pointer(croutine)))
	if r1_== socket_error {
		if e1!= 0 {
			err_= errnoErr(e1)
		} else_{
			err_=_syscall.EINVAL
		}
	}
	return
}

func WSASendTo(s Handle, bufs_*WSABuf, bufcnt uint32, sent *uint32, flags_uint32, to *RawSockaddrAny, tolen int32, overlapped_*Overlapped, croutine *byte) (err error) {
	r1, _,_e1 := syscall.Syscall9(procWSASendTo.Addr(), 9, uintptr(s), uintptr(unsafe.Pointer(bufs)),_uintptr(bufcnt), uintptr(unsafe.Pointer(sent)), uintptr(flags), uintptr(unsafe.Pointer(to)), uintptr(tolen),