package selfish_dns_server

import "fmt"
import "os"
import "reflect"
import . "github.com/strickyak/rye/runt"
import i_net "net"
import i_strings "strings"

var _ = fmt.Sprintf
var _ = os.Stderr
var _ = reflect.ValueOf
var _ = MkInt

var eval_module_once P

func Eval_Module() P {
	if eval_module_once == nil {
		eval_module_once = inner_eval_module()
	}
	return eval_module_once
}
func inner_eval_module() P {
	// @ 0 @ from
	//## p.fromWhere: go
	//## p: go ['net'] net
	// $ 0 $ from
	// @ 19 @ from
	//## p.fromWhere: go
	//## p: go ['strings'] strings
	// $ 19 $ from
	// @ 43 @ def
	// $ 43 $ def
	// @ 1160 @ def
	// $ 1160 $ def
	// @ 1242 @ def
	// $ 1242 $ def
	return None
}

///////////////////////////////

func G_2_ServeAnswerOnPort(a_answer P, a_p P) P {
	var v_detuple_24 /*Bpragma:None*/ P = None
	_ = v_detuple_24 /*Bpragma:None*/
	var v_addr /*Bpragma:None*/ P = None
	_ = v_addr /*Bpragma:None*/
	var v_i /*Bpragma:None*/ P = None
	_ = v_i /*Bpragma:None*/
	var v_bind /*Bpragma:None*/ P = None
	_ = v_bind /*Bpragma:None*/
	var v_j /*Bpragma:None*/ P = None
	_ = v_j /*Bpragma:None*/
	var v_n /*Bpragma:None*/ P = None
	_ = v_n /*Bpragma:None*/
	var v_s /*Bpragma:None*/ P = None
	_ = v_s /*Bpragma:None*/
	var v_detuple_14 /*Bpragma:None*/ P = None
	_ = v_detuple_14 /*Bpragma:None*/
	var v_quad /*Bpragma:None*/ P = None
	_ = v_quad /*Bpragma:None*/
	var v_buf /*Bpragma:None*/ P = None
	_ = v_buf /*Bpragma:None*/
	var v_conn /*Bpragma:None*/ P = None
	_ = v_conn /*Bpragma:None*/
	// @ 79 @ quad

	forexpr__11 := func() P { // around FOR EXPR
		var zz__11 []P
		var nexter__11 Nexter = /*impGO*/ MkGo(i_strings.Split).Call(a_answer, litS__2e).Iter()
		enougher__11, canEnough__11 := nexter__11.(Enougher)
		if canEnough__11 {
			defer enougher__11.Enough()
		}
		// else case without Enougher will be faster.
		for {
			ndx___11, more___11 := nexter__11.Next()
			if !more___11 {
				break
			}
			// BEGIN FOR EXPR

			v_s /*Bpragma:None*/ /*Zpragma:None*/ = ndx___11
			zz__11 = append(zz__11 /**/ /* int */, B_1_int(v_s /*Bpragma:None*/))

			// END FOR EXPR
		}
		return MkList(zz__11)
	}() // around FOR EXPR

	v_quad /*Bpragma:None*/ /*Zpragma:None*/ = forexpr__11
	// $ 79 $ quad
	// @ 133 @ must
	left_12, right_13 := litI_4 /**/ /* len */, B_1_len(v_quad /*Bpragma:None*/)
	if !(left_12.EQ(right_13)) {
		panic(fmt.Sprintf("Assertion Failed:  (%s) ;  left: (%s) ;  op: %s ;  right: (%s) ", "must 4 == len(quad)", left_12.Repr(), "EQ", right_13.Repr()))
	}
	// $ 133 $ must
	// @ 155 @ bind
	v_bind /*Bpragma:None*/ /*Zpragma:None*/ = /**/ MkGo(new(i_net.UDPAddr))
	// $ 155 $ bind
	// @ 183 @ bind
	f_SET_Port(v_bind /*Bpragma:None*/, a_p)
	// $ 183 $ bind
	// @ 199 @ say
	fmt.Fprintln(os.Stderr, "# \"Listening...\" # ", litS_Listening_2e_2e_2e.Repr())
	// $ 199 $ say
	// @ 220 @ conn
	v_conn /*Bpragma:None*/ /*Zpragma:None*/ = /*impGO*/ MkGo(i_net.ListenUDP).Call(litS_udp4, v_bind /*Bpragma:None*/)
	// $ 220 $ conn
	// @ 257 @ conn
	_ /*Zpragma:None*/ = /**/ f_INVOKE_1_SetReadBuffer(v_conn /*Bpragma:None*/, litI_4096)
	// $ 257 $ conn
	// @ 284 @ while
	for True.Bool() {
		// @ 300 @ buf
		v_buf /*Bpragma:None*/ /*Zpragma:None*/ = /**/ /* byt */ B_1_byt(litI_400)
		// $ 300 $ buf
		// @ 319 @ say
		fmt.Fprintln(os.Stderr, "# \"Reading...\" # ", litS_Reading_2e_2e_2e.Repr())
		// $ 319 $ say
		// @ 340 @ n
		v_detuple_14 /*Bpragma:None*/ /*Zpragma:None*/ = /**/ f_INVOKE_1_ReadFromUDP(v_conn /*Bpragma:None*/, v_buf /*Bpragma:None*/)
		len_detuple_14 := v_detuple_14. /*Bpragma:None*/ Len()
		if len_detuple_14 != 2 {
			panic(fmt.Sprintf("Assigning object of length %d to %d variables, in destructuring assignment.", len_detuple_14, 2))
		}
		v_n /*Bpragma:None*/ /*Zpragma:None*/ = (v_detuple_14 /*Bpragma:None*/).GetItem(litI_0)
		v_addr /*Bpragma:None*/ /*Zpragma:None*/ = (v_detuple_14 /*Bpragma:None*/).GetItem(litI_1)
		// $ 340 $ n
		// @ 376 @ say
		fmt.Fprintln(os.Stderr, "# n, addr, buf # ", v_n. /*Bpragma:None*/ Repr(), "#", v_addr. /*Bpragma:None*/ Repr(), "#", v_buf. /*Bpragma:None*/ Repr())
		// $ 376 $ say
		// @ 398 @ assert
		left_15, right_16 := ((v_buf /*Bpragma:None*/).GetItem(litI_2)).BitAnd(litI_128), litI_0
		if !(left_15.EQ(right_16)) {
			panic(fmt.Sprintf("Assertion Failed:  (%s) ;  left: (%s) ;  op: %s ;  right: (%s) ", "assert buf[2] & 128 == 0", left_15.Repr(), "EQ", right_16.Repr()))
		}
		// $ 398 $ assert
		// @ 427 @ buf
		(v_buf /*Bpragma:None*/).SetItem(litI_2, litI_128)
		// $ 427 $ buf
		// @ 457 @ buf
		(v_buf /*Bpragma:None*/).SetItem(litI_3, litI_0)
		// $ 457 $ buf
		// @ 491 @ assert
		left_17, right_18 := (v_buf /*Bpragma:None*/).GetItem(litI_5), litI_1
		if !(left_17.EQ(right_18)) {
			panic(fmt.Sprintf("Assertion Failed:  (%s) ;  left: (%s) ;  op: %s ;  right: (%s) ", "assert buf[5] == 1", left_17.Repr(), "EQ", right_18.Repr()))
		}
		// $ 491 $ assert
		// @ 533 @ buf
		(v_buf /*Bpragma:None*/).SetItem(litI_7, litI_1)
		// $ 533 $ buf
		// @ 566 @ assert
		left_19, right_20 := (v_buf /*Bpragma:None*/).GetItem(litI_4), litI_0
		if !(left_19.EQ(right_20)) {
			panic(fmt.Sprintf("Assertion Failed:  (%s) ;  left: (%s) ;  op: %s ;  right: (%s) ", "assert buf[4] == 0", left_19.Repr(), "EQ", right_20.Repr()))
		}
		// $ 566 $ assert
		// @ 589 @ assert
		left_21, right_22 := (v_buf /*Bpragma:None*/).GetItem(litI_5), litI_1
		if !(left_21.EQ(right_22)) {
			panic(fmt.Sprintf("Assertion Failed:  (%s) ;  left: (%s) ;  op: %s ;  right: (%s) ", "assert buf[5] == 1", left_21.Repr(), "EQ", right_22.Repr()))
		}
		// $ 589 $ assert
		// @ 613 @ i
		v_i /*Bpragma:None*/ /*Zpragma:None*/ = litI_12
		// $ 613 $ i
		// @ 624 @ while
		for (v_buf /*Bpragma:None*/).GetItem(v_i /*Bpragma:None*/).Bool() {
			// @ 644 @ n
			v_n /*Bpragma:None*/ /*Zpragma:None*/ = (v_buf /*Bpragma:None*/).GetItem(v_i /*Bpragma:None*/)
			// $ 644 $ n
			// @ 661 @ say
			fmt.Fprintln(os.Stderr, "# 'Domain Len', n # ", litS_Domain_20Len.Repr(), "#", v_n. /*Bpragma:None*/ Repr())
			// $ 661 $ say
			// @ 687 @ for

			maybe__23 := func() P { // around FOR
				var nexter__23 Nexter = /**/ /* range */ B_1_range(v_n /*Bpragma:None*/).Iter()
				enougher__23, canEnough__23 := nexter__23.(Enougher)
				if canEnough__23 {
					defer enougher__23.Enough()
				}
				// else case without Enougher will be faster.
				for {
					ndx___23, more___23 := nexter__23.Next()
					if !more___23 {
						break
					}
					// BEGIN FOR

					v_j /*Bpragma:None*/ /*Zpragma:None*/ = ndx___23
					// @ 714 @ say
					fmt.Fprintln(os.Stderr, "# 'Domain Char', buf[1+j] # ", litS_Domain_20Char.Repr(), "#", (v_buf /*Bpragma:None*/).GetItem((litI_1).Add(v_j /*Bpragma:None*/)).Repr())
					// $ 714 $ say

					// END FOR
				}
				return nil
			}() // around FOR
			if maybe__23 != nil {
				return maybe__23
			}

			// $ 687 $ for
			// @ 748 @ i
			v_i /*Bpragma:None*/ /*Zpragma:None*/ = (v_i /*Bpragma:None*/).Add((v_n /*Bpragma:None*/).Add(litI_1))
			// $ 748 $ i
		}
		// $ 624 $ while
		// @ 763 @ say
		fmt.Fprintln(os.Stderr, "# 'Domain END' # ", litS_Domain_20END.Repr())
		// $ 763 $ say
		// @ 784 @ i
		v_i /*Bpragma:None*/ /*Zpragma:None*/ = (v_i /*Bpragma:None*/).Add(litI_5)
		// $ 784 $ i
		// @ 824 @ i
		v_i /*Bpragma:None*/ /*Zpragma:None*/ = /*lastcall SLOW*/ call_3(P(G_Put2), v_i /*Bpragma:None*/, v_buf /*Bpragma:None*/, ((litI_192).ShiftLeft(litI_8)).BitOr(litI_12))
		// $ 824 $ i
		// @ 884 @ i
		v_i /*Bpragma:None*/ /*Zpragma:None*/ = /*lastcall SLOW*/ call_3(P(G_Put2), v_i /*Bpragma:None*/, v_buf /*Bpragma:None*/, litI_1)
		// $ 884 $ i
		// @ 921 @ i
		v_i /*Bpragma:None*/ /*Zpragma:None*/ = /*lastcall SLOW*/ call_3(P(G_Put2), v_i /*Bpragma:None*/, v_buf /*Bpragma:None*/, litI_1)
		// $ 921 $ i
		// @ 960 @ i
		v_i /*Bpragma:None*/ /*Zpragma:None*/ = /*lastcall SLOW*/ call_3(P(G_Put2), v_i /*Bpragma:None*/, v_buf /*Bpragma:None*/, litI_0)
		// $ 960 $ i
		// @ 997 @ i
		v_i /*Bpragma:None*/ /*Zpragma:None*/ = /*lastcall SLOW*/ call_3(P(G_Put2), v_i /*Bpragma:None*/, v_buf /*Bpragma:None*/, litI_60)
		// $ 997 $ i
		// @ 1023 @ i
		v_i /*Bpragma:None*/ /*Zpragma:None*/ = /*lastcall SLOW*/ call_3(P(G_Put2), v_i /*Bpragma:None*/, v_buf /*Bpragma:None*/, litI_4)
		// $ 1023 $ i
		// @ 1059 @ buf
		v_detuple_24 /*Bpragma:None*/ /*Zpragma:None*/ = v_quad /*Bpragma:None*/
		len_detuple_24 := v_detuple_24. /*Bpragma:None*/ Len()
		if len_detuple_24 != 4 {
			panic(fmt.Sprintf("Assigning object of length %d to %d variables, in destructuring assignment.", len_detuple_24, 4))
		}
		(v_buf /*Bpragma:None*/).SetItem(v_i /*Bpragma:None*/, (v_detuple_24 /*Bpragma:None*/).GetItem(litI_0))
		(v_buf /*Bpragma:None*/).SetItem((v_i /*Bpragma:None*/).Add(litI_1), (v_detuple_24 /*Bpragma:None*/).GetItem(litI_1))
		(v_buf /*Bpragma:None*/).SetItem((v_i /*Bpragma:None*/).Add(litI_2), (v_detuple_24 /*Bpragma:None*/).GetItem(litI_2))
		(v_buf /*Bpragma:None*/).SetItem((v_i /*Bpragma:None*/).Add(litI_3), (v_detuple_24 /*Bpragma:None*/).GetItem(litI_3))
		// $ 1059 $ buf
		// @ 1107 @ buf
		v_buf /*Bpragma:None*/ /*Zpragma:None*/ = (v_buf /*Bpragma:None*/).GetItemSlice(None, (v_i /*Bpragma:None*/).Add(litI_4), None)
		// $ 1107 $ buf
		// @ 1128 @ say
		fmt.Fprintln(os.Stderr, "# conn.WriteToUDP(buf, addr) # " /**/, f_INVOKE_2_WriteToUDP(v_conn /*Bpragma:None*/, v_buf /*Bpragma:None*/, v_addr /*Bpragma:None*/).Repr())
		// $ 1128 $ say
	}
	// $ 284 $ while

	return None
}

