imports

type P_compress_flate_Reader struct {
	Object    interface{}
	Read_     func(_proxy_obj_ interface{}, p []byte) (n int, err error)
	ReadByte_ func(interface{}) (byte, error)
}

type P_compress_flate_Resetter struct {
	Object interface{}
	Reset_ func(_proxy_obj_ interface{}, r io.Reader, dict []byte) error
}

type P_compress_zlib_Resetter struct {
	Object interface{}
	Reset_ func(_proxy_obj_ interface{}, r io.Reader, dict []byte) error
}

type P_container_heap_Interface struct {
	Object interface{}
	Len_   func(interface{}) int
	Less_  func(_proxy_obj_ interface{}, i int, j int) bool
	Pop_   func(interface{}) interface{}
	Push_  func(_proxy_obj_ interface{}, x interface{})
	Swap_  func(_proxy_obj_ interface{}, i int, j int)
}

type P_context_Context struct {
	Object    interface{}
	Deadline_ func(interface{}) (deadline time.Time, ok bool)
	Done_     func(interface{}) <-chan struct{}
	Err_      func(interface{}) error
	Value_    func(_proxy_obj_ interface{}, key interface{}) interface{}
}

type P_crypto_Decrypter struct {
	Object   interface{}
	Decrypt_ func(_proxy_obj_ interface{}, rand io.Reader, msg []byte, opts crypto.DecrypterOpts) (plaintext []byte, err error)
	Public_  func(interface{}) crypto.PublicKey
}

type P_crypto_Signer struct {
	Object  interface{}
	Public_ func(interface{}) crypto.PublicKey
	Sign_   func(_proxy_obj_ interface{}, rand io.Reader, digest []byte, opts crypto.SignerOpts) (signature []byte, err error)
}

type P_crypto_SignerOpts struct {
	Object    interface{}
	HashFunc_ func(interface{}) crypto.Hash
}

type P_crypto_cipher_AEAD struct {
	Object     interface{}
	NonceSize_ func(interface{}) int
	Open_      func(_proxy_obj_ interface{}, dst []byte, nonce []byte, ciphertext []byte, additionalData []byte) ([]byte, error)
	Overhead_  func(interface{}) int
	Seal_      func(_proxy_obj_ interface{}, dst []byte, nonce []byte, plaintext []byte, additionalData []byte) []byte
}

type P_crypto_cipher_Block struct {
	Object     interface{}
	BlockSize_ func(interface{}) int
	Decrypt_   func(_proxy_obj_ interface{}, dst []byte, src []byte)
	Encrypt_   func(_proxy_obj_ interface{}, dst []byte, src []byte)
}

type P_crypto_cipher_BlockMode struct {
	Object       interface{}
	BlockSize_   func(interface{}) int
	CryptBlocks_ func(_proxy_obj_ interface{}, dst []byte, src []byte)
}

type P_crypto_cipher_Stream struct {
	Object        interface{}
	XORKeyStream_ func(_proxy_obj_ interface{}, dst []byte, src []byte)
}

type P_crypto_elliptic_Curve struct {
	Object          interface{}
	Add_            func(_proxy_obj_ interface{}, x1 *big.Int, y1 *big.Int, x2 *big.Int, y2 *big.Int) (x *big.Int, y *big.Int)
	Double_         func(_proxy_obj_ interface{}, x1 *big.Int, y1 *big.Int) (x *big.Int, y *big.Int)
	IsOnCurve_      func(_proxy_obj_ interface{}, x *big.Int, y *big.Int) bool
	Params_         func(interface{}) *elliptic.CurveParams
	ScalarBaseMult_ func(_proxy_obj_ interface{}, k []byte) (x *big.Int, y *big.Int)
	ScalarMult_     func(_proxy_obj_ interface{}, x1 *big.Int, y1 *big.Int, k []byte) (x *big.Int, y *big.Int)
}

type P_crypto_tls_ClientSessionCache struct {
	Object interface{}
	Get_   func(_proxy_obj_ interface{}, sessionKey string) (session *tls.ClientSessionState, ok bool)
	Put_   func(_proxy_obj_ interface{}, sessionKey string, cs *tls.ClientSessionState)
}

