Runtime error about goloader HOT 5 CLOSED

func regItab(symPtr map[string]uintptr, name string, addr uintptr) {
	symPtr[name] = addr
	bss := strings.Split(strings.TrimLeft(name, ITAB_PREFIX), ",")
	slice := sliceHeader{addr, len(bss), len(bss)}
	ptrs := *(*[]unsafe.Pointer)(unsafe.Pointer(&slice))
	for i, ptr := range ptrs {
		tname := bss[len(bss)-i-1]
		if tname[0] == '*' {
			obj := reflect.TypeOf(0)
			(*emptyInterface)(unsafe.Pointer(&obj)).word = ptr

			prefix := TYPE_PREFIX + tname[1:]

                        //obj = obj.(reflect.Type).Elem()
		        //symPtr[prefix] = uintptr((*emptyInterface)(unsafe.Pointer(&obj)).word)

			if symPtr[prefix] != 0 {
				obj = obj.(reflect.Type).Elem()
				symPtr[prefix] = uintptr((*emptyInterface)(unsafe.Pointer(&obj)).word)
			}
		}
		symPtr[TYPE_PREFIX+tname] = uintptr(ptr)
	}
}

func mainb(server *base.TestTCPServer) {
	fmt.Println("here")
	fmt.Println(server.Protocol)
}

func main() {
       //Empty because needed in main package
}

func main() {

	runtime.GOMAXPROCS(runtime.NumCPU())

	//packets.InitPackets()
	server := &base.TestTCPServer{Port: "25565", Protocol: "tcp"}
	symPtr := make(map[string]uintptr)
	err := goloader.RegSymbol(symPtr)
	if err != nil {
		fmt.Println(err)
		return
	}

	goloader.RegTypes(symPtr, time.Duration(0), time.Unix(0, 0))
	goloader.RegTypes(symPtr, runtime.LockOSThread)
	//goloader.RegTypes(symPtr, server)

	reloc, err := goloader.ReadObjs([]string{"../plugins/test.o"}, []string{""})
	if err != nil {
		fmt.Println(err)
		return
	}
	symPtr["os.Stdout"] = uintptr(unsafe.Pointer(&os.Stdout))

	codeModule, err := goloader.Load(reloc, symPtr)
	if err != nil {
		fmt.Println("Load error:", err)
		return
	}
	runFuncPtr := codeModule.Syms["main.mainb"]
	if runFuncPtr == 0 {
		fmt.Println("Load error! not find function:", "main.mainb")
		return
	}
	funcPtrContainer := (uintptr)(unsafe.Pointer(&runFuncPtr))
	runFunc := *(*func(server *base.TestTCPServer))(unsafe.Pointer(&funcPtrContainer))
	runFunc(server)
	os.Stdout.Sync()
	codeModule.Unload()
}

package base

import (
	"brewellcore/server/world"
	"fmt"
	"net"
)

// TCPServer struct
type TestTCPServer struct {
	Protocol string
	Port     string
	Net      net.Listener
	World    *world.Map
}

//var players []*UserConnection

func (server *TestTCPServer) Run() {
	server.Net, _ = net.Listen(server.Protocol, ":"+server.Port)

	world.Generate(server.World)

	fmt.Println("[Server|Generator] World loaded")

	for {
		_, _ = server.Net.Accept()

		//go server.handleRequest(conn)
	}
}

func Generate(world *Map) {

	files, err := ioutil.ReadDir("testworld/region/")
	if err != nil {
		log.Fatal(err)
	}

	for _, file := range files {
		r, err := region.Open("testworld/region/" + file.Name())

		if err != nil {
			fmt.Println(err)
			return
		}
		defer r.Close()

		for x := 0; x < 32; x++ {
			for z := 0; z < 32; z++ {
				data, err := r.ReadSector(region.In(x, z))
				if err != nil {
					continue
				}

				r, err := zlib.NewReader(bytes.NewReader(data[1:]))
				if err != nil {
					continue
				}

				nbt.NewDecoder(r)  <<HERE ERROR
			}
		}
	}
}