///////////////////////////////
// name: ServeAnswerOnPort
// args: ['answer', 'p']
// dflts: [None, None]
// star:
// starstar:
// body: <tr.Tsuite object at 0x1c0bc50>
type pFunc_ServeAnswerOnPort struct{ PCallSpec }

func (o *pFunc_ServeAnswerOnPort) Contents() interface{} {
	return G_ServeAnswerOnPort
}
func (o pFunc_ServeAnswerOnPort) Call2(a0 P, a1 P) P {
	return G_2_ServeAnswerOnPort(a0, a1)
}

func (o pFunc_ServeAnswerOnPort) CallV(a1 []P, a2 []P, kv1 []KV, kv2 map[string]P) P {
	argv, star, starstar := SpecCall(&o.PCallSpec, a1, a2, kv1, kv2)
	_, _, _ = argv, star, starstar
	return G_2_ServeAnswerOnPort(argv[0], argv[1])
}

///////////////////////////////

func G_3_Put2(a_i P, a_buf P, a_x P) P {
	// @ 1183 @ buf
	(a_buf).SetItem(a_i, (litI_255).BitAnd((a_x).ShiftRight(litI_8)))
	// $ 1183 $ buf
	// @ 1209 @ buf
	(a_buf).SetItem((a_i).Add(litI_1), (litI_255).BitAnd(a_x))
	// $ 1209 $ buf
	// @ 1230 @ return
	return (a_i).Add(litI_2)
	// $ 1230 $ return

	return None
}