type P_debug_dwarf_Type struct {
	Object  interface{}
	Common_ func(interface{}) *dwarf.CommonType
	Size_   func(interface{}) int64
	String_ func(interface{}) string
}

type P_encoding_BinaryMarshaler struct {
	Object         interface{}
	MarshalBinary_ func(interface{}) (data []byte, err error)
}

type P_encoding_BinaryUnmarshaler struct {
	Object           interface{}
	UnmarshalBinary_ func(_proxy_obj_ interface{}, data []byte) error
}

type P_encoding_TextMarshaler struct {
	Object       interface{}
	MarshalText_ func(interface{}) (text []byte, err error)
}

type P_encoding_TextUnmarshaler struct {
	Object         interface{}
	UnmarshalText_ func(_proxy_obj_ interface{}, text []byte) error
}

type P_encoding_binary_ByteOrder struct {
	Object     interface{}
	PutUint16_ func(interface{}, []byte, uint16)
	PutUint32_ func(interface{}, []byte, uint32)
	PutUint64_ func(interface{}, []byte, uint64)
	String_    func(interface{}) string
	Uint16_    func(interface{}, []byte) uint16
	Uint32_    func(interface{}, []byte) uint32
	Uint64_    func(interface{}, []byte) uint64
}

type P_encoding_gob_GobDecoder struct {
	Object     interface{}
	GobDecode_ func(interface{}, []byte) error
}

type P_encoding_gob_GobEncoder struct {
	Object     interface{}
	GobEncode_ func(interface{}) ([]byte, error)
}

type P_encoding_json_Marshaler struct {
	Object       interface{}
	MarshalJSON_ func(interface{}) ([]byte, error)
}

type P_encoding_json_Unmarshaler struct {
	Object         interface{}
	UnmarshalJSON_ func(interface{}, []byte) error
}

type P_expvar_Var struct {
	Object  interface{}
	String_ func(interface{}) string
}

type P_flag_Getter struct {
	Object  interface{}
	Get_    func(interface{}) interface{}
	Set_    func(interface{}, string) error
	String_ func(interface{}) string
}

type P_flag_Value struct {
	Object  interface{}
	Set_    func(interface{}, string) error
	String_ func(interface{}) string
}

type P_fmt_Formatter struct {
	Object  interface{}
	Format_ func(_proxy_obj_ interface{}, f fmt.State, c rune)
}

type P_fmt_GoStringer struct {
	Object    interface{}
	GoString_ func(interface{}) string
}

type P_fmt_ScanState struct {
	Object      interface{}
	Read_       func(_proxy_obj_ interface{}, buf []byte) (n int, err error)
	ReadRune_   func(interface{}) (r rune, size int, err error)
	SkipSpace_  func(interface{})
	Token_      func(_proxy_obj_ interface{}, skipSpace bool, f func(rune) bool) (token []byte, err error)
	UnreadRune_ func(interface{}) error
	Width_      func(interface{}) (wid int, ok bool)
}

type P_fmt_Scanner struct {
	Object interface{}
	Scan_  func(_proxy_obj_ interface{}, state fmt.ScanState, verb rune) error
}

type P_fmt_State struct {
	Object     interface{}
	Flag_      func(_proxy_obj_ interface{}, c int) bool
	Precision_ func(interface{}) (prec int, ok bool)
	Width_     func(interface{}) (wid int, ok bool)
	Write_     func(_proxy_obj_ interface{}, b []byte) (n int, err error)
}

type P_fmt_Stringer struct {
	Object  interface{}
	String_ func(interface{}) string
}

type P_go_ast_Node struct {
	Object interface{}
	End_   func(interface{}) token.Pos
	Pos_   func(interface{}) token.Pos
}

type P_go_ast_Visitor struct {
	Object interface{}
	Visit_ func(_proxy_obj_ interface{}, node ast.Node) (w ast.Visitor)
}

type P_go_types_Importer struct {
	Object  interface{}
	Import_ func(_proxy_obj_ interface{}, path string) (*types.Package, error)
}

