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_database_sql_Result struct {
	Object        interface{}
	LastInsertId_ func(interface{}) (int64, error)
	RowsAffected_ func(interface{}) (int64, error)
}

type P_database_sql_Scanner struct {
	Object interface{}
	Scan_  func(_proxy_obj_ interface{}, src interface{}) error
}

type P_database_sql_driver_ColumnConverter struct {
	Object           interface{}
	ColumnConverter_ func(_proxy_obj_ interface{}, idx int) driver.ValueConverter
}

type P_database_sql_driver_Conn struct {
	Object   interface{}
	Begin_   func(interface{}) (driver.Tx, error)
	Close_   func(interface{}) error
	Prepare_ func(_proxy_obj_ interface{}, query string) (driver.Stmt, error)
}

type P_database_sql_driver_ConnBeginTx struct {
	Object   interface{}
	BeginTx_ func(_proxy_obj_ interface{}, ctx context.Context, opts driver.TxOptions) (driver.Tx, error)
}

type P_database_sql_driver_ConnPrepareContext struct {
	Object          interface{}
	PrepareContext_ func(_proxy_obj_ interface{}, ctx context.Context, query string) (driver.Stmt, error)
}

type P_database_sql_driver_Connector struct {
	Object   interface{}
	Connect_ func(interface{}, context.Context) (driver.Conn, error)
	Driver_  func(interface{}) driver.Driver
}

type P_database_sql_driver_Driver struct {
	Object interface{}
	Open_  func(_proxy_obj_ interface{}, name string) (driver.Conn, error)
}

type P_database_sql_driver_DriverContext struct {
	Object         interface{}
	OpenConnector_ func(_proxy_obj_ interface{}, name string) (driver.Connector, error)
}

type P_database_sql_driver_Execer struct {
	Object interface{}
	Exec_  func(_proxy_obj_ interface{}, query string, args []driver.Value) (driver.Result, error)
}

type P_database_sql_driver_ExecerContext struct {
	Object       interface{}
	ExecContext_ func(_proxy_obj_ interface{}, ctx context.Context, query string, args []driver.NamedValue) (driver.Result, error)
}

type P_database_sql_driver_NamedValueChecker struct {
	Object           interface{}
	CheckNamedValue_ func(interface{}, *driver.NamedValue) error
}

type P_database_sql_driver_Pinger struct {
	Object interface{}
	Ping_  func(_proxy_obj_ interface{}, ctx context.Context) error
}

type P_database_sql_driver_Queryer struct {
	Object interface{}
	Query_ func(_proxy_obj_ interface{}, query string, args []driver.Value) (driver.Rows, error)
}

type P_database_sql_driver_QueryerContext struct {
	Object        interface{}
	QueryContext_ func(_proxy_obj_ interface{}, ctx context.Context, query string, args []driver.NamedValue) (driver.Rows, error)
}

type P_database_sql_driver_Result struct {
	Object        interface{}
	LastInsertId_ func(interface{}) (int64, error)
	RowsAffected_ func(interface{}) (int64, error)
}

type P_database_sql_driver_Rows struct {
	Object   interface{}
	Close_   func(interface{}) error
	Columns_ func(interface{}) []string
	Next_    func(_proxy_obj_ interface{}, dest []driver.Value) error
}

type P_database_sql_driver_RowsColumnTypeDatabaseTypeName struct {
	Object                      interface{}
	Close_                      func(interface{}) error
	ColumnTypeDatabaseTypeName_ func(_proxy_obj_ interface{}, index int) string
	Columns_                    func(interface{}) []string
	Next_                       func(_proxy_obj_ interface{}, dest []driver.Value) error
}

type P_database_sql_driver_RowsColumnTypeLength struct {
	Object            interface{}
	Close_            func(interface{}) error
	ColumnTypeLength_ func(_proxy_obj_ interface{}, index int) (length int64, ok bool)
	Columns_          func(interface{}) []string
	Next_             func(_proxy_obj_ interface{}, dest []driver.Value) error
}

type P_database_sql_driver_RowsColumnTypeNullable struct {
	Object              interface{}
	Close_              func(interface{}) error
	ColumnTypeNullable_ func(_proxy_obj_ interface{}, index int) (nullable bool, ok bool)
	Columns_            func(interface{}) []string
	Next_               func(_proxy_obj_ interface{}, dest []driver.Value) error
}

type P_database_sql_driver_RowsColumnTypePrecisionScale struct {
	Object                    interface{}
	Close_                    func(interface{}) error
	ColumnTypePrecisionScale_ func(_proxy_obj_ interface{}, index int) (precision int64, scale int64, ok bool)
	Columns_                  func(interface{}) []string
	Next_                     func(_proxy_obj_ interface{}, dest []driver.Value) error
}

type P_database_sql_driver_RowsColumnTypeScanType struct {
	Object              interface{}
	Close_              func(interface{}) error
	ColumnTypeScanType_ func(_proxy_obj_ interface{}, index int) reflect.Type
	Columns_            func(interface{}) []string
	Next_               func(_proxy_obj_ interface{}, dest []driver.Value) error
}

type P_database_sql_driver_RowsNextResultSet struct {
	Object            interface{}
	Close_            func(interface{}) error
	Columns_          func(interface{}) []string
	HasNextResultSet_ func(interface{}) bool
	Next_             func(_proxy_obj_ interface{}, dest []driver.Value) error
	NextResultSet_    func(interface{}) error
}