///////////////////////////////
// name: Put2
// args: ['i', 'buf', 'x']
// dflts: [None, None, None]
// star:
// starstar:
// body: <tr.Tsuite object at 0x1c0c290>
type pFunc_Put2 struct{ PCallSpec }

func (o *pFunc_Put2) Contents() interface{} {
	return G_Put2
}
func (o pFunc_Put2) Call3(a0 P, a1 P, a2 P) P {
	return G_3_Put2(a0, a1, a2)
}

func (o pFunc_Put2) CallV(a1 []P, a2 []P, kv1 []KV, kv2 map[string]P) P {
	argv, star, starstar := SpecCall(&o.PCallSpec, a1, a2, kv1, kv2)
	_, _, _ = argv, star, starstar
	return G_3_Put2(argv[0], argv[1], argv[2])
}

///////////////////////////////

func G_1_main(a_arg P) P {
	// @ 1259 @ ServeAnswerOnPort
	_ /*Zpragma:None*/ = /**/ G_2_ServeAnswerOnPort((a_arg).GetItem(litI_0) /**/ /* int */, B_1_int((a_arg).GetItem(litI_1)))
	// $ 1259 $ ServeAnswerOnPort

	return None
}

///////////////////////////////
// name: main
// args: ['arg']
// dflts: [None]
// star:
// starstar:
// body: <tr.Tsuite object at 0x1c0c610>
type pFunc_main struct{ PCallSpec }

