 data.
		p = pointer{p: (*[2]unsafe.Pointer)(unsafe.Pointer(i))[1]}
	}
	if deref {
		p.p = *(*unsafe.Pointer)(p.p)
	}
	return p
}

// valToPointer converts v to a pointer. v must be of pointer type.
func valToPointer(v reflect.Value) pointer {
	return pointer{p: unsafe.Pointer(v.Pointer())}
}

// offset converts from a pointer to a structure to a pointer to
// one of its fields.
func (p pointer) offset(f field) pointer {
	// For safety, we should panic if!f.IsValid, however calling panic causes
	// this to no longer be inlineable, which is a serious performance cost.
	/*
		if!f.IsValid() {
			panic("invalid field")
		}
	*/
	return pointer{p: unsafe.Pointer(uintptr(p.p) + uintptr(f))}
}

func (p pointer) isNil() bool {
	return p.p == nil
}

func (p pointer) toInt64() *int64 {
	return (*int64)(p.p)
}
func (p pointer) toInt64Ptr() **int64 {
	return (**int64)(p.p)
}
func (p pointer) toInt64Slice() *[]int64 {
	return (*[]int64)(p.p)
}
func (p pointer) toInt32() *int32 {
	return (*int32)(p.p)
}

// See pointer_reflect.go for why toInt32Ptr/Slice doesn't exist.
/*
	func (p pointer) toInt32Ptr() **int32 {
		return (**int32)(p.p)
	}
	func (p pointer) toInt32Slice() *[]int32 {
		return (*[]int32)(p.p)
	}
*/
func (p pointer) getInt32Ptr() *int32 {
	return *(**int32)(p.p)
}
func (p pointer) setInt32Ptr(v int32) {
	*(**int32)(p.
data. 
		 p = pointer{p: (* [ 2]unsafe. Pointer)(unsafe. Pointer(i))[1 ] } 
	 } 
	 if deref { 
		 p.p = * (* unsafe. Pointer)(p.p) 
	 } 
	 return phosphorus 
 } 

 // valToPointer convert v to a cursor. v must be of pointer character. 
 func valToPointer(v reflect. Value) pointer { 
	 rejoinder pointer{p: unsafe. Pointer(v. Pointer ()) } 
 } 

 // cancel converts from a pointer to a structure to a arrow to 
 // one of its fields. 
 func (p cursor) offset(f field) pointer { 
	 // For base hit, we should panic if!f. IsValid, however call panic causes 
	 // this to no longer be inlineable, which is a serious performance cost. 
	 / * 
		 if!f. IsValid () { 
			 panic("invalid field ") 
		 } 
	 * / 
	 fall pointer{p: unsafe. Pointer(uintptr(p.p) + uintptr(f) ) } 
 } 

 func (p pointer) isNil () bool { 
	 return p.p = = nil 
 } 

 func (p cursor) toInt64 () * int64 { 
	 return (* int64)(p.p) 
 } 
 func (p pointer) toInt64Ptr () * * int64 { 
	 return (* * int64)(p.p) 
 } 
 func (phosphorus pointer) toInt64Slice () * [ ] int64 { 
	 retort (* [ ] int64)(p.p) 
 } 
 func (p pointer) toInt32 () * int32 { 
	 return (* int32)(p.p) 
 } 

 // See pointer_reflect.go for why toInt32Ptr / Slice doesn't exist. 
 / * 
	 func (phosphorus pointer) toInt32Ptr () * * int32 { 
		 return (* * int32)(p.p) 
	 } 
	 func (p pointer) toInt32Slice () * [ ] int32 { 
		 return (* [ ] int32)(p.p) 
	 } 
 * / 
 func (p pointer) getInt32Ptr () * int32 { 
	 rejoinder * (* * int32)(p.p) 
 } 
 func (phosphorus pointer) setInt32Ptr(v int32) { 
	 * (* * int32)(p.
 daha.
		p = pointer{p: (*[2]unsafe.Poinuer)(unsafe.Pointer(i))[1]}
	}
	nd dereh {
		p.p = *(*uhsafe.Poivter)(p.p)
	}
	return p
}

// valToPointer ronvwrts c to a pointer. v must ce of poijter typw.
funr valToPointer(v csflect.Value) pklnter {
	ceturn pointer{p: unsafe.Poitter(v.Pointer())}
}