type P_go_types_ImporterFrom struct {
	Object      interface{}
	Import_     func(_proxy_obj_ interface{}, path string) (*types.Package, error)
	ImportFrom_ func(_proxy_obj_ interface{}, path string, dir string, mode types.ImportMode) (*types.Package, error)
}

type P_go_types_Sizes struct {
	Object     interface{}
	Alignof_   func(_proxy_obj_ interface{}, T types.Type) int64
	Offsetsof_ func(_proxy_obj_ interface{}, fields []*types.Var) []int64
	Sizeof_    func(_proxy_obj_ interface{}, T types.Type) int64
}

type P_go_types_Type struct {
	Object      interface{}
	String_     func(interface{}) string
	Underlying_ func(interface{}) types.Type
}

type P_hash_Hash struct {
	Object     interface{}
	BlockSize_ func(interface{}) int
	Reset_     func(interface{})
	Size_      func(interface{}) int
	Sum_       func(_proxy_obj_ interface{}, b []byte) []byte
	Write_     func(_proxy_obj_ interface{}, p []byte) (n int, err error)
}

type P_hash_Hash32 struct {
	Object     interface{}
	BlockSize_ func(interface{}) int
	Reset_     func(interface{})
	Size_      func(interface{}) int
	Sum_       func(_proxy_obj_ interface{}, b []byte) []byte
	Sum32_     func(interface{}) uint32
	Write_     func(_proxy_obj_ interface{}, p []byte) (n int, err error)
}

type P_hash_Hash64 struct {
	Object     interface{}
	BlockSize_ func(interface{}) int
	Reset_     func(interface{})
	Size_      func(interface{}) int
	Sum_       func(_proxy_obj_ interface{}, b []byte) []byte
	Sum64_     func(interface{}) uint64
	Write_     func(_proxy_obj_ interface{}, p []byte) (n int, err error)
}

type P_image_Image struct {
	Object      interface{}
	At_         func(_proxy_obj_ interface{}, x int, y int) color.Color
	Bounds_     func(interface{}) image.Rectangle
	ColorModel_ func(interface{}) color.Model
}

type P_image_PalettedImage struct {
	Object        interface{}
	At_           func(_proxy_obj_ interface{}, x int, y int) color.Color
	Bounds_       func(interface{}) image.Rectangle
	ColorIndexAt_ func(_proxy_obj_ interface{}, x int, y int) uint8
	ColorModel_   func(interface{}) color.Model
}

type P_image_color_Color struct {
	Object interface{}
	RGBA_  func(interface{}) (r uint32, g uint32, b uint32, a uint32)
}

type P_image_color_Model struct {
	Object   interface{}
	Convert_ func(_proxy_obj_ interface{}, c color.Color) color.Color
}

type P_image_draw_Drawer struct {
	Object interface{}
	Draw_  func(_proxy_obj_ interface{}, dst draw.Image, r image.Rectangle, src image.Image, sp image.Point)
}

type P_image_draw_Image struct {
	Object      interface{}
	At_         func(_proxy_obj_ interface{}, x int, y int) color.Color
	Bounds_     func(interface{}) image.Rectangle
	ColorModel_ func(interface{}) color.Model
	Set_        func(_proxy_obj_ interface{}, x int, y int, c color.Color)
}

type P_image_draw_Quantizer struct {
	Object    interface{}
	Quantize_ func(_proxy_obj_ interface{}, p color.Palette, m image.Image) color.Palette
}

type P_image_jpeg_Reader struct {
	Object    interface{}
	Read_     func(_proxy_obj_ interface{}, p []byte) (n int, err error)
	ReadByte_ func(interface{}) (byte, error)
}

type P_image_png_EncoderBufferPool struct {
	Object interface{}
	Get_   func(interface{}) *png.EncoderBuffer
	Put_   func(interface{}, *png.EncoderBuffer)
}

type P_io_ByteReader struct {
	Object    interface{}
	ReadByte_ func(interface{}) (byte, error)
}