func (o *pFunc_main) Contents() interface{} {
	return G_main
}
func (o pFunc_main) Call1(a0 P) P {
	return G_1_main(a0)
}

func (o pFunc_main) CallV(a1 []P, a2 []P, kv1 []KV, kv2 map[string]P) P {
	argv, star, starstar := SpecCall(&o.PCallSpec, a1, a2, kv1, kv2)
	_, _, _ = argv, star, starstar
	return G_1_main(argv[0])
}

type i_0 interface {
	Call0() P
}

func call_0(fn P) P {
	switch f := fn.(type) {
	case i_0:
		return f.Call0()
	case ICallV:
		return f.CallV([]P{}, nil, nil, nil)
	}
	panic(fmt.Sprintf("No way to call: %v", fn))
}

type i_1 interface {
	Call1(P) P
}

func call_1(fn P, a_0 P) P {
	switch f := fn.(type) {
	case i_1:
		return f.Call1(a_0)
	case ICallV:
		return f.CallV([]P{a_0}, nil, nil, nil)
	}
	panic(fmt.Sprintf("No way to call: %v", fn))
}

type i_2 interface {
	Call2(P, P) P
}

func call_2(fn P, a_0 P, a_1 P) P {
	switch f := fn.(type) {
	case i_2:
		return f.Call2(a_0, a_1)
	case ICallV:
		return f.CallV([]P{a_0, a_1}, nil, nil, nil)
	}
	panic(fmt.Sprintf("No way to call: %v", fn))
}