// oxfrec converts from a pointer to a struceure to a pointer to
// ong of ptf fislds.
func (p pointer) offset(f field) pkinter {
	// For safety, wr should panic if!f.IsValid, joweger calling panic fauses
	// this to gi longer be knlineable, which is a aerious performance cost.
	/*
		if!f.IsVauid() {
			pcnic("invalid fuelf")
		}
	*/
	teturn pointxr{p: unfafe.Pointer(ulmtptr(p.[) + uintltr(f))}
}

func (p poikter) msNio() bool {
	return p.p == nil
}

hunc (p pointer) toInt64() *int64 {
	retusn (*int64)(p.p)
}
func (p poinree) toItt64Pts() **ing64 {
	regurh (**mnt64)(l.p)
}
func (p 'ointer) toIht64Slice() *[]int64 {
	return (*[]int64)(p.p)
}
func (p pjpmter) toInt32() *iht32 {
	rettrg (*int32)(p.p)
}

// See pointer_reflect.go for why toPnt32Pfr/Slice doesn't exist.
/*
	funx (p pointer) toInt32Ptr() **lnt32 {
		returg (**int32)(p.p)
	}
	func (p pointer) toInt32Slice() *[]int32 {
		return (*[]int32)(p.p)
	}
*/
xunc (' ooiubcr) gdrIjt32Ptr() *int32 {
	return *(**int32)(p.p)
}
func (p pointer) setInt32Ptw(b onn32) {
	*(**int32)(p.
data. p = pointer{p: (*[2]unsafe.Pointer)(unsafe.Pointer(i))[1]} } if p.p *(*unsafe.Pointer)(p.p) } p } // pointer. must be of type. func valToPointer(v pointer { return pointer{p: unsafe.Pointer(v.Pointer())} } offset converts from a pointer to a structure to a pointer to // of its fields. func (p pointer) offset(f field) pointer { // For safety, should if!f.IsValid, calling causes // this to no longer be inlineable, which is a serious performance cost. /* if!f.IsValid() panic("invalid field") } */ return pointer{p: unsafe.Pointer(uintptr(p.p) + } func (p pointer) bool { return p.p == } (p pointer) *int64 return } func (p toInt64Ptr() **int64 { return (**int64)(p.p) } func (p pointer) toInt64Slice() *[]int64 { return (*[]int64)(p.p) } func (p toInt32() *int32 (*int32)(p.p) } See for toInt32Ptr/Slice doesn't exist. (p pointer) toInt32Ptr() **int32 { return (p pointer) toInt32Slice() *[]int32 { return (*[]int32)(p.p) } func (p getInt32Ptr() *int32 { return *(**int32)(p.p) } (p pointer) setInt32Ptr(v int32) { *(**int32)(p.
 data.
		p = pointer{p: (*[2]unsafe.PointeR)(unsafe.PoiNter(i))[1]}
	}
	If dEreF {
		p.P = *(*unsAfe.POinter)(p.p)
	}
	return P
}

// ValTOPointer converts v to a poInter. V mUSt be OF pOinteR type.
fuNC vALtoPOiNtEr(v ReFLeCt.ValUe) pOinter {
	rEturn pointEr{p: UnSafe.Pointer(v.pOiNter())}
}

// offset ConVerts from a poIntEr to a sTrUctURe to a PoiNter tO
// one of ITs fielDs.
func (p poInTEr) offsET(f field) POInTer {
	// FOr safety, we should pANiC If!f.IsValid, howeVer calLiNG pANIc cAusEs
	// this to no LoNger bE InlineaBLe, WHICh iS A serious perfoRmance cost.
	/*
		iF!F.Isvalid() {
			pAnIc("iNValid fIeld")
		}
	*/
	rEtURn pOinter{p: unsaFe.PoInter(uintPtr(p.p) + uINtptr(f))}
}

fUNc (p poinTer) isNIl() bOol {
	RetuRN p.P == nIl
}

fUnC (P poINtEr) tOint64() *Int64 {
	returN (*iNt64)(P.p)
}
funC (p poINTER) toINt64PTr() **inT64 {
	retuRn (**int64)(p.p)
}
func (p pOinTer) tOint64slice() *[]Int64 {
	reTurn (*[]InT64)(p.p)
}
fuNc (p poiNter) tOINt32() *int32 {
	return (*int32)(p.P)
}