type P_database_sql_driver_SessionResetter struct {
	Object        interface{}
	ResetSession_ func(_proxy_obj_ interface{}, ctx context.Context) error
}

type P_database_sql_driver_Stmt struct {
	Object    interface{}
	Close_    func(interface{}) error
	Exec_     func(_proxy_obj_ interface{}, args []driver.Value) (driver.Result, error)
	NumInput_ func(interface{}) int
	Query_    func(_proxy_obj_ interface{}, args []driver.Value) (driver.Rows, error)
}

type P_database_sql_driver_StmtExecContext struct {
	Object       interface{}
	ExecContext_ func(_proxy_obj_ interface{}, ctx context.Context, args []driver.NamedValue) (driver.Result, error)
}

type P_database_sql_driver_StmtQueryContext struct {
	Object        interface{}
	QueryContext_ func(_proxy_obj_ interface{}, ctx context.Context, args []driver.NamedValue) (driver.Rows, error)
}

type P_database_sql_driver_Tx struct {
	Object    interface{}
	Commit_   func(interface{}) error
	Rollback_ func(interface{}) error
}

type P_database_sql_driver_ValueConverter struct {
	Object        interface{}
	ConvertValue_ func(_proxy_obj_ interface{}, v interface{}) (driver.Value, error)
}

type P_database_sql_driver_Valuer struct {
	Object interface{}
	Value_ func(interface{}) (driver.Value, error)
}

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

type P_debug_macho_Load struct {
	Object interface{}
	Raw_   func(interface{}) []byte
}

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_encoding_xml_Marshaler struct {
	Object      interface{}
	MarshalXML_ func(_proxy_obj_ interface{}, e *xml.Encoder, start xml.StartElement) error
}

type P_encoding_xml_MarshalerAttr struct {
	Object          interface{}
	MarshalXMLAttr_ func(_proxy_obj_ interface{}, name xml.Name) (xml.Attr, error)
}

type P_encoding_xml_TokenReader struct {
	Object interface{}
	Token_ func(interface{}) (xml.Token, error)
}

type P_encoding_xml_Unmarshaler struct {
	Object        interface{}
	UnmarshalXML_ func(_proxy_obj_ interface{}, d *xml.Decoder, start xml.StartElement) error
}

type P_encoding_xml_UnmarshalerAttr struct {
	Object            interface{}
	UnmarshalXMLAttr_ func(_proxy_obj_ interface{}, attr xml.Attr) 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_StringWriter struct {
	Object       interface{}
	WriteString_ func(_proxy_obj_ interface{}, s string) (n int, err 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_math_rand_Source struct {
	Object interface{}
	Int63_ func(interface{}) int64
	Seed_  func(_proxy_obj_ interface{}, seed int64)
}

type P_math_rand_Source64 struct {
	Object  interface{}
	Int63_  func(interface{}) int64
	Seed_   func(_proxy_obj_ interface{}, seed int64)
	Uint64_ func(interface{}) uint64
}

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{}, p []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{}, p []byte, addr net.Addr) (n int, err error)
}

type P_net_http_CloseNotifier struct {
	Object       interface{}
	CloseNotify_ func(interface{}) <-chan bool
}

type P_net_http_CookieJar struct {
	Object      interface{}
	Cookies_    func(_proxy_obj_ interface{}, u *url.URL) []*http.Cookie
	SetCookies_ func(_proxy_obj_ interface{}, u *url.URL, cookies []*http.Cookie)
}

type P_net_http_File struct {
	Object   interface{}
	Close_   func(interface{}) error
	Read_    func(_proxy_obj_ interface{}, p []byte) (n int, err error)
	Readdir_ func(_proxy_obj_ interface{}, count int) ([]os.FileInfo, error)
	Seek_    func(_proxy_obj_ interface{}, offset int64, whence int) (int64, error)
	Stat_    func(interface{}) (os.FileInfo, error)
}

type P_net_http_FileSystem struct {
	Object interface{}
	Open_  func(_proxy_obj_ interface{}, name string) (http.File, error)
}

type P_net_http_Flusher struct {
	Object interface{}
	Flush_ func(interface{})
}

type P_net_http_Handler struct {
	Object     interface{}
	ServeHTTP_ func(interface{}, http.ResponseWriter, *http.Request)
}

type P_net_http_Hijacker struct {
	Object  interface{}
	Hijack_ func(interface{}) (net.Conn, *bufio.ReadWriter, error)
}

type P_net_http_Pusher struct {
	Object interface{}
	Push_  func(_proxy_obj_ interface{}, target string, opts *http.PushOptions) error
}

type P_net_http_ResponseWriter struct {
	Object       interface{}
	Header_      func(interface{}) http.Header
	Write_       func(interface{}, []byte) (int, error)
	WriteHeader_ func(_proxy_obj_ interface{}, statusCode int)
}

type P_net_http_RoundTripper struct {
	Object     interface{}
	RoundTrip_ func(interface{}, *http.Request) (*http.Response, 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_os_FileInfo struct {
	Object   interface{}
	IsDir_   func(interface{}) bool
	ModTime_ func(interface{}) time.Time
	Mode_    func(interface{}) os.FileMode
	Name_    func(interface{}) string
	Size_    func(interface{}) int64
	Sys_     func(interface{}) interface{}
}

type P_os_Signal struct {
	Object  interface{}
	Signal_ func(interface{})
	String_ func(interface{}) string
}

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 PackageName string // package default name, or package alias

type PackageUnderlying = struct {
	Name    string
	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
}