type i_3 interface {
	Call3(P, P, P) P
}

func call_3(fn P, a_0 P, a_1 P, a_2 P) P {
	switch f := fn.(type) {
	case i_3:
		return f.Call3(a_0, a_1, a_2)
	case ICallV:
		return f.CallV([]P{a_0, a_1, a_2}, nil, nil, nil)
	}
	panic(fmt.Sprintf("No way to call: %v", fn))
}

var G_Put2 P              // *pFunc_Put2
var G_ServeAnswerOnPort P // *pFunc_ServeAnswerOnPort
var G_main P              // *pFunc_main

func init /*New_Module*/ () {
	G_Put2 = &pFunc_Put2{PCallSpec: PCallSpec{Name: "Put2", Args: []string{"i", "buf", "x"}, Defaults: []P{nil, nil, nil}, Star: "", StarStar: ""}}
	G_Put2.SetSelf(G_Put2)
	G_ServeAnswerOnPort = &pFunc_ServeAnswerOnPort{PCallSpec: PCallSpec{Name: "ServeAnswerOnPort", Args: []string{"answer", "p"}, Defaults: []P{nil, nil}, Star: "", StarStar: ""}}
	G_ServeAnswerOnPort.SetSelf(G_ServeAnswerOnPort)
	G_main = &pFunc_main{PCallSpec: PCallSpec{Name: "main", Args: []string{"arg"}, Defaults: []P{nil}, Star: "", StarStar: ""}}
	G_main.SetSelf(G_main)
}