type P_io_ByteScanner struct {
	Object      interface{}
	ReadByte_   func(interface{}) (byte, error)
	UnreadByte_ func(interface{}) error
}

type P_io_ByteWriter struct {
	Object     interface{}
	WriteByte_ func(_proxy_obj_ interface{}, c byte) error
}

type P_io_Closer struct {
	Object interface{}
	Close_ func(interface{}) error
}

type P_io_ReadCloser struct {
	Object interface{}
	Close_ func(interface{}) error
	Read_  func(_proxy_obj_ interface{}, p []byte) (n int, err error)
}

type P_io_ReadSeeker struct {
	Object interface{}
	Read_  func(_proxy_obj_ interface{}, p []byte) (n int, err error)
	Seek_  func(_proxy_obj_ interface{}, offset int64, whence int) (int64, error)
}

type P_io_ReadWriteCloser struct {
	Object interface{}
	Close_ func(interface{}) error
	Read_  func(_proxy_obj_ interface{}, p []byte) (n int, err error)
	Write_ func(_proxy_obj_ interface{}, p []byte) (n int, err error)
}

type P_io_ReadWriteSeeker struct {
	Object interface{}
	Read_  func(_proxy_obj_ interface{}, p []byte) (n int, err error)
	Seek_  func(_proxy_obj_ interface{}, offset int64, whence int) (int64, error)
	Write_ func(_proxy_obj_ interface{}, p []byte) (n int, err error)
}

type P_io_ReadWriter struct {
	Object interface{}
	Read_  func(_proxy_obj_ interface{}, p []byte) (n int, err error)
	Write_ func(_proxy_obj_ interface{}, p []byte) (n int, err error)
}

type P_io_Reader struct {
	Object interface{}
	Read_  func(_proxy_obj_ interface{}, p []byte) (n int, err error)
}

type P_io_ReaderAt struct {
	Object  interface{}
	ReadAt_ func(_proxy_obj_ interface{}, p []byte, off int64) (n int, err error)
}

type P_io_ReaderFrom struct {
	Object    interface{}
	ReadFrom_ func(_proxy_obj_ interface{}, r io.Reader) (n int64, err error)
}

type P_io_RuneReader struct {
	Object    interface{}
	ReadRune_ func(interface{}) (r rune, size int, err error)
}

type P_io_RuneScanner struct {
	Object      interface{}
	ReadRune_   func(interface{}) (r rune, size int, err error)
	UnreadRune_ func(interface{}) error
}

type P_io_Seeker struct {
	Object interface{}
	Seek_  func(_proxy_obj_ interface{}, offset int64, whence int) (int64, error)
}

type P_io_WriteCloser struct {
	Object interface{}
	Close_ func(interface{}) error
	Write_ func(_proxy_obj_ interface{}, p []byte) (n int, err error)
}

type P_io_WriteSeeker struct {
	Object interface{}
	Seek_  func(_proxy_obj_ interface{}, offset int64, whence int) (int64, error)
	Write_ func(_proxy_obj_ interface{}, p []byte) (n int, err error)
}

type P_io_Writer struct {
	Object interface{}
	Write_ func(_proxy_obj_ interface{}, p []byte) (n int, err error)
}

type P_io_WriterAt struct {
	Object   interface{}
	WriteAt_ func(_proxy_obj_ interface{}, p []byte, off int64) (n int, err error)
}

type P_io_WriterTo struct {
	Object   interface{}
	WriteTo_ func(_proxy_obj_ interface{}, w io.Writer) (n int64, err error)
}

type P_mime_multipart_File struct {
	Object  interface{}
	Close_  func(interface{}) error
	Read_   func(_proxy_obj_ interface{}, p []byte) (n int, err error)
	ReadAt_ func(_proxy_obj_ interface{}, p []byte, off int64) (n int, err error)
	Seek_   func(_proxy_obj_ interface{}, offset int64, whence int) (int64, error)
}

type P_net_Addr struct {
	Object   interface{}
	Network_ func(interface{}) string
	String_  func(interface{}) string
}