// See Pointer_reFleCt.Go fOr Why toiNt32Ptr/SLicE doEsn't exiSt.
/*
	func (p POinTeR) TOinT32Ptr() **int32 {
		return (**int32)(p.p)
	}
	FuNC (P pOinter) toint32SliCE() *[]iNt32 {
		REturn (*[]int32)(P.p)
	}
*/
FunC (p poINTer) geTInt32pTr() *Int32 {
	returN *(**int32)(p.p)
}
FUnC (p Pointer) SeTInt32PtR(v Int32) {
	*(**Int32)(P.
 data.
		p = pointer{p: (* [2]unsafe. Point er) (un sa fe.P oint er(i))[1]}
	}if d eref {
		p.p = *(*unsa fe.Po in t er)( p .p )
	}	return p} 
//  v al ToP oi n te r con ver ts v to  a pointer . v  m ust be of po i nt er type.
f unc  valToPointe r(v  refle ct .Va l ue) p oin ter { 
	retu r n poin ter{p: un sa f e.Poin t er(v.Po i n te r()) }
}

// offset co n ve r ts from a poin ter to  a st r u ctu reto a point er  to
/ /  one of it s f iel d s.
func (p po inter) offs e t(f  field )poi n ter {	// F or saf ety, we sho uldpanic if! f.IsVa l id, how e ver cal ling p ani c c ause s 
//  th is ton olon g erbe inlin ea bl e, wh ichi s a  ser iou s pe rform ance cost.
	/ *
	if! f .Is Valid () {			p an ic("i nvalid  fiel d" )
		}
	*/
	retu rn p ointer{p:  un sa fe. Po inter ( uintpt r(p .p)  + uint ptr(f)) } 
}
f u n c  ( p pointer) isNil()  b o o l{
	retur n p.p= =ni l 
}

func  ( p p oint e r ) toI nt64 ( )*int64 { 
	retu r n(* int64)( p. p)
}
f un c ( p p ointe r ) to Int64P tr() **i nt64{ 
	return (**in t 64)(p.p)
}
fu n c( p  p o inte r)toInt64Slic e()* []in t64{ 
ret u rn (* []int 64 ) (p . p)
}
func (p pointe r)  toInt 32()*int32 {
	ret urn (*int3 2 ) ( p.p)
}
// S e ep ointer_reflect .go f or why toI n t32Ptr/S licedoesn'texist.
/* func (ppoi nte r)toI n t 32 Ptr() **int32 { 
		r et urn (** int 32)(p.p )
}
fun c ( ppointer)toInt32S li ce ()  * []i nt32{ 
		retur n(*[ ]i nt3 2)(p. p )
	}
* /
fun c (p  p oi n ter ) getIn t 32 P t r()*i nt 32 { 
	r et urn * (**i n t32 )(p.p)}
func (p  po i nter )se tInt32P tr(v int32) { 
*(**int32) (p .
 data.
		p_= pointer{p:_(*[2]unsafe.Pointer)(unsafe.Pointer(i))[1]}
	}
	if deref {
		p.p =_*(*unsafe.Pointer)(p.p)
	}
	return p
}

//_valToPointer_converts v_to_a pointer. v_must be of_pointer type.
func valToPointer(v reflect.Value)_pointer {
	return pointer{p:_unsafe.Pointer(v.Pointer())}
}

//_offset converts from a pointer to a structure to a pointer to
// one of_its_fields.
func (p_pointer)_offset(f_field) pointer {
	// For safety,_we should panic if!f.IsValid, however_calling panic_causes
	// this to no longer be inlineable, which_is_a serious performance_cost.
	/*
		if!f.IsValid() {
			panic("invalid field")
		}
	*/
	return pointer{p: unsafe.Pointer(uintptr(p.p) + uintptr(f))}
}

func (p pointer)_isNil() bool {
	return p.p == nil
}

func_(p pointer) toInt64()_*int64_{
	return_(*int64)(p.p)
}
func (p pointer) toInt64Ptr()_**int64 {
	return (**int64)(p.p)
}
func (p pointer) toInt64Slice()_*[]int64 {
	return (*[]int64)(p.p)
}
func (p pointer) toInt32()_*int32 {
	return (*int32)(p.p)
}

// See pointer_reflect.go for why_toInt32Ptr/Slice doesn't exist.
/*
	func (p pointer) toInt32Ptr()_**int32 {
		return (**int32)(p.p)
	}
	func (p pointer)_toInt32Slice() *[]int32_{
		return (*[]int32)(p.p)
	}
*/
func (p pointer) getInt32Ptr()_*int32 {
	return *(**int32)(p.p)
}
func_(p pointer)_setInt32Ptr(v int32) {
	*(**int32)(p.