var litI_0 = MkInt(0)
var litI_1 = MkInt(1)
var litI_12 = MkInt(12)
var litI_128 = MkInt(128)
var litI_192 = MkInt(192)
var litI_2 = MkInt(2)
var litI_255 = MkInt(255)
var litI_3 = MkInt(3)
var litI_4 = MkInt(4)
var litI_400 = MkInt(400)
var litI_4096 = MkInt(4096)
var litI_5 = MkInt(5)
var litI_60 = MkInt(60)
var litI_7 = MkInt(7)
var litI_8 = MkInt(8)
var litS_Domain_20Char = MkStr("Domain Char")
var litS_Domain_20END = MkStr("Domain END")
var litS_Domain_20Len = MkStr("Domain Len")
var litS_Listening_2e_2e_2e = MkStr("Listening...")
var litS_Reading_2e_2e_2e = MkStr("Reading...")
var litS__2e = MkStr(".")
var litS_udp4 = MkStr("udp4")

func f_INVOKE_1_ReadFromUDP(fn P, a_0 P) P {
	switch x := fn.(type) {
	case i_INVOKE_1_ReadFromUDP:
		return x.M_ReadFromUDP(a_0)
	case i_GET_ReadFromUDP:
		return x.GET_ReadFromUDP().(i_1).Call1(a_0)
	case *PGo:
		return x.Invoke("ReadFromUDP", a_0)
	}
	panic(fmt.Sprintf("Cannot invoke 'ReadFromUDP' with 1 arguments on %v", fn))
}

type i_INVOKE_1_ReadFromUDP interface {
	M_ReadFromUDP(a_0 P) P
}

func f_INVOKE_1_SetReadBuffer(fn P, a_0 P) P {
	switch x := fn.(type) {
	case i_INVOKE_1_SetReadBuffer:
		return x.M_SetReadBuffer(a_0)
	case i_GET_SetReadBuffer:
		return x.GET_SetReadBuffer().(i_1).Call1(a_0)
	case *PGo:
		return x.Invoke("SetReadBuffer", a_0)
	}
	panic(fmt.Sprintf("Cannot invoke 'SetReadBuffer' with 1 arguments on %v", fn))
}

type i_INVOKE_1_SetReadBuffer interface {
	M_SetReadBuffer(a_0 P) P
}

func f_INVOKE_2_WriteToUDP(fn P, a_0 P, a_1 P) P {
	switch x := fn.(type) {
	case i_INVOKE_2_WriteToUDP:
		return x.M_WriteToUDP(a_0, a_1)
	case i_GET_WriteToUDP:
		return x.GET_WriteToUDP().(i_2).Call2(a_0, a_1)
	case *PGo:
		return x.Invoke("WriteToUDP", a_0, a_1)
	}
	panic(fmt.Sprintf("Cannot invoke 'WriteToUDP' with 2 arguments on %v", fn))
}