type P_net_Conn struct {
	Object            interface{}
	Close_            func(interface{}) error
	LocalAddr_        func(interface{}) net.Addr
	Read_             func(_proxy_obj_ interface{}, b []byte) (n int, err error)
	RemoteAddr_       func(interface{}) net.Addr
	SetDeadline_      func(_proxy_obj_ interface{}, t time.Time) error
	SetReadDeadline_  func(_proxy_obj_ interface{}, t time.Time) error
	SetWriteDeadline_ func(_proxy_obj_ interface{}, t time.Time) error
	Write_            func(_proxy_obj_ interface{}, b []byte) (n int, err error)
}

type P_net_Error struct {
	Object     interface{}
	Error_     func(interface{}) string
	Temporary_ func(interface{}) bool
	Timeout_   func(interface{}) bool
}

type P_net_Listener struct {
	Object  interface{}
	Accept_ func(interface{}) (net.Conn, error)
	Addr_   func(interface{}) net.Addr
	Close_  func(interface{}) error
}

type P_net_PacketConn struct {
	Object            interface{}
	Close_            func(interface{}) error
	LocalAddr_        func(interface{}) net.Addr
	ReadFrom_         func(_proxy_obj_ interface{}, b []byte) (n int, addr net.Addr, err error)
	SetDeadline_      func(_proxy_obj_ interface{}, t time.Time) error
	SetReadDeadline_  func(_proxy_obj_ interface{}, t time.Time) error
	SetWriteDeadline_ func(_proxy_obj_ interface{}, t time.Time) error
	WriteTo_          func(_proxy_obj_ interface{}, b []byte, addr net.Addr) (n int, err error)
}

type P_net_http_cookiejar_PublicSuffixList struct {
	Object        interface{}
	PublicSuffix_ func(_proxy_obj_ interface{}, domain string) string
	String_       func(interface{}) string
}

type P_net_http_httputil_BufferPool struct {
	Object interface{}
	Get_   func(interface{}) []byte
	Put_   func(interface{}, []byte)
}

type P_net_rpc_ClientCodec struct {
	Object              interface{}
	Close_              func(interface{}) error
	ReadResponseBody_   func(interface{}, interface{}) error
	ReadResponseHeader_ func(interface{}, *rpc.Response) error
	WriteRequest_       func(interface{}, *rpc.Request, interface{}) error
}

type P_net_rpc_ServerCodec struct {
	Object             interface{}
	Close_             func(interface{}) error
	ReadRequestBody_   func(interface{}, interface{}) error
	ReadRequestHeader_ func(interface{}, *rpc.Request) error
	WriteResponse_     func(interface{}, *rpc.Response, interface{}) error
}

type P_net_smtp_Auth struct {
	Object interface{}
	Next_  func(_proxy_obj_ interface{}, fromServer []byte, more bool) (toServer []byte, err error)
	Start_ func(_proxy_obj_ interface{}, server *smtp.ServerInfo) (proto string, toServer []byte, err error)
}

type P_runtime_Error struct {
	Object        interface{}
	Error_        func(interface{}) string
	RuntimeError_ func(interface{})
}

type P_sort_Interface struct {
	Object interface{}
	Len_   func(interface{}) int
	Less_  func(_proxy_obj_ interface{}, i int, j int) bool
	Swap_  func(_proxy_obj_ interface{}, i int, j int)
}

type P_sync_Locker struct {
	Object  interface{}
	Lock_   func(interface{})
	Unlock_ func(interface{})
}

type P_testing_quick_Generator struct {
	Object    interface{}
	Generate_ func(_proxy_obj_ interface{}, rand *rand.Rand, size int) reflect.Value
}

type Package PackageUnderlying // named, can have methods

type PackageMap map[string]Package // named, can have methods

type PackageUnderlying = struct {
	Binds   map[string]Value
	Types   map[string]Type
	Proxies map[string]Type
	// Untypeds contains a string representation of untyped constants,
	// stored without loss of precision
	Untypeds map[string]string
	// Wrappers is the list of wrapper methods for named types.
	// Stored explicitly because reflect package cannot distinguish
	// between explicit methods and wrapper methods for embedded fields
	Wrappers map[string][]string
}