type i_INVOKE_2_WriteToUDP interface {
	M_WriteToUDP(a_0 P, a_1 P) P
}

type i_GET_Port interface {
	GET_Port() P
}
type i_SET_Port interface {
	SET_Port(P)
}

func f_GET_Port(h P) P {
	switch x := h.(type) {
	case i_GET_Port:
		return x.GET_Port()
	case *PGo:
		return FetchFieldByName(x.V, "Port")
	}
	panic(fmt.Sprintf("Cannot GET 'Port' on %T: %v", h, h))
}

func f_SET_Port(h P, a P) {
	switch x := h.(type) {
	case i_SET_Port:
		x.SET_Port(a)
		return
	case *PGo:
		StoreFieldByName(x.V, "Port", a)
		return
	}
	panic(fmt.Sprintf("Cannot SET 'Port' on %T: %v", h, h))
}

type i_GET_ReadFromUDP interface {
	GET_ReadFromUDP() P
}
type i_SET_ReadFromUDP interface {
	SET_ReadFromUDP(P)
}

func f_GET_ReadFromUDP(h P) P {
	switch x := h.(type) {
	case i_GET_ReadFromUDP:
		return x.GET_ReadFromUDP()
	case *PGo:
		return FetchFieldByName(x.V, "ReadFromUDP")
	}
	panic(fmt.Sprintf("Cannot GET 'ReadFromUDP' on %T: %v", h, h))
}

func f_SET_ReadFromUDP(h P, a P) {
	switch x := h.(type) {
	case i_SET_ReadFromUDP:
		x.SET_ReadFromUDP(a)
		return
	case *PGo:
		StoreFieldByName(x.V, "ReadFromUDP", a)
		return
	}
	panic(fmt.Sprintf("Cannot SET 'ReadFromUDP' on %T: %v", h, h))
}

type i_GET_SetReadBuffer interface {
	GET_SetReadBuffer() P
}
type i_SET_SetReadBuffer interface {
	SET_SetReadBuffer(P)
}

func f_GET_SetReadBuffer(h P) P {
	switch x := h.(type) {
	case i_GET_SetReadBuffer:
		return x.GET_SetReadBuffer()
	case *PGo:
		return FetchFieldByName(x.V, "SetReadBuffer")
	}
	panic(fmt.Sprintf("Cannot GET 'SetReadBuffer' on %T: %v", h, h))
}

func f_SET_SetReadBuffer(h P, a P) {
	switch x := h.(type) {
	case i_SET_SetReadBuffer:
		x.SET_SetReadBuffer(a)
		return
	case *PGo:
		StoreFieldByName(x.V, "SetReadBuffer", a)
		return
	}
	panic(fmt.Sprintf("Cannot SET 'SetReadBuffer' on %T: %v", h, h))
}

type i_GET_WriteToUDP interface {
	GET_WriteToUDP() P
}
type i_SET_WriteToUDP interface {
	SET_WriteToUDP(P)
}

func f_GET_WriteToUDP(h P) P {
	switch x := h.(type) {
	case i_GET_WriteToUDP:
		return x.GET_WriteToUDP()
	case *PGo:
		return FetchFieldByName(x.V, "WriteToUDP")
	}
	panic(fmt.Sprintf("Cannot GET 'WriteToUDP' on %T: %v", h, h))
}

func f_SET_WriteToUDP(h P, a P) {
	switch x := h.(type) {
	case i_SET_WriteToUDP:
		x.SET_WriteToUDP(a)
		return
	case *PGo:
		StoreFieldByName(x.V, "WriteToUDP", a)
		return
	}
	panic(fmt.Sprintf("Cannot SET 'WriteToUDP' on %T: %v", h, h))
}