deusdata--codebase-memory-mcp/internal/cbm/lsp/generated/go_stdlib_data.c

// AUTO-GENERATED by scripts/gen-go-stdlib.go — DO NOT EDIT
// Go stdlib type information for LSP type resolver.

#include "../type_rep.h"
#include "../type_registry.h"
#include <string.h>

// 2328 functions, 321 types from 34 packages

void cbm_go_stdlib_register(CBMTypeRegistry* reg, CBMArena* arena) {
    CBMRegisteredFunc rf;
    CBMRegisteredType rt;

    static const char* context_Context_methods[] = {"Deadline", "Done", "Err", "Value", NULL};
    static const char* crypto_Decapsulator_methods[] = {"Decapsulate", "Encapsulator", NULL};
    static const char* crypto_Decrypter_methods[] = {"Decrypt", "Public", NULL};
    static const char* crypto_Encapsulator_methods[] = {"Bytes", "Encapsulate", NULL};
    static const char* crypto_MessageSigner_methods[] = {"SignMessage", NULL};
    static const char* crypto_Signer_methods[] = {"Public", "Sign", NULL};
    static const char* crypto_SignerOpts_methods[] = {"HashFunc", NULL};
    static const char* database_sql_Result_methods[] = {"LastInsertId", "RowsAffected", NULL};
    static const char* database_sql_Scanner_methods[] = {"Scan", NULL};
    static const char* encoding_BinaryAppender_methods[] = {"AppendBinary", NULL};
    static const char* encoding_BinaryMarshaler_methods[] = {"MarshalBinary", NULL};
    static const char* encoding_BinaryUnmarshaler_methods[] = {"UnmarshalBinary", NULL};
    static const char* encoding_TextAppender_methods[] = {"AppendText", NULL};
    static const char* encoding_TextMarshaler_methods[] = {"MarshalText", NULL};
    static const char* encoding_TextUnmarshaler_methods[] = {"UnmarshalText", NULL};
    static const char* encoding_json_Marshaler_methods[] = {"MarshalJSON", NULL};
    static const char* encoding_json_Unmarshaler_methods[] = {"UnmarshalJSON", NULL};
    static const char* encoding_xml_Marshaler_methods[] = {"MarshalXML", NULL};
    static const char* encoding_xml_MarshalerAttr_methods[] = {"MarshalXMLAttr", NULL};
    static const char* encoding_xml_TokenReader_methods[] = {"Token", NULL};
    static const char* encoding_xml_Unmarshaler_methods[] = {"UnmarshalXML", NULL};
    static const char* encoding_xml_UnmarshalerAttr_methods[] = {"UnmarshalXMLAttr", NULL};
    static const char* fmt_Formatter_methods[] = {"Format", NULL};
    static const char* fmt_GoStringer_methods[] = {"GoString", NULL};
    static const char* fmt_ScanState_methods[] = {"Read", "ReadRune", "SkipSpace", "Token", "UnreadRune", "Width", NULL};
    static const char* fmt_Scanner_methods[] = {"Scan", NULL};
    static const char* fmt_State_methods[] = {"Flag", "Precision", "Width", "Write", NULL};
    static const char* fmt_Stringer_methods[] = {"String", NULL};
    static const char* hash_Cloner_methods[] = {"Clone", NULL};
    static const char* hash_Hash_methods[] = {"BlockSize", "Reset", "Size", "Sum", NULL};
    static const char* hash_Hash32_methods[] = {"Sum32", NULL};
    static const char* hash_Hash64_methods[] = {"Sum64", NULL};
    static const char* hash_XOF_methods[] = {"BlockSize", "Reset", NULL};
    static const char* io_ByteReader_methods[] = {"ReadByte", NULL};
    static const char* io_ByteScanner_methods[] = {"UnreadByte", NULL};
    static const char* io_ByteWriter_methods[] = {"WriteByte", NULL};
    static const char* io_Closer_methods[] = {"Close", NULL};
    static const char* io_Reader_methods[] = {"Read", NULL};
    static const char* io_ReaderAt_methods[] = {"ReadAt", NULL};
    static const char* io_ReaderFrom_methods[] = {"ReadFrom", NULL};
    static const char* io_RuneReader_methods[] = {"ReadRune", NULL};
    static const char* io_RuneScanner_methods[] = {"UnreadRune", NULL};
    static const char* io_Seeker_methods[] = {"Seek", NULL};
    static const char* io_StringWriter_methods[] = {"WriteString", NULL};
    static const char* io_Writer_methods[] = {"Write", NULL};
    static const char* io_WriterAt_methods[] = {"WriteAt", NULL};
    static const char* io_WriterTo_methods[] = {"WriteTo", NULL};
    static const char* io_fs_DirEntry_methods[] = {"Info", "IsDir", "Name", "Type", NULL};
    static const char* io_fs_FS_methods[] = {"Open", NULL};
    static const char* io_fs_File_methods[] = {"Close", "Read", "Stat", NULL};
    static const char* io_fs_FileInfo_methods[] = {"IsDir", "ModTime", "Mode", "Name", "Size", "Sys", NULL};
    static const char* io_fs_GlobFS_methods[] = {"Glob", NULL};
    static const char* io_fs_ReadDirFS_methods[] = {"ReadDir", NULL};
    static const char* io_fs_ReadDirFile_methods[] = {"ReadDir", NULL};
    static const char* io_fs_ReadFileFS_methods[] = {"ReadFile", NULL};
    static const char* io_fs_ReadLinkFS_methods[] = {"Lstat", "ReadLink", NULL};
    static const char* io_fs_StatFS_methods[] = {"Stat", NULL};
    static const char* io_fs_SubFS_methods[] = {"Sub", NULL};
    static const char* log_slog_Handler_methods[] = {"Enabled", "Handle", "WithAttrs", "WithGroup", NULL};
    static const char* log_slog_Leveler_methods[] = {"Level", NULL};
    static const char* log_slog_LogValuer_methods[] = {"LogValue", NULL};
    static const char* net_Addr_methods[] = {"Network", "String", NULL};
    static const char* net_Conn_methods[] = {"Close", "LocalAddr", "Read", "RemoteAddr", "SetDeadline", "SetReadDeadline", "SetWriteDeadline", "Write", NULL};
    static const char* net_Error_methods[] = {"Temporary", "Timeout", NULL};
    static const char* net_Listener_methods[] = {"Accept", "Addr", "Close", NULL};
    static const char* net_PacketConn_methods[] = {"Close", "LocalAddr", "ReadFrom", "SetDeadline", "SetReadDeadline", "SetWriteDeadline", "WriteTo", NULL};
    static const char* net_http_CloseNotifier_methods[] = {"CloseNotify", NULL};
    static const char* net_http_CookieJar_methods[] = {"Cookies", "SetCookies", NULL};
    static const char* net_http_File_methods[] = {"Readdir", "Stat", NULL};
    static const char* net_http_FileSystem_methods[] = {"Open", NULL};
    static const char* net_http_Flusher_methods[] = {"Flush", NULL};
    static const char* net_http_Handler_methods[] = {"ServeHTTP", NULL};
    static const char* net_http_Hijacker_methods[] = {"Hijack", NULL};
    static const char* net_http_Pusher_methods[] = {"Push", NULL};
    static const char* net_http_ResponseWriter_methods[] = {"Header", "Write", "WriteHeader", NULL};
    static const char* net_http_RoundTripper_methods[] = {"RoundTrip", NULL};
    static const char* os_Signal_methods[] = {"Signal", "String", NULL};
    static const char* sort_Interface_methods[] = {"Len", "Less", "Swap", NULL};
    static const char* sync_Locker_methods[] = {"Lock", "Unlock", NULL};
    static const char* testing_TB_methods[] = {"ArtifactDir", "Attr", "Chdir", "Cleanup", "Context", "Error", "Errorf", "Fail", "FailNow", "Failed", "Fatal", "Fatalf", "Helper", "Log", "Logf", "Name", "Output", "Setenv", "Skip", "SkipNow", "Skipf", "Skipped", "TempDir", NULL};

    // Type: bufio.ReadWriter
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "bufio.ReadWriter";
    rt.short_name = "ReadWriter";
    cbm_registry_add_type(reg, rt);

    // Type: bufio.Reader
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "bufio.Reader";
    rt.short_name = "Reader";
    cbm_registry_add_type(reg, rt);

    // Type: bufio.Scanner
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "bufio.Scanner";
    rt.short_name = "Scanner";
    cbm_registry_add_type(reg, rt);

    // Type: bufio.SplitFunc
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "bufio.SplitFunc";
    rt.short_name = "SplitFunc";
    cbm_registry_add_type(reg, rt);

    // Type: bufio.Writer
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "bufio.Writer";
    rt.short_name = "Writer";
    cbm_registry_add_type(reg, rt);

    // Type: bytes.Buffer
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "bytes.Buffer";
    rt.short_name = "Buffer";
    cbm_registry_add_type(reg, rt);

    // Type: bytes.Reader
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "bytes.Reader";
    rt.short_name = "Reader";
    cbm_registry_add_type(reg, rt);

    // Type: context.CancelCauseFunc
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "context.CancelCauseFunc";
    rt.short_name = "CancelCauseFunc";
    cbm_registry_add_type(reg, rt);

    // Type: context.CancelFunc
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "context.CancelFunc";
    rt.short_name = "CancelFunc";
    cbm_registry_add_type(reg, rt);

    // Type: context.Context
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "context.Context";
    rt.short_name = "Context";
    rt.is_interface = true;
    rt.method_names = context_Context_methods;
    cbm_registry_add_type(reg, rt);

    // Type: crypto.Decapsulator
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "crypto.Decapsulator";
    rt.short_name = "Decapsulator";
    rt.is_interface = true;
    rt.method_names = crypto_Decapsulator_methods;
    cbm_registry_add_type(reg, rt);

    // Type: crypto.Decrypter
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "crypto.Decrypter";
    rt.short_name = "Decrypter";
    rt.is_interface = true;
    rt.method_names = crypto_Decrypter_methods;
    cbm_registry_add_type(reg, rt);

    // Type: crypto.DecrypterOpts
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "crypto.DecrypterOpts";
    rt.short_name = "DecrypterOpts";
    cbm_registry_add_type(reg, rt);

    // Type: crypto.Encapsulator
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "crypto.Encapsulator";
    rt.short_name = "Encapsulator";
    rt.is_interface = true;
    rt.method_names = crypto_Encapsulator_methods;
    cbm_registry_add_type(reg, rt);

    // Type: crypto.Hash
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "crypto.Hash";
    rt.short_name = "Hash";
    cbm_registry_add_type(reg, rt);

    // Type: crypto.MessageSigner
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "crypto.MessageSigner";
    rt.short_name = "MessageSigner";
    rt.is_interface = true;
    rt.method_names = crypto_MessageSigner_methods;
    cbm_registry_add_type(reg, rt);

    // Type: crypto.PrivateKey
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "crypto.PrivateKey";
    rt.short_name = "PrivateKey";
    cbm_registry_add_type(reg, rt);

    // Type: crypto.PublicKey
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "crypto.PublicKey";
    rt.short_name = "PublicKey";
    cbm_registry_add_type(reg, rt);

    // Type: crypto.Signer
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "crypto.Signer";
    rt.short_name = "Signer";
    rt.is_interface = true;
    rt.method_names = crypto_Signer_methods;
    cbm_registry_add_type(reg, rt);

    // Type: crypto.SignerOpts
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "crypto.SignerOpts";
    rt.short_name = "SignerOpts";
    rt.is_interface = true;
    rt.method_names = crypto_SignerOpts_methods;
    cbm_registry_add_type(reg, rt);

    // Type: database/sql.ColumnType
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "database/sql.ColumnType";
    rt.short_name = "ColumnType";
    cbm_registry_add_type(reg, rt);

    // Type: database/sql.Conn
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "database/sql.Conn";
    rt.short_name = "Conn";
    cbm_registry_add_type(reg, rt);

    // Type: database/sql.DB
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "database/sql.DB";
    rt.short_name = "DB";
    cbm_registry_add_type(reg, rt);

    // Type: database/sql.DBStats
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "database/sql.DBStats";
    rt.short_name = "DBStats";
    cbm_registry_add_type(reg, rt);

    // Type: database/sql.IsolationLevel
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "database/sql.IsolationLevel";
    rt.short_name = "IsolationLevel";
    cbm_registry_add_type(reg, rt);

    // Type: database/sql.NamedArg
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "database/sql.NamedArg";
    rt.short_name = "NamedArg";
    cbm_registry_add_type(reg, rt);

    // Type: database/sql.Null
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "database/sql.Null";
    rt.short_name = "Null";
    cbm_registry_add_type(reg, rt);

    // Type: database/sql.NullBool
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "database/sql.NullBool";
    rt.short_name = "NullBool";
    cbm_registry_add_type(reg, rt);

    // Type: database/sql.NullByte
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "database/sql.NullByte";
    rt.short_name = "NullByte";
    cbm_registry_add_type(reg, rt);

    // Type: database/sql.NullFloat64
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "database/sql.NullFloat64";
    rt.short_name = "NullFloat64";
    cbm_registry_add_type(reg, rt);

    // Type: database/sql.NullInt16
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "database/sql.NullInt16";
    rt.short_name = "NullInt16";
    cbm_registry_add_type(reg, rt);

    // Type: database/sql.NullInt32
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "database/sql.NullInt32";
    rt.short_name = "NullInt32";
    cbm_registry_add_type(reg, rt);

    // Type: database/sql.NullInt64
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "database/sql.NullInt64";
    rt.short_name = "NullInt64";
    cbm_registry_add_type(reg, rt);

    // Type: database/sql.NullString
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "database/sql.NullString";
    rt.short_name = "NullString";
    cbm_registry_add_type(reg, rt);

    // Type: database/sql.NullTime
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "database/sql.NullTime";
    rt.short_name = "NullTime";
    cbm_registry_add_type(reg, rt);

    // Type: database/sql.Out
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "database/sql.Out";
    rt.short_name = "Out";
    cbm_registry_add_type(reg, rt);

    // Type: database/sql.RawBytes
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "database/sql.RawBytes";
    rt.short_name = "RawBytes";
    cbm_registry_add_type(reg, rt);

    // Type: database/sql.Result
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "database/sql.Result";
    rt.short_name = "Result";
    rt.is_interface = true;
    rt.method_names = database_sql_Result_methods;
    cbm_registry_add_type(reg, rt);

    // Type: database/sql.Row
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "database/sql.Row";
    rt.short_name = "Row";
    cbm_registry_add_type(reg, rt);

    // Type: database/sql.Rows
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "database/sql.Rows";
    rt.short_name = "Rows";
    cbm_registry_add_type(reg, rt);

    // Type: database/sql.Scanner
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "database/sql.Scanner";
    rt.short_name = "Scanner";
    rt.is_interface = true;
    rt.method_names = database_sql_Scanner_methods;
    cbm_registry_add_type(reg, rt);

    // Type: database/sql.Stmt
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "database/sql.Stmt";
    rt.short_name = "Stmt";
    cbm_registry_add_type(reg, rt);

    // Type: database/sql.Tx
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "database/sql.Tx";
    rt.short_name = "Tx";
    cbm_registry_add_type(reg, rt);

    // Type: database/sql.TxOptions
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "database/sql.TxOptions";
    rt.short_name = "TxOptions";
    cbm_registry_add_type(reg, rt);

    // Type: encoding.BinaryAppender
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding.BinaryAppender";
    rt.short_name = "BinaryAppender";
    rt.is_interface = true;
    rt.method_names = encoding_BinaryAppender_methods;
    cbm_registry_add_type(reg, rt);

    // Type: encoding.BinaryMarshaler
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding.BinaryMarshaler";
    rt.short_name = "BinaryMarshaler";
    rt.is_interface = true;
    rt.method_names = encoding_BinaryMarshaler_methods;
    cbm_registry_add_type(reg, rt);

    // Type: encoding.BinaryUnmarshaler
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding.BinaryUnmarshaler";
    rt.short_name = "BinaryUnmarshaler";
    rt.is_interface = true;
    rt.method_names = encoding_BinaryUnmarshaler_methods;
    cbm_registry_add_type(reg, rt);

    // Type: encoding.TextAppender
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding.TextAppender";
    rt.short_name = "TextAppender";
    rt.is_interface = true;
    rt.method_names = encoding_TextAppender_methods;
    cbm_registry_add_type(reg, rt);

    // Type: encoding.TextMarshaler
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding.TextMarshaler";
    rt.short_name = "TextMarshaler";
    rt.is_interface = true;
    rt.method_names = encoding_TextMarshaler_methods;
    cbm_registry_add_type(reg, rt);

    // Type: encoding.TextUnmarshaler
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding.TextUnmarshaler";
    rt.short_name = "TextUnmarshaler";
    rt.is_interface = true;
    rt.method_names = encoding_TextUnmarshaler_methods;
    cbm_registry_add_type(reg, rt);

    // Type: encoding/json.Decoder
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/json.Decoder";
    rt.short_name = "Decoder";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/json.Decoder
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/json.Decoder";
    rt.short_name = "Decoder";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/json.Delim
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/json.Delim";
    rt.short_name = "Delim";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/json.Delim
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/json.Delim";
    rt.short_name = "Delim";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/json.Encoder
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/json.Encoder";
    rt.short_name = "Encoder";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/json.Encoder
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/json.Encoder";
    rt.short_name = "Encoder";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/json.InvalidUTF8Error
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/json.InvalidUTF8Error";
    rt.short_name = "InvalidUTF8Error";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/json.InvalidUTF8Error
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/json.InvalidUTF8Error";
    rt.short_name = "InvalidUTF8Error";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/json.InvalidUnmarshalError
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/json.InvalidUnmarshalError";
    rt.short_name = "InvalidUnmarshalError";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/json.InvalidUnmarshalError
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/json.InvalidUnmarshalError";
    rt.short_name = "InvalidUnmarshalError";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/json.Marshaler
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/json.Marshaler";
    rt.short_name = "Marshaler";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/json.Marshaler
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/json.Marshaler";
    rt.short_name = "Marshaler";
    rt.is_interface = true;
    rt.method_names = encoding_json_Marshaler_methods;
    cbm_registry_add_type(reg, rt);

    // Type: encoding/json.MarshalerError
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/json.MarshalerError";
    rt.short_name = "MarshalerError";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/json.MarshalerError
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/json.MarshalerError";
    rt.short_name = "MarshalerError";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/json.Number
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/json.Number";
    rt.short_name = "Number";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/json.Number
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/json.Number";
    rt.short_name = "Number";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/json.Options
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/json.Options";
    rt.short_name = "Options";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/json.RawMessage
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/json.RawMessage";
    rt.short_name = "RawMessage";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/json.RawMessage
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/json.RawMessage";
    rt.short_name = "RawMessage";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/json.SyntaxError
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/json.SyntaxError";
    rt.short_name = "SyntaxError";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/json.SyntaxError
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/json.SyntaxError";
    rt.short_name = "SyntaxError";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/json.Token
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/json.Token";
    rt.short_name = "Token";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/json.Token
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/json.Token";
    rt.short_name = "Token";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/json.UnmarshalFieldError
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/json.UnmarshalFieldError";
    rt.short_name = "UnmarshalFieldError";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/json.UnmarshalFieldError
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/json.UnmarshalFieldError";
    rt.short_name = "UnmarshalFieldError";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/json.UnmarshalTypeError
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/json.UnmarshalTypeError";
    rt.short_name = "UnmarshalTypeError";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/json.UnmarshalTypeError
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/json.UnmarshalTypeError";
    rt.short_name = "UnmarshalTypeError";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/json.Unmarshaler
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/json.Unmarshaler";
    rt.short_name = "Unmarshaler";
    rt.is_interface = true;
    rt.method_names = encoding_json_Unmarshaler_methods;
    cbm_registry_add_type(reg, rt);

    // Type: encoding/json.Unmarshaler
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/json.Unmarshaler";
    rt.short_name = "Unmarshaler";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/json.UnsupportedTypeError
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/json.UnsupportedTypeError";
    rt.short_name = "UnsupportedTypeError";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/json.UnsupportedTypeError
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/json.UnsupportedTypeError";
    rt.short_name = "UnsupportedTypeError";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/json.UnsupportedValueError
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/json.UnsupportedValueError";
    rt.short_name = "UnsupportedValueError";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/json.UnsupportedValueError
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/json.UnsupportedValueError";
    rt.short_name = "UnsupportedValueError";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/xml.Attr
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/xml.Attr";
    rt.short_name = "Attr";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/xml.CharData
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/xml.CharData";
    rt.short_name = "CharData";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/xml.Comment
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/xml.Comment";
    rt.short_name = "Comment";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/xml.Decoder
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/xml.Decoder";
    rt.short_name = "Decoder";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/xml.Directive
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/xml.Directive";
    rt.short_name = "Directive";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/xml.Encoder
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/xml.Encoder";
    rt.short_name = "Encoder";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/xml.EndElement
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/xml.EndElement";
    rt.short_name = "EndElement";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/xml.Marshaler
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/xml.Marshaler";
    rt.short_name = "Marshaler";
    rt.is_interface = true;
    rt.method_names = encoding_xml_Marshaler_methods;
    cbm_registry_add_type(reg, rt);

    // Type: encoding/xml.MarshalerAttr
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/xml.MarshalerAttr";
    rt.short_name = "MarshalerAttr";
    rt.is_interface = true;
    rt.method_names = encoding_xml_MarshalerAttr_methods;
    cbm_registry_add_type(reg, rt);

    // Type: encoding/xml.Name
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/xml.Name";
    rt.short_name = "Name";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/xml.ProcInst
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/xml.ProcInst";
    rt.short_name = "ProcInst";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/xml.StartElement
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/xml.StartElement";
    rt.short_name = "StartElement";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/xml.SyntaxError
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/xml.SyntaxError";
    rt.short_name = "SyntaxError";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/xml.TagPathError
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/xml.TagPathError";
    rt.short_name = "TagPathError";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/xml.Token
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/xml.Token";
    rt.short_name = "Token";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/xml.TokenReader
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/xml.TokenReader";
    rt.short_name = "TokenReader";
    rt.is_interface = true;
    rt.method_names = encoding_xml_TokenReader_methods;
    cbm_registry_add_type(reg, rt);

    // Type: encoding/xml.UnmarshalError
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/xml.UnmarshalError";
    rt.short_name = "UnmarshalError";
    cbm_registry_add_type(reg, rt);

    // Type: encoding/xml.Unmarshaler
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/xml.Unmarshaler";
    rt.short_name = "Unmarshaler";
    rt.is_interface = true;
    rt.method_names = encoding_xml_Unmarshaler_methods;
    cbm_registry_add_type(reg, rt);

    // Type: encoding/xml.UnmarshalerAttr
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/xml.UnmarshalerAttr";
    rt.short_name = "UnmarshalerAttr";
    rt.is_interface = true;
    rt.method_names = encoding_xml_UnmarshalerAttr_methods;
    cbm_registry_add_type(reg, rt);

    // Type: encoding/xml.UnsupportedTypeError
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "encoding/xml.UnsupportedTypeError";
    rt.short_name = "UnsupportedTypeError";
    cbm_registry_add_type(reg, rt);

    // Type: fmt.Formatter
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "fmt.Formatter";
    rt.short_name = "Formatter";
    rt.is_interface = true;
    rt.method_names = fmt_Formatter_methods;
    cbm_registry_add_type(reg, rt);

    // Type: fmt.GoStringer
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "fmt.GoStringer";
    rt.short_name = "GoStringer";
    rt.is_interface = true;
    rt.method_names = fmt_GoStringer_methods;
    cbm_registry_add_type(reg, rt);

    // Type: fmt.ScanState
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "fmt.ScanState";
    rt.short_name = "ScanState";
    rt.is_interface = true;
    rt.method_names = fmt_ScanState_methods;
    cbm_registry_add_type(reg, rt);

    // Type: fmt.Scanner
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "fmt.Scanner";
    rt.short_name = "Scanner";
    rt.is_interface = true;
    rt.method_names = fmt_Scanner_methods;
    cbm_registry_add_type(reg, rt);

    // Type: fmt.State
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "fmt.State";
    rt.short_name = "State";
    rt.is_interface = true;
    rt.method_names = fmt_State_methods;
    cbm_registry_add_type(reg, rt);

    // Type: fmt.Stringer
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "fmt.Stringer";
    rt.short_name = "Stringer";
    rt.is_interface = true;
    rt.method_names = fmt_Stringer_methods;
    cbm_registry_add_type(reg, rt);

    // Type: hash.Cloner
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "hash.Cloner";
    rt.short_name = "Cloner";
    rt.is_interface = true;
    rt.method_names = hash_Cloner_methods;
    cbm_registry_add_type(reg, rt);

    // Type: hash.Hash
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "hash.Hash";
    rt.short_name = "Hash";
    rt.is_interface = true;
    rt.method_names = hash_Hash_methods;
    cbm_registry_add_type(reg, rt);

    // Type: hash.Hash32
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "hash.Hash32";
    rt.short_name = "Hash32";
    rt.is_interface = true;
    rt.method_names = hash_Hash32_methods;
    cbm_registry_add_type(reg, rt);

    // Type: hash.Hash64
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "hash.Hash64";
    rt.short_name = "Hash64";
    rt.is_interface = true;
    rt.method_names = hash_Hash64_methods;
    cbm_registry_add_type(reg, rt);

    // Type: hash.XOF
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "hash.XOF";
    rt.short_name = "XOF";
    rt.is_interface = true;
    rt.method_names = hash_XOF_methods;
    cbm_registry_add_type(reg, rt);

    // Type: io.ByteReader
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io.ByteReader";
    rt.short_name = "ByteReader";
    rt.is_interface = true;
    rt.method_names = io_ByteReader_methods;
    cbm_registry_add_type(reg, rt);

    // Type: io.ByteScanner
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io.ByteScanner";
    rt.short_name = "ByteScanner";
    rt.is_interface = true;
    rt.method_names = io_ByteScanner_methods;
    cbm_registry_add_type(reg, rt);

    // Type: io.ByteWriter
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io.ByteWriter";
    rt.short_name = "ByteWriter";
    rt.is_interface = true;
    rt.method_names = io_ByteWriter_methods;
    cbm_registry_add_type(reg, rt);

    // Type: io.Closer
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io.Closer";
    rt.short_name = "Closer";
    rt.is_interface = true;
    rt.method_names = io_Closer_methods;
    cbm_registry_add_type(reg, rt);

    // Type: io.LimitedReader
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io.LimitedReader";
    rt.short_name = "LimitedReader";
    cbm_registry_add_type(reg, rt);

    // Type: io.OffsetWriter
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io.OffsetWriter";
    rt.short_name = "OffsetWriter";
    cbm_registry_add_type(reg, rt);

    // Type: io.PipeReader
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io.PipeReader";
    rt.short_name = "PipeReader";
    cbm_registry_add_type(reg, rt);

    // Type: io.PipeWriter
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io.PipeWriter";
    rt.short_name = "PipeWriter";
    cbm_registry_add_type(reg, rt);

    // Type: io.ReadCloser
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io.ReadCloser";
    rt.short_name = "ReadCloser";
    rt.is_interface = true;
    cbm_registry_add_type(reg, rt);

    // Type: io.ReadSeekCloser
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io.ReadSeekCloser";
    rt.short_name = "ReadSeekCloser";
    rt.is_interface = true;
    cbm_registry_add_type(reg, rt);

    // Type: io.ReadSeeker
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io.ReadSeeker";
    rt.short_name = "ReadSeeker";
    rt.is_interface = true;
    cbm_registry_add_type(reg, rt);

    // Type: io.ReadWriteCloser
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io.ReadWriteCloser";
    rt.short_name = "ReadWriteCloser";
    rt.is_interface = true;
    cbm_registry_add_type(reg, rt);

    // Type: io.ReadWriteSeeker
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io.ReadWriteSeeker";
    rt.short_name = "ReadWriteSeeker";
    rt.is_interface = true;
    cbm_registry_add_type(reg, rt);

    // Type: io.ReadWriter
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io.ReadWriter";
    rt.short_name = "ReadWriter";
    rt.is_interface = true;
    cbm_registry_add_type(reg, rt);

    // Type: io.Reader
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io.Reader";
    rt.short_name = "Reader";
    rt.is_interface = true;
    rt.method_names = io_Reader_methods;
    cbm_registry_add_type(reg, rt);

    // Type: io.ReaderAt
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io.ReaderAt";
    rt.short_name = "ReaderAt";
    rt.is_interface = true;
    rt.method_names = io_ReaderAt_methods;
    cbm_registry_add_type(reg, rt);

    // Type: io.ReaderFrom
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io.ReaderFrom";
    rt.short_name = "ReaderFrom";
    rt.is_interface = true;
    rt.method_names = io_ReaderFrom_methods;
    cbm_registry_add_type(reg, rt);

    // Type: io.RuneReader
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io.RuneReader";
    rt.short_name = "RuneReader";
    rt.is_interface = true;
    rt.method_names = io_RuneReader_methods;
    cbm_registry_add_type(reg, rt);

    // Type: io.RuneScanner
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io.RuneScanner";
    rt.short_name = "RuneScanner";
    rt.is_interface = true;
    rt.method_names = io_RuneScanner_methods;
    cbm_registry_add_type(reg, rt);

    // Type: io.SectionReader
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io.SectionReader";
    rt.short_name = "SectionReader";
    cbm_registry_add_type(reg, rt);

    // Type: io.Seeker
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io.Seeker";
    rt.short_name = "Seeker";
    rt.is_interface = true;
    rt.method_names = io_Seeker_methods;
    cbm_registry_add_type(reg, rt);

    // Type: io.StringWriter
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io.StringWriter";
    rt.short_name = "StringWriter";
    rt.is_interface = true;
    rt.method_names = io_StringWriter_methods;
    cbm_registry_add_type(reg, rt);

    // Type: io.WriteCloser
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io.WriteCloser";
    rt.short_name = "WriteCloser";
    rt.is_interface = true;
    cbm_registry_add_type(reg, rt);

    // Type: io.WriteSeeker
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io.WriteSeeker";
    rt.short_name = "WriteSeeker";
    rt.is_interface = true;
    cbm_registry_add_type(reg, rt);

    // Type: io.Writer
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io.Writer";
    rt.short_name = "Writer";
    rt.is_interface = true;
    rt.method_names = io_Writer_methods;
    cbm_registry_add_type(reg, rt);

    // Type: io.WriterAt
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io.WriterAt";
    rt.short_name = "WriterAt";
    rt.is_interface = true;
    rt.method_names = io_WriterAt_methods;
    cbm_registry_add_type(reg, rt);

    // Type: io.WriterTo
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io.WriterTo";
    rt.short_name = "WriterTo";
    rt.is_interface = true;
    rt.method_names = io_WriterTo_methods;
    cbm_registry_add_type(reg, rt);

    // Type: io/fs.DirEntry
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io/fs.DirEntry";
    rt.short_name = "DirEntry";
    rt.is_interface = true;
    rt.method_names = io_fs_DirEntry_methods;
    cbm_registry_add_type(reg, rt);

    // Type: io/fs.FS
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io/fs.FS";
    rt.short_name = "FS";
    rt.is_interface = true;
    rt.method_names = io_fs_FS_methods;
    cbm_registry_add_type(reg, rt);

    // Type: io/fs.File
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io/fs.File";
    rt.short_name = "File";
    rt.is_interface = true;
    rt.method_names = io_fs_File_methods;
    cbm_registry_add_type(reg, rt);

    // Type: io/fs.FileInfo
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io/fs.FileInfo";
    rt.short_name = "FileInfo";
    rt.is_interface = true;
    rt.method_names = io_fs_FileInfo_methods;
    cbm_registry_add_type(reg, rt);

    // Type: io/fs.FileMode
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io/fs.FileMode";
    rt.short_name = "FileMode";
    cbm_registry_add_type(reg, rt);

    // Type: io/fs.GlobFS
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io/fs.GlobFS";
    rt.short_name = "GlobFS";
    rt.is_interface = true;
    rt.method_names = io_fs_GlobFS_methods;
    cbm_registry_add_type(reg, rt);

    // Type: io/fs.PathError
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io/fs.PathError";
    rt.short_name = "PathError";
    cbm_registry_add_type(reg, rt);

    // Type: io/fs.ReadDirFS
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io/fs.ReadDirFS";
    rt.short_name = "ReadDirFS";
    rt.is_interface = true;
    rt.method_names = io_fs_ReadDirFS_methods;
    cbm_registry_add_type(reg, rt);

    // Type: io/fs.ReadDirFile
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io/fs.ReadDirFile";
    rt.short_name = "ReadDirFile";
    rt.is_interface = true;
    rt.method_names = io_fs_ReadDirFile_methods;
    cbm_registry_add_type(reg, rt);

    // Type: io/fs.ReadFileFS
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io/fs.ReadFileFS";
    rt.short_name = "ReadFileFS";
    rt.is_interface = true;
    rt.method_names = io_fs_ReadFileFS_methods;
    cbm_registry_add_type(reg, rt);

    // Type: io/fs.ReadLinkFS
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io/fs.ReadLinkFS";
    rt.short_name = "ReadLinkFS";
    rt.is_interface = true;
    rt.method_names = io_fs_ReadLinkFS_methods;
    cbm_registry_add_type(reg, rt);

    // Type: io/fs.StatFS
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io/fs.StatFS";
    rt.short_name = "StatFS";
    rt.is_interface = true;
    rt.method_names = io_fs_StatFS_methods;
    cbm_registry_add_type(reg, rt);

    // Type: io/fs.SubFS
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io/fs.SubFS";
    rt.short_name = "SubFS";
    rt.is_interface = true;
    rt.method_names = io_fs_SubFS_methods;
    cbm_registry_add_type(reg, rt);

    // Type: io/fs.WalkDirFunc
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "io/fs.WalkDirFunc";
    rt.short_name = "WalkDirFunc";
    cbm_registry_add_type(reg, rt);

    // Type: log.Logger
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "log.Logger";
    rt.short_name = "Logger";
    cbm_registry_add_type(reg, rt);

    // Type: log/slog.Attr
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "log/slog.Attr";
    rt.short_name = "Attr";
    cbm_registry_add_type(reg, rt);

    // Type: log/slog.Handler
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "log/slog.Handler";
    rt.short_name = "Handler";
    rt.is_interface = true;
    rt.method_names = log_slog_Handler_methods;
    cbm_registry_add_type(reg, rt);

    // Type: log/slog.HandlerOptions
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "log/slog.HandlerOptions";
    rt.short_name = "HandlerOptions";
    cbm_registry_add_type(reg, rt);

    // Type: log/slog.JSONHandler
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "log/slog.JSONHandler";
    rt.short_name = "JSONHandler";
    cbm_registry_add_type(reg, rt);

    // Type: log/slog.Kind
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "log/slog.Kind";
    rt.short_name = "Kind";
    cbm_registry_add_type(reg, rt);

    // Type: log/slog.Level
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "log/slog.Level";
    rt.short_name = "Level";
    cbm_registry_add_type(reg, rt);

    // Type: log/slog.LevelVar
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "log/slog.LevelVar";
    rt.short_name = "LevelVar";
    cbm_registry_add_type(reg, rt);

    // Type: log/slog.Leveler
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "log/slog.Leveler";
    rt.short_name = "Leveler";
    rt.is_interface = true;
    rt.method_names = log_slog_Leveler_methods;
    cbm_registry_add_type(reg, rt);

    // Type: log/slog.LogValuer
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "log/slog.LogValuer";
    rt.short_name = "LogValuer";
    rt.is_interface = true;
    rt.method_names = log_slog_LogValuer_methods;
    cbm_registry_add_type(reg, rt);

    // Type: log/slog.Logger
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "log/slog.Logger";
    rt.short_name = "Logger";
    cbm_registry_add_type(reg, rt);

    // Type: log/slog.MultiHandler
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "log/slog.MultiHandler";
    rt.short_name = "MultiHandler";
    cbm_registry_add_type(reg, rt);

    // Type: log/slog.Record
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "log/slog.Record";
    rt.short_name = "Record";
    cbm_registry_add_type(reg, rt);

    // Type: log/slog.Source
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "log/slog.Source";
    rt.short_name = "Source";
    cbm_registry_add_type(reg, rt);

    // Type: log/slog.TextHandler
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "log/slog.TextHandler";
    rt.short_name = "TextHandler";
    cbm_registry_add_type(reg, rt);

    // Type: log/slog.Value
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "log/slog.Value";
    rt.short_name = "Value";
    cbm_registry_add_type(reg, rt);

    // Type: mime.WordDecoder
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "mime.WordDecoder";
    rt.short_name = "WordDecoder";
    cbm_registry_add_type(reg, rt);

    // Type: mime.WordEncoder
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "mime.WordEncoder";
    rt.short_name = "WordEncoder";
    cbm_registry_add_type(reg, rt);

    // Type: net.Addr
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net.Addr";
    rt.short_name = "Addr";
    rt.is_interface = true;
    rt.method_names = net_Addr_methods;
    cbm_registry_add_type(reg, rt);

    // Type: net.AddrError
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net.AddrError";
    rt.short_name = "AddrError";
    cbm_registry_add_type(reg, rt);

    // Type: net.Buffers
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net.Buffers";
    rt.short_name = "Buffers";
    cbm_registry_add_type(reg, rt);

    // Type: net.Conn
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net.Conn";
    rt.short_name = "Conn";
    rt.is_interface = true;
    rt.method_names = net_Conn_methods;
    cbm_registry_add_type(reg, rt);

    // Type: net.DNSConfigError
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net.DNSConfigError";
    rt.short_name = "DNSConfigError";
    cbm_registry_add_type(reg, rt);

    // Type: net.DNSError
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net.DNSError";
    rt.short_name = "DNSError";
    cbm_registry_add_type(reg, rt);

    // Type: net.Dialer
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net.Dialer";
    rt.short_name = "Dialer";
    cbm_registry_add_type(reg, rt);

    // Type: net.Error
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net.Error";
    rt.short_name = "Error";
    rt.is_interface = true;
    rt.method_names = net_Error_methods;
    cbm_registry_add_type(reg, rt);

    // Type: net.Flags
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net.Flags";
    rt.short_name = "Flags";
    cbm_registry_add_type(reg, rt);

    // Type: net.HardwareAddr
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net.HardwareAddr";
    rt.short_name = "HardwareAddr";
    cbm_registry_add_type(reg, rt);

    // Type: net.IP
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net.IP";
    rt.short_name = "IP";
    cbm_registry_add_type(reg, rt);

    // Type: net.IPAddr
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net.IPAddr";
    rt.short_name = "IPAddr";
    cbm_registry_add_type(reg, rt);

    // Type: net.IPConn
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net.IPConn";
    rt.short_name = "IPConn";
    cbm_registry_add_type(reg, rt);

    // Type: net.IPMask
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net.IPMask";
    rt.short_name = "IPMask";
    cbm_registry_add_type(reg, rt);

    // Type: net.IPNet
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net.IPNet";
    rt.short_name = "IPNet";
    cbm_registry_add_type(reg, rt);

    // Type: net.Interface
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net.Interface";
    rt.short_name = "Interface";
    cbm_registry_add_type(reg, rt);

    // Type: net.InvalidAddrError
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net.InvalidAddrError";
    rt.short_name = "InvalidAddrError";
    cbm_registry_add_type(reg, rt);

    // Type: net.KeepAliveConfig
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net.KeepAliveConfig";
    rt.short_name = "KeepAliveConfig";
    cbm_registry_add_type(reg, rt);

    // Type: net.ListenConfig
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net.ListenConfig";
    rt.short_name = "ListenConfig";
    cbm_registry_add_type(reg, rt);

    // Type: net.Listener
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net.Listener";
    rt.short_name = "Listener";
    rt.is_interface = true;
    rt.method_names = net_Listener_methods;
    cbm_registry_add_type(reg, rt);

    // Type: net.MX
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net.MX";
    rt.short_name = "MX";
    cbm_registry_add_type(reg, rt);

    // Type: net.NS
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net.NS";
    rt.short_name = "NS";
    cbm_registry_add_type(reg, rt);

    // Type: net.OpError
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net.OpError";
    rt.short_name = "OpError";
    cbm_registry_add_type(reg, rt);

    // Type: net.PacketConn
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net.PacketConn";
    rt.short_name = "PacketConn";
    rt.is_interface = true;
    rt.method_names = net_PacketConn_methods;
    cbm_registry_add_type(reg, rt);

    // Type: net.ParseError
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net.ParseError";
    rt.short_name = "ParseError";
    cbm_registry_add_type(reg, rt);

    // Type: net.Resolver
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net.Resolver";
    rt.short_name = "Resolver";
    cbm_registry_add_type(reg, rt);

    // Type: net.SRV
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net.SRV";
    rt.short_name = "SRV";
    cbm_registry_add_type(reg, rt);

    // Type: net.TCPAddr
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net.TCPAddr";
    rt.short_name = "TCPAddr";
    cbm_registry_add_type(reg, rt);

    // Type: net.TCPConn
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net.TCPConn";
    rt.short_name = "TCPConn";
    cbm_registry_add_type(reg, rt);

    // Type: net.TCPListener
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net.TCPListener";
    rt.short_name = "TCPListener";
    cbm_registry_add_type(reg, rt);

    // Type: net.UDPAddr
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net.UDPAddr";
    rt.short_name = "UDPAddr";
    cbm_registry_add_type(reg, rt);

    // Type: net.UDPConn
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net.UDPConn";
    rt.short_name = "UDPConn";
    cbm_registry_add_type(reg, rt);

    // Type: net.UnixAddr
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net.UnixAddr";
    rt.short_name = "UnixAddr";
    cbm_registry_add_type(reg, rt);

    // Type: net.UnixConn
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net.UnixConn";
    rt.short_name = "UnixConn";
    cbm_registry_add_type(reg, rt);

    // Type: net.UnixListener
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net.UnixListener";
    rt.short_name = "UnixListener";
    cbm_registry_add_type(reg, rt);

    // Type: net.UnknownNetworkError
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net.UnknownNetworkError";
    rt.short_name = "UnknownNetworkError";
    cbm_registry_add_type(reg, rt);

    // Type: net/http.Chan
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net/http.Chan";
    rt.short_name = "Chan";
    cbm_registry_add_type(reg, rt);

    // Type: net/http.Client
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net/http.Client";
    rt.short_name = "Client";
    cbm_registry_add_type(reg, rt);

    // Type: net/http.ClientConn
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net/http.ClientConn";
    rt.short_name = "ClientConn";
    cbm_registry_add_type(reg, rt);

    // Type: net/http.CloseNotifier
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net/http.CloseNotifier";
    rt.short_name = "CloseNotifier";
    rt.is_interface = true;
    rt.method_names = net_http_CloseNotifier_methods;
    cbm_registry_add_type(reg, rt);

    // Type: net/http.ConnState
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net/http.ConnState";
    rt.short_name = "ConnState";
    cbm_registry_add_type(reg, rt);

    // Type: net/http.Cookie
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net/http.Cookie";
    rt.short_name = "Cookie";
    cbm_registry_add_type(reg, rt);

    // Type: net/http.CookieJar
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net/http.CookieJar";
    rt.short_name = "CookieJar";
    rt.is_interface = true;
    rt.method_names = net_http_CookieJar_methods;
    cbm_registry_add_type(reg, rt);

    // Type: net/http.Counter
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net/http.Counter";
    rt.short_name = "Counter";
    cbm_registry_add_type(reg, rt);

    // Type: net/http.CrossOriginProtection
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net/http.CrossOriginProtection";
    rt.short_name = "CrossOriginProtection";
    cbm_registry_add_type(reg, rt);

    // Type: net/http.Dir
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net/http.Dir";
    rt.short_name = "Dir";
    cbm_registry_add_type(reg, rt);

    // Type: net/http.File
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net/http.File";
    rt.short_name = "File";
    rt.is_interface = true;
    rt.method_names = net_http_File_methods;
    cbm_registry_add_type(reg, rt);

    // Type: net/http.FileSystem
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net/http.FileSystem";
    rt.short_name = "FileSystem";
    rt.is_interface = true;
    rt.method_names = net_http_FileSystem_methods;
    cbm_registry_add_type(reg, rt);

    // Type: net/http.Flusher
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net/http.Flusher";
    rt.short_name = "Flusher";
    rt.is_interface = true;
    rt.method_names = net_http_Flusher_methods;
    cbm_registry_add_type(reg, rt);

    // Type: net/http.HTTP2Config
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net/http.HTTP2Config";
    rt.short_name = "HTTP2Config";
    cbm_registry_add_type(reg, rt);

    // Type: net/http.Handler
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net/http.Handler";
    rt.short_name = "Handler";
    rt.is_interface = true;
    rt.method_names = net_http_Handler_methods;
    cbm_registry_add_type(reg, rt);

    // Type: net/http.HandlerFunc
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net/http.HandlerFunc";
    rt.short_name = "HandlerFunc";
    cbm_registry_add_type(reg, rt);

    // Type: net/http.Header
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net/http.Header";
    rt.short_name = "Header";
    cbm_registry_add_type(reg, rt);

    // Type: net/http.Hijacker
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net/http.Hijacker";
    rt.short_name = "Hijacker";
    rt.is_interface = true;
    rt.method_names = net_http_Hijacker_methods;
    cbm_registry_add_type(reg, rt);

    // Type: net/http.MaxBytesError
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net/http.MaxBytesError";
    rt.short_name = "MaxBytesError";
    cbm_registry_add_type(reg, rt);

    // Type: net/http.ProtocolError
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net/http.ProtocolError";
    rt.short_name = "ProtocolError";
    cbm_registry_add_type(reg, rt);

    // Type: net/http.Protocols
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net/http.Protocols";
    rt.short_name = "Protocols";
    cbm_registry_add_type(reg, rt);

    // Type: net/http.PushOptions
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net/http.PushOptions";
    rt.short_name = "PushOptions";
    cbm_registry_add_type(reg, rt);

    // Type: net/http.Pusher
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net/http.Pusher";
    rt.short_name = "Pusher";
    rt.is_interface = true;
    rt.method_names = net_http_Pusher_methods;
    cbm_registry_add_type(reg, rt);

    // Type: net/http.Request
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net/http.Request";
    rt.short_name = "Request";
    cbm_registry_add_type(reg, rt);

    // Type: net/http.Response
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net/http.Response";
    rt.short_name = "Response";
    cbm_registry_add_type(reg, rt);

    // Type: net/http.ResponseController
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net/http.ResponseController";
    rt.short_name = "ResponseController";
    cbm_registry_add_type(reg, rt);

    // Type: net/http.ResponseWriter
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net/http.ResponseWriter";
    rt.short_name = "ResponseWriter";
    rt.is_interface = true;
    rt.method_names = net_http_ResponseWriter_methods;
    cbm_registry_add_type(reg, rt);

    // Type: net/http.RoundTripper
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net/http.RoundTripper";
    rt.short_name = "RoundTripper";
    rt.is_interface = true;
    rt.method_names = net_http_RoundTripper_methods;
    cbm_registry_add_type(reg, rt);

    // Type: net/http.SameSite
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net/http.SameSite";
    rt.short_name = "SameSite";
    cbm_registry_add_type(reg, rt);

    // Type: net/http.ServeMux
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net/http.ServeMux";
    rt.short_name = "ServeMux";
    cbm_registry_add_type(reg, rt);

    // Type: net/http.Server
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net/http.Server";
    rt.short_name = "Server";
    cbm_registry_add_type(reg, rt);

    // Type: net/http.Transport
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net/http.Transport";
    rt.short_name = "Transport";
    cbm_registry_add_type(reg, rt);

    // Type: net/url.Error
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net/url.Error";
    rt.short_name = "Error";
    cbm_registry_add_type(reg, rt);

    // Type: net/url.EscapeError
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net/url.EscapeError";
    rt.short_name = "EscapeError";
    cbm_registry_add_type(reg, rt);

    // Type: net/url.InvalidHostError
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net/url.InvalidHostError";
    rt.short_name = "InvalidHostError";
    cbm_registry_add_type(reg, rt);

    // Type: net/url.URL
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net/url.URL";
    rt.short_name = "URL";
    cbm_registry_add_type(reg, rt);

    // Type: net/url.Userinfo
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net/url.Userinfo";
    rt.short_name = "Userinfo";
    cbm_registry_add_type(reg, rt);

    // Type: net/url.Values
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "net/url.Values";
    rt.short_name = "Values";
    cbm_registry_add_type(reg, rt);

    // Type: os.DirEntry
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "os.DirEntry";
    rt.short_name = "DirEntry";
    cbm_registry_add_type(reg, rt);

    // Type: os.File
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "os.File";
    rt.short_name = "File";
    cbm_registry_add_type(reg, rt);

    // Type: os.FileInfo
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "os.FileInfo";
    rt.short_name = "FileInfo";
    cbm_registry_add_type(reg, rt);

    // Type: os.FileMode
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "os.FileMode";
    rt.short_name = "FileMode";
    cbm_registry_add_type(reg, rt);

    // Type: os.LinkError
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "os.LinkError";
    rt.short_name = "LinkError";
    cbm_registry_add_type(reg, rt);

    // Type: os.PathError
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "os.PathError";
    rt.short_name = "PathError";
    cbm_registry_add_type(reg, rt);

    // Type: os.ProcAttr
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "os.ProcAttr";
    rt.short_name = "ProcAttr";
    cbm_registry_add_type(reg, rt);

    // Type: os.Process
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "os.Process";
    rt.short_name = "Process";
    cbm_registry_add_type(reg, rt);

    // Type: os.ProcessState
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "os.ProcessState";
    rt.short_name = "ProcessState";
    cbm_registry_add_type(reg, rt);

    // Type: os.ProcessState
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "os.ProcessState";
    rt.short_name = "ProcessState";
    cbm_registry_add_type(reg, rt);

    // Type: os.Root
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "os.Root";
    rt.short_name = "Root";
    cbm_registry_add_type(reg, rt);

    // Type: os.Signal
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "os.Signal";
    rt.short_name = "Signal";
    rt.is_interface = true;
    rt.method_names = os_Signal_methods;
    cbm_registry_add_type(reg, rt);

    // Type: os.SyscallError
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "os.SyscallError";
    rt.short_name = "SyscallError";
    cbm_registry_add_type(reg, rt);

    // Type: os/exec.Cmd
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "os/exec.Cmd";
    rt.short_name = "Cmd";
    cbm_registry_add_type(reg, rt);

    // Type: os/exec.Error
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "os/exec.Error";
    rt.short_name = "Error";
    cbm_registry_add_type(reg, rt);

    // Type: os/exec.ExitError
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "os/exec.ExitError";
    rt.short_name = "ExitError";
    cbm_registry_add_type(reg, rt);

    // Type: path/filepath.WalkFunc
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "path/filepath.WalkFunc";
    rt.short_name = "WalkFunc";
    cbm_registry_add_type(reg, rt);

    // Type: regexp.Regexp
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "regexp.Regexp";
    rt.short_name = "Regexp";
    cbm_registry_add_type(reg, rt);

    // Type: sort.Float64Slice
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "sort.Float64Slice";
    rt.short_name = "Float64Slice";
    cbm_registry_add_type(reg, rt);

    // Type: sort.IntSlice
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "sort.IntSlice";
    rt.short_name = "IntSlice";
    cbm_registry_add_type(reg, rt);

    // Type: sort.Interface
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "sort.Interface";
    rt.short_name = "Interface";
    rt.is_interface = true;
    rt.method_names = sort_Interface_methods;
    cbm_registry_add_type(reg, rt);

    // Type: sort.StringSlice
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "sort.StringSlice";
    rt.short_name = "StringSlice";
    cbm_registry_add_type(reg, rt);

    // Type: sort.Variant
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "sort.Variant";
    rt.short_name = "Variant";
    cbm_registry_add_type(reg, rt);

    // Type: strconv.NumError
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "strconv.NumError";
    rt.short_name = "NumError";
    cbm_registry_add_type(reg, rt);

    // Type: strings.Builder
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "strings.Builder";
    rt.short_name = "Builder";
    cbm_registry_add_type(reg, rt);

    // Type: strings.Reader
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "strings.Reader";
    rt.short_name = "Reader";
    cbm_registry_add_type(reg, rt);

    // Type: strings.Replacer
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "strings.Replacer";
    rt.short_name = "Replacer";
    cbm_registry_add_type(reg, rt);

    // Type: sync.Cond
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "sync.Cond";
    rt.short_name = "Cond";
    cbm_registry_add_type(reg, rt);

    // Type: sync.Locker
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "sync.Locker";
    rt.short_name = "Locker";
    rt.is_interface = true;
    rt.method_names = sync_Locker_methods;
    cbm_registry_add_type(reg, rt);

    // Type: sync.Map
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "sync.Map";
    rt.short_name = "Map";
    cbm_registry_add_type(reg, rt);

    // Type: sync.Mutex
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "sync.Mutex";
    rt.short_name = "Mutex";
    cbm_registry_add_type(reg, rt);

    // Type: sync.Once
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "sync.Once";
    rt.short_name = "Once";
    cbm_registry_add_type(reg, rt);

    // Type: sync.Pool
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "sync.Pool";
    rt.short_name = "Pool";
    cbm_registry_add_type(reg, rt);

    // Type: sync.RWMutex
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "sync.RWMutex";
    rt.short_name = "RWMutex";
    cbm_registry_add_type(reg, rt);

    // Type: sync.WaitGroup
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "sync.WaitGroup";
    rt.short_name = "WaitGroup";
    cbm_registry_add_type(reg, rt);

    // Type: sync/atomic.Bool
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "sync/atomic.Bool";
    rt.short_name = "Bool";
    cbm_registry_add_type(reg, rt);

    // Type: sync/atomic.Int32
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "sync/atomic.Int32";
    rt.short_name = "Int32";
    cbm_registry_add_type(reg, rt);

    // Type: sync/atomic.Int64
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "sync/atomic.Int64";
    rt.short_name = "Int64";
    cbm_registry_add_type(reg, rt);

    // Type: sync/atomic.Pointer
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "sync/atomic.Pointer";
    rt.short_name = "Pointer";
    cbm_registry_add_type(reg, rt);

    // Type: sync/atomic.Uint32
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "sync/atomic.Uint32";
    rt.short_name = "Uint32";
    cbm_registry_add_type(reg, rt);

    // Type: sync/atomic.Uint64
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "sync/atomic.Uint64";
    rt.short_name = "Uint64";
    cbm_registry_add_type(reg, rt);

    // Type: sync/atomic.Uintptr
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "sync/atomic.Uintptr";
    rt.short_name = "Uintptr";
    cbm_registry_add_type(reg, rt);

    // Type: sync/atomic.Value
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "sync/atomic.Value";
    rt.short_name = "Value";
    cbm_registry_add_type(reg, rt);

    // Type: testing.B
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "testing.B";
    rt.short_name = "B";
    cbm_registry_add_type(reg, rt);

    // Type: testing.BenchmarkResult
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "testing.BenchmarkResult";
    rt.short_name = "BenchmarkResult";
    cbm_registry_add_type(reg, rt);

    // Type: testing.Cover
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "testing.Cover";
    rt.short_name = "Cover";
    cbm_registry_add_type(reg, rt);

    // Type: testing.CoverBlock
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "testing.CoverBlock";
    rt.short_name = "CoverBlock";
    cbm_registry_add_type(reg, rt);

    // Type: testing.F
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "testing.F";
    rt.short_name = "F";
    cbm_registry_add_type(reg, rt);

    // Type: testing.InternalBenchmark
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "testing.InternalBenchmark";
    rt.short_name = "InternalBenchmark";
    cbm_registry_add_type(reg, rt);

    // Type: testing.InternalExample
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "testing.InternalExample";
    rt.short_name = "InternalExample";
    cbm_registry_add_type(reg, rt);

    // Type: testing.InternalFuzzTarget
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "testing.InternalFuzzTarget";
    rt.short_name = "InternalFuzzTarget";
    cbm_registry_add_type(reg, rt);

    // Type: testing.InternalTest
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "testing.InternalTest";
    rt.short_name = "InternalTest";
    cbm_registry_add_type(reg, rt);

    // Type: testing.M
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "testing.M";
    rt.short_name = "M";
    cbm_registry_add_type(reg, rt);

    // Type: testing.PB
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "testing.PB";
    rt.short_name = "PB";
    cbm_registry_add_type(reg, rt);

    // Type: testing.T
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "testing.T";
    rt.short_name = "T";
    cbm_registry_add_type(reg, rt);

    // Type: testing.TB
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "testing.TB";
    rt.short_name = "TB";
    rt.is_interface = true;
    rt.method_names = testing_TB_methods;
    cbm_registry_add_type(reg, rt);

    // Type: text/template.ExecError
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "text/template.ExecError";
    rt.short_name = "ExecError";
    cbm_registry_add_type(reg, rt);

    // Type: text/template.FuncMap
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "text/template.FuncMap";
    rt.short_name = "FuncMap";
    cbm_registry_add_type(reg, rt);

    // Type: text/template.Template
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "text/template.Template";
    rt.short_name = "Template";
    cbm_registry_add_type(reg, rt);

    // Type: time.Duration
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "time.Duration";
    rt.short_name = "Duration";
    cbm_registry_add_type(reg, rt);

    // Type: time.Location
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "time.Location";
    rt.short_name = "Location";
    cbm_registry_add_type(reg, rt);

    // Type: time.MapZone
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "time.MapZone";
    rt.short_name = "MapZone";
    cbm_registry_add_type(reg, rt);

    // Type: time.Month
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "time.Month";
    rt.short_name = "Month";
    cbm_registry_add_type(reg, rt);

    // Type: time.ParseError
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "time.ParseError";
    rt.short_name = "ParseError";
    cbm_registry_add_type(reg, rt);

    // Type: time.SupplementalData
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "time.SupplementalData";
    rt.short_name = "SupplementalData";
    cbm_registry_add_type(reg, rt);

    // Type: time.Ticker
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "time.Ticker";
    rt.short_name = "Ticker";
    cbm_registry_add_type(reg, rt);

    // Type: time.Time
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "time.Time";
    rt.short_name = "Time";
    cbm_registry_add_type(reg, rt);

    // Type: time.Timer
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "time.Timer";
    rt.short_name = "Timer";
    cbm_registry_add_type(reg, rt);

    // Type: time.Weekday
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "time.Weekday";
    rt.short_name = "Weekday";
    cbm_registry_add_type(reg, rt);

    // Type: unicode.CaseRange
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unicode.CaseRange";
    rt.short_name = "CaseRange";
    cbm_registry_add_type(reg, rt);

    // Type: unicode.Range16
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unicode.Range16";
    rt.short_name = "Range16";
    cbm_registry_add_type(reg, rt);

    // Type: unicode.Range32
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unicode.Range32";
    rt.short_name = "Range32";
    cbm_registry_add_type(reg, rt);

    // Type: unicode.RangeTable
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unicode.RangeTable";
    rt.short_name = "RangeTable";
    cbm_registry_add_type(reg, rt);

    // Type: unicode.SpecialCase
    memset(&rt, 0, sizeof(rt));
    rt.qualified_name = "unicode.SpecialCase";
    rt.short_name = "SpecialCase";
    cbm_registry_add_type(reg, rt);

    // bufio.Writer.Available
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bufio.Writer.Available";
    rf.short_name = "Available";
    rf.receiver_type = "bufio.Writer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bufio.Writer.AvailableBuffer
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bufio.Writer.AvailableBuffer";
    rf.short_name = "AvailableBuffer";
    rf.receiver_type = "bufio.Writer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bufio.Scanner.Buffer
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bufio.Scanner.Buffer";
    rf.short_name = "Buffer";
    rf.receiver_type = "bufio.Scanner";
    cbm_registry_add_func(reg, rf);

    // bufio.Writer.Buffered
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bufio.Writer.Buffered";
    rf.short_name = "Buffered";
    rf.receiver_type = "bufio.Writer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bufio.Reader.Buffered
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bufio.Reader.Buffered";
    rf.short_name = "Buffered";
    rf.receiver_type = "bufio.Reader";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bufio.Scanner.Bytes
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bufio.Scanner.Bytes";
    rf.short_name = "Bytes";
    rf.receiver_type = "bufio.Scanner";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bufio.Reader.Discard
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bufio.Reader.Discard";
    rf.short_name = "Discard";
    rf.receiver_type = "bufio.Reader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bufio.Scanner.Err
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bufio.Scanner.Err";
    rf.short_name = "Err";
    rf.receiver_type = "bufio.Scanner";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bufio.Writer.Flush
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bufio.Writer.Flush";
    rf.short_name = "Flush";
    rf.receiver_type = "bufio.Writer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bufio.NewReadWriter
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bufio.NewReadWriter";
    rf.short_name = "NewReadWriter";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "bufio.ReadWriter"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bufio.NewReader
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bufio.NewReader";
    rf.short_name = "NewReader";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "bufio.Reader"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bufio.NewReaderSize
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bufio.NewReaderSize";
    rf.short_name = "NewReaderSize";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "bufio.Reader"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bufio.NewScanner
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bufio.NewScanner";
    rf.short_name = "NewScanner";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "bufio.Scanner"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bufio.NewWriter
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bufio.NewWriter";
    rf.short_name = "NewWriter";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "bufio.Writer"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bufio.NewWriterSize
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bufio.NewWriterSize";
    rf.short_name = "NewWriterSize";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "bufio.Writer"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bufio.Reader.Peek
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bufio.Reader.Peek";
    rf.short_name = "Peek";
    rf.receiver_type = "bufio.Reader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bufio.Reader.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bufio.Reader.Read";
    rf.short_name = "Read";
    rf.receiver_type = "bufio.Reader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bufio.Reader.ReadByte
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bufio.Reader.ReadByte";
    rf.short_name = "ReadByte";
    rf.receiver_type = "bufio.Reader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "byte");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bufio.Reader.ReadBytes
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bufio.Reader.ReadBytes";
    rf.short_name = "ReadBytes";
    rf.receiver_type = "bufio.Reader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bufio.Writer.ReadFrom
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bufio.Writer.ReadFrom";
    rf.short_name = "ReadFrom";
    rf.receiver_type = "bufio.Writer";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bufio.Reader.ReadLine
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bufio.Reader.ReadLine";
    rf.short_name = "ReadLine";
    rf.receiver_type = "bufio.Reader";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "bool");
        ret[2] = cbm_type_builtin(arena, "error");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bufio.Reader.ReadRune
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bufio.Reader.ReadRune";
    rf.short_name = "ReadRune";
    rf.receiver_type = "bufio.Reader";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_builtin(arena, "rune");
        ret[1] = cbm_type_builtin(arena, "int");
        ret[2] = cbm_type_builtin(arena, "error");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bufio.Reader.ReadSlice
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bufio.Reader.ReadSlice";
    rf.short_name = "ReadSlice";
    rf.receiver_type = "bufio.Reader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bufio.Reader.ReadString
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bufio.Reader.ReadString";
    rf.short_name = "ReadString";
    rf.receiver_type = "bufio.Reader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bufio.Writer.Reset
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bufio.Writer.Reset";
    rf.short_name = "Reset";
    rf.receiver_type = "bufio.Writer";
    cbm_registry_add_func(reg, rf);

    // bufio.Reader.Reset
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bufio.Reader.Reset";
    rf.short_name = "Reset";
    rf.receiver_type = "bufio.Reader";
    cbm_registry_add_func(reg, rf);

    // bufio.Scanner.Scan
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bufio.Scanner.Scan";
    rf.short_name = "Scan";
    rf.receiver_type = "bufio.Scanner";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bufio.ScanBytes
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bufio.ScanBytes";
    rf.short_name = "ScanBytes";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[2] = cbm_type_builtin(arena, "error");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bufio.ScanLines
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bufio.ScanLines";
    rf.short_name = "ScanLines";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[2] = cbm_type_builtin(arena, "error");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bufio.ScanRunes
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bufio.ScanRunes";
    rf.short_name = "ScanRunes";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[2] = cbm_type_builtin(arena, "error");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bufio.ScanWords
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bufio.ScanWords";
    rf.short_name = "ScanWords";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[2] = cbm_type_builtin(arena, "error");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bufio.Writer.Size
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bufio.Writer.Size";
    rf.short_name = "Size";
    rf.receiver_type = "bufio.Writer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bufio.Reader.Size
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bufio.Reader.Size";
    rf.short_name = "Size";
    rf.receiver_type = "bufio.Reader";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bufio.Scanner.Split
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bufio.Scanner.Split";
    rf.short_name = "Split";
    rf.receiver_type = "bufio.Scanner";
    cbm_registry_add_func(reg, rf);

    // bufio.Scanner.Text
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bufio.Scanner.Text";
    rf.short_name = "Text";
    rf.receiver_type = "bufio.Scanner";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bufio.Reader.UnreadByte
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bufio.Reader.UnreadByte";
    rf.short_name = "UnreadByte";
    rf.receiver_type = "bufio.Reader";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bufio.Reader.UnreadRune
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bufio.Reader.UnreadRune";
    rf.short_name = "UnreadRune";
    rf.receiver_type = "bufio.Reader";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bufio.Writer.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bufio.Writer.Write";
    rf.short_name = "Write";
    rf.receiver_type = "bufio.Writer";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bufio.Writer.WriteByte
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bufio.Writer.WriteByte";
    rf.short_name = "WriteByte";
    rf.receiver_type = "bufio.Writer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bufio.Writer.WriteRune
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bufio.Writer.WriteRune";
    rf.short_name = "WriteRune";
    rf.receiver_type = "bufio.Writer";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bufio.Writer.WriteString
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bufio.Writer.WriteString";
    rf.short_name = "WriteString";
    rf.receiver_type = "bufio.Writer";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bufio.Reader.WriteTo
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bufio.Reader.WriteTo";
    rf.short_name = "WriteTo";
    rf.receiver_type = "bufio.Reader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Buffer.Available
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Buffer.Available";
    rf.short_name = "Available";
    rf.receiver_type = "bytes.Buffer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Buffer.AvailableBuffer
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Buffer.AvailableBuffer";
    rf.short_name = "AvailableBuffer";
    rf.receiver_type = "bytes.Buffer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Buffer.Bytes
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Buffer.Bytes";
    rf.short_name = "Bytes";
    rf.receiver_type = "bytes.Buffer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Buffer.Cap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Buffer.Cap";
    rf.short_name = "Cap";
    rf.receiver_type = "bytes.Buffer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Clone
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Clone";
    rf.short_name = "Clone";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Compare
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Compare";
    rf.short_name = "Compare";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Contains
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Contains";
    rf.short_name = "Contains";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.ContainsAny
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.ContainsAny";
    rf.short_name = "ContainsAny";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.ContainsFunc
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.ContainsFunc";
    rf.short_name = "ContainsFunc";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.ContainsRune
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.ContainsRune";
    rf.short_name = "ContainsRune";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Count
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Count";
    rf.short_name = "Count";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Cut
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Cut";
    rf.short_name = "Cut";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[2] = cbm_type_builtin(arena, "bool");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.CutPrefix
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.CutPrefix";
    rf.short_name = "CutPrefix";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "bool");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.CutSuffix
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.CutSuffix";
    rf.short_name = "CutSuffix";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "bool");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Equal
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Equal";
    rf.short_name = "Equal";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.EqualFold
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.EqualFold";
    rf.short_name = "EqualFold";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Fields
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Fields";
    rf.short_name = "Fields";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "bytes.[]byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.FieldsFunc
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.FieldsFunc";
    rf.short_name = "FieldsFunc";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "bytes.[]byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.FieldsFuncSeq
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.FieldsFuncSeq";
    rf.short_name = "FieldsFuncSeq";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "any");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.FieldsSeq
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.FieldsSeq";
    rf.short_name = "FieldsSeq";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "any");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Buffer.Grow
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Buffer.Grow";
    rf.short_name = "Grow";
    rf.receiver_type = "bytes.Buffer";
    cbm_registry_add_func(reg, rf);

    // bytes.HasPrefix
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.HasPrefix";
    rf.short_name = "HasPrefix";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.HasSuffix
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.HasSuffix";
    rf.short_name = "HasSuffix";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Index
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Index";
    rf.short_name = "Index";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.IndexAny
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.IndexAny";
    rf.short_name = "IndexAny";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.IndexByte
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.IndexByte";
    rf.short_name = "IndexByte";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.IndexFunc
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.IndexFunc";
    rf.short_name = "IndexFunc";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.IndexRune
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.IndexRune";
    rf.short_name = "IndexRune";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Join
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Join";
    rf.short_name = "Join";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.LastIndex
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.LastIndex";
    rf.short_name = "LastIndex";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.LastIndexAny
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.LastIndexAny";
    rf.short_name = "LastIndexAny";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.LastIndexByte
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.LastIndexByte";
    rf.short_name = "LastIndexByte";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.LastIndexFunc
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.LastIndexFunc";
    rf.short_name = "LastIndexFunc";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Buffer.Len
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Buffer.Len";
    rf.short_name = "Len";
    rf.receiver_type = "bytes.Buffer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Reader.Len
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Reader.Len";
    rf.short_name = "Len";
    rf.receiver_type = "bytes.Reader";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Lines
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Lines";
    rf.short_name = "Lines";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "any");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Map
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Map";
    rf.short_name = "Map";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.NewBuffer
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.NewBuffer";
    rf.short_name = "NewBuffer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "bytes.Buffer"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.NewBufferString
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.NewBufferString";
    rf.short_name = "NewBufferString";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "bytes.Buffer"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.NewReader
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.NewReader";
    rf.short_name = "NewReader";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "bytes.Reader"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Buffer.Next
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Buffer.Next";
    rf.short_name = "Next";
    rf.receiver_type = "bytes.Buffer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Buffer.Peek
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Buffer.Peek";
    rf.short_name = "Peek";
    rf.receiver_type = "bytes.Buffer";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Buffer.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Buffer.Read";
    rf.short_name = "Read";
    rf.receiver_type = "bytes.Buffer";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Reader.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Reader.Read";
    rf.short_name = "Read";
    rf.receiver_type = "bytes.Reader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Reader.ReadAt
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Reader.ReadAt";
    rf.short_name = "ReadAt";
    rf.receiver_type = "bytes.Reader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Reader.ReadByte
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Reader.ReadByte";
    rf.short_name = "ReadByte";
    rf.receiver_type = "bytes.Reader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "byte");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Buffer.ReadByte
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Buffer.ReadByte";
    rf.short_name = "ReadByte";
    rf.receiver_type = "bytes.Buffer";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "byte");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Buffer.ReadBytes
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Buffer.ReadBytes";
    rf.short_name = "ReadBytes";
    rf.receiver_type = "bytes.Buffer";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Buffer.ReadFrom
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Buffer.ReadFrom";
    rf.short_name = "ReadFrom";
    rf.receiver_type = "bytes.Buffer";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Buffer.ReadRune
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Buffer.ReadRune";
    rf.short_name = "ReadRune";
    rf.receiver_type = "bytes.Buffer";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_builtin(arena, "rune");
        ret[1] = cbm_type_builtin(arena, "int");
        ret[2] = cbm_type_builtin(arena, "error");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Reader.ReadRune
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Reader.ReadRune";
    rf.short_name = "ReadRune";
    rf.receiver_type = "bytes.Reader";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_builtin(arena, "rune");
        ret[1] = cbm_type_builtin(arena, "int");
        ret[2] = cbm_type_builtin(arena, "error");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Buffer.ReadString
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Buffer.ReadString";
    rf.short_name = "ReadString";
    rf.receiver_type = "bytes.Buffer";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Repeat
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Repeat";
    rf.short_name = "Repeat";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Replace
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Replace";
    rf.short_name = "Replace";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.ReplaceAll
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.ReplaceAll";
    rf.short_name = "ReplaceAll";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Reader.Reset
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Reader.Reset";
    rf.short_name = "Reset";
    rf.receiver_type = "bytes.Reader";
    cbm_registry_add_func(reg, rf);

    // bytes.Buffer.Reset
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Buffer.Reset";
    rf.short_name = "Reset";
    rf.receiver_type = "bytes.Buffer";
    cbm_registry_add_func(reg, rf);

    // bytes.Runes
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Runes";
    rf.short_name = "Runes";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "rune"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Reader.Seek
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Reader.Seek";
    rf.short_name = "Seek";
    rf.receiver_type = "bytes.Reader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Reader.Size
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Reader.Size";
    rf.short_name = "Size";
    rf.receiver_type = "bytes.Reader";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Split
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Split";
    rf.short_name = "Split";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "bytes.[]byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.SplitAfter
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.SplitAfter";
    rf.short_name = "SplitAfter";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "bytes.[]byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.SplitAfterN
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.SplitAfterN";
    rf.short_name = "SplitAfterN";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "bytes.[]byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.SplitAfterSeq
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.SplitAfterSeq";
    rf.short_name = "SplitAfterSeq";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "any");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.SplitN
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.SplitN";
    rf.short_name = "SplitN";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "bytes.[]byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.SplitSeq
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.SplitSeq";
    rf.short_name = "SplitSeq";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "any");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Buffer.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Buffer.String";
    rf.short_name = "String";
    rf.receiver_type = "bytes.Buffer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Title
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Title";
    rf.short_name = "Title";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.ToLower
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.ToLower";
    rf.short_name = "ToLower";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.ToLowerSpecial
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.ToLowerSpecial";
    rf.short_name = "ToLowerSpecial";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.ToTitle
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.ToTitle";
    rf.short_name = "ToTitle";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.ToTitleSpecial
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.ToTitleSpecial";
    rf.short_name = "ToTitleSpecial";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.ToUpper
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.ToUpper";
    rf.short_name = "ToUpper";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.ToUpperSpecial
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.ToUpperSpecial";
    rf.short_name = "ToUpperSpecial";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.ToValidUTF8
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.ToValidUTF8";
    rf.short_name = "ToValidUTF8";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Trim
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Trim";
    rf.short_name = "Trim";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.TrimFunc
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.TrimFunc";
    rf.short_name = "TrimFunc";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.TrimLeft
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.TrimLeft";
    rf.short_name = "TrimLeft";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.TrimLeftFunc
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.TrimLeftFunc";
    rf.short_name = "TrimLeftFunc";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.TrimPrefix
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.TrimPrefix";
    rf.short_name = "TrimPrefix";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.TrimRight
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.TrimRight";
    rf.short_name = "TrimRight";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.TrimRightFunc
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.TrimRightFunc";
    rf.short_name = "TrimRightFunc";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.TrimSpace
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.TrimSpace";
    rf.short_name = "TrimSpace";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.TrimSuffix
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.TrimSuffix";
    rf.short_name = "TrimSuffix";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Buffer.Truncate
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Buffer.Truncate";
    rf.short_name = "Truncate";
    rf.receiver_type = "bytes.Buffer";
    cbm_registry_add_func(reg, rf);

    // bytes.Buffer.UnreadByte
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Buffer.UnreadByte";
    rf.short_name = "UnreadByte";
    rf.receiver_type = "bytes.Buffer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Reader.UnreadByte
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Reader.UnreadByte";
    rf.short_name = "UnreadByte";
    rf.receiver_type = "bytes.Reader";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Reader.UnreadRune
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Reader.UnreadRune";
    rf.short_name = "UnreadRune";
    rf.receiver_type = "bytes.Reader";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Buffer.UnreadRune
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Buffer.UnreadRune";
    rf.short_name = "UnreadRune";
    rf.receiver_type = "bytes.Buffer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Buffer.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Buffer.Write";
    rf.short_name = "Write";
    rf.receiver_type = "bytes.Buffer";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Buffer.WriteByte
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Buffer.WriteByte";
    rf.short_name = "WriteByte";
    rf.receiver_type = "bytes.Buffer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Buffer.WriteRune
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Buffer.WriteRune";
    rf.short_name = "WriteRune";
    rf.receiver_type = "bytes.Buffer";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Buffer.WriteString
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Buffer.WriteString";
    rf.short_name = "WriteString";
    rf.receiver_type = "bytes.Buffer";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Reader.WriteTo
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Reader.WriteTo";
    rf.short_name = "WriteTo";
    rf.receiver_type = "bytes.Reader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // bytes.Buffer.WriteTo
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "bytes.Buffer.WriteTo";
    rf.short_name = "WriteTo";
    rf.receiver_type = "bytes.Buffer";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // context.AfterFunc
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "context.AfterFunc";
    rf.short_name = "AfterFunc";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "context.func()");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // context.Background
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "context.Background";
    rf.short_name = "Background";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "context.Context");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // context.Cause
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "context.Cause";
    rf.short_name = "Cause";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // context.emptyCtx.Deadline
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "context.emptyCtx.Deadline";
    rf.short_name = "Deadline";
    rf.receiver_type = "context.emptyCtx";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "time.Time");
        ret[1] = cbm_type_builtin(arena, "bool");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // context.timerCtx.Deadline
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "context.timerCtx.Deadline";
    rf.short_name = "Deadline";
    rf.receiver_type = "context.timerCtx";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "time.Time");
        ret[1] = cbm_type_builtin(arena, "bool");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // context.withoutCancelCtx.Deadline
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "context.withoutCancelCtx.Deadline";
    rf.short_name = "Deadline";
    rf.receiver_type = "context.withoutCancelCtx";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "time.Time");
        ret[1] = cbm_type_builtin(arena, "bool");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // context.withoutCancelCtx.Done
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "context.withoutCancelCtx.Done";
    rf.short_name = "Done";
    rf.receiver_type = "context.withoutCancelCtx";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "context.chan any");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // context.emptyCtx.Done
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "context.emptyCtx.Done";
    rf.short_name = "Done";
    rf.receiver_type = "context.emptyCtx";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "context.chan any");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // context.cancelCtx.Done
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "context.cancelCtx.Done";
    rf.short_name = "Done";
    rf.receiver_type = "context.cancelCtx";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "context.chan any");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // context.emptyCtx.Err
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "context.emptyCtx.Err";
    rf.short_name = "Err";
    rf.receiver_type = "context.emptyCtx";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // context.cancelCtx.Err
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "context.cancelCtx.Err";
    rf.short_name = "Err";
    rf.receiver_type = "context.cancelCtx";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // context.withoutCancelCtx.Err
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "context.withoutCancelCtx.Err";
    rf.short_name = "Err";
    rf.receiver_type = "context.withoutCancelCtx";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // context.deadlineExceededError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "context.deadlineExceededError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "context.deadlineExceededError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // context.todoCtx.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "context.todoCtx.String";
    rf.short_name = "String";
    rf.receiver_type = "context.todoCtx";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // context.withoutCancelCtx.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "context.withoutCancelCtx.String";
    rf.short_name = "String";
    rf.receiver_type = "context.withoutCancelCtx";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // context.valueCtx.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "context.valueCtx.String";
    rf.short_name = "String";
    rf.receiver_type = "context.valueCtx";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // context.backgroundCtx.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "context.backgroundCtx.String";
    rf.short_name = "String";
    rf.receiver_type = "context.backgroundCtx";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // context.cancelCtx.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "context.cancelCtx.String";
    rf.short_name = "String";
    rf.receiver_type = "context.cancelCtx";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // context.timerCtx.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "context.timerCtx.String";
    rf.short_name = "String";
    rf.receiver_type = "context.timerCtx";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // context.TODO
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "context.TODO";
    rf.short_name = "TODO";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "context.Context");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // context.deadlineExceededError.Temporary
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "context.deadlineExceededError.Temporary";
    rf.short_name = "Temporary";
    rf.receiver_type = "context.deadlineExceededError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // context.deadlineExceededError.Timeout
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "context.deadlineExceededError.Timeout";
    rf.short_name = "Timeout";
    rf.receiver_type = "context.deadlineExceededError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // context.emptyCtx.Value
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "context.emptyCtx.Value";
    rf.short_name = "Value";
    rf.receiver_type = "context.emptyCtx";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "any");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // context.cancelCtx.Value
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "context.cancelCtx.Value";
    rf.short_name = "Value";
    rf.receiver_type = "context.cancelCtx";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "any");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // context.withoutCancelCtx.Value
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "context.withoutCancelCtx.Value";
    rf.short_name = "Value";
    rf.receiver_type = "context.withoutCancelCtx";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "any");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // context.valueCtx.Value
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "context.valueCtx.Value";
    rf.short_name = "Value";
    rf.receiver_type = "context.valueCtx";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "any");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // context.WithCancel
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "context.WithCancel";
    rf.short_name = "WithCancel";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "context.Context");
        ret[1] = cbm_type_named(arena, "context.CancelFunc");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // context.WithCancelCause
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "context.WithCancelCause";
    rf.short_name = "WithCancelCause";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "context.Context");
        ret[1] = cbm_type_named(arena, "context.CancelCauseFunc");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // context.WithDeadline
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "context.WithDeadline";
    rf.short_name = "WithDeadline";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "context.Context");
        ret[1] = cbm_type_named(arena, "context.CancelFunc");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // context.WithDeadlineCause
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "context.WithDeadlineCause";
    rf.short_name = "WithDeadlineCause";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "context.Context");
        ret[1] = cbm_type_named(arena, "context.CancelFunc");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // context.WithTimeout
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "context.WithTimeout";
    rf.short_name = "WithTimeout";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "context.Context");
        ret[1] = cbm_type_named(arena, "context.CancelFunc");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // context.WithTimeoutCause
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "context.WithTimeoutCause";
    rf.short_name = "WithTimeoutCause";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "context.Context");
        ret[1] = cbm_type_named(arena, "context.CancelFunc");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // context.WithValue
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "context.WithValue";
    rf.short_name = "WithValue";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "context.Context");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // context.WithoutCancel
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "context.WithoutCancel";
    rf.short_name = "WithoutCancel";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "context.Context");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // crypto.Hash.Available
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "crypto.Hash.Available";
    rf.short_name = "Available";
    rf.receiver_type = "crypto.Hash";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // crypto.Hash.HashFunc
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "crypto.Hash.HashFunc";
    rf.short_name = "HashFunc";
    rf.receiver_type = "crypto.Hash";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "crypto.Hash");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // crypto.Hash.New
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "crypto.Hash.New";
    rf.short_name = "New";
    rf.receiver_type = "crypto.Hash";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "hash.Hash");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // crypto.RegisterHash
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "crypto.RegisterHash";
    rf.short_name = "RegisterHash";
    cbm_registry_add_func(reg, rf);

    // crypto.SignMessage
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "crypto.SignMessage";
    rf.short_name = "SignMessage";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // crypto.Hash.Size
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "crypto.Hash.Size";
    rf.short_name = "Size";
    rf.receiver_type = "crypto.Hash";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // crypto.Hash.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "crypto.Hash.String";
    rf.short_name = "String";
    rf.receiver_type = "crypto.Hash";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.connRequestSet.Add
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.connRequestSet.Add";
    rf.short_name = "Add";
    rf.receiver_type = "database/sql.connRequestSet";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "database/sql.connRequestDelHandle");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.DB.Begin
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.DB.Begin";
    rf.short_name = "Begin";
    rf.receiver_type = "database/sql.DB";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "database/sql.Tx"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.DB.BeginTx
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.DB.BeginTx";
    rf.short_name = "BeginTx";
    rf.receiver_type = "database/sql.DB";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "database/sql.Tx"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.Conn.BeginTx
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.Conn.BeginTx";
    rf.short_name = "BeginTx";
    rf.receiver_type = "database/sql.Conn";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "database/sql.Tx"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.ccChecker.CheckNamedValue
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.ccChecker.CheckNamedValue";
    rf.short_name = "CheckNamedValue";
    rf.receiver_type = "database/sql.ccChecker";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.driverStmt.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.driverStmt.Close";
    rf.short_name = "Close";
    rf.receiver_type = "database/sql.driverStmt";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.driverConn.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.driverConn.Close";
    rf.short_name = "Close";
    rf.receiver_type = "database/sql.driverConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.DB.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.DB.Close";
    rf.short_name = "Close";
    rf.receiver_type = "database/sql.DB";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.Rows.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.Rows.Close";
    rf.short_name = "Close";
    rf.receiver_type = "database/sql.Rows";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.Conn.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.Conn.Close";
    rf.short_name = "Close";
    rf.receiver_type = "database/sql.Conn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.Stmt.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.Stmt.Close";
    rf.short_name = "Close";
    rf.receiver_type = "database/sql.Stmt";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.connRequestSet.CloseAndRemoveAll
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.connRequestSet.CloseAndRemoveAll";
    rf.short_name = "CloseAndRemoveAll";
    rf.receiver_type = "database/sql.connRequestSet";
    cbm_registry_add_func(reg, rf);

    // database/sql.Rows.ColumnTypes
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.Rows.ColumnTypes";
    rf.short_name = "ColumnTypes";
    rf.receiver_type = "database/sql.Rows";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "database/sql.*ColumnType"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.Rows.Columns
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.Rows.Columns";
    rf.short_name = "Columns";
    rf.receiver_type = "database/sql.Rows";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "string"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.Tx.Commit
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.Tx.Commit";
    rf.short_name = "Commit";
    rf.receiver_type = "database/sql.Tx";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.DB.Conn
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.DB.Conn";
    rf.short_name = "Conn";
    rf.receiver_type = "database/sql.DB";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "database/sql.Conn"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.dsnConnector.Connect
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.dsnConnector.Connect";
    rf.short_name = "Connect";
    rf.receiver_type = "database/sql.dsnConnector";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "driver.Conn");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.ColumnType.DatabaseTypeName
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.ColumnType.DatabaseTypeName";
    rf.short_name = "DatabaseTypeName";
    rf.receiver_type = "database/sql.ColumnType";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.ColumnType.DecimalSize
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.ColumnType.DecimalSize";
    rf.short_name = "DecimalSize";
    rf.receiver_type = "database/sql.ColumnType";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = cbm_type_builtin(arena, "int64");
        ret[2] = cbm_type_builtin(arena, "bool");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.connRequestSet.Delete
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.connRequestSet.Delete";
    rf.short_name = "Delete";
    rf.receiver_type = "database/sql.connRequestSet";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.DB.Driver
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.DB.Driver";
    rf.short_name = "Driver";
    rf.receiver_type = "database/sql.DB";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "driver.Driver");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.dsnConnector.Driver
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.dsnConnector.Driver";
    rf.short_name = "Driver";
    rf.receiver_type = "database/sql.dsnConnector";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "driver.Driver");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.Drivers
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.Drivers";
    rf.short_name = "Drivers";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "string"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.Row.Err
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.Row.Err";
    rf.short_name = "Err";
    rf.receiver_type = "database/sql.Row";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.Rows.Err
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.Rows.Err";
    rf.short_name = "Err";
    rf.receiver_type = "database/sql.Rows";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.Tx.Exec
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.Tx.Exec";
    rf.short_name = "Exec";
    rf.receiver_type = "database/sql.Tx";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "database/sql.Result");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.Stmt.Exec
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.Stmt.Exec";
    rf.short_name = "Exec";
    rf.receiver_type = "database/sql.Stmt";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "database/sql.Result");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.DB.Exec
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.DB.Exec";
    rf.short_name = "Exec";
    rf.receiver_type = "database/sql.DB";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "database/sql.Result");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.Stmt.ExecContext
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.Stmt.ExecContext";
    rf.short_name = "ExecContext";
    rf.receiver_type = "database/sql.Stmt";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "database/sql.Result");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.DB.ExecContext
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.DB.ExecContext";
    rf.short_name = "ExecContext";
    rf.receiver_type = "database/sql.DB";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "database/sql.Result");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.Tx.ExecContext
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.Tx.ExecContext";
    rf.short_name = "ExecContext";
    rf.receiver_type = "database/sql.Tx";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "database/sql.Result");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.Conn.ExecContext
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.Conn.ExecContext";
    rf.short_name = "ExecContext";
    rf.receiver_type = "database/sql.Conn";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "database/sql.Result");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.driverResult.LastInsertId
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.driverResult.LastInsertId";
    rf.short_name = "LastInsertId";
    rf.receiver_type = "database/sql.driverResult";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.connRequestSet.Len
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.connRequestSet.Len";
    rf.short_name = "Len";
    rf.receiver_type = "database/sql.connRequestSet";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.ColumnType.Length
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.ColumnType.Length";
    rf.short_name = "Length";
    rf.receiver_type = "database/sql.ColumnType";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = cbm_type_builtin(arena, "bool");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.ColumnType.Name
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.ColumnType.Name";
    rf.short_name = "Name";
    rf.receiver_type = "database/sql.ColumnType";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.Named
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.Named";
    rf.short_name = "Named";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "database/sql.NamedArg");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.Rows.Next
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.Rows.Next";
    rf.short_name = "Next";
    rf.receiver_type = "database/sql.Rows";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.Rows.NextResultSet
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.Rows.NextResultSet";
    rf.short_name = "NextResultSet";
    rf.receiver_type = "database/sql.Rows";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.ColumnType.Nullable
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.ColumnType.Nullable";
    rf.short_name = "Nullable";
    rf.receiver_type = "database/sql.ColumnType";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = cbm_type_builtin(arena, "bool");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.Open
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.Open";
    rf.short_name = "Open";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "database/sql.DB"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.OpenDB
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.OpenDB";
    rf.short_name = "OpenDB";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "database/sql.DB"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.DB.Ping
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.DB.Ping";
    rf.short_name = "Ping";
    rf.receiver_type = "database/sql.DB";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.DB.PingContext
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.DB.PingContext";
    rf.short_name = "PingContext";
    rf.receiver_type = "database/sql.DB";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.Conn.PingContext
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.Conn.PingContext";
    rf.short_name = "PingContext";
    rf.receiver_type = "database/sql.Conn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.Tx.Prepare
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.Tx.Prepare";
    rf.short_name = "Prepare";
    rf.receiver_type = "database/sql.Tx";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "database/sql.Stmt"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.DB.Prepare
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.DB.Prepare";
    rf.short_name = "Prepare";
    rf.receiver_type = "database/sql.DB";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "database/sql.Stmt"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.Tx.PrepareContext
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.Tx.PrepareContext";
    rf.short_name = "PrepareContext";
    rf.receiver_type = "database/sql.Tx";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "database/sql.Stmt"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.DB.PrepareContext
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.DB.PrepareContext";
    rf.short_name = "PrepareContext";
    rf.receiver_type = "database/sql.DB";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "database/sql.Stmt"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.Conn.PrepareContext
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.Conn.PrepareContext";
    rf.short_name = "PrepareContext";
    rf.receiver_type = "database/sql.Conn";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "database/sql.Stmt"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.Tx.Query
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.Tx.Query";
    rf.short_name = "Query";
    rf.receiver_type = "database/sql.Tx";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "database/sql.Rows"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.Stmt.Query
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.Stmt.Query";
    rf.short_name = "Query";
    rf.receiver_type = "database/sql.Stmt";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "database/sql.Rows"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.DB.Query
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.DB.Query";
    rf.short_name = "Query";
    rf.receiver_type = "database/sql.DB";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "database/sql.Rows"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.Conn.QueryContext
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.Conn.QueryContext";
    rf.short_name = "QueryContext";
    rf.receiver_type = "database/sql.Conn";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "database/sql.Rows"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.Tx.QueryContext
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.Tx.QueryContext";
    rf.short_name = "QueryContext";
    rf.receiver_type = "database/sql.Tx";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "database/sql.Rows"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.DB.QueryContext
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.DB.QueryContext";
    rf.short_name = "QueryContext";
    rf.receiver_type = "database/sql.DB";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "database/sql.Rows"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.Stmt.QueryContext
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.Stmt.QueryContext";
    rf.short_name = "QueryContext";
    rf.receiver_type = "database/sql.Stmt";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "database/sql.Rows"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.Tx.QueryRow
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.Tx.QueryRow";
    rf.short_name = "QueryRow";
    rf.receiver_type = "database/sql.Tx";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "database/sql.Row"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.Stmt.QueryRow
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.Stmt.QueryRow";
    rf.short_name = "QueryRow";
    rf.receiver_type = "database/sql.Stmt";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "database/sql.Row"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.DB.QueryRow
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.DB.QueryRow";
    rf.short_name = "QueryRow";
    rf.receiver_type = "database/sql.DB";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "database/sql.Row"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.DB.QueryRowContext
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.DB.QueryRowContext";
    rf.short_name = "QueryRowContext";
    rf.receiver_type = "database/sql.DB";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "database/sql.Row"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.Stmt.QueryRowContext
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.Stmt.QueryRowContext";
    rf.short_name = "QueryRowContext";
    rf.receiver_type = "database/sql.Stmt";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "database/sql.Row"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.Tx.QueryRowContext
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.Tx.QueryRowContext";
    rf.short_name = "QueryRowContext";
    rf.receiver_type = "database/sql.Tx";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "database/sql.Row"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.Conn.QueryRowContext
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.Conn.QueryRowContext";
    rf.short_name = "QueryRowContext";
    rf.receiver_type = "database/sql.Conn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "database/sql.Row"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.Conn.Raw
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.Conn.Raw";
    rf.short_name = "Raw";
    rf.receiver_type = "database/sql.Conn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.Register
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.Register";
    rf.short_name = "Register";
    cbm_registry_add_func(reg, rf);

    // database/sql.Tx.Rollback
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.Tx.Rollback";
    rf.short_name = "Rollback";
    rf.receiver_type = "database/sql.Tx";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.driverResult.RowsAffected
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.driverResult.RowsAffected";
    rf.short_name = "RowsAffected";
    rf.receiver_type = "database/sql.driverResult";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.NullTime.Scan
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.NullTime.Scan";
    rf.short_name = "Scan";
    rf.receiver_type = "database/sql.NullTime";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.any.Scan
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.any.Scan";
    rf.short_name = "Scan";
    rf.receiver_type = "database/sql.any";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.NullByte.Scan
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.NullByte.Scan";
    rf.short_name = "Scan";
    rf.receiver_type = "database/sql.NullByte";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.NullFloat64.Scan
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.NullFloat64.Scan";
    rf.short_name = "Scan";
    rf.receiver_type = "database/sql.NullFloat64";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.NullString.Scan
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.NullString.Scan";
    rf.short_name = "Scan";
    rf.receiver_type = "database/sql.NullString";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.Rows.Scan
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.Rows.Scan";
    rf.short_name = "Scan";
    rf.receiver_type = "database/sql.Rows";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.NullInt64.Scan
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.NullInt64.Scan";
    rf.short_name = "Scan";
    rf.receiver_type = "database/sql.NullInt64";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.NullBool.Scan
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.NullBool.Scan";
    rf.short_name = "Scan";
    rf.receiver_type = "database/sql.NullBool";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.NullInt16.Scan
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.NullInt16.Scan";
    rf.short_name = "Scan";
    rf.receiver_type = "database/sql.NullInt16";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.Row.Scan
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.Row.Scan";
    rf.short_name = "Scan";
    rf.receiver_type = "database/sql.Row";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.NullInt32.Scan
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.NullInt32.Scan";
    rf.short_name = "Scan";
    rf.receiver_type = "database/sql.NullInt32";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.ColumnType.ScanType
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.ColumnType.ScanType";
    rf.short_name = "ScanType";
    rf.receiver_type = "database/sql.ColumnType";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "reflect.Type");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.DB.SetConnMaxIdleTime
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.DB.SetConnMaxIdleTime";
    rf.short_name = "SetConnMaxIdleTime";
    rf.receiver_type = "database/sql.DB";
    cbm_registry_add_func(reg, rf);

    // database/sql.DB.SetConnMaxLifetime
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.DB.SetConnMaxLifetime";
    rf.short_name = "SetConnMaxLifetime";
    rf.receiver_type = "database/sql.DB";
    cbm_registry_add_func(reg, rf);

    // database/sql.DB.SetMaxIdleConns
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.DB.SetMaxIdleConns";
    rf.short_name = "SetMaxIdleConns";
    rf.receiver_type = "database/sql.DB";
    cbm_registry_add_func(reg, rf);

    // database/sql.DB.SetMaxOpenConns
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.DB.SetMaxOpenConns";
    rf.short_name = "SetMaxOpenConns";
    rf.receiver_type = "database/sql.DB";
    cbm_registry_add_func(reg, rf);

    // database/sql.DB.Stats
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.DB.Stats";
    rf.short_name = "Stats";
    rf.receiver_type = "database/sql.DB";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "database/sql.DBStats");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.Tx.Stmt
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.Tx.Stmt";
    rf.short_name = "Stmt";
    rf.receiver_type = "database/sql.Tx";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "database/sql.Stmt"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.Tx.StmtContext
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.Tx.StmtContext";
    rf.short_name = "StmtContext";
    rf.receiver_type = "database/sql.Tx";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "database/sql.Stmt"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.IsolationLevel.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.IsolationLevel.String";
    rf.short_name = "String";
    rf.receiver_type = "database/sql.IsolationLevel";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.connRequestSet.TakeRandom
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.connRequestSet.TakeRandom";
    rf.short_name = "TakeRandom";
    rf.receiver_type = "database/sql.connRequestSet";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "database/sql.chan connRequest");
        ret[1] = cbm_type_builtin(arena, "bool");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.NullBool.Value
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.NullBool.Value";
    rf.short_name = "Value";
    rf.receiver_type = "database/sql.NullBool";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "driver.Value");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.NullString.Value
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.NullString.Value";
    rf.short_name = "Value";
    rf.receiver_type = "database/sql.NullString";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "driver.Value");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.any.Value
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.any.Value";
    rf.short_name = "Value";
    rf.receiver_type = "database/sql.any";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "driver.Value");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.NullInt64.Value
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.NullInt64.Value";
    rf.short_name = "Value";
    rf.receiver_type = "database/sql.NullInt64";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "driver.Value");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.NullTime.Value
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.NullTime.Value";
    rf.short_name = "Value";
    rf.receiver_type = "database/sql.NullTime";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "driver.Value");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.NullInt32.Value
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.NullInt32.Value";
    rf.short_name = "Value";
    rf.receiver_type = "database/sql.NullInt32";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "driver.Value");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.NullByte.Value
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.NullByte.Value";
    rf.short_name = "Value";
    rf.receiver_type = "database/sql.NullByte";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "driver.Value");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.NullInt16.Value
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.NullInt16.Value";
    rf.short_name = "Value";
    rf.receiver_type = "database/sql.NullInt16";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "driver.Value");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // database/sql.NullFloat64.Value
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "database/sql.NullFloat64.Value";
    rf.short_name = "Value";
    rf.receiver_type = "database/sql.NullFloat64";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "driver.Value");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.Decoder.Buffered
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.Decoder.Buffered";
    rf.short_name = "Buffered";
    rf.receiver_type = "encoding/json.Decoder";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "io.Reader");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.Decoder.Buffered
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.Decoder.Buffered";
    rf.short_name = "Buffered";
    rf.receiver_type = "encoding/json.Decoder";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "io.Reader");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.CallMethodsWithLegacySemantics
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.CallMethodsWithLegacySemantics";
    rf.short_name = "CallMethodsWithLegacySemantics";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "encoding/json.Options");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.Compact
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.Compact";
    rf.short_name = "Compact";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.Compact
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.Compact";
    rf.short_name = "Compact";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.tagOptions.Contains
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.tagOptions.Contains";
    rf.short_name = "Contains";
    rf.receiver_type = "encoding/json.tagOptions";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.Decoder.Decode
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.Decoder.Decode";
    rf.short_name = "Decode";
    rf.receiver_type = "encoding/json.Decoder";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.Decoder.Decode
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.Decoder.Decode";
    rf.short_name = "Decode";
    rf.receiver_type = "encoding/json.Decoder";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.DefaultOptionsV1
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.DefaultOptionsV1";
    rf.short_name = "DefaultOptionsV1";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "encoding/json.Options");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.Decoder.DisallowUnknownFields
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.Decoder.DisallowUnknownFields";
    rf.short_name = "DisallowUnknownFields";
    rf.receiver_type = "encoding/json.Decoder";
    cbm_registry_add_func(reg, rf);

    // encoding/json.Decoder.DisallowUnknownFields
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.Decoder.DisallowUnknownFields";
    rf.short_name = "DisallowUnknownFields";
    rf.receiver_type = "encoding/json.Decoder";
    cbm_registry_add_func(reg, rf);

    // encoding/json.Encoder.Encode
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.Encoder.Encode";
    rf.short_name = "Encode";
    rf.receiver_type = "encoding/json.Encoder";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.Encoder.Encode
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.Encoder.Encode";
    rf.short_name = "Encode";
    rf.receiver_type = "encoding/json.Encoder";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.UnsupportedValueError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.UnsupportedValueError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "encoding/json.UnsupportedValueError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.UnmarshalFieldError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.UnmarshalFieldError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "encoding/json.UnmarshalFieldError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.SyntaxError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.SyntaxError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "encoding/json.SyntaxError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.UnmarshalTypeError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.UnmarshalTypeError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "encoding/json.UnmarshalTypeError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.MarshalerError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.MarshalerError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "encoding/json.MarshalerError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.InvalidUTF8Error.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.InvalidUTF8Error.Error";
    rf.short_name = "Error";
    rf.receiver_type = "encoding/json.InvalidUTF8Error";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.UnsupportedTypeError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.UnsupportedTypeError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "encoding/json.UnsupportedTypeError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.InvalidUnmarshalError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.InvalidUnmarshalError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "encoding/json.InvalidUnmarshalError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.UnsupportedTypeError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.UnsupportedTypeError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "encoding/json.UnsupportedTypeError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.UnsupportedValueError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.UnsupportedValueError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "encoding/json.UnsupportedValueError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.InvalidUTF8Error.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.InvalidUTF8Error.Error";
    rf.short_name = "Error";
    rf.receiver_type = "encoding/json.InvalidUTF8Error";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.MarshalerError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.MarshalerError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "encoding/json.MarshalerError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.InvalidUnmarshalError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.InvalidUnmarshalError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "encoding/json.InvalidUnmarshalError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.UnmarshalFieldError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.UnmarshalFieldError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "encoding/json.UnmarshalFieldError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.SyntaxError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.SyntaxError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "encoding/json.SyntaxError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.UnmarshalTypeError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.UnmarshalTypeError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "encoding/json.UnmarshalTypeError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.Number.Float64
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.Number.Float64";
    rf.short_name = "Float64";
    rf.receiver_type = "encoding/json.Number";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.Number.Float64
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.Number.Float64";
    rf.short_name = "Float64";
    rf.receiver_type = "encoding/json.Number";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.FormatByteArrayAsArray
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.FormatByteArrayAsArray";
    rf.short_name = "FormatByteArrayAsArray";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "encoding/json.Options");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.FormatBytesWithLegacySemantics
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.FormatBytesWithLegacySemantics";
    rf.short_name = "FormatBytesWithLegacySemantics";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "encoding/json.Options");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.FormatDurationAsNano
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.FormatDurationAsNano";
    rf.short_name = "FormatDurationAsNano";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "encoding/json.Options");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.HTMLEscape
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.HTMLEscape";
    rf.short_name = "HTMLEscape";
    cbm_registry_add_func(reg, rf);

    // encoding/json.HTMLEscape
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.HTMLEscape";
    rf.short_name = "HTMLEscape";
    cbm_registry_add_func(reg, rf);

    // encoding/json.Indent
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.Indent";
    rf.short_name = "Indent";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.Indent
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.Indent";
    rf.short_name = "Indent";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.Decoder.InputOffset
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.Decoder.InputOffset";
    rf.short_name = "InputOffset";
    rf.receiver_type = "encoding/json.Decoder";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.Decoder.InputOffset
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.Decoder.InputOffset";
    rf.short_name = "InputOffset";
    rf.receiver_type = "encoding/json.Decoder";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.Number.Int64
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.Number.Int64";
    rf.short_name = "Int64";
    rf.receiver_type = "encoding/json.Number";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.Number.Int64
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.Number.Int64";
    rf.short_name = "Int64";
    rf.receiver_type = "encoding/json.Number";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.Marshal
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.Marshal";
    rf.short_name = "Marshal";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.Marshal
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.Marshal";
    rf.short_name = "Marshal";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.MarshalIndent
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.MarshalIndent";
    rf.short_name = "MarshalIndent";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.MarshalIndent
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.MarshalIndent";
    rf.short_name = "MarshalIndent";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.RawMessage.MarshalJSON
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.RawMessage.MarshalJSON";
    rf.short_name = "MarshalJSON";
    rf.receiver_type = "encoding/json.RawMessage";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.Number.MarshalJSONTo
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.Number.MarshalJSONTo";
    rf.short_name = "MarshalJSONTo";
    rf.receiver_type = "encoding/json.Number";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.MatchCaseSensitiveDelimiter
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.MatchCaseSensitiveDelimiter";
    rf.short_name = "MatchCaseSensitiveDelimiter";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "encoding/json.Options");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.MergeWithLegacySemantics
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.MergeWithLegacySemantics";
    rf.short_name = "MergeWithLegacySemantics";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "encoding/json.Options");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.Decoder.More
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.Decoder.More";
    rf.short_name = "More";
    rf.receiver_type = "encoding/json.Decoder";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.Decoder.More
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.Decoder.More";
    rf.short_name = "More";
    rf.receiver_type = "encoding/json.Decoder";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.NewDecoder
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.NewDecoder";
    rf.short_name = "NewDecoder";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "encoding/json.Decoder"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.NewDecoder
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.NewDecoder";
    rf.short_name = "NewDecoder";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "encoding/json.Decoder"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.NewEncoder
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.NewEncoder";
    rf.short_name = "NewEncoder";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "encoding/json.Encoder"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.NewEncoder
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.NewEncoder";
    rf.short_name = "NewEncoder";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "encoding/json.Encoder"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.OmitEmptyWithLegacySemantics
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.OmitEmptyWithLegacySemantics";
    rf.short_name = "OmitEmptyWithLegacySemantics";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "encoding/json.Options");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.ParseBytesWithLooseRFC4648
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.ParseBytesWithLooseRFC4648";
    rf.short_name = "ParseBytesWithLooseRFC4648";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "encoding/json.Options");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.ParseTimeWithLooseRFC3339
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.ParseTimeWithLooseRFC3339";
    rf.short_name = "ParseTimeWithLooseRFC3339";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "encoding/json.Options");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.ReportErrorsWithLegacySemantics
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.ReportErrorsWithLegacySemantics";
    rf.short_name = "ReportErrorsWithLegacySemantics";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "encoding/json.Options");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.Encoder.SetEscapeHTML
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.Encoder.SetEscapeHTML";
    rf.short_name = "SetEscapeHTML";
    rf.receiver_type = "encoding/json.Encoder";
    cbm_registry_add_func(reg, rf);

    // encoding/json.Encoder.SetEscapeHTML
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.Encoder.SetEscapeHTML";
    rf.short_name = "SetEscapeHTML";
    rf.receiver_type = "encoding/json.Encoder";
    cbm_registry_add_func(reg, rf);

    // encoding/json.Encoder.SetIndent
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.Encoder.SetIndent";
    rf.short_name = "SetIndent";
    rf.receiver_type = "encoding/json.Encoder";
    cbm_registry_add_func(reg, rf);

    // encoding/json.Encoder.SetIndent
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.Encoder.SetIndent";
    rf.short_name = "SetIndent";
    rf.receiver_type = "encoding/json.Encoder";
    cbm_registry_add_func(reg, rf);

    // encoding/json.Number.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.Number.String";
    rf.short_name = "String";
    rf.receiver_type = "encoding/json.Number";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.Delim.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.Delim.String";
    rf.short_name = "String";
    rf.receiver_type = "encoding/json.Delim";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.Number.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.Number.String";
    rf.short_name = "String";
    rf.receiver_type = "encoding/json.Number";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.Delim.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.Delim.String";
    rf.short_name = "String";
    rf.receiver_type = "encoding/json.Delim";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.StringifyWithLegacySemantics
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.StringifyWithLegacySemantics";
    rf.short_name = "StringifyWithLegacySemantics";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "encoding/json.Options");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.Decoder.Token
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.Decoder.Token";
    rf.short_name = "Token";
    rf.receiver_type = "encoding/json.Decoder";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "encoding/json.Token");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.Decoder.Token
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.Decoder.Token";
    rf.short_name = "Token";
    rf.receiver_type = "encoding/json.Decoder";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "encoding/json.Token");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.Unmarshal
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.Unmarshal";
    rf.short_name = "Unmarshal";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.Unmarshal
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.Unmarshal";
    rf.short_name = "Unmarshal";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.UnmarshalArrayFromAnyLength
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.UnmarshalArrayFromAnyLength";
    rf.short_name = "UnmarshalArrayFromAnyLength";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "encoding/json.Options");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.RawMessage.UnmarshalJSON
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.RawMessage.UnmarshalJSON";
    rf.short_name = "UnmarshalJSON";
    rf.receiver_type = "encoding/json.RawMessage";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.Number.UnmarshalJSONFrom
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.Number.UnmarshalJSONFrom";
    rf.short_name = "UnmarshalJSONFrom";
    rf.receiver_type = "encoding/json.Number";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.MarshalerError.Unwrap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.MarshalerError.Unwrap";
    rf.short_name = "Unwrap";
    rf.receiver_type = "encoding/json.MarshalerError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.MarshalerError.Unwrap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.MarshalerError.Unwrap";
    rf.short_name = "Unwrap";
    rf.receiver_type = "encoding/json.MarshalerError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.UnmarshalTypeError.Unwrap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.UnmarshalTypeError.Unwrap";
    rf.short_name = "Unwrap";
    rf.receiver_type = "encoding/json.UnmarshalTypeError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.Decoder.UseNumber
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.Decoder.UseNumber";
    rf.short_name = "UseNumber";
    rf.receiver_type = "encoding/json.Decoder";
    cbm_registry_add_func(reg, rf);

    // encoding/json.Decoder.UseNumber
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.Decoder.UseNumber";
    rf.short_name = "UseNumber";
    rf.receiver_type = "encoding/json.Decoder";
    cbm_registry_add_func(reg, rf);

    // encoding/json.Valid
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.Valid";
    rf.short_name = "Valid";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/json.Valid
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/json.Valid";
    rf.short_name = "Valid";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/xml.Encoder.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/xml.Encoder.Close";
    rf.short_name = "Close";
    rf.receiver_type = "encoding/xml.Encoder";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/xml.printer.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/xml.printer.Close";
    rf.short_name = "Close";
    rf.receiver_type = "encoding/xml.printer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/xml.ProcInst.Copy
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/xml.ProcInst.Copy";
    rf.short_name = "Copy";
    rf.receiver_type = "encoding/xml.ProcInst";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "encoding/xml.ProcInst");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/xml.CharData.Copy
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/xml.CharData.Copy";
    rf.short_name = "Copy";
    rf.receiver_type = "encoding/xml.CharData";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "encoding/xml.CharData");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/xml.Comment.Copy
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/xml.Comment.Copy";
    rf.short_name = "Copy";
    rf.receiver_type = "encoding/xml.Comment";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "encoding/xml.Comment");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/xml.Directive.Copy
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/xml.Directive.Copy";
    rf.short_name = "Copy";
    rf.receiver_type = "encoding/xml.Directive";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "encoding/xml.Directive");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/xml.StartElement.Copy
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/xml.StartElement.Copy";
    rf.short_name = "Copy";
    rf.receiver_type = "encoding/xml.StartElement";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "encoding/xml.StartElement");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/xml.CopyToken
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/xml.CopyToken";
    rf.short_name = "CopyToken";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "encoding/xml.Token");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/xml.Decoder.Decode
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/xml.Decoder.Decode";
    rf.short_name = "Decode";
    rf.receiver_type = "encoding/xml.Decoder";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/xml.Decoder.DecodeElement
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/xml.Decoder.DecodeElement";
    rf.short_name = "DecodeElement";
    rf.receiver_type = "encoding/xml.Decoder";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/xml.Encoder.Encode
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/xml.Encoder.Encode";
    rf.short_name = "Encode";
    rf.receiver_type = "encoding/xml.Encoder";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/xml.Encoder.EncodeElement
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/xml.Encoder.EncodeElement";
    rf.short_name = "EncodeElement";
    rf.receiver_type = "encoding/xml.Encoder";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/xml.Encoder.EncodeToken
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/xml.Encoder.EncodeToken";
    rf.short_name = "EncodeToken";
    rf.receiver_type = "encoding/xml.Encoder";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/xml.StartElement.End
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/xml.StartElement.End";
    rf.short_name = "End";
    rf.receiver_type = "encoding/xml.StartElement";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "encoding/xml.EndElement");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/xml.TagPathError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/xml.TagPathError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "encoding/xml.TagPathError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/xml.UnsupportedTypeError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/xml.UnsupportedTypeError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "encoding/xml.UnsupportedTypeError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/xml.UnmarshalError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/xml.UnmarshalError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "encoding/xml.UnmarshalError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/xml.SyntaxError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/xml.SyntaxError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "encoding/xml.SyntaxError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/xml.Escape
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/xml.Escape";
    rf.short_name = "Escape";
    cbm_registry_add_func(reg, rf);

    // encoding/xml.printer.EscapeString
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/xml.printer.EscapeString";
    rf.short_name = "EscapeString";
    rf.receiver_type = "encoding/xml.printer";
    cbm_registry_add_func(reg, rf);

    // encoding/xml.EscapeText
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/xml.EscapeText";
    rf.short_name = "EscapeText";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/xml.Encoder.Flush
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/xml.Encoder.Flush";
    rf.short_name = "Flush";
    rf.receiver_type = "encoding/xml.Encoder";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/xml.Encoder.Indent
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/xml.Encoder.Indent";
    rf.short_name = "Indent";
    rf.receiver_type = "encoding/xml.Encoder";
    cbm_registry_add_func(reg, rf);

    // encoding/xml.Decoder.InputOffset
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/xml.Decoder.InputOffset";
    rf.short_name = "InputOffset";
    rf.receiver_type = "encoding/xml.Decoder";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/xml.Decoder.InputPos
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/xml.Decoder.InputPos";
    rf.short_name = "InputPos";
    rf.receiver_type = "encoding/xml.Decoder";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "int");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/xml.Marshal
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/xml.Marshal";
    rf.short_name = "Marshal";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/xml.MarshalIndent
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/xml.MarshalIndent";
    rf.short_name = "MarshalIndent";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/xml.NewDecoder
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/xml.NewDecoder";
    rf.short_name = "NewDecoder";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "encoding/xml.Decoder"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/xml.NewEncoder
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/xml.NewEncoder";
    rf.short_name = "NewEncoder";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "encoding/xml.Encoder"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/xml.NewTokenDecoder
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/xml.NewTokenDecoder";
    rf.short_name = "NewTokenDecoder";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "encoding/xml.Decoder"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/xml.Decoder.RawToken
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/xml.Decoder.RawToken";
    rf.short_name = "RawToken";
    rf.receiver_type = "encoding/xml.Decoder";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "encoding/xml.Token");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/xml.Decoder.Skip
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/xml.Decoder.Skip";
    rf.short_name = "Skip";
    rf.receiver_type = "encoding/xml.Decoder";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/xml.Decoder.Token
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/xml.Decoder.Token";
    rf.short_name = "Token";
    rf.receiver_type = "encoding/xml.Decoder";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "encoding/xml.Token");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/xml.Unmarshal
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/xml.Unmarshal";
    rf.short_name = "Unmarshal";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/xml.printer.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/xml.printer.Write";
    rf.short_name = "Write";
    rf.receiver_type = "encoding/xml.printer";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/xml.printer.WriteByte
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/xml.printer.WriteByte";
    rf.short_name = "WriteByte";
    rf.receiver_type = "encoding/xml.printer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // encoding/xml.printer.WriteString
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "encoding/xml.printer.WriteString";
    rf.short_name = "WriteString";
    rf.receiver_type = "encoding/xml.printer";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // errors.As
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "errors.As";
    rf.short_name = "As";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // errors.AsType
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "errors.AsType";
    rf.short_name = "AsType";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "errors.E");
        ret[1] = cbm_type_builtin(arena, "bool");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // errors.joinError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "errors.joinError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "errors.joinError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // errors.errorString.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "errors.errorString.Error";
    rf.short_name = "Error";
    rf.receiver_type = "errors.errorString";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // errors.Is
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "errors.Is";
    rf.short_name = "Is";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // errors.Join
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "errors.Join";
    rf.short_name = "Join";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // errors.New
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "errors.New";
    rf.short_name = "New";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // errors.joinError.Unwrap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "errors.joinError.Unwrap";
    rf.short_name = "Unwrap";
    rf.receiver_type = "errors.joinError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "error"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // errors.Unwrap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "errors.Unwrap";
    rf.short_name = "Unwrap";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // fmt.Append
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "fmt.Append";
    rf.short_name = "Append";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // fmt.Appendf
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "fmt.Appendf";
    rf.short_name = "Appendf";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // fmt.Appendln
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "fmt.Appendln";
    rf.short_name = "Appendln";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // fmt.wrapError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "fmt.wrapError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "fmt.wrapError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // fmt.wrapErrors.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "fmt.wrapErrors.Error";
    rf.short_name = "Error";
    rf.receiver_type = "fmt.wrapErrors";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // fmt.Errorf
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "fmt.Errorf";
    rf.short_name = "Errorf";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // fmt.pp.Flag
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "fmt.pp.Flag";
    rf.short_name = "Flag";
    rf.receiver_type = "fmt.pp";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // fmt.FormatString
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "fmt.FormatString";
    rf.short_name = "FormatString";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // fmt.Fprint
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "fmt.Fprint";
    rf.short_name = "Fprint";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // fmt.Fprintf
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "fmt.Fprintf";
    rf.short_name = "Fprintf";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // fmt.Fprintln
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "fmt.Fprintln";
    rf.short_name = "Fprintln";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // fmt.Fscan
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "fmt.Fscan";
    rf.short_name = "Fscan";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // fmt.Fscanf
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "fmt.Fscanf";
    rf.short_name = "Fscanf";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // fmt.Fscanln
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "fmt.Fscanln";
    rf.short_name = "Fscanln";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // fmt.pp.Precision
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "fmt.pp.Precision";
    rf.short_name = "Precision";
    rf.receiver_type = "fmt.pp";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "bool");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // fmt.Print
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "fmt.Print";
    rf.short_name = "Print";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // fmt.Printf
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "fmt.Printf";
    rf.short_name = "Printf";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // fmt.Println
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "fmt.Println";
    rf.short_name = "Println";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // fmt.stringReader.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "fmt.stringReader.Read";
    rf.short_name = "Read";
    rf.receiver_type = "fmt.stringReader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // fmt.ss.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "fmt.ss.Read";
    rf.short_name = "Read";
    rf.receiver_type = "fmt.ss";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // fmt.ss.ReadRune
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "fmt.ss.ReadRune";
    rf.short_name = "ReadRune";
    rf.receiver_type = "fmt.ss";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_builtin(arena, "rune");
        ret[1] = cbm_type_builtin(arena, "int");
        ret[2] = cbm_type_builtin(arena, "error");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // fmt.readRune.ReadRune
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "fmt.readRune.ReadRune";
    rf.short_name = "ReadRune";
    rf.receiver_type = "fmt.readRune";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_builtin(arena, "rune");
        ret[1] = cbm_type_builtin(arena, "int");
        ret[2] = cbm_type_builtin(arena, "error");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // fmt.Scan
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "fmt.Scan";
    rf.short_name = "Scan";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // fmt.Scanf
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "fmt.Scanf";
    rf.short_name = "Scanf";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // fmt.Scanln
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "fmt.Scanln";
    rf.short_name = "Scanln";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // fmt.ss.SkipSpace
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "fmt.ss.SkipSpace";
    rf.short_name = "SkipSpace";
    rf.receiver_type = "fmt.ss";
    cbm_registry_add_func(reg, rf);

    // fmt.Sprint
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "fmt.Sprint";
    rf.short_name = "Sprint";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // fmt.Sprintf
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "fmt.Sprintf";
    rf.short_name = "Sprintf";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // fmt.Sprintln
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "fmt.Sprintln";
    rf.short_name = "Sprintln";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // fmt.Sscan
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "fmt.Sscan";
    rf.short_name = "Sscan";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // fmt.Sscanf
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "fmt.Sscanf";
    rf.short_name = "Sscanf";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // fmt.Sscanln
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "fmt.Sscanln";
    rf.short_name = "Sscanln";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // fmt.ss.Token
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "fmt.ss.Token";
    rf.short_name = "Token";
    rf.receiver_type = "fmt.ss";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // fmt.ss.UnreadRune
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "fmt.ss.UnreadRune";
    rf.short_name = "UnreadRune";
    rf.receiver_type = "fmt.ss";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // fmt.readRune.UnreadRune
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "fmt.readRune.UnreadRune";
    rf.short_name = "UnreadRune";
    rf.receiver_type = "fmt.readRune";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // fmt.wrapErrors.Unwrap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "fmt.wrapErrors.Unwrap";
    rf.short_name = "Unwrap";
    rf.receiver_type = "fmt.wrapErrors";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "error"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // fmt.wrapError.Unwrap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "fmt.wrapError.Unwrap";
    rf.short_name = "Unwrap";
    rf.receiver_type = "fmt.wrapError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // fmt.ss.Width
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "fmt.ss.Width";
    rf.short_name = "Width";
    rf.receiver_type = "fmt.ss";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "bool");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // fmt.pp.Width
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "fmt.pp.Width";
    rf.short_name = "Width";
    rf.receiver_type = "fmt.pp";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "bool");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // fmt.pp.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "fmt.pp.Write";
    rf.short_name = "Write";
    rf.receiver_type = "fmt.pp";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // fmt.pp.WriteString
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "fmt.pp.WriteString";
    rf.short_name = "WriteString";
    rf.receiver_type = "fmt.pp";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.PipeReader.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.PipeReader.Close";
    rf.short_name = "Close";
    rf.receiver_type = "io.PipeReader";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.PipeWriter.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.PipeWriter.Close";
    rf.short_name = "Close";
    rf.receiver_type = "io.PipeWriter";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.nopCloser.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.nopCloser.Close";
    rf.short_name = "Close";
    rf.receiver_type = "io.nopCloser";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.nopCloserWriterTo.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.nopCloserWriterTo.Close";
    rf.short_name = "Close";
    rf.receiver_type = "io.nopCloserWriterTo";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.PipeWriter.CloseWithError
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.PipeWriter.CloseWithError";
    rf.short_name = "CloseWithError";
    rf.receiver_type = "io.PipeWriter";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.PipeReader.CloseWithError
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.PipeReader.CloseWithError";
    rf.short_name = "CloseWithError";
    rf.receiver_type = "io.PipeReader";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.Copy
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.Copy";
    rf.short_name = "Copy";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.CopyBuffer
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.CopyBuffer";
    rf.short_name = "CopyBuffer";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.CopyN
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.CopyN";
    rf.short_name = "CopyN";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.LimitReader
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.LimitReader";
    rf.short_name = "LimitReader";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "io.Reader");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.onceError.Load
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.onceError.Load";
    rf.short_name = "Load";
    rf.receiver_type = "io.onceError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.MultiReader
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.MultiReader";
    rf.short_name = "MultiReader";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "io.Reader");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.MultiWriter
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.MultiWriter";
    rf.short_name = "MultiWriter";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "io.Writer");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.NewOffsetWriter
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.NewOffsetWriter";
    rf.short_name = "NewOffsetWriter";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "io.OffsetWriter"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.NewSectionReader
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.NewSectionReader";
    rf.short_name = "NewSectionReader";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "io.SectionReader"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.NopCloser
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.NopCloser";
    rf.short_name = "NopCloser";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "io.ReadCloser");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.SectionReader.Outer
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.SectionReader.Outer";
    rf.short_name = "Outer";
    rf.receiver_type = "io.SectionReader";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_named(arena, "io.ReaderAt");
        ret[1] = cbm_type_builtin(arena, "int64");
        ret[2] = cbm_type_builtin(arena, "int64");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.Pipe
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.Pipe";
    rf.short_name = "Pipe";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "io.PipeReader"));
        ret[1] = cbm_type_pointer(arena, cbm_type_named(arena, "io.PipeWriter"));
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.PipeReader.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.PipeReader.Read";
    rf.short_name = "Read";
    rf.receiver_type = "io.PipeReader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.SectionReader.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.SectionReader.Read";
    rf.short_name = "Read";
    rf.receiver_type = "io.SectionReader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.eofReader.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.eofReader.Read";
    rf.short_name = "Read";
    rf.receiver_type = "io.eofReader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.multiReader.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.multiReader.Read";
    rf.short_name = "Read";
    rf.receiver_type = "io.multiReader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.teeReader.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.teeReader.Read";
    rf.short_name = "Read";
    rf.receiver_type = "io.teeReader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.LimitedReader.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.LimitedReader.Read";
    rf.short_name = "Read";
    rf.receiver_type = "io.LimitedReader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.ReadAll
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.ReadAll";
    rf.short_name = "ReadAll";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.SectionReader.ReadAt
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.SectionReader.ReadAt";
    rf.short_name = "ReadAt";
    rf.receiver_type = "io.SectionReader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.ReadAtLeast
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.ReadAtLeast";
    rf.short_name = "ReadAtLeast";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.discard.ReadFrom
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.discard.ReadFrom";
    rf.short_name = "ReadFrom";
    rf.receiver_type = "io.discard";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.ReadFull
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.ReadFull";
    rf.short_name = "ReadFull";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.OffsetWriter.Seek
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.OffsetWriter.Seek";
    rf.short_name = "Seek";
    rf.receiver_type = "io.OffsetWriter";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.SectionReader.Seek
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.SectionReader.Seek";
    rf.short_name = "Seek";
    rf.receiver_type = "io.SectionReader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.SectionReader.Size
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.SectionReader.Size";
    rf.short_name = "Size";
    rf.receiver_type = "io.SectionReader";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.onceError.Store
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.onceError.Store";
    rf.short_name = "Store";
    rf.receiver_type = "io.onceError";
    cbm_registry_add_func(reg, rf);

    // io.TeeReader
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.TeeReader";
    rf.short_name = "TeeReader";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "io.Reader");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.PipeWriter.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.PipeWriter.Write";
    rf.short_name = "Write";
    rf.receiver_type = "io.PipeWriter";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.discard.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.discard.Write";
    rf.short_name = "Write";
    rf.receiver_type = "io.discard";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.OffsetWriter.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.OffsetWriter.Write";
    rf.short_name = "Write";
    rf.receiver_type = "io.OffsetWriter";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.multiWriter.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.multiWriter.Write";
    rf.short_name = "Write";
    rf.receiver_type = "io.multiWriter";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.OffsetWriter.WriteAt
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.OffsetWriter.WriteAt";
    rf.short_name = "WriteAt";
    rf.receiver_type = "io.OffsetWriter";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.multiWriter.WriteString
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.multiWriter.WriteString";
    rf.short_name = "WriteString";
    rf.receiver_type = "io.multiWriter";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.WriteString
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.WriteString";
    rf.short_name = "WriteString";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.discard.WriteString
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.discard.WriteString";
    rf.short_name = "WriteString";
    rf.receiver_type = "io.discard";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.multiReader.WriteTo
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.multiReader.WriteTo";
    rf.short_name = "WriteTo";
    rf.receiver_type = "io.multiReader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io.nopCloserWriterTo.WriteTo
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io.nopCloserWriterTo.WriteTo";
    rf.short_name = "WriteTo";
    rf.receiver_type = "io.nopCloserWriterTo";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io/fs.PathError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io/fs.PathError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "io/fs.PathError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io/fs.FileInfoToDirEntry
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io/fs.FileInfoToDirEntry";
    rf.short_name = "FileInfoToDirEntry";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "io/fs.DirEntry");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io/fs.FormatDirEntry
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io/fs.FormatDirEntry";
    rf.short_name = "FormatDirEntry";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io/fs.FormatFileInfo
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io/fs.FormatFileInfo";
    rf.short_name = "FormatFileInfo";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io/fs.subFS.Glob
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io/fs.subFS.Glob";
    rf.short_name = "Glob";
    rf.receiver_type = "io/fs.subFS";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "string"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io/fs.Glob
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io/fs.Glob";
    rf.short_name = "Glob";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "string"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io/fs.dirInfo.Info
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io/fs.dirInfo.Info";
    rf.short_name = "Info";
    rf.receiver_type = "io/fs.dirInfo";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "io/fs.FileInfo");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io/fs.dirInfo.IsDir
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io/fs.dirInfo.IsDir";
    rf.short_name = "IsDir";
    rf.receiver_type = "io/fs.dirInfo";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io/fs.FileMode.IsDir
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io/fs.FileMode.IsDir";
    rf.short_name = "IsDir";
    rf.receiver_type = "io/fs.FileMode";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io/fs.FileMode.IsRegular
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io/fs.FileMode.IsRegular";
    rf.short_name = "IsRegular";
    rf.receiver_type = "io/fs.FileMode";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io/fs.Lstat
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io/fs.Lstat";
    rf.short_name = "Lstat";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "io/fs.FileInfo");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io/fs.subFS.Lstat
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io/fs.subFS.Lstat";
    rf.short_name = "Lstat";
    rf.receiver_type = "io/fs.subFS";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "io/fs.FileInfo");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io/fs.dirInfo.Name
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io/fs.dirInfo.Name";
    rf.short_name = "Name";
    rf.receiver_type = "io/fs.dirInfo";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io/fs.subFS.Open
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io/fs.subFS.Open";
    rf.short_name = "Open";
    rf.receiver_type = "io/fs.subFS";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "io/fs.File");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io/fs.FileMode.Perm
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io/fs.FileMode.Perm";
    rf.short_name = "Perm";
    rf.receiver_type = "io/fs.FileMode";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "io/fs.FileMode");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io/fs.ReadDir
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io/fs.ReadDir";
    rf.short_name = "ReadDir";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "io/fs.DirEntry"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io/fs.subFS.ReadDir
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io/fs.subFS.ReadDir";
    rf.short_name = "ReadDir";
    rf.receiver_type = "io/fs.subFS";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "io/fs.DirEntry"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io/fs.ReadFile
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io/fs.ReadFile";
    rf.short_name = "ReadFile";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io/fs.subFS.ReadFile
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io/fs.subFS.ReadFile";
    rf.short_name = "ReadFile";
    rf.receiver_type = "io/fs.subFS";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io/fs.subFS.ReadLink
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io/fs.subFS.ReadLink";
    rf.short_name = "ReadLink";
    rf.receiver_type = "io/fs.subFS";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io/fs.ReadLink
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io/fs.ReadLink";
    rf.short_name = "ReadLink";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io/fs.Stat
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io/fs.Stat";
    rf.short_name = "Stat";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "io/fs.FileInfo");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io/fs.FileMode.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io/fs.FileMode.String";
    rf.short_name = "String";
    rf.receiver_type = "io/fs.FileMode";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io/fs.dirInfo.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io/fs.dirInfo.String";
    rf.short_name = "String";
    rf.receiver_type = "io/fs.dirInfo";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io/fs.Sub
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io/fs.Sub";
    rf.short_name = "Sub";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "io/fs.FS");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io/fs.subFS.Sub
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io/fs.subFS.Sub";
    rf.short_name = "Sub";
    rf.receiver_type = "io/fs.subFS";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "io/fs.FS");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io/fs.PathError.Timeout
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io/fs.PathError.Timeout";
    rf.short_name = "Timeout";
    rf.receiver_type = "io/fs.PathError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io/fs.FileMode.Type
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io/fs.FileMode.Type";
    rf.short_name = "Type";
    rf.receiver_type = "io/fs.FileMode";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "io/fs.FileMode");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io/fs.dirInfo.Type
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io/fs.dirInfo.Type";
    rf.short_name = "Type";
    rf.receiver_type = "io/fs.dirInfo";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "io/fs.FileMode");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io/fs.PathError.Unwrap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io/fs.PathError.Unwrap";
    rf.short_name = "Unwrap";
    rf.receiver_type = "io/fs.PathError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io/fs.ValidPath
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io/fs.ValidPath";
    rf.short_name = "ValidPath";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // io/fs.WalkDir
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "io/fs.WalkDir";
    rf.short_name = "WalkDir";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log.Default
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log.Default";
    rf.short_name = "Default";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "log.Logger"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log.Fatal
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log.Fatal";
    rf.short_name = "Fatal";
    cbm_registry_add_func(reg, rf);

    // log.Logger.Fatal
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log.Logger.Fatal";
    rf.short_name = "Fatal";
    rf.receiver_type = "log.Logger";
    cbm_registry_add_func(reg, rf);

    // log.Fatalf
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log.Fatalf";
    rf.short_name = "Fatalf";
    cbm_registry_add_func(reg, rf);

    // log.Logger.Fatalf
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log.Logger.Fatalf";
    rf.short_name = "Fatalf";
    rf.receiver_type = "log.Logger";
    cbm_registry_add_func(reg, rf);

    // log.Fatalln
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log.Fatalln";
    rf.short_name = "Fatalln";
    cbm_registry_add_func(reg, rf);

    // log.Logger.Fatalln
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log.Logger.Fatalln";
    rf.short_name = "Fatalln";
    rf.receiver_type = "log.Logger";
    cbm_registry_add_func(reg, rf);

    // log.Logger.Flags
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log.Logger.Flags";
    rf.short_name = "Flags";
    rf.receiver_type = "log.Logger";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log.Flags
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log.Flags";
    rf.short_name = "Flags";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log.New
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log.New";
    rf.short_name = "New";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "log.Logger"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log.Logger.Output
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log.Logger.Output";
    rf.short_name = "Output";
    rf.receiver_type = "log.Logger";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log.Output
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log.Output";
    rf.short_name = "Output";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log.Logger.Panic
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log.Logger.Panic";
    rf.short_name = "Panic";
    rf.receiver_type = "log.Logger";
    cbm_registry_add_func(reg, rf);

    // log.Panic
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log.Panic";
    rf.short_name = "Panic";
    cbm_registry_add_func(reg, rf);

    // log.Panicf
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log.Panicf";
    rf.short_name = "Panicf";
    cbm_registry_add_func(reg, rf);

    // log.Logger.Panicf
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log.Logger.Panicf";
    rf.short_name = "Panicf";
    rf.receiver_type = "log.Logger";
    cbm_registry_add_func(reg, rf);

    // log.Panicln
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log.Panicln";
    rf.short_name = "Panicln";
    cbm_registry_add_func(reg, rf);

    // log.Logger.Panicln
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log.Logger.Panicln";
    rf.short_name = "Panicln";
    rf.receiver_type = "log.Logger";
    cbm_registry_add_func(reg, rf);

    // log.Logger.Prefix
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log.Logger.Prefix";
    rf.short_name = "Prefix";
    rf.receiver_type = "log.Logger";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log.Prefix
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log.Prefix";
    rf.short_name = "Prefix";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log.Print
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log.Print";
    rf.short_name = "Print";
    cbm_registry_add_func(reg, rf);

    // log.Logger.Print
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log.Logger.Print";
    rf.short_name = "Print";
    rf.receiver_type = "log.Logger";
    cbm_registry_add_func(reg, rf);

    // log.Printf
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log.Printf";
    rf.short_name = "Printf";
    cbm_registry_add_func(reg, rf);

    // log.Logger.Printf
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log.Logger.Printf";
    rf.short_name = "Printf";
    rf.receiver_type = "log.Logger";
    cbm_registry_add_func(reg, rf);

    // log.Logger.Println
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log.Logger.Println";
    rf.short_name = "Println";
    rf.receiver_type = "log.Logger";
    cbm_registry_add_func(reg, rf);

    // log.Println
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log.Println";
    rf.short_name = "Println";
    cbm_registry_add_func(reg, rf);

    // log.SetFlags
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log.SetFlags";
    rf.short_name = "SetFlags";
    cbm_registry_add_func(reg, rf);

    // log.Logger.SetFlags
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log.Logger.SetFlags";
    rf.short_name = "SetFlags";
    rf.receiver_type = "log.Logger";
    cbm_registry_add_func(reg, rf);

    // log.SetOutput
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log.SetOutput";
    rf.short_name = "SetOutput";
    cbm_registry_add_func(reg, rf);

    // log.Logger.SetOutput
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log.Logger.SetOutput";
    rf.short_name = "SetOutput";
    rf.receiver_type = "log.Logger";
    cbm_registry_add_func(reg, rf);

    // log.SetPrefix
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log.SetPrefix";
    rf.short_name = "SetPrefix";
    cbm_registry_add_func(reg, rf);

    // log.Logger.SetPrefix
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log.Logger.SetPrefix";
    rf.short_name = "SetPrefix";
    rf.receiver_type = "log.Logger";
    cbm_registry_add_func(reg, rf);

    // log.Logger.Writer
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log.Logger.Writer";
    rf.short_name = "Writer";
    rf.receiver_type = "log.Logger";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "io.Writer");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log.Writer
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log.Writer";
    rf.short_name = "Writer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "io.Writer");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Record.Add
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Record.Add";
    rf.short_name = "Add";
    rf.receiver_type = "log/slog.Record";
    cbm_registry_add_func(reg, rf);

    // log/slog.Record.AddAttrs
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Record.AddAttrs";
    rf.short_name = "AddAttrs";
    rf.receiver_type = "log/slog.Record";
    cbm_registry_add_func(reg, rf);

    // log/slog.Any
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Any";
    rf.short_name = "Any";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "log/slog.Attr");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Value.Any
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Value.Any";
    rf.short_name = "Any";
    rf.receiver_type = "log/slog.Value";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "any");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.AnyValue
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.AnyValue";
    rf.short_name = "AnyValue";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "log/slog.Value");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.LevelVar.AppendText
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.LevelVar.AppendText";
    rf.short_name = "AppendText";
    rf.receiver_type = "log/slog.LevelVar";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Level.AppendText
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Level.AppendText";
    rf.short_name = "AppendText";
    rf.receiver_type = "log/slog.Level";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Record.Attrs
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Record.Attrs";
    rf.short_name = "Attrs";
    rf.receiver_type = "log/slog.Record";
    cbm_registry_add_func(reg, rf);

    // log/slog.Value.Bool
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Value.Bool";
    rf.short_name = "Bool";
    rf.receiver_type = "log/slog.Value";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Bool
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Bool";
    rf.short_name = "Bool";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "log/slog.Attr");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.BoolValue
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.BoolValue";
    rf.short_name = "BoolValue";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "log/slog.Value");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Record.Clone
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Record.Clone";
    rf.short_name = "Clone";
    rf.receiver_type = "log/slog.Record";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "log/slog.Record");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Debug
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Debug";
    rf.short_name = "Debug";
    cbm_registry_add_func(reg, rf);

    // log/slog.Logger.Debug
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Logger.Debug";
    rf.short_name = "Debug";
    rf.receiver_type = "log/slog.Logger";
    cbm_registry_add_func(reg, rf);

    // log/slog.DebugContext
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.DebugContext";
    rf.short_name = "DebugContext";
    cbm_registry_add_func(reg, rf);

    // log/slog.Logger.DebugContext
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Logger.DebugContext";
    rf.short_name = "DebugContext";
    rf.receiver_type = "log/slog.Logger";
    cbm_registry_add_func(reg, rf);

    // log/slog.Default
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Default";
    rf.short_name = "Default";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "log/slog.Logger"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Value.Duration
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Value.Duration";
    rf.short_name = "Duration";
    rf.receiver_type = "log/slog.Value";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "time.Duration");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Duration
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Duration";
    rf.short_name = "Duration";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "log/slog.Attr");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.DurationValue
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.DurationValue";
    rf.short_name = "DurationValue";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "log/slog.Value");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.defaultHandler.Enabled
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.defaultHandler.Enabled";
    rf.short_name = "Enabled";
    rf.receiver_type = "log/slog.defaultHandler";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.JSONHandler.Enabled
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.JSONHandler.Enabled";
    rf.short_name = "Enabled";
    rf.receiver_type = "log/slog.JSONHandler";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.discardHandler.Enabled
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.discardHandler.Enabled";
    rf.short_name = "Enabled";
    rf.receiver_type = "log/slog.discardHandler";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.MultiHandler.Enabled
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.MultiHandler.Enabled";
    rf.short_name = "Enabled";
    rf.receiver_type = "log/slog.MultiHandler";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.TextHandler.Enabled
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.TextHandler.Enabled";
    rf.short_name = "Enabled";
    rf.receiver_type = "log/slog.TextHandler";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Logger.Enabled
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Logger.Enabled";
    rf.short_name = "Enabled";
    rf.receiver_type = "log/slog.Logger";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Attr.Equal
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Attr.Equal";
    rf.short_name = "Equal";
    rf.receiver_type = "log/slog.Attr";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Value.Equal
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Value.Equal";
    rf.short_name = "Equal";
    rf.receiver_type = "log/slog.Value";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Logger.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Logger.Error";
    rf.short_name = "Error";
    rf.receiver_type = "log/slog.Logger";
    cbm_registry_add_func(reg, rf);

    // log/slog.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Error";
    rf.short_name = "Error";
    cbm_registry_add_func(reg, rf);

    // log/slog.Logger.ErrorContext
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Logger.ErrorContext";
    rf.short_name = "ErrorContext";
    rf.receiver_type = "log/slog.Logger";
    cbm_registry_add_func(reg, rf);

    // log/slog.ErrorContext
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.ErrorContext";
    rf.short_name = "ErrorContext";
    cbm_registry_add_func(reg, rf);

    // log/slog.Float64
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Float64";
    rf.short_name = "Float64";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "log/slog.Attr");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Value.Float64
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Value.Float64";
    rf.short_name = "Float64";
    rf.receiver_type = "log/slog.Value";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Float64Value
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Float64Value";
    rf.short_name = "Float64Value";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "log/slog.Value");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Value.Group
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Value.Group";
    rf.short_name = "Group";
    rf.receiver_type = "log/slog.Value";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "log/slog.Attr"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Group
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Group";
    rf.short_name = "Group";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "log/slog.Attr");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.GroupAttrs
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.GroupAttrs";
    rf.short_name = "GroupAttrs";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "log/slog.Attr");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.GroupValue
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.GroupValue";
    rf.short_name = "GroupValue";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "log/slog.Value");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.JSONHandler.Handle
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.JSONHandler.Handle";
    rf.short_name = "Handle";
    rf.receiver_type = "log/slog.JSONHandler";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.defaultHandler.Handle
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.defaultHandler.Handle";
    rf.short_name = "Handle";
    rf.receiver_type = "log/slog.defaultHandler";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.TextHandler.Handle
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.TextHandler.Handle";
    rf.short_name = "Handle";
    rf.receiver_type = "log/slog.TextHandler";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.MultiHandler.Handle
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.MultiHandler.Handle";
    rf.short_name = "Handle";
    rf.receiver_type = "log/slog.MultiHandler";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.discardHandler.Handle
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.discardHandler.Handle";
    rf.short_name = "Handle";
    rf.receiver_type = "log/slog.discardHandler";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Logger.Handler
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Logger.Handler";
    rf.short_name = "Handler";
    rf.receiver_type = "log/slog.Logger";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "log/slog.Handler");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Info
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Info";
    rf.short_name = "Info";
    cbm_registry_add_func(reg, rf);

    // log/slog.Logger.Info
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Logger.Info";
    rf.short_name = "Info";
    rf.receiver_type = "log/slog.Logger";
    cbm_registry_add_func(reg, rf);

    // log/slog.InfoContext
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.InfoContext";
    rf.short_name = "InfoContext";
    cbm_registry_add_func(reg, rf);

    // log/slog.Logger.InfoContext
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Logger.InfoContext";
    rf.short_name = "InfoContext";
    rf.receiver_type = "log/slog.Logger";
    cbm_registry_add_func(reg, rf);

    // log/slog.Int
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Int";
    rf.short_name = "Int";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "log/slog.Attr");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Int64
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Int64";
    rf.short_name = "Int64";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "log/slog.Attr");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Value.Int64
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Value.Int64";
    rf.short_name = "Int64";
    rf.receiver_type = "log/slog.Value";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Int64Value
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Int64Value";
    rf.short_name = "Int64Value";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "log/slog.Value");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.IntValue
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.IntValue";
    rf.short_name = "IntValue";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "log/slog.Value");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Value.Kind
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Value.Kind";
    rf.short_name = "Kind";
    rf.receiver_type = "log/slog.Value";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "log/slog.Kind");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.LevelVar.Level
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.LevelVar.Level";
    rf.short_name = "Level";
    rf.receiver_type = "log/slog.LevelVar";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "log/slog.Level");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Level.Level
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Level.Level";
    rf.short_name = "Level";
    rf.receiver_type = "log/slog.Level";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "log/slog.Level");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Log
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Log";
    rf.short_name = "Log";
    cbm_registry_add_func(reg, rf);

    // log/slog.Logger.Log
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Logger.Log";
    rf.short_name = "Log";
    rf.receiver_type = "log/slog.Logger";
    cbm_registry_add_func(reg, rf);

    // log/slog.Logger.LogAttrs
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Logger.LogAttrs";
    rf.short_name = "LogAttrs";
    rf.receiver_type = "log/slog.Logger";
    cbm_registry_add_func(reg, rf);

    // log/slog.LogAttrs
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.LogAttrs";
    rf.short_name = "LogAttrs";
    cbm_registry_add_func(reg, rf);

    // log/slog.Value.LogValuer
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Value.LogValuer";
    rf.short_name = "LogValuer";
    rf.receiver_type = "log/slog.Value";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "log/slog.LogValuer");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Level.MarshalJSON
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Level.MarshalJSON";
    rf.short_name = "MarshalJSON";
    rf.receiver_type = "log/slog.Level";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Level.MarshalText
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Level.MarshalText";
    rf.short_name = "MarshalText";
    rf.receiver_type = "log/slog.Level";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.LevelVar.MarshalText
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.LevelVar.MarshalText";
    rf.short_name = "MarshalText";
    rf.receiver_type = "log/slog.LevelVar";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.New
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.New";
    rf.short_name = "New";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "log/slog.Logger"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.NewJSONHandler
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.NewJSONHandler";
    rf.short_name = "NewJSONHandler";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "log/slog.JSONHandler"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.NewLogLogger
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.NewLogLogger";
    rf.short_name = "NewLogLogger";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "log.Logger"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.NewMultiHandler
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.NewMultiHandler";
    rf.short_name = "NewMultiHandler";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "log/slog.MultiHandler"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.NewRecord
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.NewRecord";
    rf.short_name = "NewRecord";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "log/slog.Record");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.NewTextHandler
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.NewTextHandler";
    rf.short_name = "NewTextHandler";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "log/slog.TextHandler"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Record.NumAttrs
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Record.NumAttrs";
    rf.short_name = "NumAttrs";
    rf.receiver_type = "log/slog.Record";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Value.Resolve
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Value.Resolve";
    rf.short_name = "Resolve";
    rf.receiver_type = "log/slog.Value";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "log/slog.Value");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.LevelVar.Set
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.LevelVar.Set";
    rf.short_name = "Set";
    rf.receiver_type = "log/slog.LevelVar";
    cbm_registry_add_func(reg, rf);

    // log/slog.SetDefault
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.SetDefault";
    rf.short_name = "SetDefault";
    cbm_registry_add_func(reg, rf);

    // log/slog.SetLogLoggerLevel
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.SetLogLoggerLevel";
    rf.short_name = "SetLogLoggerLevel";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "log/slog.Level");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Record.Source
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Record.Source";
    rf.short_name = "Source";
    rf.receiver_type = "log/slog.Record";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "log/slog.Source"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Kind.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Kind.String";
    rf.short_name = "String";
    rf.receiver_type = "log/slog.Kind";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Level.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Level.String";
    rf.short_name = "String";
    rf.receiver_type = "log/slog.Level";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.String";
    rf.short_name = "String";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "log/slog.Attr");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Value.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Value.String";
    rf.short_name = "String";
    rf.receiver_type = "log/slog.Value";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Attr.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Attr.String";
    rf.short_name = "String";
    rf.receiver_type = "log/slog.Attr";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.LevelVar.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.LevelVar.String";
    rf.short_name = "String";
    rf.receiver_type = "log/slog.LevelVar";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.StringValue
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.StringValue";
    rf.short_name = "StringValue";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "log/slog.Value");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Time
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Time";
    rf.short_name = "Time";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "log/slog.Attr");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Value.Time
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Value.Time";
    rf.short_name = "Time";
    rf.receiver_type = "log/slog.Value";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "time.Time");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.TimeValue
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.TimeValue";
    rf.short_name = "TimeValue";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "log/slog.Value");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Uint64
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Uint64";
    rf.short_name = "Uint64";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "log/slog.Attr");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Value.Uint64
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Value.Uint64";
    rf.short_name = "Uint64";
    rf.receiver_type = "log/slog.Value";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "uint64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Uint64Value
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Uint64Value";
    rf.short_name = "Uint64Value";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "log/slog.Value");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Level.UnmarshalJSON
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Level.UnmarshalJSON";
    rf.short_name = "UnmarshalJSON";
    rf.receiver_type = "log/slog.Level";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.LevelVar.UnmarshalText
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.LevelVar.UnmarshalText";
    rf.short_name = "UnmarshalText";
    rf.receiver_type = "log/slog.LevelVar";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Level.UnmarshalText
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Level.UnmarshalText";
    rf.short_name = "UnmarshalText";
    rf.receiver_type = "log/slog.Level";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Logger.Warn
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Logger.Warn";
    rf.short_name = "Warn";
    rf.receiver_type = "log/slog.Logger";
    cbm_registry_add_func(reg, rf);

    // log/slog.Warn
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Warn";
    rf.short_name = "Warn";
    cbm_registry_add_func(reg, rf);

    // log/slog.Logger.WarnContext
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Logger.WarnContext";
    rf.short_name = "WarnContext";
    rf.receiver_type = "log/slog.Logger";
    cbm_registry_add_func(reg, rf);

    // log/slog.WarnContext
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.WarnContext";
    rf.short_name = "WarnContext";
    cbm_registry_add_func(reg, rf);

    // log/slog.Logger.With
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Logger.With";
    rf.short_name = "With";
    rf.receiver_type = "log/slog.Logger";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "log/slog.Logger"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.With
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.With";
    rf.short_name = "With";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "log/slog.Logger"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.defaultHandler.WithAttrs
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.defaultHandler.WithAttrs";
    rf.short_name = "WithAttrs";
    rf.receiver_type = "log/slog.defaultHandler";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "log/slog.Handler");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.discardHandler.WithAttrs
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.discardHandler.WithAttrs";
    rf.short_name = "WithAttrs";
    rf.receiver_type = "log/slog.discardHandler";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "log/slog.Handler");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.MultiHandler.WithAttrs
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.MultiHandler.WithAttrs";
    rf.short_name = "WithAttrs";
    rf.receiver_type = "log/slog.MultiHandler";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "log/slog.Handler");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.JSONHandler.WithAttrs
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.JSONHandler.WithAttrs";
    rf.short_name = "WithAttrs";
    rf.receiver_type = "log/slog.JSONHandler";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "log/slog.Handler");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.TextHandler.WithAttrs
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.TextHandler.WithAttrs";
    rf.short_name = "WithAttrs";
    rf.receiver_type = "log/slog.TextHandler";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "log/slog.Handler");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.discardHandler.WithGroup
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.discardHandler.WithGroup";
    rf.short_name = "WithGroup";
    rf.receiver_type = "log/slog.discardHandler";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "log/slog.Handler");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.MultiHandler.WithGroup
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.MultiHandler.WithGroup";
    rf.short_name = "WithGroup";
    rf.receiver_type = "log/slog.MultiHandler";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "log/slog.Handler");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.defaultHandler.WithGroup
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.defaultHandler.WithGroup";
    rf.short_name = "WithGroup";
    rf.receiver_type = "log/slog.defaultHandler";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "log/slog.Handler");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.Logger.WithGroup
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.Logger.WithGroup";
    rf.short_name = "WithGroup";
    rf.receiver_type = "log/slog.Logger";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "log/slog.Logger"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.JSONHandler.WithGroup
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.JSONHandler.WithGroup";
    rf.short_name = "WithGroup";
    rf.receiver_type = "log/slog.JSONHandler";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "log/slog.Handler");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.TextHandler.WithGroup
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.TextHandler.WithGroup";
    rf.short_name = "WithGroup";
    rf.receiver_type = "log/slog.TextHandler";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "log/slog.Handler");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // log/slog.handlerWriter.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "log/slog.handlerWriter.Write";
    rf.short_name = "Write";
    rf.receiver_type = "log/slog.handlerWriter";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Abs
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Abs";
    rf.short_name = "Abs";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Acos
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Acos";
    rf.short_name = "Acos";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Acosh
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Acosh";
    rf.short_name = "Acosh";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Asin
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Asin";
    rf.short_name = "Asin";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Asinh
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Asinh";
    rf.short_name = "Asinh";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Atan
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Atan";
    rf.short_name = "Atan";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Atan2
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Atan2";
    rf.short_name = "Atan2";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Atanh
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Atanh";
    rf.short_name = "Atanh";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Cbrt
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Cbrt";
    rf.short_name = "Cbrt";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Ceil
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Ceil";
    rf.short_name = "Ceil";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Copysign
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Copysign";
    rf.short_name = "Copysign";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Cos
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Cos";
    rf.short_name = "Cos";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Cosh
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Cosh";
    rf.short_name = "Cosh";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Dim
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Dim";
    rf.short_name = "Dim";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Erf
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Erf";
    rf.short_name = "Erf";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Erfc
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Erfc";
    rf.short_name = "Erfc";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Erfcinv
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Erfcinv";
    rf.short_name = "Erfcinv";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Erfinv
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Erfinv";
    rf.short_name = "Erfinv";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Exp
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Exp";
    rf.short_name = "Exp";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Exp2
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Exp2";
    rf.short_name = "Exp2";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Expm1
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Expm1";
    rf.short_name = "Expm1";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.FMA
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.FMA";
    rf.short_name = "FMA";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Float32bits
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Float32bits";
    rf.short_name = "Float32bits";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "uint32");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Float32frombits
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Float32frombits";
    rf.short_name = "Float32frombits";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float32");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Float64bits
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Float64bits";
    rf.short_name = "Float64bits";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "uint64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Float64frombits
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Float64frombits";
    rf.short_name = "Float64frombits";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Floor
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Floor";
    rf.short_name = "Floor";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Frexp
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Frexp";
    rf.short_name = "Frexp";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = cbm_type_builtin(arena, "int");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Gamma
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Gamma";
    rf.short_name = "Gamma";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Hypot
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Hypot";
    rf.short_name = "Hypot";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Ilogb
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Ilogb";
    rf.short_name = "Ilogb";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Inf
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Inf";
    rf.short_name = "Inf";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.IsInf
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.IsInf";
    rf.short_name = "IsInf";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.IsNaN
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.IsNaN";
    rf.short_name = "IsNaN";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.J0
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.J0";
    rf.short_name = "J0";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.J1
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.J1";
    rf.short_name = "J1";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Jn
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Jn";
    rf.short_name = "Jn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Ldexp
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Ldexp";
    rf.short_name = "Ldexp";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Lgamma
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Lgamma";
    rf.short_name = "Lgamma";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = cbm_type_builtin(arena, "int");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Log
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Log";
    rf.short_name = "Log";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Log10
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Log10";
    rf.short_name = "Log10";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Log1p
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Log1p";
    rf.short_name = "Log1p";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Log2
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Log2";
    rf.short_name = "Log2";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Logb
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Logb";
    rf.short_name = "Logb";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Max
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Max";
    rf.short_name = "Max";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Min
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Min";
    rf.short_name = "Min";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Mod
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Mod";
    rf.short_name = "Mod";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Modf
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Modf";
    rf.short_name = "Modf";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = cbm_type_builtin(arena, "float64");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.NaN
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.NaN";
    rf.short_name = "NaN";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Nextafter
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Nextafter";
    rf.short_name = "Nextafter";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Nextafter32
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Nextafter32";
    rf.short_name = "Nextafter32";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float32");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Pow
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Pow";
    rf.short_name = "Pow";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Pow10
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Pow10";
    rf.short_name = "Pow10";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Remainder
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Remainder";
    rf.short_name = "Remainder";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Round
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Round";
    rf.short_name = "Round";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.RoundToEven
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.RoundToEven";
    rf.short_name = "RoundToEven";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Signbit
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Signbit";
    rf.short_name = "Signbit";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Sin
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Sin";
    rf.short_name = "Sin";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Sincos
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Sincos";
    rf.short_name = "Sincos";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = cbm_type_builtin(arena, "float64");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Sinh
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Sinh";
    rf.short_name = "Sinh";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Sqrt
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Sqrt";
    rf.short_name = "Sqrt";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Tan
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Tan";
    rf.short_name = "Tan";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Tanh
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Tanh";
    rf.short_name = "Tanh";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Trunc
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Trunc";
    rf.short_name = "Trunc";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Y0
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Y0";
    rf.short_name = "Y0";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Y1
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Y1";
    rf.short_name = "Y1";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // math.Yn
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "math.Yn";
    rf.short_name = "Yn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // mime.AddExtensionType
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "mime.AddExtensionType";
    rf.short_name = "AddExtensionType";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // mime.WordDecoder.Decode
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "mime.WordDecoder.Decode";
    rf.short_name = "Decode";
    rf.receiver_type = "mime.WordDecoder";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // mime.WordDecoder.DecodeHeader
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "mime.WordDecoder.DecodeHeader";
    rf.short_name = "DecodeHeader";
    rf.receiver_type = "mime.WordDecoder";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // mime.WordEncoder.Encode
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "mime.WordEncoder.Encode";
    rf.short_name = "Encode";
    rf.receiver_type = "mime.WordEncoder";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // mime.ExtensionsByType
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "mime.ExtensionsByType";
    rf.short_name = "ExtensionsByType";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "string"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // mime.FormatMediaType
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "mime.FormatMediaType";
    rf.short_name = "FormatMediaType";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // mime.ParseMediaType
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "mime.ParseMediaType";
    rf.short_name = "ParseMediaType";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_named(arena, "mime.map[string]string");
        ret[2] = cbm_type_builtin(arena, "error");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // mime.TypeByExtension
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "mime.TypeByExtension";
    rf.short_name = "TypeByExtension";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.UnixListener.Accept
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.UnixListener.Accept";
    rf.short_name = "Accept";
    rf.receiver_type = "net.UnixListener";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "net.Conn");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.TCPListener.Accept
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.TCPListener.Accept";
    rf.short_name = "Accept";
    rf.receiver_type = "net.TCPListener";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "net.Conn");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.TCPListener.AcceptTCP
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.TCPListener.AcceptTCP";
    rf.short_name = "AcceptTCP";
    rf.receiver_type = "net.TCPListener";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net.TCPConn"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.UnixListener.AcceptUnix
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.UnixListener.AcceptUnix";
    rf.short_name = "AcceptUnix";
    rf.receiver_type = "net.UnixListener";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net.UnixConn"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.TCPListener.Addr
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.TCPListener.Addr";
    rf.short_name = "Addr";
    rf.receiver_type = "net.TCPListener";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net.Addr");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.UnixListener.Addr
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.UnixListener.Addr";
    rf.short_name = "Addr";
    rf.receiver_type = "net.UnixListener";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net.Addr");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.TCPAddr.AddrPort
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.TCPAddr.AddrPort";
    rf.short_name = "AddrPort";
    rf.receiver_type = "net.TCPAddr";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "netip.AddrPort");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.UDPAddr.AddrPort
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.UDPAddr.AddrPort";
    rf.short_name = "AddrPort";
    rf.receiver_type = "net.UDPAddr";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "netip.AddrPort");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.Interface.Addrs
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.Interface.Addrs";
    rf.short_name = "Addrs";
    rf.receiver_type = "net.Interface";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "net.Addr"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.IP.AppendText
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.IP.AppendText";
    rf.short_name = "AppendText";
    rf.receiver_type = "net.IP";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.udpHeader.Bytes
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.udpHeader.Bytes";
    rf.short_name = "Bytes";
    rf.receiver_type = "net.udpHeader";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.CIDRMask
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.CIDRMask";
    rf.short_name = "CIDRMask";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net.IPMask");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.policyTable.Classify
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.policyTable.Classify";
    rf.short_name = "Classify";
    rf.receiver_type = "net.policyTable";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net.policyTableEntry");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.conn.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.conn.Close";
    rf.short_name = "Close";
    rf.receiver_type = "net.conn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.UnixListener.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.UnixListener.Close";
    rf.short_name = "Close";
    rf.receiver_type = "net.UnixListener";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.fakeNetFD.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.fakeNetFD.Close";
    rf.short_name = "Close";
    rf.receiver_type = "net.fakeNetFD";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.pipe.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.pipe.Close";
    rf.short_name = "Close";
    rf.receiver_type = "net.pipe";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.netFD.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.netFD.Close";
    rf.short_name = "Close";
    rf.receiver_type = "net.netFD";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.netFD.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.netFD.Close";
    rf.short_name = "Close";
    rf.receiver_type = "net.netFD";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.TCPListener.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.TCPListener.Close";
    rf.short_name = "Close";
    rf.receiver_type = "net.TCPListener";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.netFD.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.netFD.Close";
    rf.short_name = "Close";
    rf.receiver_type = "net.netFD";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.UnixConn.CloseRead
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.UnixConn.CloseRead";
    rf.short_name = "CloseRead";
    rf.receiver_type = "net.UnixConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.TCPConn.CloseRead
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.TCPConn.CloseRead";
    rf.short_name = "CloseRead";
    rf.receiver_type = "net.TCPConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.UnixConn.CloseWrite
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.UnixConn.CloseWrite";
    rf.short_name = "CloseWrite";
    rf.receiver_type = "net.UnixConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.TCPConn.CloseWrite
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.TCPConn.CloseWrite";
    rf.short_name = "CloseWrite";
    rf.receiver_type = "net.TCPConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.IPNet.Contains
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.IPNet.Contains";
    rf.short_name = "Contains";
    rf.receiver_type = "net.IPNet";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.rawConn.Control
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.rawConn.Control";
    rf.short_name = "Control";
    rf.receiver_type = "net.rawConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.IP.DefaultMask
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.IP.DefaultMask";
    rf.short_name = "DefaultMask";
    rf.receiver_type = "net.IP";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net.IPMask");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.Dial
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.Dial";
    rf.short_name = "Dial";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "net.Conn");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.Dialer.Dial
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.Dialer.Dial";
    rf.short_name = "Dial";
    rf.receiver_type = "net.Dialer";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "net.Conn");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.Dialer.DialContext
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.Dialer.DialContext";
    rf.short_name = "DialContext";
    rf.receiver_type = "net.Dialer";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "net.Conn");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.Dialer.DialIP
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.Dialer.DialIP";
    rf.short_name = "DialIP";
    rf.receiver_type = "net.Dialer";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net.IPConn"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.DialIP
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.DialIP";
    rf.short_name = "DialIP";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net.IPConn"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.Dialer.DialTCP
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.Dialer.DialTCP";
    rf.short_name = "DialTCP";
    rf.receiver_type = "net.Dialer";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net.TCPConn"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.DialTCP
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.DialTCP";
    rf.short_name = "DialTCP";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net.TCPConn"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.DialTimeout
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.DialTimeout";
    rf.short_name = "DialTimeout";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "net.Conn");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.DialUDP
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.DialUDP";
    rf.short_name = "DialUDP";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net.UDPConn"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.Dialer.DialUDP
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.Dialer.DialUDP";
    rf.short_name = "DialUDP";
    rf.receiver_type = "net.Dialer";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net.UDPConn"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.Dialer.DialUnix
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.Dialer.DialUnix";
    rf.short_name = "DialUnix";
    rf.receiver_type = "net.Dialer";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net.UnixConn"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.DialUnix
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.DialUnix";
    rf.short_name = "DialUnix";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net.UnixConn"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.IP.Equal
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.IP.Equal";
    rf.short_name = "Equal";
    rf.receiver_type = "net.IP";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.OpError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.OpError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "net.OpError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.UnknownNetworkError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.UnknownNetworkError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "net.UnknownNetworkError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.canceledError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.canceledError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "net.canceledError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.temporaryError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.temporaryError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "net.temporaryError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.notFoundError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.notFoundError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "net.notFoundError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.ParseError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.ParseError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "net.ParseError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.AddrError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.AddrError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "net.AddrError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.DNSConfigError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.DNSConfigError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "net.DNSConfigError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.addrinfoErrno.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.addrinfoErrno.Error";
    rf.short_name = "Error";
    rf.receiver_type = "net.addrinfoErrno";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.DNSError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.DNSError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "net.DNSError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.InvalidAddrError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.InvalidAddrError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "net.InvalidAddrError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.timeoutError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.timeoutError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "net.timeoutError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.TCPListener.File
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.TCPListener.File";
    rf.short_name = "File";
    rf.receiver_type = "net.TCPListener";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "os.File"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.conn.File
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.conn.File";
    rf.short_name = "File";
    rf.receiver_type = "net.conn";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "os.File"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.UnixListener.File
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.UnixListener.File";
    rf.short_name = "File";
    rf.receiver_type = "net.UnixListener";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "os.File"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.FileConn
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.FileConn";
    rf.short_name = "FileConn";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "net.Conn");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.FileListener
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.FileListener";
    rf.short_name = "FileListener";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "net.Listener");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.FilePacketConn
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.FilePacketConn";
    rf.short_name = "FilePacketConn";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "net.PacketConn");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.IPv4
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.IPv4";
    rf.short_name = "IPv4";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net.IP");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.IPv4Mask
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.IPv4Mask";
    rf.short_name = "IPv4Mask";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net.IPMask");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.InterfaceAddrs
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.InterfaceAddrs";
    rf.short_name = "InterfaceAddrs";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "net.Addr"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.InterfaceByIndex
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.InterfaceByIndex";
    rf.short_name = "InterfaceByIndex";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net.Interface"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.InterfaceByName
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.InterfaceByName";
    rf.short_name = "InterfaceByName";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net.Interface"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.Interfaces
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.Interfaces";
    rf.short_name = "Interfaces";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "net.Interface"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.timeoutError.Is
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.timeoutError.Is";
    rf.short_name = "Is";
    rf.receiver_type = "net.timeoutError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.canceledError.Is
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.canceledError.Is";
    rf.short_name = "Is";
    rf.receiver_type = "net.canceledError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.IP.IsGlobalUnicast
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.IP.IsGlobalUnicast";
    rf.short_name = "IsGlobalUnicast";
    rf.receiver_type = "net.IP";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.IP.IsInterfaceLocalMulticast
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.IP.IsInterfaceLocalMulticast";
    rf.short_name = "IsInterfaceLocalMulticast";
    rf.receiver_type = "net.IP";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.IP.IsLinkLocalMulticast
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.IP.IsLinkLocalMulticast";
    rf.short_name = "IsLinkLocalMulticast";
    rf.receiver_type = "net.IP";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.IP.IsLinkLocalUnicast
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.IP.IsLinkLocalUnicast";
    rf.short_name = "IsLinkLocalUnicast";
    rf.receiver_type = "net.IP";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.IP.IsLoopback
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.IP.IsLoopback";
    rf.short_name = "IsLoopback";
    rf.receiver_type = "net.IP";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.IP.IsMulticast
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.IP.IsMulticast";
    rf.short_name = "IsMulticast";
    rf.receiver_type = "net.IP";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.IP.IsPrivate
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.IP.IsPrivate";
    rf.short_name = "IsPrivate";
    rf.receiver_type = "net.IP";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.IP.IsUnspecified
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.IP.IsUnspecified";
    rf.short_name = "IsUnspecified";
    rf.receiver_type = "net.IP";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.JoinHostPort
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.JoinHostPort";
    rf.short_name = "JoinHostPort";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.Listen
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.Listen";
    rf.short_name = "Listen";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "net.Listener");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.ListenConfig.Listen
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.ListenConfig.Listen";
    rf.short_name = "Listen";
    rf.receiver_type = "net.ListenConfig";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "net.Listener");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.ListenIP
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.ListenIP";
    rf.short_name = "ListenIP";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net.IPConn"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.ListenMulticastUDP
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.ListenMulticastUDP";
    rf.short_name = "ListenMulticastUDP";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net.UDPConn"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.ListenPacket
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.ListenPacket";
    rf.short_name = "ListenPacket";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "net.PacketConn");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.ListenConfig.ListenPacket
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.ListenConfig.ListenPacket";
    rf.short_name = "ListenPacket";
    rf.receiver_type = "net.ListenConfig";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "net.PacketConn");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.ListenTCP
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.ListenTCP";
    rf.short_name = "ListenTCP";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net.TCPListener"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.ListenUDP
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.ListenUDP";
    rf.short_name = "ListenUDP";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net.UDPConn"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.ListenUnix
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.ListenUnix";
    rf.short_name = "ListenUnix";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net.UnixListener"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.ListenUnixgram
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.ListenUnixgram";
    rf.short_name = "ListenUnixgram";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net.UnixConn"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.pipe.LocalAddr
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.pipe.LocalAddr";
    rf.short_name = "LocalAddr";
    rf.receiver_type = "net.pipe";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net.Addr");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.conn.LocalAddr
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.conn.LocalAddr";
    rf.short_name = "LocalAddr";
    rf.receiver_type = "net.conn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net.Addr");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.LookupAddr
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.LookupAddr";
    rf.short_name = "LookupAddr";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "string"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.Resolver.LookupAddr
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.Resolver.LookupAddr";
    rf.short_name = "LookupAddr";
    rf.receiver_type = "net.Resolver";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "string"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.Resolver.LookupCNAME
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.Resolver.LookupCNAME";
    rf.short_name = "LookupCNAME";
    rf.receiver_type = "net.Resolver";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.LookupCNAME
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.LookupCNAME";
    rf.short_name = "LookupCNAME";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.LookupHost
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.LookupHost";
    rf.short_name = "LookupHost";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "string"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.Resolver.LookupHost
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.Resolver.LookupHost";
    rf.short_name = "LookupHost";
    rf.receiver_type = "net.Resolver";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "string"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.LookupIP
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.LookupIP";
    rf.short_name = "LookupIP";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "net.IP"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.Resolver.LookupIP
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.Resolver.LookupIP";
    rf.short_name = "LookupIP";
    rf.receiver_type = "net.Resolver";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "net.IP"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.Resolver.LookupIPAddr
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.Resolver.LookupIPAddr";
    rf.short_name = "LookupIPAddr";
    rf.receiver_type = "net.Resolver";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "net.IPAddr"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.LookupMX
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.LookupMX";
    rf.short_name = "LookupMX";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "net.*MX"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.Resolver.LookupMX
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.Resolver.LookupMX";
    rf.short_name = "LookupMX";
    rf.receiver_type = "net.Resolver";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "net.*MX"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.LookupNS
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.LookupNS";
    rf.short_name = "LookupNS";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "net.*NS"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.Resolver.LookupNS
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.Resolver.LookupNS";
    rf.short_name = "LookupNS";
    rf.receiver_type = "net.Resolver";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "net.*NS"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.Resolver.LookupNetIP
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.Resolver.LookupNetIP";
    rf.short_name = "LookupNetIP";
    rf.receiver_type = "net.Resolver";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "netip.Addr"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.LookupPort
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.LookupPort";
    rf.short_name = "LookupPort";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.Resolver.LookupPort
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.Resolver.LookupPort";
    rf.short_name = "LookupPort";
    rf.receiver_type = "net.Resolver";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.Resolver.LookupSRV
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.Resolver.LookupSRV";
    rf.short_name = "LookupSRV";
    rf.receiver_type = "net.Resolver";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_slice(arena, cbm_type_named(arena, "net.*SRV"));
        ret[2] = cbm_type_builtin(arena, "error");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.LookupSRV
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.LookupSRV";
    rf.short_name = "LookupSRV";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_slice(arena, cbm_type_named(arena, "net.*SRV"));
        ret[2] = cbm_type_builtin(arena, "error");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.Resolver.LookupTXT
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.Resolver.LookupTXT";
    rf.short_name = "LookupTXT";
    rf.receiver_type = "net.Resolver";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "string"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.LookupTXT
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.LookupTXT";
    rf.short_name = "LookupTXT";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "string"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.IP.MarshalText
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.IP.MarshalText";
    rf.short_name = "MarshalText";
    rf.receiver_type = "net.IP";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.IP.Mask
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.IP.Mask";
    rf.short_name = "Mask";
    rf.receiver_type = "net.IP";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net.IP");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.Interface.MulticastAddrs
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.Interface.MulticastAddrs";
    rf.short_name = "MulticastAddrs";
    rf.receiver_type = "net.Interface";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "net.Addr"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.Dialer.MultipathTCP
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.Dialer.MultipathTCP";
    rf.short_name = "MultipathTCP";
    rf.receiver_type = "net.Dialer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.ListenConfig.MultipathTCP
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.ListenConfig.MultipathTCP";
    rf.short_name = "MultipathTCP";
    rf.receiver_type = "net.ListenConfig";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.TCPConn.MultipathTCP
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.TCPConn.MultipathTCP";
    rf.short_name = "MultipathTCP";
    rf.receiver_type = "net.TCPConn";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.addrPortUDPAddr.Network
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.addrPortUDPAddr.Network";
    rf.short_name = "Network";
    rf.receiver_type = "net.addrPortUDPAddr";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.IPNet.Network
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.IPNet.Network";
    rf.short_name = "Network";
    rf.receiver_type = "net.IPNet";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.unknownAddr.Network
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.unknownAddr.Network";
    rf.short_name = "Network";
    rf.receiver_type = "net.unknownAddr";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.TCPAddr.Network
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.TCPAddr.Network";
    rf.short_name = "Network";
    rf.receiver_type = "net.TCPAddr";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.UDPAddr.Network
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.UDPAddr.Network";
    rf.short_name = "Network";
    rf.receiver_type = "net.UDPAddr";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.fileAddr.Network
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.fileAddr.Network";
    rf.short_name = "Network";
    rf.receiver_type = "net.fileAddr";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.UnixAddr.Network
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.UnixAddr.Network";
    rf.short_name = "Network";
    rf.receiver_type = "net.UnixAddr";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.IPAddr.Network
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.IPAddr.Network";
    rf.short_name = "Network";
    rf.receiver_type = "net.IPAddr";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.rawConn.Network
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.rawConn.Network";
    rf.short_name = "Network";
    rf.receiver_type = "net.rawConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "poll.String");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.pipeAddr.Network
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.pipeAddr.Network";
    rf.short_name = "Network";
    rf.receiver_type = "net.pipeAddr";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.ParseCIDR
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.ParseCIDR";
    rf.short_name = "ParseCIDR";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_named(arena, "net.IP");
        ret[1] = cbm_type_pointer(arena, cbm_type_named(arena, "net.IPNet"));
        ret[2] = cbm_type_builtin(arena, "error");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.ParseIP
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.ParseIP";
    rf.short_name = "ParseIP";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net.IP");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.ParseMAC
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.ParseMAC";
    rf.short_name = "ParseMAC";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "net.HardwareAddr");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.Pipe
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.Pipe";
    rf.short_name = "Pipe";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "net.Conn");
        ret[1] = cbm_type_named(arena, "net.Conn");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.rawConn.PollFD
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.rawConn.PollFD";
    rf.short_name = "PollFD";
    rf.receiver_type = "net.rawConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "poll.FD"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.netFD.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.netFD.Read";
    rf.short_name = "Read";
    rf.receiver_type = "net.netFD";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.rawListener.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.rawListener.Read";
    rf.short_name = "Read";
    rf.receiver_type = "net.rawListener";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.netFD.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.netFD.Read";
    rf.short_name = "Read";
    rf.receiver_type = "net.netFD";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.Buffers.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.Buffers.Read";
    rf.short_name = "Read";
    rf.receiver_type = "net.Buffers";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.netFD.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.netFD.Read";
    rf.short_name = "Read";
    rf.receiver_type = "net.netFD";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.rawConn.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.rawConn.Read";
    rf.short_name = "Read";
    rf.receiver_type = "net.rawConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.pipe.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.pipe.Read";
    rf.short_name = "Read";
    rf.receiver_type = "net.pipe";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.fakeNetFD.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.fakeNetFD.Read";
    rf.short_name = "Read";
    rf.receiver_type = "net.fakeNetFD";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.conn.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.conn.Read";
    rf.short_name = "Read";
    rf.receiver_type = "net.conn";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.IPConn.ReadFrom
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.IPConn.ReadFrom";
    rf.short_name = "ReadFrom";
    rf.receiver_type = "net.IPConn";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_named(arena, "net.Addr");
        ret[2] = cbm_type_builtin(arena, "error");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.UDPConn.ReadFrom
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.UDPConn.ReadFrom";
    rf.short_name = "ReadFrom";
    rf.receiver_type = "net.UDPConn";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_named(arena, "net.Addr");
        ret[2] = cbm_type_builtin(arena, "error");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.noReadFrom.ReadFrom
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.noReadFrom.ReadFrom";
    rf.short_name = "ReadFrom";
    rf.receiver_type = "net.noReadFrom";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.UnixConn.ReadFrom
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.UnixConn.ReadFrom";
    rf.short_name = "ReadFrom";
    rf.receiver_type = "net.UnixConn";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_named(arena, "net.Addr");
        ret[2] = cbm_type_builtin(arena, "error");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.TCPConn.ReadFrom
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.TCPConn.ReadFrom";
    rf.short_name = "ReadFrom";
    rf.receiver_type = "net.TCPConn";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.IPConn.ReadFromIP
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.IPConn.ReadFromIP";
    rf.short_name = "ReadFromIP";
    rf.receiver_type = "net.IPConn";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_pointer(arena, cbm_type_named(arena, "net.IPAddr"));
        ret[2] = cbm_type_builtin(arena, "error");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.UDPConn.ReadFromUDP
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.UDPConn.ReadFromUDP";
    rf.short_name = "ReadFromUDP";
    rf.receiver_type = "net.UDPConn";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_pointer(arena, cbm_type_named(arena, "net.UDPAddr"));
        ret[2] = cbm_type_builtin(arena, "error");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.UDPConn.ReadFromUDPAddrPort
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.UDPConn.ReadFromUDPAddrPort";
    rf.short_name = "ReadFromUDPAddrPort";
    rf.receiver_type = "net.UDPConn";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_named(arena, "netip.AddrPort");
        ret[2] = cbm_type_builtin(arena, "error");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.UnixConn.ReadFromUnix
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.UnixConn.ReadFromUnix";
    rf.short_name = "ReadFromUnix";
    rf.receiver_type = "net.UnixConn";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_pointer(arena, cbm_type_named(arena, "net.UnixAddr"));
        ret[2] = cbm_type_builtin(arena, "error");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.IPConn.ReadMsgIP
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.IPConn.ReadMsgIP";
    rf.short_name = "ReadMsgIP";
    rf.receiver_type = "net.IPConn";
    {
        const CBMType* ret[6];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "int");
        ret[2] = cbm_type_builtin(arena, "int");
        ret[3] = cbm_type_pointer(arena, cbm_type_named(arena, "net.IPAddr"));
        ret[4] = cbm_type_builtin(arena, "error");
        ret[5] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.UDPConn.ReadMsgUDP
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.UDPConn.ReadMsgUDP";
    rf.short_name = "ReadMsgUDP";
    rf.receiver_type = "net.UDPConn";
    {
        const CBMType* ret[6];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "int");
        ret[2] = cbm_type_builtin(arena, "int");
        ret[3] = cbm_type_pointer(arena, cbm_type_named(arena, "net.UDPAddr"));
        ret[4] = cbm_type_builtin(arena, "error");
        ret[5] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.UDPConn.ReadMsgUDPAddrPort
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.UDPConn.ReadMsgUDPAddrPort";
    rf.short_name = "ReadMsgUDPAddrPort";
    rf.receiver_type = "net.UDPConn";
    {
        const CBMType* ret[6];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "int");
        ret[2] = cbm_type_builtin(arena, "int");
        ret[3] = cbm_type_named(arena, "netip.AddrPort");
        ret[4] = cbm_type_builtin(arena, "error");
        ret[5] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.UnixConn.ReadMsgUnix
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.UnixConn.ReadMsgUnix";
    rf.short_name = "ReadMsgUnix";
    rf.receiver_type = "net.UnixConn";
    {
        const CBMType* ret[6];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "int");
        ret[2] = cbm_type_builtin(arena, "int");
        ret[3] = cbm_type_pointer(arena, cbm_type_named(arena, "net.UnixAddr"));
        ret[4] = cbm_type_builtin(arena, "error");
        ret[5] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.pipe.RemoteAddr
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.pipe.RemoteAddr";
    rf.short_name = "RemoteAddr";
    rf.receiver_type = "net.pipe";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net.Addr");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.conn.RemoteAddr
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.conn.RemoteAddr";
    rf.short_name = "RemoteAddr";
    rf.receiver_type = "net.conn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net.Addr");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.deadlineTimer.Reset
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.deadlineTimer.Reset";
    rf.short_name = "Reset";
    rf.receiver_type = "net.deadlineTimer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.ResolveIPAddr
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.ResolveIPAddr";
    rf.short_name = "ResolveIPAddr";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net.IPAddr"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.ResolveTCPAddr
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.ResolveTCPAddr";
    rf.short_name = "ResolveTCPAddr";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net.TCPAddr"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.ResolveUDPAddr
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.ResolveUDPAddr";
    rf.short_name = "ResolveUDPAddr";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net.UDPAddr"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.ResolveUnixAddr
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.ResolveUnixAddr";
    rf.short_name = "ResolveUnixAddr";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net.UnixAddr"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.conn.SetDeadline
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.conn.SetDeadline";
    rf.short_name = "SetDeadline";
    rf.receiver_type = "net.conn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.netFD.SetDeadline
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.netFD.SetDeadline";
    rf.short_name = "SetDeadline";
    rf.receiver_type = "net.netFD";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.TCPListener.SetDeadline
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.TCPListener.SetDeadline";
    rf.short_name = "SetDeadline";
    rf.receiver_type = "net.TCPListener";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.netFD.SetDeadline
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.netFD.SetDeadline";
    rf.short_name = "SetDeadline";
    rf.receiver_type = "net.netFD";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.pipe.SetDeadline
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.pipe.SetDeadline";
    rf.short_name = "SetDeadline";
    rf.receiver_type = "net.pipe";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.fakeNetFD.SetDeadline
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.fakeNetFD.SetDeadline";
    rf.short_name = "SetDeadline";
    rf.receiver_type = "net.fakeNetFD";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.UnixListener.SetDeadline
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.UnixListener.SetDeadline";
    rf.short_name = "SetDeadline";
    rf.receiver_type = "net.UnixListener";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.netFD.SetDeadline
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.netFD.SetDeadline";
    rf.short_name = "SetDeadline";
    rf.receiver_type = "net.netFD";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.TCPConn.SetKeepAlive
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.TCPConn.SetKeepAlive";
    rf.short_name = "SetKeepAlive";
    rf.receiver_type = "net.TCPConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.TCPConn.SetKeepAliveConfig
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.TCPConn.SetKeepAliveConfig";
    rf.short_name = "SetKeepAliveConfig";
    rf.receiver_type = "net.TCPConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.TCPConn.SetKeepAliveConfig
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.TCPConn.SetKeepAliveConfig";
    rf.short_name = "SetKeepAliveConfig";
    rf.receiver_type = "net.TCPConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.TCPConn.SetKeepAliveConfig
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.TCPConn.SetKeepAliveConfig";
    rf.short_name = "SetKeepAliveConfig";
    rf.receiver_type = "net.TCPConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.TCPConn.SetKeepAlivePeriod
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.TCPConn.SetKeepAlivePeriod";
    rf.short_name = "SetKeepAlivePeriod";
    rf.receiver_type = "net.TCPConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.TCPConn.SetLinger
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.TCPConn.SetLinger";
    rf.short_name = "SetLinger";
    rf.receiver_type = "net.TCPConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.Dialer.SetMultipathTCP
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.Dialer.SetMultipathTCP";
    rf.short_name = "SetMultipathTCP";
    rf.receiver_type = "net.Dialer";
    cbm_registry_add_func(reg, rf);

    // net.ListenConfig.SetMultipathTCP
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.ListenConfig.SetMultipathTCP";
    rf.short_name = "SetMultipathTCP";
    rf.receiver_type = "net.ListenConfig";
    cbm_registry_add_func(reg, rf);

    // net.TCPConn.SetNoDelay
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.TCPConn.SetNoDelay";
    rf.short_name = "SetNoDelay";
    rf.receiver_type = "net.TCPConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.conn.SetReadBuffer
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.conn.SetReadBuffer";
    rf.short_name = "SetReadBuffer";
    rf.receiver_type = "net.conn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.fakeNetFD.SetReadDeadline
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.fakeNetFD.SetReadDeadline";
    rf.short_name = "SetReadDeadline";
    rf.receiver_type = "net.fakeNetFD";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.netFD.SetReadDeadline
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.netFD.SetReadDeadline";
    rf.short_name = "SetReadDeadline";
    rf.receiver_type = "net.netFD";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.pipe.SetReadDeadline
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.pipe.SetReadDeadline";
    rf.short_name = "SetReadDeadline";
    rf.receiver_type = "net.pipe";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.netFD.SetReadDeadline
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.netFD.SetReadDeadline";
    rf.short_name = "SetReadDeadline";
    rf.receiver_type = "net.netFD";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.netFD.SetReadDeadline
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.netFD.SetReadDeadline";
    rf.short_name = "SetReadDeadline";
    rf.receiver_type = "net.netFD";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.conn.SetReadDeadline
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.conn.SetReadDeadline";
    rf.short_name = "SetReadDeadline";
    rf.receiver_type = "net.conn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.UnixListener.SetUnlinkOnClose
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.UnixListener.SetUnlinkOnClose";
    rf.short_name = "SetUnlinkOnClose";
    rf.receiver_type = "net.UnixListener";
    cbm_registry_add_func(reg, rf);

    // net.conn.SetWriteBuffer
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.conn.SetWriteBuffer";
    rf.short_name = "SetWriteBuffer";
    rf.receiver_type = "net.conn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.conn.SetWriteDeadline
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.conn.SetWriteDeadline";
    rf.short_name = "SetWriteDeadline";
    rf.receiver_type = "net.conn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.netFD.SetWriteDeadline
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.netFD.SetWriteDeadline";
    rf.short_name = "SetWriteDeadline";
    rf.receiver_type = "net.netFD";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.fakeNetFD.SetWriteDeadline
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.fakeNetFD.SetWriteDeadline";
    rf.short_name = "SetWriteDeadline";
    rf.receiver_type = "net.fakeNetFD";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.netFD.SetWriteDeadline
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.netFD.SetWriteDeadline";
    rf.short_name = "SetWriteDeadline";
    rf.receiver_type = "net.netFD";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.netFD.SetWriteDeadline
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.netFD.SetWriteDeadline";
    rf.short_name = "SetWriteDeadline";
    rf.receiver_type = "net.netFD";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.pipe.SetWriteDeadline
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.pipe.SetWriteDeadline";
    rf.short_name = "SetWriteDeadline";
    rf.receiver_type = "net.pipe";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.IPMask.Size
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.IPMask.Size";
    rf.short_name = "Size";
    rf.receiver_type = "net.IPMask";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "int");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.SplitHostPort
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.SplitHostPort";
    rf.short_name = "SplitHostPort";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_builtin(arena, "string");
        ret[2] = cbm_type_builtin(arena, "error");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.HardwareAddr.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.HardwareAddr.String";
    rf.short_name = "String";
    rf.receiver_type = "net.HardwareAddr";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.IP.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.IP.String";
    rf.short_name = "String";
    rf.receiver_type = "net.IP";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.IPAddr.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.IPAddr.String";
    rf.short_name = "String";
    rf.receiver_type = "net.IPAddr";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.pipeAddr.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.pipeAddr.String";
    rf.short_name = "String";
    rf.receiver_type = "net.pipeAddr";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.Flags.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.Flags.String";
    rf.short_name = "String";
    rf.receiver_type = "net.Flags";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.hostLookupOrder.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.hostLookupOrder.String";
    rf.short_name = "String";
    rf.receiver_type = "net.hostLookupOrder";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.fileAddr.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.fileAddr.String";
    rf.short_name = "String";
    rf.receiver_type = "net.fileAddr";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.IPNet.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.IPNet.String";
    rf.short_name = "String";
    rf.receiver_type = "net.IPNet";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.UnixAddr.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.UnixAddr.String";
    rf.short_name = "String";
    rf.receiver_type = "net.UnixAddr";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.IPMask.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.IPMask.String";
    rf.short_name = "String";
    rf.receiver_type = "net.IPMask";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.unknownAddr.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.unknownAddr.String";
    rf.short_name = "String";
    rf.receiver_type = "net.unknownAddr";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.TCPAddr.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.TCPAddr.String";
    rf.short_name = "String";
    rf.receiver_type = "net.TCPAddr";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.UDPAddr.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.UDPAddr.String";
    rf.short_name = "String";
    rf.receiver_type = "net.UDPAddr";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.UDPConn.SyscallConn
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.UDPConn.SyscallConn";
    rf.short_name = "SyscallConn";
    rf.receiver_type = "net.UDPConn";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "syscall.RawConn");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.UnixListener.SyscallConn
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.UnixListener.SyscallConn";
    rf.short_name = "SyscallConn";
    rf.receiver_type = "net.UnixListener";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "syscall.RawConn");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.IPConn.SyscallConn
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.IPConn.SyscallConn";
    rf.short_name = "SyscallConn";
    rf.receiver_type = "net.IPConn";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "syscall.RawConn");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.TCPConn.SyscallConn
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.TCPConn.SyscallConn";
    rf.short_name = "SyscallConn";
    rf.receiver_type = "net.TCPConn";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "syscall.RawConn");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.UnixConn.SyscallConn
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.UnixConn.SyscallConn";
    rf.short_name = "SyscallConn";
    rf.receiver_type = "net.UnixConn";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "syscall.RawConn");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.TCPListener.SyscallConn
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.TCPListener.SyscallConn";
    rf.short_name = "SyscallConn";
    rf.receiver_type = "net.TCPListener";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "syscall.RawConn");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.TCPAddrFromAddrPort
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.TCPAddrFromAddrPort";
    rf.short_name = "TCPAddrFromAddrPort";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net.TCPAddr"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.OpError.Temporary
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.OpError.Temporary";
    rf.short_name = "Temporary";
    rf.receiver_type = "net.OpError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.DNSConfigError.Temporary
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.DNSConfigError.Temporary";
    rf.short_name = "Temporary";
    rf.receiver_type = "net.DNSConfigError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.temporaryError.Temporary
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.temporaryError.Temporary";
    rf.short_name = "Temporary";
    rf.receiver_type = "net.temporaryError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.addrinfoErrno.Temporary
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.addrinfoErrno.Temporary";
    rf.short_name = "Temporary";
    rf.receiver_type = "net.addrinfoErrno";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.timeoutError.Temporary
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.timeoutError.Temporary";
    rf.short_name = "Temporary";
    rf.receiver_type = "net.timeoutError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.ParseError.Temporary
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.ParseError.Temporary";
    rf.short_name = "Temporary";
    rf.receiver_type = "net.ParseError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.InvalidAddrError.Temporary
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.InvalidAddrError.Temporary";
    rf.short_name = "Temporary";
    rf.receiver_type = "net.InvalidAddrError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.AddrError.Temporary
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.AddrError.Temporary";
    rf.short_name = "Temporary";
    rf.receiver_type = "net.AddrError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.DNSError.Temporary
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.DNSError.Temporary";
    rf.short_name = "Temporary";
    rf.receiver_type = "net.DNSError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.UnknownNetworkError.Temporary
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.UnknownNetworkError.Temporary";
    rf.short_name = "Temporary";
    rf.receiver_type = "net.UnknownNetworkError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.DNSConfigError.Timeout
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.DNSConfigError.Timeout";
    rf.short_name = "Timeout";
    rf.receiver_type = "net.DNSConfigError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.timeoutError.Timeout
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.timeoutError.Timeout";
    rf.short_name = "Timeout";
    rf.receiver_type = "net.timeoutError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.addrinfoErrno.Timeout
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.addrinfoErrno.Timeout";
    rf.short_name = "Timeout";
    rf.receiver_type = "net.addrinfoErrno";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.temporaryError.Timeout
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.temporaryError.Timeout";
    rf.short_name = "Timeout";
    rf.receiver_type = "net.temporaryError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.DNSError.Timeout
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.DNSError.Timeout";
    rf.short_name = "Timeout";
    rf.receiver_type = "net.DNSError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.UnknownNetworkError.Timeout
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.UnknownNetworkError.Timeout";
    rf.short_name = "Timeout";
    rf.receiver_type = "net.UnknownNetworkError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.InvalidAddrError.Timeout
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.InvalidAddrError.Timeout";
    rf.short_name = "Timeout";
    rf.receiver_type = "net.InvalidAddrError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.ParseError.Timeout
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.ParseError.Timeout";
    rf.short_name = "Timeout";
    rf.receiver_type = "net.ParseError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.AddrError.Timeout
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.AddrError.Timeout";
    rf.short_name = "Timeout";
    rf.receiver_type = "net.AddrError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.OpError.Timeout
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.OpError.Timeout";
    rf.short_name = "Timeout";
    rf.receiver_type = "net.OpError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.IP.To16
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.IP.To16";
    rf.short_name = "To16";
    rf.receiver_type = "net.IP";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net.IP");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.IP.To4
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.IP.To4";
    rf.short_name = "To4";
    rf.receiver_type = "net.IP";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net.IP");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.UDPAddrFromAddrPort
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.UDPAddrFromAddrPort";
    rf.short_name = "UDPAddrFromAddrPort";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net.UDPAddr"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.IP.UnmarshalText
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.IP.UnmarshalText";
    rf.short_name = "UnmarshalText";
    rf.receiver_type = "net.IP";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.OpError.Unwrap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.OpError.Unwrap";
    rf.short_name = "Unwrap";
    rf.receiver_type = "net.OpError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.DNSConfigError.Unwrap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.DNSConfigError.Unwrap";
    rf.short_name = "Unwrap";
    rf.receiver_type = "net.DNSConfigError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.DNSError.Unwrap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.DNSError.Unwrap";
    rf.short_name = "Unwrap";
    rf.receiver_type = "net.DNSError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.onlyValuesCtx.Value
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.onlyValuesCtx.Value";
    rf.short_name = "Value";
    rf.receiver_type = "net.onlyValuesCtx";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "any");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.rawConn.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.rawConn.Write";
    rf.short_name = "Write";
    rf.receiver_type = "net.rawConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.netFD.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.netFD.Write";
    rf.short_name = "Write";
    rf.receiver_type = "net.netFD";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.pipe.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.pipe.Write";
    rf.short_name = "Write";
    rf.receiver_type = "net.pipe";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.fakeNetFD.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.fakeNetFD.Write";
    rf.short_name = "Write";
    rf.receiver_type = "net.fakeNetFD";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.netFD.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.netFD.Write";
    rf.short_name = "Write";
    rf.receiver_type = "net.netFD";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.netFD.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.netFD.Write";
    rf.short_name = "Write";
    rf.receiver_type = "net.netFD";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.conn.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.conn.Write";
    rf.short_name = "Write";
    rf.receiver_type = "net.conn";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.rawListener.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.rawListener.Write";
    rf.short_name = "Write";
    rf.receiver_type = "net.rawListener";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.IPConn.WriteMsgIP
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.IPConn.WriteMsgIP";
    rf.short_name = "WriteMsgIP";
    rf.receiver_type = "net.IPConn";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "int");
        ret[2] = cbm_type_builtin(arena, "error");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.UDPConn.WriteMsgUDP
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.UDPConn.WriteMsgUDP";
    rf.short_name = "WriteMsgUDP";
    rf.receiver_type = "net.UDPConn";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "int");
        ret[2] = cbm_type_builtin(arena, "error");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.UDPConn.WriteMsgUDPAddrPort
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.UDPConn.WriteMsgUDPAddrPort";
    rf.short_name = "WriteMsgUDPAddrPort";
    rf.receiver_type = "net.UDPConn";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "int");
        ret[2] = cbm_type_builtin(arena, "error");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.UnixConn.WriteMsgUnix
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.UnixConn.WriteMsgUnix";
    rf.short_name = "WriteMsgUnix";
    rf.receiver_type = "net.UnixConn";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "int");
        ret[2] = cbm_type_builtin(arena, "error");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.UnixConn.WriteTo
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.UnixConn.WriteTo";
    rf.short_name = "WriteTo";
    rf.receiver_type = "net.UnixConn";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.UDPConn.WriteTo
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.UDPConn.WriteTo";
    rf.short_name = "WriteTo";
    rf.receiver_type = "net.UDPConn";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.TCPConn.WriteTo
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.TCPConn.WriteTo";
    rf.short_name = "WriteTo";
    rf.receiver_type = "net.TCPConn";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.noWriteTo.WriteTo
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.noWriteTo.WriteTo";
    rf.short_name = "WriteTo";
    rf.receiver_type = "net.noWriteTo";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.IPConn.WriteTo
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.IPConn.WriteTo";
    rf.short_name = "WriteTo";
    rf.receiver_type = "net.IPConn";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.Buffers.WriteTo
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.Buffers.WriteTo";
    rf.short_name = "WriteTo";
    rf.receiver_type = "net.Buffers";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.IPConn.WriteToIP
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.IPConn.WriteToIP";
    rf.short_name = "WriteToIP";
    rf.receiver_type = "net.IPConn";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.UDPConn.WriteToUDP
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.UDPConn.WriteToUDP";
    rf.short_name = "WriteToUDP";
    rf.receiver_type = "net.UDPConn";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.UDPConn.WriteToUDPAddrPort
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.UDPConn.WriteToUDPAddrPort";
    rf.short_name = "WriteToUDPAddrPort";
    rf.receiver_type = "net.UDPConn";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net.UnixConn.WriteToUnix
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net.UnixConn.WriteToUnix";
    rf.short_name = "WriteToUnix";
    rf.receiver_type = "net.UnixConn";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Header.Add
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Header.Add";
    rf.short_name = "Add";
    rf.receiver_type = "net/http.Header";
    cbm_registry_add_func(reg, rf);

    // net/http.Request.AddCookie
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Request.AddCookie";
    rf.short_name = "AddCookie";
    rf.receiver_type = "net/http.Request";
    cbm_registry_add_func(reg, rf);

    // net/http.CrossOriginProtection.AddInsecureBypassPattern
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.CrossOriginProtection.AddInsecureBypassPattern";
    rf.short_name = "AddInsecureBypassPattern";
    rf.receiver_type = "net/http.CrossOriginProtection";
    cbm_registry_add_func(reg, rf);

    // net/http.CrossOriginProtection.AddTrustedOrigin
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.CrossOriginProtection.AddTrustedOrigin";
    rf.short_name = "AddTrustedOrigin";
    rf.receiver_type = "net/http.CrossOriginProtection";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2roundRobinWriteScheduler.AdjustStream
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2roundRobinWriteScheduler.AdjustStream";
    rf.short_name = "AdjustStream";
    rf.receiver_type = "net/http.http2roundRobinWriteScheduler";
    cbm_registry_add_func(reg, rf);

    // net/http.http2priorityWriteSchedulerRFC7540.AdjustStream
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2priorityWriteSchedulerRFC7540.AdjustStream";
    rf.short_name = "AdjustStream";
    rf.receiver_type = "net/http.http2priorityWriteSchedulerRFC7540";
    cbm_registry_add_func(reg, rf);

    // net/http.http2priorityWriteSchedulerRFC9218.AdjustStream
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2priorityWriteSchedulerRFC9218.AdjustStream";
    rf.short_name = "AdjustStream";
    rf.receiver_type = "net/http.http2priorityWriteSchedulerRFC9218";
    cbm_registry_add_func(reg, rf);

    // net/http.http2randomWriteScheduler.AdjustStream
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2randomWriteScheduler.AdjustStream";
    rf.short_name = "AdjustStream";
    rf.receiver_type = "net/http.http2randomWriteScheduler";
    cbm_registry_add_func(reg, rf);

    // net/http.AllowQuerySemicolons
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.AllowQuerySemicolons";
    rf.short_name = "AllowQuerySemicolons";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net/http.Handler");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.ArgServer
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ArgServer";
    rf.short_name = "ArgServer";
    cbm_registry_add_func(reg, rf);

    // net/http.http2StreamError.As
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2StreamError.As";
    rf.short_name = "As";
    rf.receiver_type = "net/http.http2StreamError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.socksUsernamePassword.Authenticate
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.socksUsernamePassword.Authenticate";
    rf.short_name = "Authenticate";
    rf.receiver_type = "net/http.socksUsernamePassword";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.ClientConn.Available
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ClientConn.Available";
    rf.short_name = "Available";
    rf.receiver_type = "net/http.ClientConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2bufferedWriter.Available
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2bufferedWriter.Available";
    rf.short_name = "Available";
    rf.receiver_type = "net/http.http2bufferedWriter";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http1ClientConn.Available
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http1ClientConn.Available";
    rf.short_name = "Available";
    rf.receiver_type = "net/http.http1ClientConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2netHTTPClientConn.Available
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2netHTTPClientConn.Available";
    rf.short_name = "Available";
    rf.receiver_type = "net/http.http2netHTTPClientConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.unencryptedHTTP2Request.BaseContext
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.unencryptedHTTP2Request.BaseContext";
    rf.short_name = "BaseContext";
    rf.receiver_type = "net/http.unencryptedHTTP2Request";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "context.Context");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.initALPNRequest.BaseContext
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.initALPNRequest.BaseContext";
    rf.short_name = "BaseContext";
    rf.receiver_type = "net/http.initALPNRequest";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "context.Context");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Request.BasicAuth
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Request.BasicAuth";
    rf.short_name = "BasicAuth";
    rf.receiver_type = "net/http.Request";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_builtin(arena, "string");
        ret[2] = cbm_type_builtin(arena, "bool");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.socksConn.BoundAddr
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.socksConn.BoundAddr";
    rf.short_name = "BoundAddr";
    rf.receiver_type = "net/http.socksConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net.Addr");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2pipe.BreakWithError
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2pipe.BreakWithError";
    rf.short_name = "BreakWithError";
    rf.receiver_type = "net/http.http2pipe";
    cbm_registry_add_func(reg, rf);

    // net/http.http2ClientConn.CanTakeNewRequest
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2ClientConn.CanTakeNewRequest";
    rf.short_name = "CanTakeNewRequest";
    rf.receiver_type = "net/http.http2ClientConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Transport.CancelRequest
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Transport.CancelRequest";
    rf.short_name = "CancelRequest";
    rf.receiver_type = "net/http.Transport";
    cbm_registry_add_func(reg, rf);

    // net/http.CanonicalHeaderKey
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.CanonicalHeaderKey";
    rf.short_name = "CanonicalHeaderKey";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.ChanCreate
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ChanCreate";
    rf.short_name = "ChanCreate";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net/http.Chan");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.CrossOriginProtection.Check
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.CrossOriginProtection.Check";
    rf.short_name = "Check";
    rf.receiver_type = "net/http.CrossOriginProtection";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Header.Clone
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Header.Clone";
    rf.short_name = "Clone";
    rf.receiver_type = "net/http.Header";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net/http.Header");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Transport.Clone
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Transport.Clone";
    rf.short_name = "Clone";
    rf.receiver_type = "net/http.Transport";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/http.Transport"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Request.Clone
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Request.Clone";
    rf.short_name = "Clone";
    rf.receiver_type = "net/http.Request";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/http.Request"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.ioFile.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ioFile.Close";
    rf.short_name = "Close";
    rf.receiver_type = "net/http.ioFile";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.maxBytesReader.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.maxBytesReader.Close";
    rf.short_name = "Close";
    rf.receiver_type = "net/http.maxBytesReader";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.streamReader.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.streamReader.Close";
    rf.short_name = "Close";
    rf.receiver_type = "net/http.streamReader";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Server.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Server.Close";
    rf.short_name = "Close";
    rf.receiver_type = "net/http.Server";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.expectContinueReader.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.expectContinueReader.Close";
    rf.short_name = "Close";
    rf.receiver_type = "net/http.expectContinueReader";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.onceCloseListener.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.onceCloseListener.Close";
    rf.short_name = "Close";
    rf.receiver_type = "net/http.onceCloseListener";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.noBody.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.noBody.Close";
    rf.short_name = "Close";
    rf.receiver_type = "net/http.noBody";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.loggingConn.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.loggingConn.Close";
    rf.short_name = "Close";
    rf.receiver_type = "net/http.loggingConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.body.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.body.Close";
    rf.short_name = "Close";
    rf.receiver_type = "net/http.body";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.ClientConn.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ClientConn.Close";
    rf.short_name = "Close";
    rf.receiver_type = "net/http.ClientConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http1ClientConn.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http1ClientConn.Close";
    rf.short_name = "Close";
    rf.receiver_type = "net/http.http1ClientConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.cancelTimerBody.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.cancelTimerBody.Close";
    rf.short_name = "Close";
    rf.receiver_type = "net/http.cancelTimerBody";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2netHTTPClientConn.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2netHTTPClientConn.Close";
    rf.short_name = "Close";
    rf.receiver_type = "net/http.http2netHTTPClientConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.gzipReader.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.gzipReader.Close";
    rf.short_name = "Close";
    rf.receiver_type = "net/http.gzipReader";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2gzipReader.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2gzipReader.Close";
    rf.short_name = "Close";
    rf.receiver_type = "net/http.http2gzipReader";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2missingBody.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2missingBody.Close";
    rf.short_name = "Close";
    rf.receiver_type = "net/http.http2missingBody";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2noBodyReader.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2noBodyReader.Close";
    rf.short_name = "Close";
    rf.receiver_type = "net/http.http2noBodyReader";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.arrayReader.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.arrayReader.Close";
    rf.short_name = "Close";
    rf.receiver_type = "net/http.arrayReader";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2transportResponseBody.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2transportResponseBody.Close";
    rf.short_name = "Close";
    rf.receiver_type = "net/http.http2transportResponseBody";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.bodyEOFSignal.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.bodyEOFSignal.Close";
    rf.short_name = "Close";
    rf.receiver_type = "net/http.bodyEOFSignal";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2ClientConn.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2ClientConn.Close";
    rf.short_name = "Close";
    rf.receiver_type = "net/http.http2ClientConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.readTrackingBody.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.readTrackingBody.Close";
    rf.short_name = "Close";
    rf.receiver_type = "net/http.readTrackingBody";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2requestBody.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2requestBody.Close";
    rf.short_name = "Close";
    rf.receiver_type = "net/http.http2requestBody";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2closeWaiter.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2closeWaiter.Close";
    rf.short_name = "Close";
    rf.receiver_type = "net/http.http2closeWaiter";
    cbm_registry_add_func(reg, rf);

    // net/http.http2serverConn.CloseConn
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2serverConn.CloseConn";
    rf.short_name = "CloseConn";
    rf.receiver_type = "net/http.http2serverConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Client.CloseIdleConnections
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Client.CloseIdleConnections";
    rf.short_name = "CloseIdleConnections";
    rf.receiver_type = "net/http.Client";
    cbm_registry_add_func(reg, rf);

    // net/http.http2Transport.CloseIdleConnections
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2Transport.CloseIdleConnections";
    rf.short_name = "CloseIdleConnections";
    rf.receiver_type = "net/http.http2Transport";
    cbm_registry_add_func(reg, rf);

    // net/http.Transport.CloseIdleConnections
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Transport.CloseIdleConnections";
    rf.short_name = "CloseIdleConnections";
    rf.receiver_type = "net/http.Transport";
    cbm_registry_add_func(reg, rf);

    // net/http.http2Transport.CloseIdleConnections
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2Transport.CloseIdleConnections";
    rf.short_name = "CloseIdleConnections";
    rf.receiver_type = "net/http.http2Transport";
    cbm_registry_add_func(reg, rf);

    // net/http.http2responseWriter.CloseNotify
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2responseWriter.CloseNotify";
    rf.short_name = "CloseNotify";
    rf.receiver_type = "net/http.http2responseWriter";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net/http.chan bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.response.CloseNotify
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.response.CloseNotify";
    rf.short_name = "CloseNotify";
    rf.receiver_type = "net/http.response";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net/http.chan bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2randomWriteScheduler.CloseStream
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2randomWriteScheduler.CloseStream";
    rf.short_name = "CloseStream";
    rf.receiver_type = "net/http.http2randomWriteScheduler";
    cbm_registry_add_func(reg, rf);

    // net/http.http2priorityWriteSchedulerRFC9218.CloseStream
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2priorityWriteSchedulerRFC9218.CloseStream";
    rf.short_name = "CloseStream";
    rf.receiver_type = "net/http.http2priorityWriteSchedulerRFC9218";
    cbm_registry_add_func(reg, rf);

    // net/http.http2priorityWriteSchedulerRFC7540.CloseStream
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2priorityWriteSchedulerRFC7540.CloseStream";
    rf.short_name = "CloseStream";
    rf.receiver_type = "net/http.http2priorityWriteSchedulerRFC7540";
    cbm_registry_add_func(reg, rf);

    // net/http.http2roundRobinWriteScheduler.CloseStream
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2roundRobinWriteScheduler.CloseStream";
    rf.short_name = "CloseStream";
    rf.receiver_type = "net/http.http2roundRobinWriteScheduler";
    cbm_registry_add_func(reg, rf);

    // net/http.http2pipe.CloseWithError
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2pipe.CloseWithError";
    rf.short_name = "CloseWithError";
    rf.receiver_type = "net/http.http2pipe";
    cbm_registry_add_func(reg, rf);

    // net/http.readWriteCloserBody.CloseWrite
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.readWriteCloserBody.CloseWrite";
    rf.short_name = "CloseWrite";
    rf.receiver_type = "net/http.readWriteCloserBody";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2FrameWriteRequest.Consume
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2FrameWriteRequest.Consume";
    rf.short_name = "Consume";
    rf.receiver_type = "net/http.http2FrameWriteRequest";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_named(arena, "net/http.http2FrameWriteRequest");
        ret[1] = cbm_type_named(arena, "net/http.http2FrameWriteRequest");
        ret[2] = cbm_type_builtin(arena, "int");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Request.Context
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Request.Context";
    rf.short_name = "Context";
    rf.receiver_type = "net/http.Request";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "context.Context");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Request.Cookie
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Request.Cookie";
    rf.short_name = "Cookie";
    rf.receiver_type = "net/http.Request";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/http.Cookie"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Response.Cookies
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Response.Cookies";
    rf.short_name = "Cookies";
    rf.receiver_type = "net/http.Response";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "net/http.*Cookie"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Request.Cookies
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Request.Cookies";
    rf.short_name = "Cookies";
    rf.receiver_type = "net/http.Request";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "net/http.*Cookie"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Request.CookiesNamed
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Request.CookiesNamed";
    rf.short_name = "CookiesNamed";
    rf.receiver_type = "net/http.Request";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "net/http.*Cookie"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2DataFrame.Data
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2DataFrame.Data";
    rf.short_name = "Data";
    rf.receiver_type = "net/http.http2DataFrame";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2FrameWriteRequest.DataSize
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2FrameWriteRequest.DataSize";
    rf.short_name = "DataSize";
    rf.receiver_type = "net/http.http2FrameWriteRequest";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.DateServer
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.DateServer";
    rf.short_name = "DateServer";
    cbm_registry_add_func(reg, rf);

    // net/http.http2GoAwayFrame.DebugData
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2GoAwayFrame.DebugData";
    rf.short_name = "DebugData";
    rf.receiver_type = "net/http.http2GoAwayFrame";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Header.Del
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Header.Del";
    rf.short_name = "Del";
    rf.receiver_type = "net/http.Header";
    cbm_registry_add_func(reg, rf);

    // net/http.DetectContentType
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.DetectContentType";
    rf.short_name = "DetectContentType";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.socksDialer.Dial
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.socksDialer.Dial";
    rf.short_name = "Dial";
    rf.receiver_type = "net/http.socksDialer";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "net.Conn");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.socksDialer.DialContext
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.socksDialer.DialContext";
    rf.short_name = "DialContext";
    rf.receiver_type = "net/http.socksDialer";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "net.Conn");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.socksDialer.DialWithConn
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.socksDialer.DialWithConn";
    rf.short_name = "DialWithConn";
    rf.receiver_type = "net/http.socksDialer";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "net.Addr");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Client.Do
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Client.Do";
    rf.short_name = "Do";
    rf.receiver_type = "net/http.Client";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/http.Response"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2pipe.Done
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2pipe.Done";
    rf.short_name = "Done";
    rf.receiver_type = "net/http.http2pipe";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net/http.chan any");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.response.EnableFullDuplex
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.response.EnableFullDuplex";
    rf.short_name = "EnableFullDuplex";
    rf.receiver_type = "net/http.response";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2responseWriter.EnableFullDuplex
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2responseWriter.EnableFullDuplex";
    rf.short_name = "EnableFullDuplex";
    rf.receiver_type = "net/http.http2responseWriter";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.ResponseController.EnableFullDuplex
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ResponseController.EnableFullDuplex";
    rf.short_name = "EnableFullDuplex";
    rf.receiver_type = "net/http.ResponseController";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http1ClientConn.Err
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http1ClientConn.Err";
    rf.short_name = "Err";
    rf.receiver_type = "net/http.http1ClientConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2netHTTPClientConn.Err
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2netHTTPClientConn.Err";
    rf.short_name = "Err";
    rf.receiver_type = "net/http.http2netHTTPClientConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2pipe.Err
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2pipe.Err";
    rf.short_name = "Err";
    rf.receiver_type = "net/http.http2pipe";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.ClientConn.Err
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ClientConn.Err";
    rf.short_name = "Err";
    rf.receiver_type = "net/http.ClientConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.unsupportedTEError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.unsupportedTEError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "net/http.unsupportedTEError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2ConnectionError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2ConnectionError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "net/http.http2ConnectionError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.tlsHandshakeTimeoutError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.tlsHandshakeTimeoutError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "net/http.tlsHandshakeTimeoutError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.timeoutError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.timeoutError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "net/http.timeoutError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.transportReadFromServerError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.transportReadFromServerError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "net/http.transportReadFromServerError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.ProtocolError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ProtocolError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "net/http.ProtocolError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2noCachedConnError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2noCachedConnError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "net/http.http2noCachedConnError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2GoAwayError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2GoAwayError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "net/http.http2GoAwayError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Error";
    rf.short_name = "Error";
    cbm_registry_add_func(reg, rf);

    // net/http.statusError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.statusError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "net/http.statusError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2StreamError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2StreamError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "net/http.http2StreamError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2goAwayFlowError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2goAwayFlowError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "net/http.http2goAwayFlowError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2connError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2connError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "net/http.http2connError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2pseudoHeaderError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2pseudoHeaderError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "net/http.http2pseudoHeaderError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2duplicatePseudoHeaderError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2duplicatePseudoHeaderError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "net/http.http2duplicatePseudoHeaderError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2headerFieldNameError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2headerFieldNameError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "net/http.http2headerFieldNameError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2headerFieldValueError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2headerFieldValueError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "net/http.http2headerFieldValueError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2noCachedConnError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2noCachedConnError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "net/http.http2noCachedConnError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2httpError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2httpError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "net/http.http2httpError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.MaxBytesError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.MaxBytesError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "net/http.MaxBytesError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2Framer.ErrorDetail
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2Framer.ErrorDetail";
    rf.short_name = "ErrorDetail";
    rf.receiver_type = "net/http.http2Framer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.FS
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.FS";
    rf.short_name = "FS";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net/http.FileSystem");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.FileServer
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.FileServer";
    rf.short_name = "FileServer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net/http.Handler");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.FileServerFS
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.FileServerFS";
    rf.short_name = "FileServerFS";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net/http.Handler");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.FlagServer
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.FlagServer";
    rf.short_name = "FlagServer";
    cbm_registry_add_func(reg, rf);

    // net/http.ResponseController.Flush
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ResponseController.Flush";
    rf.short_name = "Flush";
    rf.receiver_type = "net/http.ResponseController";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2serverConn.Flush
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2serverConn.Flush";
    rf.short_name = "Flush";
    rf.receiver_type = "net/http.http2serverConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2bufferedWriter.Flush
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2bufferedWriter.Flush";
    rf.short_name = "Flush";
    rf.receiver_type = "net/http.http2bufferedWriter";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2responseWriter.Flush
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2responseWriter.Flush";
    rf.short_name = "Flush";
    rf.receiver_type = "net/http.http2responseWriter";
    cbm_registry_add_func(reg, rf);

    // net/http.response.Flush
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.response.Flush";
    rf.short_name = "Flush";
    rf.receiver_type = "net/http.response";
    cbm_registry_add_func(reg, rf);

    // net/http.response.FlushError
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.response.FlushError";
    rf.short_name = "FlushError";
    rf.receiver_type = "net/http.response";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2responseWriter.FlushError
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2responseWriter.FlushError";
    rf.short_name = "FlushError";
    rf.receiver_type = "net/http.http2responseWriter";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2SettingsFrame.ForeachSetting
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2SettingsFrame.ForeachSetting";
    rf.short_name = "ForeachSetting";
    rf.receiver_type = "net/http.http2SettingsFrame";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Request.FormFile
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Request.FormFile";
    rf.short_name = "FormFile";
    rf.receiver_type = "net/http.Request";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_named(arena, "multipart.File");
        ret[1] = cbm_type_pointer(arena, cbm_type_named(arena, "multipart.FileHeader"));
        ret[2] = cbm_type_builtin(arena, "error");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Request.FormValue
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Request.FormValue";
    rf.short_name = "FormValue";
    rf.receiver_type = "net/http.Request";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2serverConn.Framer
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2serverConn.Framer";
    rf.short_name = "Framer";
    rf.receiver_type = "net/http.http2serverConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/http.http2Framer"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Client.Get
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Client.Get";
    rf.short_name = "Get";
    rf.receiver_type = "net/http.Client";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/http.Response"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Get
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Get";
    rf.short_name = "Get";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/http.Response"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Header.Get
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Header.Get";
    rf.short_name = "Get";
    rf.receiver_type = "net/http.Header";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2clientConnPool.GetClientConn
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2clientConnPool.GetClientConn";
    rf.short_name = "GetClientConn";
    rf.receiver_type = "net/http.http2clientConnPool";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/http.http2ClientConn"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2noDialClientConnPool.GetClientConn
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2noDialClientConnPool.GetClientConn";
    rf.short_name = "GetClientConn";
    rf.receiver_type = "net/http.http2noDialClientConnPool";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/http.http2ClientConn"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Protocols.HTTP1
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Protocols.HTTP1";
    rf.short_name = "HTTP1";
    rf.receiver_type = "net/http.Protocols";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Protocols.HTTP2
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Protocols.HTTP2";
    rf.short_name = "HTTP2";
    rf.receiver_type = "net/http.Protocols";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.ServeMux.Handle
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ServeMux.Handle";
    rf.short_name = "Handle";
    rf.receiver_type = "net/http.ServeMux";
    cbm_registry_add_func(reg, rf);

    // net/http.Handle
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Handle";
    rf.short_name = "Handle";
    cbm_registry_add_func(reg, rf);

    // net/http.ServeMux.HandleFunc
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ServeMux.HandleFunc";
    rf.short_name = "HandleFunc";
    rf.receiver_type = "net/http.ServeMux";
    cbm_registry_add_func(reg, rf);

    // net/http.HandleFunc
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.HandleFunc";
    rf.short_name = "HandleFunc";
    cbm_registry_add_func(reg, rf);

    // net/http.CrossOriginProtection.Handler
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.CrossOriginProtection.Handler";
    rf.short_name = "Handler";
    rf.receiver_type = "net/http.CrossOriginProtection";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net/http.Handler");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.ServeMux.Handler
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ServeMux.Handler";
    rf.short_name = "Handler";
    rf.receiver_type = "net/http.ServeMux";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "net/http.Handler");
        ret[1] = cbm_type_builtin(arena, "string");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2Flags.Has
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2Flags.Has";
    rf.short_name = "Has";
    rf.receiver_type = "net/http.http2Flags";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2SettingsFrame.HasDuplicates
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2SettingsFrame.HasDuplicates";
    rf.short_name = "HasDuplicates";
    rf.receiver_type = "net/http.http2SettingsFrame";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2HeadersFrame.HasPriority
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2HeadersFrame.HasPriority";
    rf.short_name = "HasPriority";
    rf.receiver_type = "net/http.http2HeadersFrame";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Head
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Head";
    rf.short_name = "Head";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/http.Response"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Client.Head
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Client.Head";
    rf.short_name = "Head";
    rf.receiver_type = "net/http.Client";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/http.Response"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2responseWriter.Header
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2responseWriter.Header";
    rf.short_name = "Header";
    rf.receiver_type = "net/http.http2responseWriter";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net/http.Header");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.populateResponse.Header
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.populateResponse.Header";
    rf.short_name = "Header";
    rf.receiver_type = "net/http.populateResponse";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net/http.Header");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.response.Header
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.response.Header";
    rf.short_name = "Header";
    rf.receiver_type = "net/http.response";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net/http.Header");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.timeoutWriter.Header
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.timeoutWriter.Header";
    rf.short_name = "Header";
    rf.receiver_type = "net/http.timeoutWriter";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net/http.Header");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2FrameHeader.Header
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2FrameHeader.Header";
    rf.short_name = "Header";
    rf.receiver_type = "net/http.http2FrameHeader";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net/http.http2FrameHeader");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2ContinuationFrame.HeaderBlockFragment
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2ContinuationFrame.HeaderBlockFragment";
    rf.short_name = "HeaderBlockFragment";
    rf.receiver_type = "net/http.http2ContinuationFrame";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2PushPromiseFrame.HeaderBlockFragment
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2PushPromiseFrame.HeaderBlockFragment";
    rf.short_name = "HeaderBlockFragment";
    rf.receiver_type = "net/http.http2PushPromiseFrame";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2HeadersFrame.HeaderBlockFragment
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2HeadersFrame.HeaderBlockFragment";
    rf.short_name = "HeaderBlockFragment";
    rf.receiver_type = "net/http.http2HeadersFrame";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2serverConn.HeaderEncoder
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2serverConn.HeaderEncoder";
    rf.short_name = "HeaderEncoder";
    rf.receiver_type = "net/http.http2serverConn";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "hpack.Encoder"));
        ret[1] = cbm_type_pointer(arena, cbm_type_named(arena, "bytes.Buffer"));
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2PushPromiseFrame.HeadersEnded
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2PushPromiseFrame.HeadersEnded";
    rf.short_name = "HeadersEnded";
    rf.receiver_type = "net/http.http2PushPromiseFrame";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2ContinuationFrame.HeadersEnded
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2ContinuationFrame.HeadersEnded";
    rf.short_name = "HeadersEnded";
    rf.receiver_type = "net/http.http2ContinuationFrame";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2HeadersFrame.HeadersEnded
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2HeadersFrame.HeadersEnded";
    rf.short_name = "HeadersEnded";
    rf.receiver_type = "net/http.http2HeadersFrame";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.HelloServer
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.HelloServer";
    rf.short_name = "HelloServer";
    cbm_registry_add_func(reg, rf);

    // net/http.response.Hijack
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.response.Hijack";
    rf.short_name = "Hijack";
    rf.receiver_type = "net/http.response";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_named(arena, "net.Conn");
        ret[1] = cbm_type_pointer(arena, cbm_type_named(arena, "bufio.ReadWriter"));
        ret[2] = cbm_type_builtin(arena, "error");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.ResponseController.Hijack
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ResponseController.Hijack";
    rf.short_name = "Hijack";
    rf.receiver_type = "net/http.ResponseController";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_named(arena, "net.Conn");
        ret[1] = cbm_type_pointer(arena, cbm_type_named(arena, "bufio.ReadWriter"));
        ret[2] = cbm_type_builtin(arena, "error");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.ClientConn.InFlight
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ClientConn.InFlight";
    rf.short_name = "InFlight";
    rf.receiver_type = "net/http.ClientConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http1ClientConn.InFlight
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http1ClientConn.InFlight";
    rf.short_name = "InFlight";
    rf.receiver_type = "net/http.http1ClientConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2netHTTPClientConn.InFlight
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2netHTTPClientConn.InFlight";
    rf.short_name = "InFlight";
    rf.receiver_type = "net/http.http2netHTTPClientConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2closeWaiter.Init
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2closeWaiter.Init";
    rf.short_name = "Init";
    rf.receiver_type = "net/http.http2closeWaiter";
    cbm_registry_add_func(reg, rf);

    // net/http.timeoutError.Is
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.timeoutError.Is";
    rf.short_name = "Is";
    rf.receiver_type = "net/http.timeoutError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.ProtocolError.Is
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ProtocolError.Is";
    rf.short_name = "Is";
    rf.receiver_type = "net/http.ProtocolError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2PingFrame.IsAck
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2PingFrame.IsAck";
    rf.short_name = "IsAck";
    rf.receiver_type = "net/http.http2PingFrame";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2SettingsFrame.IsAck
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2SettingsFrame.IsAck";
    rf.short_name = "IsAck";
    rf.receiver_type = "net/http.http2SettingsFrame";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2noCachedConnError.IsHTTP2NoCachedConnError
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2noCachedConnError.IsHTTP2NoCachedConnError";
    rf.short_name = "IsHTTP2NoCachedConnError";
    rf.receiver_type = "net/http.http2noCachedConnError";
    cbm_registry_add_func(reg, rf);

    // net/http.http2noCachedConnError.IsHTTP2NoCachedConnError
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2noCachedConnError.IsHTTP2NoCachedConnError";
    rf.short_name = "IsHTTP2NoCachedConnError";
    rf.receiver_type = "net/http.http2noCachedConnError";
    cbm_registry_add_func(reg, rf);

    // net/http.http2PriorityParam.IsZero
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2PriorityParam.IsZero";
    rf.short_name = "IsZero";
    rf.receiver_type = "net/http.http2PriorityParam";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2sorter.Keys
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2sorter.Keys";
    rf.short_name = "Keys";
    rf.receiver_type = "net/http.http2sorter";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "string"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2sorter.Len
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2sorter.Len";
    rf.short_name = "Len";
    rf.receiver_type = "net/http.http2sorter";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2dataBuffer.Len
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2dataBuffer.Len";
    rf.short_name = "Len";
    rf.receiver_type = "net/http.http2dataBuffer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2pipe.Len
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2pipe.Len";
    rf.short_name = "Len";
    rf.receiver_type = "net/http.http2pipe";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2sortPriorityNodeSiblingsRFC7540.Len
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2sortPriorityNodeSiblingsRFC7540.Len";
    rf.short_name = "Len";
    rf.receiver_type = "net/http.http2sortPriorityNodeSiblingsRFC7540";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2sortPriorityNodeSiblingsRFC7540.Less
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2sortPriorityNodeSiblingsRFC7540.Less";
    rf.short_name = "Less";
    rf.receiver_type = "net/http.http2sortPriorityNodeSiblingsRFC7540";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2sorter.Less
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2sorter.Less";
    rf.short_name = "Less";
    rf.receiver_type = "net/http.http2sorter";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Server.ListenAndServe
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Server.ListenAndServe";
    rf.short_name = "ListenAndServe";
    rf.receiver_type = "net/http.Server";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.ListenAndServe
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ListenAndServe";
    rf.short_name = "ListenAndServe";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.ListenAndServeTLS
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ListenAndServeTLS";
    rf.short_name = "ListenAndServeTLS";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Server.ListenAndServeTLS
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Server.ListenAndServeTLS";
    rf.short_name = "ListenAndServeTLS";
    rf.receiver_type = "net/http.Server";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Response.Location
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Response.Location";
    rf.short_name = "Location";
    rf.receiver_type = "net/http.Response";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "url.URL"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.fakeLocker.Lock
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.fakeLocker.Lock";
    rf.short_name = "Lock";
    rf.receiver_type = "net/http.fakeLocker";
    cbm_registry_add_func(reg, rf);

    // net/http.Logger
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Logger";
    rf.short_name = "Logger";
    cbm_registry_add_func(reg, rf);

    // net/http.http2clientConnPool.MarkDead
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2clientConnPool.MarkDead";
    rf.short_name = "MarkDead";
    rf.receiver_type = "net/http.http2clientConnPool";
    cbm_registry_add_func(reg, rf);

    // net/http.MaxBytesHandler
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.MaxBytesHandler";
    rf.short_name = "MaxBytesHandler";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net/http.Handler");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.MaxBytesReader
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.MaxBytesReader";
    rf.short_name = "MaxBytesReader";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "io.ReadCloser");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Request.MultipartReader
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Request.MultipartReader";
    rf.short_name = "MultipartReader";
    rf.receiver_type = "net/http.Request";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "multipart.Reader"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.socksAddr.Network
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.socksAddr.Network";
    rf.short_name = "Network";
    rf.receiver_type = "net/http.socksAddr";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2noDialH2RoundTripper.NewClientConn
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2noDialH2RoundTripper.NewClientConn";
    rf.short_name = "NewClientConn";
    rf.receiver_type = "net/http.http2noDialH2RoundTripper";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "net/http.RoundTripper");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2Transport.NewClientConn
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2Transport.NewClientConn";
    rf.short_name = "NewClientConn";
    rf.receiver_type = "net/http.http2Transport";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/http.http2ClientConn"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Transport.NewClientConn
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Transport.NewClientConn";
    rf.short_name = "NewClientConn";
    rf.receiver_type = "net/http.Transport";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/http.ClientConn"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.NewCrossOriginProtection
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.NewCrossOriginProtection";
    rf.short_name = "NewCrossOriginProtection";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/http.CrossOriginProtection"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.NewFileTransport
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.NewFileTransport";
    rf.short_name = "NewFileTransport";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net/http.RoundTripper");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.NewFileTransportFS
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.NewFileTransportFS";
    rf.short_name = "NewFileTransportFS";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net/http.RoundTripper");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.NewRequest
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.NewRequest";
    rf.short_name = "NewRequest";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/http.Request"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.NewRequestWithContext
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.NewRequestWithContext";
    rf.short_name = "NewRequestWithContext";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/http.Request"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.NewResponseController
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.NewResponseController";
    rf.short_name = "NewResponseController";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/http.ResponseController"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.NewServeMux
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.NewServeMux";
    rf.short_name = "NewServeMux";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/http.ServeMux"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.NotFound
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.NotFound";
    rf.short_name = "NotFound";
    cbm_registry_add_func(reg, rf);

    // net/http.NotFoundHandler
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.NotFoundHandler";
    rf.short_name = "NotFoundHandler";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net/http.Handler");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2SettingsFrame.NumSettings
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2SettingsFrame.NumSettings";
    rf.short_name = "NumSettings";
    rf.receiver_type = "net/http.http2SettingsFrame";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Dir.Open
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Dir.Open";
    rf.short_name = "Open";
    rf.receiver_type = "net/http.Dir";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "net/http.File");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.ioFS.Open
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ioFS.Open";
    rf.short_name = "Open";
    rf.receiver_type = "net/http.ioFS";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "net/http.File");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2priorityWriteSchedulerRFC7540.OpenStream
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2priorityWriteSchedulerRFC7540.OpenStream";
    rf.short_name = "OpenStream";
    rf.receiver_type = "net/http.http2priorityWriteSchedulerRFC7540";
    cbm_registry_add_func(reg, rf);

    // net/http.http2randomWriteScheduler.OpenStream
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2randomWriteScheduler.OpenStream";
    rf.short_name = "OpenStream";
    rf.receiver_type = "net/http.http2randomWriteScheduler";
    cbm_registry_add_func(reg, rf);

    // net/http.http2roundRobinWriteScheduler.OpenStream
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2roundRobinWriteScheduler.OpenStream";
    rf.short_name = "OpenStream";
    rf.receiver_type = "net/http.http2roundRobinWriteScheduler";
    cbm_registry_add_func(reg, rf);

    // net/http.http2priorityWriteSchedulerRFC9218.OpenStream
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2priorityWriteSchedulerRFC9218.OpenStream";
    rf.short_name = "OpenStream";
    rf.receiver_type = "net/http.http2priorityWriteSchedulerRFC9218";
    cbm_registry_add_func(reg, rf);

    // net/http.ParseCookie
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ParseCookie";
    rf.short_name = "ParseCookie";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "net/http.*Cookie"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Request.ParseForm
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Request.ParseForm";
    rf.short_name = "ParseForm";
    rf.receiver_type = "net/http.Request";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.ParseHTTPVersion
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ParseHTTPVersion";
    rf.short_name = "ParseHTTPVersion";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "int");
        ret[2] = cbm_type_builtin(arena, "bool");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Request.ParseMultipartForm
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Request.ParseMultipartForm";
    rf.short_name = "ParseMultipartForm";
    rf.receiver_type = "net/http.Request";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.ParseSetCookie
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ParseSetCookie";
    rf.short_name = "ParseSetCookie";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/http.Cookie"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.ParseTime
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ParseTime";
    rf.short_name = "ParseTime";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "time.Time");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Request.PathValue
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Request.PathValue";
    rf.short_name = "PathValue";
    rf.receiver_type = "net/http.Request";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2UnknownFrame.Payload
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2UnknownFrame.Payload";
    rf.short_name = "Payload";
    rf.receiver_type = "net/http.http2UnknownFrame";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2ClientConn.Ping
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2ClientConn.Ping";
    rf.short_name = "Ping";
    rf.receiver_type = "net/http.http2ClientConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2roundRobinWriteScheduler.Pop
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2roundRobinWriteScheduler.Pop";
    rf.short_name = "Pop";
    rf.receiver_type = "net/http.http2roundRobinWriteScheduler";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "net/http.http2FrameWriteRequest");
        ret[1] = cbm_type_builtin(arena, "bool");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2randomWriteScheduler.Pop
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2randomWriteScheduler.Pop";
    rf.short_name = "Pop";
    rf.receiver_type = "net/http.http2randomWriteScheduler";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "net/http.http2FrameWriteRequest");
        ret[1] = cbm_type_builtin(arena, "bool");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2priorityWriteSchedulerRFC7540.Pop
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2priorityWriteSchedulerRFC7540.Pop";
    rf.short_name = "Pop";
    rf.receiver_type = "net/http.http2priorityWriteSchedulerRFC7540";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "net/http.http2FrameWriteRequest");
        ret[1] = cbm_type_builtin(arena, "bool");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2priorityWriteSchedulerRFC9218.Pop
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2priorityWriteSchedulerRFC9218.Pop";
    rf.short_name = "Pop";
    rf.receiver_type = "net/http.http2priorityWriteSchedulerRFC9218";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "net/http.http2FrameWriteRequest");
        ret[1] = cbm_type_builtin(arena, "bool");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Post
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Post";
    rf.short_name = "Post";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/http.Response"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Client.Post
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Client.Post";
    rf.short_name = "Post";
    rf.receiver_type = "net/http.Client";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/http.Response"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Client.PostForm
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Client.PostForm";
    rf.short_name = "PostForm";
    rf.receiver_type = "net/http.Client";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/http.Response"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.PostForm
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.PostForm";
    rf.short_name = "PostForm";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/http.Response"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Request.PostFormValue
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Request.PostFormValue";
    rf.short_name = "PostFormValue";
    rf.receiver_type = "net/http.Request";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Request.ProtoAtLeast
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Request.ProtoAtLeast";
    rf.short_name = "ProtoAtLeast";
    rf.receiver_type = "net/http.Request";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Response.ProtoAtLeast
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Response.ProtoAtLeast";
    rf.short_name = "ProtoAtLeast";
    rf.receiver_type = "net/http.Response";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.ProxyFromEnvironment
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ProxyFromEnvironment";
    rf.short_name = "ProxyFromEnvironment";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "url.URL"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.ProxyURL
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ProxyURL";
    rf.short_name = "ProxyURL";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net/http.func()");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2MetaHeadersFrame.PseudoFields
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2MetaHeadersFrame.PseudoFields";
    rf.short_name = "PseudoFields";
    rf.receiver_type = "net/http.http2MetaHeadersFrame";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "hpack.HeaderField"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2MetaHeadersFrame.PseudoValue
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2MetaHeadersFrame.PseudoValue";
    rf.short_name = "PseudoValue";
    rf.receiver_type = "net/http.http2MetaHeadersFrame";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2priorityWriteSchedulerRFC9218.Push
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2priorityWriteSchedulerRFC9218.Push";
    rf.short_name = "Push";
    rf.receiver_type = "net/http.http2priorityWriteSchedulerRFC9218";
    cbm_registry_add_func(reg, rf);

    // net/http.http2priorityWriteSchedulerRFC7540.Push
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2priorityWriteSchedulerRFC7540.Push";
    rf.short_name = "Push";
    rf.receiver_type = "net/http.http2priorityWriteSchedulerRFC7540";
    cbm_registry_add_func(reg, rf);

    // net/http.timeoutWriter.Push
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.timeoutWriter.Push";
    rf.short_name = "Push";
    rf.receiver_type = "net/http.timeoutWriter";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2roundRobinWriteScheduler.Push
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2roundRobinWriteScheduler.Push";
    rf.short_name = "Push";
    rf.receiver_type = "net/http.http2roundRobinWriteScheduler";
    cbm_registry_add_func(reg, rf);

    // net/http.http2randomWriteScheduler.Push
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2randomWriteScheduler.Push";
    rf.short_name = "Push";
    rf.receiver_type = "net/http.http2randomWriteScheduler";
    cbm_registry_add_func(reg, rf);

    // net/http.http2responseWriter.Push
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2responseWriter.Push";
    rf.short_name = "Push";
    rf.receiver_type = "net/http.http2responseWriter";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.noBody.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.noBody.Read";
    rf.short_name = "Read";
    rf.receiver_type = "net/http.noBody";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2dataBuffer.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2dataBuffer.Read";
    rf.short_name = "Read";
    rf.receiver_type = "net/http.http2dataBuffer";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.expectContinueReader.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.expectContinueReader.Read";
    rf.short_name = "Read";
    rf.receiver_type = "net/http.expectContinueReader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.finishAsyncByteRead.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.finishAsyncByteRead.Read";
    rf.short_name = "Read";
    rf.receiver_type = "net/http.finishAsyncByteRead";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.cancelTimerBody.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.cancelTimerBody.Read";
    rf.short_name = "Read";
    rf.receiver_type = "net/http.cancelTimerBody";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.arrayReader.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.arrayReader.Read";
    rf.short_name = "Read";
    rf.receiver_type = "net/http.arrayReader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2transportResponseBody.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2transportResponseBody.Read";
    rf.short_name = "Read";
    rf.receiver_type = "net/http.http2transportResponseBody";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.persistConn.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.persistConn.Read";
    rf.short_name = "Read";
    rf.receiver_type = "net/http.persistConn";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.readWriteCloserBody.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.readWriteCloserBody.Read";
    rf.short_name = "Read";
    rf.receiver_type = "net/http.readWriteCloserBody";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.bodyLocked.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.bodyLocked.Read";
    rf.short_name = "Read";
    rf.receiver_type = "net/http.bodyLocked";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.connReader.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.connReader.Read";
    rf.short_name = "Read";
    rf.receiver_type = "net/http.connReader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.body.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.body.Read";
    rf.short_name = "Read";
    rf.receiver_type = "net/http.body";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.streamReader.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.streamReader.Read";
    rf.short_name = "Read";
    rf.receiver_type = "net/http.streamReader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.maxBytesReader.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.maxBytesReader.Read";
    rf.short_name = "Read";
    rf.receiver_type = "net/http.maxBytesReader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2noBodyReader.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2noBodyReader.Read";
    rf.short_name = "Read";
    rf.receiver_type = "net/http.http2noBodyReader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.readTrackingBody.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.readTrackingBody.Read";
    rf.short_name = "Read";
    rf.receiver_type = "net/http.readTrackingBody";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2pipe.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2pipe.Read";
    rf.short_name = "Read";
    rf.receiver_type = "net/http.http2pipe";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.byteReader.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.byteReader.Read";
    rf.short_name = "Read";
    rf.receiver_type = "net/http.byteReader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2missingBody.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2missingBody.Read";
    rf.short_name = "Read";
    rf.receiver_type = "net/http.http2missingBody";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.bodyEOFSignal.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.bodyEOFSignal.Read";
    rf.short_name = "Read";
    rf.receiver_type = "net/http.bodyEOFSignal";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.ioFile.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ioFile.Read";
    rf.short_name = "Read";
    rf.receiver_type = "net/http.ioFile";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.loggingConn.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.loggingConn.Read";
    rf.short_name = "Read";
    rf.receiver_type = "net/http.loggingConn";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2eofReader.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2eofReader.Read";
    rf.short_name = "Read";
    rf.receiver_type = "net/http.http2eofReader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.gzipReader.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.gzipReader.Read";
    rf.short_name = "Read";
    rf.receiver_type = "net/http.gzipReader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2gzipReader.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2gzipReader.Read";
    rf.short_name = "Read";
    rf.receiver_type = "net/http.http2gzipReader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.errorReader.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.errorReader.Read";
    rf.short_name = "Read";
    rf.receiver_type = "net/http.errorReader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2errorReader.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2errorReader.Read";
    rf.short_name = "Read";
    rf.receiver_type = "net/http.http2errorReader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.eofReader.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.eofReader.Read";
    rf.short_name = "Read";
    rf.receiver_type = "net/http.eofReader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2requestBody.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2requestBody.Read";
    rf.short_name = "Read";
    rf.receiver_type = "net/http.http2requestBody";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2eofReader.ReadByte
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2eofReader.ReadByte";
    rf.short_name = "ReadByte";
    rf.receiver_type = "net/http.http2eofReader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "byte");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.eofReader.ReadByte
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.eofReader.ReadByte";
    rf.short_name = "ReadByte";
    rf.receiver_type = "net/http.eofReader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "byte");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.ioFile.ReadDir
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ioFile.ReadDir";
    rf.short_name = "ReadDir";
    rf.receiver_type = "net/http.ioFile";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "fs.DirEntry"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2Framer.ReadFrame
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2Framer.ReadFrame";
    rf.short_name = "ReadFrame";
    rf.receiver_type = "net/http.http2Framer";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "net/http.http2Frame");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2Framer.ReadFrameForHeader
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2Framer.ReadFrameForHeader";
    rf.short_name = "ReadFrameForHeader";
    rf.receiver_type = "net/http.http2Framer";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "net/http.http2Frame");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2Framer.ReadFrameHeader
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2Framer.ReadFrameHeader";
    rf.short_name = "ReadFrameHeader";
    rf.receiver_type = "net/http.http2Framer";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "net/http.http2FrameHeader");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.persistConnWriter.ReadFrom
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.persistConnWriter.ReadFrom";
    rf.short_name = "ReadFrom";
    rf.receiver_type = "net/http.persistConnWriter";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.response.ReadFrom
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.response.ReadFrom";
    rf.short_name = "ReadFrom";
    rf.receiver_type = "net/http.response";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.ReadRequest
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ReadRequest";
    rf.short_name = "ReadRequest";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/http.Request"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.ReadResponse
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ReadResponse";
    rf.short_name = "ReadResponse";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/http.Response"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.ioFile.Readdir
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ioFile.Readdir";
    rf.short_name = "Readdir";
    rf.receiver_type = "net/http.ioFile";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "fs.FileInfo"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Redirect
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Redirect";
    rf.short_name = "Redirect";
    cbm_registry_add_func(reg, rf);

    // net/http.RedirectHandler
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.RedirectHandler";
    rf.short_name = "RedirectHandler";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net/http.Handler");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Request.Referer
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Request.Referer";
    rf.short_name = "Referer";
    rf.receiver_type = "net/http.Request";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Server.RegisterOnShutdown
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Server.RegisterOnShutdown";
    rf.short_name = "RegisterOnShutdown";
    rf.receiver_type = "net/http.Server";
    cbm_registry_add_func(reg, rf);

    // net/http.Transport.RegisterProtocol
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Transport.RegisterProtocol";
    rf.short_name = "RegisterProtocol";
    rf.receiver_type = "net/http.Transport";
    cbm_registry_add_func(reg, rf);

    // net/http.http2MetaHeadersFrame.RegularFields
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2MetaHeadersFrame.RegularFields";
    rf.short_name = "RegularFields";
    rf.receiver_type = "net/http.http2MetaHeadersFrame";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "hpack.HeaderField"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.ClientConn.Release
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ClientConn.Release";
    rf.short_name = "Release";
    rf.receiver_type = "net/http.ClientConn";
    cbm_registry_add_func(reg, rf);

    // net/http.http2netHTTPClientConn.Release
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2netHTTPClientConn.Release";
    rf.short_name = "Release";
    rf.receiver_type = "net/http.http2netHTTPClientConn";
    cbm_registry_add_func(reg, rf);

    // net/http.http1ClientConn.Release
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http1ClientConn.Release";
    rf.short_name = "Release";
    rf.receiver_type = "net/http.http1ClientConn";
    cbm_registry_add_func(reg, rf);

    // net/http.ClientConn.Reserve
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ClientConn.Reserve";
    rf.short_name = "Reserve";
    rf.receiver_type = "net/http.ClientConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http1ClientConn.Reserve
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http1ClientConn.Reserve";
    rf.short_name = "Reserve";
    rf.receiver_type = "net/http.http1ClientConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2netHTTPClientConn.Reserve
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2netHTTPClientConn.Reserve";
    rf.short_name = "Reserve";
    rf.receiver_type = "net/http.http2netHTTPClientConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2ClientConn.ReserveNewRequest
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2ClientConn.ReserveNewRequest";
    rf.short_name = "ReserveNewRequest";
    rf.receiver_type = "net/http.http2ClientConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2netHTTPClientConn.RoundTrip
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2netHTTPClientConn.RoundTrip";
    rf.short_name = "RoundTrip";
    rf.receiver_type = "net/http.http2netHTTPClientConn";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/http.Response"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2noDialH2RoundTripper.RoundTrip
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2noDialH2RoundTripper.RoundTrip";
    rf.short_name = "RoundTrip";
    rf.receiver_type = "net/http.http2noDialH2RoundTripper";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/http.Response"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2ClientConn.RoundTrip
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2ClientConn.RoundTrip";
    rf.short_name = "RoundTrip";
    rf.receiver_type = "net/http.http2ClientConn";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/http.Response"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Transport.RoundTrip
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Transport.RoundTrip";
    rf.short_name = "RoundTrip";
    rf.receiver_type = "net/http.Transport";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/http.Response"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2noDialH2RoundTripper.RoundTrip
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2noDialH2RoundTripper.RoundTrip";
    rf.short_name = "RoundTrip";
    rf.receiver_type = "net/http.http2noDialH2RoundTripper";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/http.Response"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.fileTransport.RoundTrip
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.fileTransport.RoundTrip";
    rf.short_name = "RoundTrip";
    rf.receiver_type = "net/http.fileTransport";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/http.Response"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Transport.RoundTrip
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Transport.RoundTrip";
    rf.short_name = "RoundTrip";
    rf.receiver_type = "net/http.Transport";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/http.Response"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2Transport.RoundTrip
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2Transport.RoundTrip";
    rf.short_name = "RoundTrip";
    rf.receiver_type = "net/http.http2Transport";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/http.Response"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.ClientConn.RoundTrip
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ClientConn.RoundTrip";
    rf.short_name = "RoundTrip";
    rf.receiver_type = "net/http.ClientConn";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/http.Response"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2Transport.RoundTrip
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2Transport.RoundTrip";
    rf.short_name = "RoundTrip";
    rf.receiver_type = "net/http.http2Transport";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/http.Response"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2unencryptedTransport.RoundTrip
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2unencryptedTransport.RoundTrip";
    rf.short_name = "RoundTrip";
    rf.receiver_type = "net/http.http2unencryptedTransport";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/http.Response"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http1ClientConn.RoundTrip
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http1ClientConn.RoundTrip";
    rf.short_name = "RoundTrip";
    rf.receiver_type = "net/http.http1ClientConn";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/http.Response"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2erringRoundTripper.RoundTrip
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2erringRoundTripper.RoundTrip";
    rf.short_name = "RoundTrip";
    rf.receiver_type = "net/http.http2erringRoundTripper";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/http.Response"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2erringRoundTripper.RoundTripErr
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2erringRoundTripper.RoundTripErr";
    rf.short_name = "RoundTripErr";
    rf.receiver_type = "net/http.http2erringRoundTripper";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2Transport.RoundTripOpt
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2Transport.RoundTripOpt";
    rf.short_name = "RoundTripOpt";
    rf.receiver_type = "net/http.http2Transport";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/http.Response"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.ioFile.Seek
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ioFile.Seek";
    rf.short_name = "Seek";
    rf.receiver_type = "net/http.ioFile";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Server.Serve
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Server.Serve";
    rf.short_name = "Serve";
    rf.receiver_type = "net/http.Server";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Serve
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Serve";
    rf.short_name = "Serve";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2Server.ServeConn
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2Server.ServeConn";
    rf.short_name = "ServeConn";
    rf.receiver_type = "net/http.http2Server";
    cbm_registry_add_func(reg, rf);

    // net/http.ServeContent
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ServeContent";
    rf.short_name = "ServeContent";
    cbm_registry_add_func(reg, rf);

    // net/http.ServeFile
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ServeFile";
    rf.short_name = "ServeFile";
    cbm_registry_add_func(reg, rf);

    // net/http.ServeFileFS
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ServeFileFS";
    rf.short_name = "ServeFileFS";
    cbm_registry_add_func(reg, rf);

    // net/http.unencryptedHTTP2Request.ServeHTTP
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.unencryptedHTTP2Request.ServeHTTP";
    rf.short_name = "ServeHTTP";
    rf.receiver_type = "net/http.unencryptedHTTP2Request";
    cbm_registry_add_func(reg, rf);

    // net/http.initALPNRequest.ServeHTTP
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.initALPNRequest.ServeHTTP";
    rf.short_name = "ServeHTTP";
    rf.receiver_type = "net/http.initALPNRequest";
    cbm_registry_add_func(reg, rf);

    // net/http.ServeMux.ServeHTTP
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ServeMux.ServeHTTP";
    rf.short_name = "ServeHTTP";
    rf.receiver_type = "net/http.ServeMux";
    cbm_registry_add_func(reg, rf);

    // net/http.timeoutHandler.ServeHTTP
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.timeoutHandler.ServeHTTP";
    rf.short_name = "ServeHTTP";
    rf.receiver_type = "net/http.timeoutHandler";
    cbm_registry_add_func(reg, rf);

    // net/http.noopHandler.ServeHTTP
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.noopHandler.ServeHTTP";
    rf.short_name = "ServeHTTP";
    rf.receiver_type = "net/http.noopHandler";
    cbm_registry_add_func(reg, rf);

    // net/http.Chan.ServeHTTP
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Chan.ServeHTTP";
    rf.short_name = "ServeHTTP";
    rf.receiver_type = "net/http.Chan";
    cbm_registry_add_func(reg, rf);

    // net/http.globalOptionsHandler.ServeHTTP
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.globalOptionsHandler.ServeHTTP";
    rf.short_name = "ServeHTTP";
    rf.receiver_type = "net/http.globalOptionsHandler";
    cbm_registry_add_func(reg, rf);

    // net/http.Counter.ServeHTTP
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Counter.ServeHTTP";
    rf.short_name = "ServeHTTP";
    rf.receiver_type = "net/http.Counter";
    cbm_registry_add_func(reg, rf);

    // net/http.fileHandler.ServeHTTP
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.fileHandler.ServeHTTP";
    rf.short_name = "ServeHTTP";
    rf.receiver_type = "net/http.fileHandler";
    cbm_registry_add_func(reg, rf);

    // net/http.serverHandler.ServeHTTP
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.serverHandler.ServeHTTP";
    rf.short_name = "ServeHTTP";
    rf.receiver_type = "net/http.serverHandler";
    cbm_registry_add_func(reg, rf);

    // net/http.HandlerFunc.ServeHTTP
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.HandlerFunc.ServeHTTP";
    rf.short_name = "ServeHTTP";
    rf.receiver_type = "net/http.HandlerFunc";
    cbm_registry_add_func(reg, rf);

    // net/http.redirectHandler.ServeHTTP
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.redirectHandler.ServeHTTP";
    rf.short_name = "ServeHTTP";
    rf.receiver_type = "net/http.redirectHandler";
    cbm_registry_add_func(reg, rf);

    // net/http.Server.ServeTLS
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Server.ServeTLS";
    rf.short_name = "ServeTLS";
    rf.receiver_type = "net/http.Server";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.ServeTLS
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ServeTLS";
    rf.short_name = "ServeTLS";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Header.Set
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Header.Set";
    rf.short_name = "Set";
    rf.receiver_type = "net/http.Header";
    cbm_registry_add_func(reg, rf);

    // net/http.Request.SetBasicAuth
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Request.SetBasicAuth";
    rf.short_name = "SetBasicAuth";
    rf.receiver_type = "net/http.Request";
    cbm_registry_add_func(reg, rf);

    // net/http.SetCookie
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.SetCookie";
    rf.short_name = "SetCookie";
    cbm_registry_add_func(reg, rf);

    // net/http.CrossOriginProtection.SetDenyHandler
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.CrossOriginProtection.SetDenyHandler";
    rf.short_name = "SetDenyHandler";
    rf.receiver_type = "net/http.CrossOriginProtection";
    cbm_registry_add_func(reg, rf);

    // net/http.http2ClientConn.SetDoNotReuse
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2ClientConn.SetDoNotReuse";
    rf.short_name = "SetDoNotReuse";
    rf.receiver_type = "net/http.http2ClientConn";
    cbm_registry_add_func(reg, rf);

    // net/http.Protocols.SetHTTP1
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Protocols.SetHTTP1";
    rf.short_name = "SetHTTP1";
    rf.receiver_type = "net/http.Protocols";
    cbm_registry_add_func(reg, rf);

    // net/http.Protocols.SetHTTP2
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Protocols.SetHTTP2";
    rf.short_name = "SetHTTP2";
    rf.receiver_type = "net/http.Protocols";
    cbm_registry_add_func(reg, rf);

    // net/http.Server.SetKeepAlivesEnabled
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Server.SetKeepAlivesEnabled";
    rf.short_name = "SetKeepAlivesEnabled";
    rf.receiver_type = "net/http.Server";
    cbm_registry_add_func(reg, rf);

    // net/http.http2Framer.SetMaxReadFrameSize
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2Framer.SetMaxReadFrameSize";
    rf.short_name = "SetMaxReadFrameSize";
    rf.receiver_type = "net/http.http2Framer";
    cbm_registry_add_func(reg, rf);

    // net/http.Request.SetPathValue
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Request.SetPathValue";
    rf.short_name = "SetPathValue";
    rf.receiver_type = "net/http.Request";
    cbm_registry_add_func(reg, rf);

    // net/http.http2responseWriter.SetReadDeadline
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2responseWriter.SetReadDeadline";
    rf.short_name = "SetReadDeadline";
    rf.receiver_type = "net/http.http2responseWriter";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.response.SetReadDeadline
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.response.SetReadDeadline";
    rf.short_name = "SetReadDeadline";
    rf.receiver_type = "net/http.response";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.ResponseController.SetReadDeadline
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ResponseController.SetReadDeadline";
    rf.short_name = "SetReadDeadline";
    rf.receiver_type = "net/http.ResponseController";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2Framer.SetReuseFrames
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2Framer.SetReuseFrames";
    rf.short_name = "SetReuseFrames";
    rf.receiver_type = "net/http.http2Framer";
    cbm_registry_add_func(reg, rf);

    // net/http.ClientConn.SetStateHook
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ClientConn.SetStateHook";
    rf.short_name = "SetStateHook";
    rf.receiver_type = "net/http.ClientConn";
    cbm_registry_add_func(reg, rf);

    // net/http.Protocols.SetUnencryptedHTTP2
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Protocols.SetUnencryptedHTTP2";
    rf.short_name = "SetUnencryptedHTTP2";
    rf.receiver_type = "net/http.Protocols";
    cbm_registry_add_func(reg, rf);

    // net/http.http2responseWriter.SetWriteDeadline
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2responseWriter.SetWriteDeadline";
    rf.short_name = "SetWriteDeadline";
    rf.receiver_type = "net/http.http2responseWriter";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.ResponseController.SetWriteDeadline
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ResponseController.SetWriteDeadline";
    rf.short_name = "SetWriteDeadline";
    rf.receiver_type = "net/http.ResponseController";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.response.SetWriteDeadline
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.response.SetWriteDeadline";
    rf.short_name = "SetWriteDeadline";
    rf.receiver_type = "net/http.response";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2SettingsFrame.Setting
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2SettingsFrame.Setting";
    rf.short_name = "Setting";
    rf.receiver_type = "net/http.http2SettingsFrame";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net/http.http2Setting");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Server.Shutdown
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Server.Shutdown";
    rf.short_name = "Shutdown";
    rf.receiver_type = "net/http.Server";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2ClientConn.Shutdown
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2ClientConn.Shutdown";
    rf.short_name = "Shutdown";
    rf.receiver_type = "net/http.http2ClientConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2sorter.SortStrings
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2sorter.SortStrings";
    rf.short_name = "SortStrings";
    rf.receiver_type = "net/http.http2sorter";
    cbm_registry_add_func(reg, rf);

    // net/http.ioFile.Stat
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ioFile.Stat";
    rf.short_name = "Stat";
    rf.receiver_type = "net/http.ioFile";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "fs.FileInfo");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2ClientConn.State
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2ClientConn.State";
    rf.short_name = "State";
    rf.receiver_type = "net/http.http2ClientConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net/http.http2ClientConnState");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.StatusText
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.StatusText";
    rf.short_name = "StatusText";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2DataFrame.StreamEnded
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2DataFrame.StreamEnded";
    rf.short_name = "StreamEnded";
    rf.receiver_type = "net/http.http2DataFrame";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2HeadersFrame.StreamEnded
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2HeadersFrame.StreamEnded";
    rf.short_name = "StreamEnded";
    rf.receiver_type = "net/http.http2HeadersFrame";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2FrameWriteRequest.StreamID
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2FrameWriteRequest.StreamID";
    rf.short_name = "StreamID";
    rf.receiver_type = "net/http.http2FrameWriteRequest";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "uint32");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Protocols.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Protocols.String";
    rf.short_name = "String";
    rf.receiver_type = "net/http.Protocols";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Cookie.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Cookie.String";
    rf.short_name = "String";
    rf.receiver_type = "net/http.Cookie";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.pattern.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.pattern.String";
    rf.short_name = "String";
    rf.receiver_type = "net/http.pattern";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.socksAddr.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.socksAddr.String";
    rf.short_name = "String";
    rf.receiver_type = "net/http.socksAddr";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Counter.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Counter.String";
    rf.short_name = "String";
    rf.receiver_type = "net/http.Counter";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2SettingID.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2SettingID.String";
    rf.short_name = "String";
    rf.receiver_type = "net/http.http2SettingID";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.contextKey.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.contextKey.String";
    rf.short_name = "String";
    rf.receiver_type = "net/http.contextKey";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.socksCommand.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.socksCommand.String";
    rf.short_name = "String";
    rf.receiver_type = "net/http.socksCommand";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.socksReply.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.socksReply.String";
    rf.short_name = "String";
    rf.receiver_type = "net/http.socksReply";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2streamState.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2streamState.String";
    rf.short_name = "String";
    rf.receiver_type = "net/http.http2streamState";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.ConnState.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.ConnState.String";
    rf.short_name = "String";
    rf.receiver_type = "net/http.ConnState";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2ErrCode.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2ErrCode.String";
    rf.short_name = "String";
    rf.receiver_type = "net/http.http2ErrCode";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2FrameType.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2FrameType.String";
    rf.short_name = "String";
    rf.receiver_type = "net/http.http2FrameType";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.connectMethodKey.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.connectMethodKey.String";
    rf.short_name = "String";
    rf.receiver_type = "net/http.connectMethodKey";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2FrameHeader.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2FrameHeader.String";
    rf.short_name = "String";
    rf.receiver_type = "net/http.http2FrameHeader";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2writeData.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2writeData.String";
    rf.short_name = "String";
    rf.receiver_type = "net/http.http2writeData";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2FrameWriteRequest.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2FrameWriteRequest.String";
    rf.short_name = "String";
    rf.receiver_type = "net/http.http2FrameWriteRequest";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2Setting.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2Setting.String";
    rf.short_name = "String";
    rf.receiver_type = "net/http.http2Setting";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.StripPrefix
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.StripPrefix";
    rf.short_name = "StripPrefix";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net/http.Handler");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2sortPriorityNodeSiblingsRFC7540.Swap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2sortPriorityNodeSiblingsRFC7540.Swap";
    rf.short_name = "Swap";
    rf.receiver_type = "net/http.http2sortPriorityNodeSiblingsRFC7540";
    cbm_registry_add_func(reg, rf);

    // net/http.http2sorter.Swap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2sorter.Swap";
    rf.short_name = "Swap";
    rf.receiver_type = "net/http.http2sorter";
    cbm_registry_add_func(reg, rf);

    // net/http.timeoutError.Temporary
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.timeoutError.Temporary";
    rf.short_name = "Temporary";
    rf.receiver_type = "net/http.timeoutError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2httpError.Temporary
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2httpError.Temporary";
    rf.short_name = "Temporary";
    rf.receiver_type = "net/http.http2httpError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.tlsHandshakeTimeoutError.Temporary
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.tlsHandshakeTimeoutError.Temporary";
    rf.short_name = "Temporary";
    rf.receiver_type = "net/http.tlsHandshakeTimeoutError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.tlsHandshakeTimeoutError.Timeout
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.tlsHandshakeTimeoutError.Timeout";
    rf.short_name = "Timeout";
    rf.receiver_type = "net/http.tlsHandshakeTimeoutError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2httpError.Timeout
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2httpError.Timeout";
    rf.short_name = "Timeout";
    rf.receiver_type = "net/http.http2httpError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.timeoutError.Timeout
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.timeoutError.Timeout";
    rf.short_name = "Timeout";
    rf.receiver_type = "net/http.timeoutError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.TimeoutHandler
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.TimeoutHandler";
    rf.short_name = "TimeoutHandler";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net/http.Handler");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Protocols.UnencryptedHTTP2
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Protocols.UnencryptedHTTP2";
    rf.short_name = "UnencryptedHTTP2";
    rf.receiver_type = "net/http.Protocols";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.unencryptedNetConnInTLSConn.UnencryptedNetConn
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.unencryptedNetConnInTLSConn.UnencryptedNetConn";
    rf.short_name = "UnencryptedNetConn";
    rf.receiver_type = "net/http.unencryptedNetConnInTLSConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net.Conn");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.fakeLocker.Unlock
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.fakeLocker.Unlock";
    rf.short_name = "Unlock";
    rf.receiver_type = "net/http.fakeLocker";
    cbm_registry_add_func(reg, rf);

    // net/http.nothingWrittenError.Unwrap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.nothingWrittenError.Unwrap";
    rf.short_name = "Unwrap";
    rf.receiver_type = "net/http.nothingWrittenError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.transportReadFromServerError.Unwrap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.transportReadFromServerError.Unwrap";
    rf.short_name = "Unwrap";
    rf.receiver_type = "net/http.transportReadFromServerError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Request.UserAgent
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Request.UserAgent";
    rf.short_name = "UserAgent";
    rf.receiver_type = "net/http.Request";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Cookie.Valid
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Cookie.Valid";
    rf.short_name = "Valid";
    rf.receiver_type = "net/http.Cookie";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2Setting.Valid
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2Setting.Valid";
    rf.short_name = "Valid";
    rf.receiver_type = "net/http.http2Setting";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2SettingsFrame.Value
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2SettingsFrame.Value";
    rf.short_name = "Value";
    rf.receiver_type = "net/http.http2SettingsFrame";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "uint32");
        ret[1] = cbm_type_builtin(arena, "bool");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Header.Values
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Header.Values";
    rf.short_name = "Values";
    rf.receiver_type = "net/http.Header";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "string"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2closeWaiter.Wait
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2closeWaiter.Wait";
    rf.short_name = "Wait";
    rf.receiver_type = "net/http.http2closeWaiter";
    cbm_registry_add_func(reg, rf);

    // net/http.Request.WithContext
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Request.WithContext";
    rf.short_name = "WithContext";
    rf.receiver_type = "net/http.Request";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/http.Request"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.bufioFlushWriter.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.bufioFlushWriter.Write";
    rf.short_name = "Write";
    rf.receiver_type = "net/http.bufioFlushWriter";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2pipe.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2pipe.Write";
    rf.short_name = "Write";
    rf.receiver_type = "net/http.http2pipe";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.persistConnWriter.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.persistConnWriter.Write";
    rf.short_name = "Write";
    rf.receiver_type = "net/http.persistConnWriter";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2dataBuffer.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2dataBuffer.Write";
    rf.short_name = "Write";
    rf.receiver_type = "net/http.http2dataBuffer";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.populateResponse.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.populateResponse.Write";
    rf.short_name = "Write";
    rf.receiver_type = "net/http.populateResponse";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Response.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Response.Write";
    rf.short_name = "Write";
    rf.receiver_type = "net/http.Response";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2stickyErrWriter.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2stickyErrWriter.Write";
    rf.short_name = "Write";
    rf.receiver_type = "net/http.http2stickyErrWriter";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.extraHeader.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.extraHeader.Write";
    rf.short_name = "Write";
    rf.receiver_type = "net/http.extraHeader";
    cbm_registry_add_func(reg, rf);

    // net/http.http2responseWriter.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2responseWriter.Write";
    rf.short_name = "Write";
    rf.receiver_type = "net/http.http2responseWriter";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.chunkWriter.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.chunkWriter.Write";
    rf.short_name = "Write";
    rf.receiver_type = "net/http.chunkWriter";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Request.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Request.Write";
    rf.short_name = "Write";
    rf.receiver_type = "net/http.Request";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2chunkWriter.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2chunkWriter.Write";
    rf.short_name = "Write";
    rf.receiver_type = "net/http.http2chunkWriter";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Header.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Header.Write";
    rf.short_name = "Write";
    rf.receiver_type = "net/http.Header";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.checkConnErrorWriter.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.checkConnErrorWriter.Write";
    rf.short_name = "Write";
    rf.receiver_type = "net/http.checkConnErrorWriter";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2bufferedWriterTimeoutWriter.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2bufferedWriterTimeoutWriter.Write";
    rf.short_name = "Write";
    rf.receiver_type = "net/http.http2bufferedWriterTimeoutWriter";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2bufferedWriter.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2bufferedWriter.Write";
    rf.short_name = "Write";
    rf.receiver_type = "net/http.http2bufferedWriter";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.response.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.response.Write";
    rf.short_name = "Write";
    rf.receiver_type = "net/http.response";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.countingWriter.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.countingWriter.Write";
    rf.short_name = "Write";
    rf.receiver_type = "net/http.countingWriter";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.timeoutWriter.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.timeoutWriter.Write";
    rf.short_name = "Write";
    rf.receiver_type = "net/http.timeoutWriter";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.loggingConn.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.loggingConn.Write";
    rf.short_name = "Write";
    rf.receiver_type = "net/http.loggingConn";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2Framer.WriteContinuation
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2Framer.WriteContinuation";
    rf.short_name = "WriteContinuation";
    rf.receiver_type = "net/http.http2Framer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2Framer.WriteData
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2Framer.WriteData";
    rf.short_name = "WriteData";
    rf.receiver_type = "net/http.http2Framer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2Framer.WriteDataPadded
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2Framer.WriteDataPadded";
    rf.short_name = "WriteDataPadded";
    rf.receiver_type = "net/http.http2Framer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2Framer.WriteGoAway
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2Framer.WriteGoAway";
    rf.short_name = "WriteGoAway";
    rf.receiver_type = "net/http.http2Framer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.timeoutWriter.WriteHeader
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.timeoutWriter.WriteHeader";
    rf.short_name = "WriteHeader";
    rf.receiver_type = "net/http.timeoutWriter";
    cbm_registry_add_func(reg, rf);

    // net/http.response.WriteHeader
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.response.WriteHeader";
    rf.short_name = "WriteHeader";
    rf.receiver_type = "net/http.response";
    cbm_registry_add_func(reg, rf);

    // net/http.http2responseWriter.WriteHeader
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2responseWriter.WriteHeader";
    rf.short_name = "WriteHeader";
    rf.receiver_type = "net/http.http2responseWriter";
    cbm_registry_add_func(reg, rf);

    // net/http.populateResponse.WriteHeader
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.populateResponse.WriteHeader";
    rf.short_name = "WriteHeader";
    rf.receiver_type = "net/http.populateResponse";
    cbm_registry_add_func(reg, rf);

    // net/http.http2Framer.WriteHeaders
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2Framer.WriteHeaders";
    rf.short_name = "WriteHeaders";
    rf.receiver_type = "net/http.http2Framer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2Framer.WritePing
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2Framer.WritePing";
    rf.short_name = "WritePing";
    rf.receiver_type = "net/http.http2Framer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2Framer.WritePriority
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2Framer.WritePriority";
    rf.short_name = "WritePriority";
    rf.receiver_type = "net/http.http2Framer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Request.WriteProxy
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Request.WriteProxy";
    rf.short_name = "WriteProxy";
    rf.receiver_type = "net/http.Request";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2Framer.WritePushPromise
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2Framer.WritePushPromise";
    rf.short_name = "WritePushPromise";
    rf.receiver_type = "net/http.http2Framer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2Framer.WriteRSTStream
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2Framer.WriteRSTStream";
    rf.short_name = "WriteRSTStream";
    rf.receiver_type = "net/http.http2Framer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2Framer.WriteRawFrame
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2Framer.WriteRawFrame";
    rf.short_name = "WriteRawFrame";
    rf.receiver_type = "net/http.http2Framer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2Framer.WriteSettings
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2Framer.WriteSettings";
    rf.short_name = "WriteSettings";
    rf.receiver_type = "net/http.http2Framer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2Framer.WriteSettingsAck
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2Framer.WriteSettingsAck";
    rf.short_name = "WriteSettingsAck";
    rf.receiver_type = "net/http.http2Framer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2responseWriter.WriteString
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2responseWriter.WriteString";
    rf.short_name = "WriteString";
    rf.receiver_type = "net/http.http2responseWriter";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.stringWriter.WriteString
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.stringWriter.WriteString";
    rf.short_name = "WriteString";
    rf.receiver_type = "net/http.stringWriter";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.response.WriteString
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.response.WriteString";
    rf.short_name = "WriteString";
    rf.receiver_type = "net/http.response";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.Header.WriteSubset
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.Header.WriteSubset";
    rf.short_name = "WriteSubset";
    rf.receiver_type = "net/http.Header";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.noBody.WriteTo
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.noBody.WriteTo";
    rf.short_name = "WriteTo";
    rf.receiver_type = "net/http.noBody";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/http.http2Framer.WriteWindowUpdate
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/http.http2Framer.WriteWindowUpdate";
    rf.short_name = "WriteWindowUpdate";
    rf.receiver_type = "net/http.http2Framer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/url.Values.Add
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/url.Values.Add";
    rf.short_name = "Add";
    rf.receiver_type = "net/url.Values";
    cbm_registry_add_func(reg, rf);

    // net/url.URL.AppendBinary
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/url.URL.AppendBinary";
    rf.short_name = "AppendBinary";
    rf.receiver_type = "net/url.URL";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/url.Values.Del
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/url.Values.Del";
    rf.short_name = "Del";
    rf.receiver_type = "net/url.Values";
    cbm_registry_add_func(reg, rf);

    // net/url.Values.Encode
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/url.Values.Encode";
    rf.short_name = "Encode";
    rf.receiver_type = "net/url.Values";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/url.Error.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/url.Error.Error";
    rf.short_name = "Error";
    rf.receiver_type = "net/url.Error";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/url.InvalidHostError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/url.InvalidHostError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "net/url.InvalidHostError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/url.EscapeError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/url.EscapeError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "net/url.EscapeError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/url.URL.EscapedFragment
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/url.URL.EscapedFragment";
    rf.short_name = "EscapedFragment";
    rf.receiver_type = "net/url.URL";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/url.URL.EscapedPath
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/url.URL.EscapedPath";
    rf.short_name = "EscapedPath";
    rf.receiver_type = "net/url.URL";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/url.Values.Get
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/url.Values.Get";
    rf.short_name = "Get";
    rf.receiver_type = "net/url.Values";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/url.Values.Has
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/url.Values.Has";
    rf.short_name = "Has";
    rf.receiver_type = "net/url.Values";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/url.URL.Hostname
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/url.URL.Hostname";
    rf.short_name = "Hostname";
    rf.receiver_type = "net/url.URL";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/url.URL.IsAbs
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/url.URL.IsAbs";
    rf.short_name = "IsAbs";
    rf.receiver_type = "net/url.URL";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/url.JoinPath
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/url.JoinPath";
    rf.short_name = "JoinPath";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/url.URL.JoinPath
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/url.URL.JoinPath";
    rf.short_name = "JoinPath";
    rf.receiver_type = "net/url.URL";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/url.URL"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/url.URL.MarshalBinary
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/url.URL.MarshalBinary";
    rf.short_name = "MarshalBinary";
    rf.receiver_type = "net/url.URL";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/url.Parse
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/url.Parse";
    rf.short_name = "Parse";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/url.URL"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/url.URL.Parse
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/url.URL.Parse";
    rf.short_name = "Parse";
    rf.receiver_type = "net/url.URL";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/url.URL"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/url.ParseQuery
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/url.ParseQuery";
    rf.short_name = "ParseQuery";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "net/url.Values");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/url.ParseRequestURI
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/url.ParseRequestURI";
    rf.short_name = "ParseRequestURI";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/url.URL"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/url.Userinfo.Password
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/url.Userinfo.Password";
    rf.short_name = "Password";
    rf.receiver_type = "net/url.Userinfo";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_builtin(arena, "bool");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/url.PathEscape
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/url.PathEscape";
    rf.short_name = "PathEscape";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/url.PathUnescape
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/url.PathUnescape";
    rf.short_name = "PathUnescape";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/url.URL.Port
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/url.URL.Port";
    rf.short_name = "Port";
    rf.receiver_type = "net/url.URL";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/url.URL.Query
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/url.URL.Query";
    rf.short_name = "Query";
    rf.receiver_type = "net/url.URL";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "net/url.Values");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/url.QueryEscape
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/url.QueryEscape";
    rf.short_name = "QueryEscape";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/url.QueryUnescape
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/url.QueryUnescape";
    rf.short_name = "QueryUnescape";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/url.URL.Redacted
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/url.URL.Redacted";
    rf.short_name = "Redacted";
    rf.receiver_type = "net/url.URL";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/url.URL.RequestURI
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/url.URL.RequestURI";
    rf.short_name = "RequestURI";
    rf.receiver_type = "net/url.URL";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/url.URL.ResolveReference
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/url.URL.ResolveReference";
    rf.short_name = "ResolveReference";
    rf.receiver_type = "net/url.URL";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/url.URL"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/url.Values.Set
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/url.Values.Set";
    rf.short_name = "Set";
    rf.receiver_type = "net/url.Values";
    cbm_registry_add_func(reg, rf);

    // net/url.URL.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/url.URL.String";
    rf.short_name = "String";
    rf.receiver_type = "net/url.URL";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/url.Userinfo.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/url.Userinfo.String";
    rf.short_name = "String";
    rf.receiver_type = "net/url.Userinfo";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/url.Error.Temporary
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/url.Error.Temporary";
    rf.short_name = "Temporary";
    rf.receiver_type = "net/url.Error";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/url.Error.Timeout
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/url.Error.Timeout";
    rf.short_name = "Timeout";
    rf.receiver_type = "net/url.Error";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/url.URL.UnmarshalBinary
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/url.URL.UnmarshalBinary";
    rf.short_name = "UnmarshalBinary";
    rf.receiver_type = "net/url.URL";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/url.Error.Unwrap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/url.Error.Unwrap";
    rf.short_name = "Unwrap";
    rf.receiver_type = "net/url.Error";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/url.User
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/url.User";
    rf.short_name = "User";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/url.Userinfo"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/url.UserPassword
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/url.UserPassword";
    rf.short_name = "UserPassword";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "net/url.Userinfo"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // net/url.Userinfo.Username
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "net/url.Userinfo.Username";
    rf.short_name = "Username";
    rf.receiver_type = "net/url.Userinfo";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.File.Chdir
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.File.Chdir";
    rf.short_name = "Chdir";
    rf.receiver_type = "os.File";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.File.Chdir
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.File.Chdir";
    rf.short_name = "Chdir";
    rf.receiver_type = "os.File";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Chdir
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Chdir";
    rf.short_name = "Chdir";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Root.Chmod
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Root.Chmod";
    rf.short_name = "Chmod";
    rf.receiver_type = "os.Root";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.File.Chmod
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.File.Chmod";
    rf.short_name = "Chmod";
    rf.receiver_type = "os.File";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Chmod
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Chmod";
    rf.short_name = "Chmod";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.File.Chown
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.File.Chown";
    rf.short_name = "Chown";
    rf.receiver_type = "os.File";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Root.Chown
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Root.Chown";
    rf.short_name = "Chown";
    rf.receiver_type = "os.Root";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Chown
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Chown";
    rf.short_name = "Chown";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Chown
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Chown";
    rf.short_name = "Chown";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.File.Chown
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.File.Chown";
    rf.short_name = "Chown";
    rf.receiver_type = "os.File";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Chtimes
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Chtimes";
    rf.short_name = "Chtimes";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Root.Chtimes
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Root.Chtimes";
    rf.short_name = "Chtimes";
    rf.receiver_type = "os.Root";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Chtimes
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Chtimes";
    rf.short_name = "Chtimes";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Clearenv
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Clearenv";
    rf.short_name = "Clearenv";
    cbm_registry_add_func(reg, rf);

    // os.File.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.File.Close";
    rf.short_name = "Close";
    rf.receiver_type = "os.File";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Root.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Root.Close";
    rf.short_name = "Close";
    rf.receiver_type = "os.Root";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.File.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.File.Close";
    rf.short_name = "Close";
    rf.receiver_type = "os.File";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.root.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.root.Close";
    rf.short_name = "Close";
    rf.receiver_type = "os.root";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.root.Close
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.root.Close";
    rf.short_name = "Close";
    rf.receiver_type = "os.root";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.rawConn.Control
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.rawConn.Control";
    rf.short_name = "Control";
    rf.receiver_type = "os.rawConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.rawConn.Control
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.rawConn.Control";
    rf.short_name = "Control";
    rf.receiver_type = "os.rawConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.CopyFS
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.CopyFS";
    rf.short_name = "CopyFS";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Create
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Create";
    rf.short_name = "Create";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "os.File"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Root.Create
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Root.Create";
    rf.short_name = "Create";
    rf.receiver_type = "os.Root";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "os.File"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.CreateTemp
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.CreateTemp";
    rf.short_name = "CreateTemp";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "os.File"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.DirFS
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.DirFS";
    rf.short_name = "DirFS";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "fs.FS");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Environ
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Environ";
    rf.short_name = "Environ";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "string"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.errSymlink.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.errSymlink.Error";
    rf.short_name = "Error";
    rf.receiver_type = "os.errSymlink";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.LinkError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.LinkError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "os.LinkError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.SyscallError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.SyscallError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "os.SyscallError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Executable
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Executable";
    rf.short_name = "Executable";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Exit
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Exit";
    rf.short_name = "Exit";
    cbm_registry_add_func(reg, rf);

    // os.ProcessState.ExitCode
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.ProcessState.ExitCode";
    rf.short_name = "ExitCode";
    rf.receiver_type = "os.ProcessState";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.ProcessState.ExitCode
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.ProcessState.ExitCode";
    rf.short_name = "ExitCode";
    rf.receiver_type = "os.ProcessState";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.ProcessState.Exited
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.ProcessState.Exited";
    rf.short_name = "Exited";
    rf.receiver_type = "os.ProcessState";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Expand
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Expand";
    rf.short_name = "Expand";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.ExpandEnv
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.ExpandEnv";
    rf.short_name = "ExpandEnv";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Root.FS
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Root.FS";
    rf.short_name = "FS";
    rf.receiver_type = "os.Root";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "fs.FS");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.File.Fd
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.File.Fd";
    rf.short_name = "Fd";
    rf.receiver_type = "os.File";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "uintptr");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.FindProcess
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.FindProcess";
    rf.short_name = "FindProcess";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "os.Process"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Getegid
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Getegid";
    rf.short_name = "Getegid";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Getenv
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Getenv";
    rf.short_name = "Getenv";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Geteuid
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Geteuid";
    rf.short_name = "Geteuid";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Getgid
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Getgid";
    rf.short_name = "Getgid";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Getgroups
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Getgroups";
    rf.short_name = "Getgroups";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "int"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Getpagesize
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Getpagesize";
    rf.short_name = "Getpagesize";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Getpid
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Getpid";
    rf.short_name = "Getpid";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Getppid
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Getppid";
    rf.short_name = "Getppid";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Getuid
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Getuid";
    rf.short_name = "Getuid";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Getwd
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Getwd";
    rf.short_name = "Getwd";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Hostname
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Hostname";
    rf.short_name = "Hostname";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.dirEntry.Info
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.dirEntry.Info";
    rf.short_name = "Info";
    rf.receiver_type = "os.dirEntry";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "os.FileInfo");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.unixDirent.Info
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.unixDirent.Info";
    rf.short_name = "Info";
    rf.receiver_type = "os.unixDirent";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "os.FileInfo");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.dirEntry.Info
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.dirEntry.Info";
    rf.short_name = "Info";
    rf.receiver_type = "os.dirEntry";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "os.FileInfo");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.unixDirent.IsDir
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.unixDirent.IsDir";
    rf.short_name = "IsDir";
    rf.receiver_type = "os.unixDirent";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.dirEntry.IsDir
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.dirEntry.IsDir";
    rf.short_name = "IsDir";
    rf.receiver_type = "os.dirEntry";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.dirEntry.IsDir
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.dirEntry.IsDir";
    rf.short_name = "IsDir";
    rf.receiver_type = "os.dirEntry";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.fileStat.IsDir
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.fileStat.IsDir";
    rf.short_name = "IsDir";
    rf.receiver_type = "os.fileStat";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.IsExist
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.IsExist";
    rf.short_name = "IsExist";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.IsNotExist
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.IsNotExist";
    rf.short_name = "IsNotExist";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.IsPathSeparator
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.IsPathSeparator";
    rf.short_name = "IsPathSeparator";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.IsPathSeparator
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.IsPathSeparator";
    rf.short_name = "IsPathSeparator";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.IsPathSeparator
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.IsPathSeparator";
    rf.short_name = "IsPathSeparator";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.IsPermission
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.IsPermission";
    rf.short_name = "IsPermission";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.IsTimeout
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.IsTimeout";
    rf.short_name = "IsTimeout";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Process.Kill
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Process.Kill";
    rf.short_name = "Kill";
    rf.receiver_type = "os.Process";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Root.Lchown
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Root.Lchown";
    rf.short_name = "Lchown";
    rf.receiver_type = "os.Root";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Lchown
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Lchown";
    rf.short_name = "Lchown";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Lchown
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Lchown";
    rf.short_name = "Lchown";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Link
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Link";
    rf.short_name = "Link";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Link
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Link";
    rf.short_name = "Link";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Link
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Link";
    rf.short_name = "Link";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Root.Link
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Root.Link";
    rf.short_name = "Link";
    rf.receiver_type = "os.Root";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.LookupEnv
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.LookupEnv";
    rf.short_name = "LookupEnv";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_builtin(arena, "bool");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Root.Lstat
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Root.Lstat";
    rf.short_name = "Lstat";
    rf.receiver_type = "os.Root";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "os.FileInfo");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.dirFS.Lstat
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.dirFS.Lstat";
    rf.short_name = "Lstat";
    rf.receiver_type = "os.dirFS";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "fs.FileInfo");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Lstat
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Lstat";
    rf.short_name = "Lstat";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "os.FileInfo");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.rootFS.Lstat
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.rootFS.Lstat";
    rf.short_name = "Lstat";
    rf.receiver_type = "os.rootFS";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "os.FileInfo");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Root.Mkdir
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Root.Mkdir";
    rf.short_name = "Mkdir";
    rf.receiver_type = "os.Root";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Mkdir
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Mkdir";
    rf.short_name = "Mkdir";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.MkdirAll
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.MkdirAll";
    rf.short_name = "MkdirAll";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Root.MkdirAll
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Root.MkdirAll";
    rf.short_name = "MkdirAll";
    rf.receiver_type = "os.Root";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.MkdirTemp
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.MkdirTemp";
    rf.short_name = "MkdirTemp";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.fileStat.ModTime
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.fileStat.ModTime";
    rf.short_name = "ModTime";
    rf.receiver_type = "os.fileStat";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "time.Time");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.fileStat.ModTime
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.fileStat.ModTime";
    rf.short_name = "ModTime";
    rf.receiver_type = "os.fileStat";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "time.Time");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.fileStat.ModTime
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.fileStat.ModTime";
    rf.short_name = "ModTime";
    rf.receiver_type = "os.fileStat";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "time.Time");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.fileStat.Mode
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.fileStat.Mode";
    rf.short_name = "Mode";
    rf.receiver_type = "os.fileStat";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "os.FileMode");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.fileStat.Mode
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.fileStat.Mode";
    rf.short_name = "Mode";
    rf.receiver_type = "os.fileStat";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "os.FileMode");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.fileStat.Mode
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.fileStat.Mode";
    rf.short_name = "Mode";
    rf.receiver_type = "os.fileStat";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "os.FileMode");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Root.Name
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Root.Name";
    rf.short_name = "Name";
    rf.receiver_type = "os.Root";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.unixDirent.Name
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.unixDirent.Name";
    rf.short_name = "Name";
    rf.receiver_type = "os.unixDirent";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.root.Name
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.root.Name";
    rf.short_name = "Name";
    rf.receiver_type = "os.root";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.dirEntry.Name
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.dirEntry.Name";
    rf.short_name = "Name";
    rf.receiver_type = "os.dirEntry";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.root.Name
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.root.Name";
    rf.short_name = "Name";
    rf.receiver_type = "os.root";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.File.Name
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.File.Name";
    rf.short_name = "Name";
    rf.receiver_type = "os.File";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.dirEntry.Name
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.dirEntry.Name";
    rf.short_name = "Name";
    rf.receiver_type = "os.dirEntry";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.fileStat.Name
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.fileStat.Name";
    rf.short_name = "Name";
    rf.receiver_type = "os.fileStat";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.NewFile
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.NewFile";
    rf.short_name = "NewFile";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "os.File"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.NewSyscallError
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.NewSyscallError";
    rf.short_name = "NewSyscallError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Root.Open
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Root.Open";
    rf.short_name = "Open";
    rf.receiver_type = "os.Root";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "os.File"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.rootFS.Open
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.rootFS.Open";
    rf.short_name = "Open";
    rf.receiver_type = "os.rootFS";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "fs.File");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.dirFS.Open
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.dirFS.Open";
    rf.short_name = "Open";
    rf.receiver_type = "os.dirFS";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "fs.File");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Open
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Open";
    rf.short_name = "Open";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "os.File"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Root.OpenFile
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Root.OpenFile";
    rf.short_name = "OpenFile";
    rf.receiver_type = "os.Root";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "os.File"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.OpenFile
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.OpenFile";
    rf.short_name = "OpenFile";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "os.File"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.OpenInRoot
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.OpenInRoot";
    rf.short_name = "OpenInRoot";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "os.File"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Root.OpenRoot
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Root.OpenRoot";
    rf.short_name = "OpenRoot";
    rf.receiver_type = "os.Root";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "os.Root"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.OpenRoot
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.OpenRoot";
    rf.short_name = "OpenRoot";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "os.Root"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.ProcessState.Pid
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.ProcessState.Pid";
    rf.short_name = "Pid";
    rf.receiver_type = "os.ProcessState";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.ProcessState.Pid
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.ProcessState.Pid";
    rf.short_name = "Pid";
    rf.receiver_type = "os.ProcessState";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Pipe
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Pipe";
    rf.short_name = "Pipe";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "os.File"));
        ret[1] = cbm_type_pointer(arena, cbm_type_named(arena, "os.File"));
        ret[2] = cbm_type_builtin(arena, "error");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Pipe
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Pipe";
    rf.short_name = "Pipe";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "os.File"));
        ret[1] = cbm_type_pointer(arena, cbm_type_named(arena, "os.File"));
        ret[2] = cbm_type_builtin(arena, "error");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Pipe
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Pipe";
    rf.short_name = "Pipe";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "os.File"));
        ret[1] = cbm_type_pointer(arena, cbm_type_named(arena, "os.File"));
        ret[2] = cbm_type_builtin(arena, "error");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Pipe
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Pipe";
    rf.short_name = "Pipe";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "os.File"));
        ret[1] = cbm_type_pointer(arena, cbm_type_named(arena, "os.File"));
        ret[2] = cbm_type_builtin(arena, "error");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Pipe
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Pipe";
    rf.short_name = "Pipe";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "os.File"));
        ret[1] = cbm_type_pointer(arena, cbm_type_named(arena, "os.File"));
        ret[2] = cbm_type_builtin(arena, "error");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.file.PollFD
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.file.PollFD";
    rf.short_name = "PollFD";
    rf.receiver_type = "os.file";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "poll.FD"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.rawConn.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.rawConn.Read";
    rf.short_name = "Read";
    rf.receiver_type = "os.rawConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.rawConn.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.rawConn.Read";
    rf.short_name = "Read";
    rf.receiver_type = "os.rawConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.File.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.File.Read";
    rf.short_name = "Read";
    rf.receiver_type = "os.File";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.File.ReadAt
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.File.ReadAt";
    rf.short_name = "ReadAt";
    rf.receiver_type = "os.File";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.rootFS.ReadDir
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.rootFS.ReadDir";
    rf.short_name = "ReadDir";
    rf.receiver_type = "os.rootFS";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "os.DirEntry"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.ReadDir
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.ReadDir";
    rf.short_name = "ReadDir";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "os.DirEntry"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.File.ReadDir
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.File.ReadDir";
    rf.short_name = "ReadDir";
    rf.receiver_type = "os.File";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "os.DirEntry"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.dirFS.ReadDir
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.dirFS.ReadDir";
    rf.short_name = "ReadDir";
    rf.receiver_type = "os.dirFS";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "os.DirEntry"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Root.ReadFile
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Root.ReadFile";
    rf.short_name = "ReadFile";
    rf.receiver_type = "os.Root";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.ReadFile
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.ReadFile";
    rf.short_name = "ReadFile";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.rootFS.ReadFile
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.rootFS.ReadFile";
    rf.short_name = "ReadFile";
    rf.receiver_type = "os.rootFS";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.dirFS.ReadFile
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.dirFS.ReadFile";
    rf.short_name = "ReadFile";
    rf.receiver_type = "os.dirFS";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.File.ReadFrom
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.File.ReadFrom";
    rf.short_name = "ReadFrom";
    rf.receiver_type = "os.File";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.noReadFrom.ReadFrom
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.noReadFrom.ReadFrom";
    rf.short_name = "ReadFrom";
    rf.receiver_type = "os.noReadFrom";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.rootFS.ReadLink
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.rootFS.ReadLink";
    rf.short_name = "ReadLink";
    rf.receiver_type = "os.rootFS";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.dirFS.ReadLink
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.dirFS.ReadLink";
    rf.short_name = "ReadLink";
    rf.receiver_type = "os.dirFS";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.File.Readdir
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.File.Readdir";
    rf.short_name = "Readdir";
    rf.receiver_type = "os.File";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "os.FileInfo"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.File.Readdirnames
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.File.Readdirnames";
    rf.short_name = "Readdirnames";
    rf.receiver_type = "os.File";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "string"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Root.Readlink
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Root.Readlink";
    rf.short_name = "Readlink";
    rf.receiver_type = "os.Root";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Readlink
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Readlink";
    rf.short_name = "Readlink";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Process.Release
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Process.Release";
    rf.short_name = "Release";
    rf.receiver_type = "os.Process";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Remove
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Remove";
    rf.short_name = "Remove";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Root.Remove
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Root.Remove";
    rf.short_name = "Remove";
    rf.receiver_type = "os.Root";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Remove
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Remove";
    rf.short_name = "Remove";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Remove
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Remove";
    rf.short_name = "Remove";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.RemoveAll
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.RemoveAll";
    rf.short_name = "RemoveAll";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Root.RemoveAll
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Root.RemoveAll";
    rf.short_name = "RemoveAll";
    rf.receiver_type = "os.Root";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Rename
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Rename";
    rf.short_name = "Rename";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Root.Rename
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Root.Rename";
    rf.short_name = "Rename";
    rf.receiver_type = "os.Root";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.SameFile
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.SameFile";
    rf.short_name = "SameFile";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.File.Seek
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.File.Seek";
    rf.short_name = "Seek";
    rf.receiver_type = "os.File";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.File.SetDeadline
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.File.SetDeadline";
    rf.short_name = "SetDeadline";
    rf.receiver_type = "os.File";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.File.SetReadDeadline
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.File.SetReadDeadline";
    rf.short_name = "SetReadDeadline";
    rf.receiver_type = "os.File";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.File.SetWriteDeadline
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.File.SetWriteDeadline";
    rf.short_name = "SetWriteDeadline";
    rf.receiver_type = "os.File";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Setenv
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Setenv";
    rf.short_name = "Setenv";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Process.Signal
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Process.Signal";
    rf.short_name = "Signal";
    rf.receiver_type = "os.Process";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.fileStat.Size
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.fileStat.Size";
    rf.short_name = "Size";
    rf.receiver_type = "os.fileStat";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.fileStat.Size
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.fileStat.Size";
    rf.short_name = "Size";
    rf.receiver_type = "os.fileStat";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.fileStat.Size
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.fileStat.Size";
    rf.short_name = "Size";
    rf.receiver_type = "os.fileStat";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.StartProcess
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.StartProcess";
    rf.short_name = "StartProcess";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "os.Process"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.File.Stat
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.File.Stat";
    rf.short_name = "Stat";
    rf.receiver_type = "os.File";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "os.FileInfo");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Root.Stat
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Root.Stat";
    rf.short_name = "Stat";
    rf.receiver_type = "os.Root";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "os.FileInfo");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.rootFS.Stat
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.rootFS.Stat";
    rf.short_name = "Stat";
    rf.receiver_type = "os.rootFS";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "os.FileInfo");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.File.Stat
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.File.Stat";
    rf.short_name = "Stat";
    rf.receiver_type = "os.File";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "os.FileInfo");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Stat
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Stat";
    rf.short_name = "Stat";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "os.FileInfo");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.File.Stat
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.File.Stat";
    rf.short_name = "Stat";
    rf.receiver_type = "os.File";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "os.FileInfo");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.dirFS.Stat
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.dirFS.Stat";
    rf.short_name = "Stat";
    rf.receiver_type = "os.dirFS";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "fs.FileInfo");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.dirEntry.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.dirEntry.String";
    rf.short_name = "String";
    rf.receiver_type = "os.dirEntry";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.ProcessState.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.ProcessState.String";
    rf.short_name = "String";
    rf.receiver_type = "os.ProcessState";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.unixDirent.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.unixDirent.String";
    rf.short_name = "String";
    rf.receiver_type = "os.unixDirent";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.ProcessState.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.ProcessState.String";
    rf.short_name = "String";
    rf.receiver_type = "os.ProcessState";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.dirEntry.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.dirEntry.String";
    rf.short_name = "String";
    rf.receiver_type = "os.dirEntry";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.ProcessState.Success
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.ProcessState.Success";
    rf.short_name = "Success";
    rf.receiver_type = "os.ProcessState";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Symlink
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Symlink";
    rf.short_name = "Symlink";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Symlink
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Symlink";
    rf.short_name = "Symlink";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Root.Symlink
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Root.Symlink";
    rf.short_name = "Symlink";
    rf.receiver_type = "os.Root";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Symlink
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Symlink";
    rf.short_name = "Symlink";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.File.Sync
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.File.Sync";
    rf.short_name = "Sync";
    rf.receiver_type = "os.File";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.File.Sync
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.File.Sync";
    rf.short_name = "Sync";
    rf.receiver_type = "os.File";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.fileStat.Sys
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.fileStat.Sys";
    rf.short_name = "Sys";
    rf.receiver_type = "os.fileStat";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "any");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.fileStat.Sys
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.fileStat.Sys";
    rf.short_name = "Sys";
    rf.receiver_type = "os.fileStat";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "any");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.fileStat.Sys
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.fileStat.Sys";
    rf.short_name = "Sys";
    rf.receiver_type = "os.fileStat";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "any");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.ProcessState.Sys
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.ProcessState.Sys";
    rf.short_name = "Sys";
    rf.receiver_type = "os.ProcessState";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "any");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.ProcessState.SysUsage
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.ProcessState.SysUsage";
    rf.short_name = "SysUsage";
    rf.receiver_type = "os.ProcessState";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "any");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.File.SyscallConn
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.File.SyscallConn";
    rf.short_name = "SyscallConn";
    rf.receiver_type = "os.File";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "syscall.RawConn");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.ProcessState.SystemTime
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.ProcessState.SystemTime";
    rf.short_name = "SystemTime";
    rf.receiver_type = "os.ProcessState";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "time.Duration");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.TempDir
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.TempDir";
    rf.short_name = "TempDir";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.SyscallError.Timeout
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.SyscallError.Timeout";
    rf.short_name = "Timeout";
    rf.receiver_type = "os.SyscallError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.File.Truncate
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.File.Truncate";
    rf.short_name = "Truncate";
    rf.receiver_type = "os.File";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.File.Truncate
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.File.Truncate";
    rf.short_name = "Truncate";
    rf.receiver_type = "os.File";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Truncate
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Truncate";
    rf.short_name = "Truncate";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Truncate
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Truncate";
    rf.short_name = "Truncate";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Truncate
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Truncate";
    rf.short_name = "Truncate";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.unixDirent.Type
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.unixDirent.Type";
    rf.short_name = "Type";
    rf.receiver_type = "os.unixDirent";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "os.FileMode");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.dirEntry.Type
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.dirEntry.Type";
    rf.short_name = "Type";
    rf.receiver_type = "os.dirEntry";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "os.FileMode");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.dirEntry.Type
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.dirEntry.Type";
    rf.short_name = "Type";
    rf.receiver_type = "os.dirEntry";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "os.FileMode");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Unsetenv
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Unsetenv";
    rf.short_name = "Unsetenv";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.SyscallError.Unwrap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.SyscallError.Unwrap";
    rf.short_name = "Unwrap";
    rf.receiver_type = "os.SyscallError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.LinkError.Unwrap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.LinkError.Unwrap";
    rf.short_name = "Unwrap";
    rf.receiver_type = "os.LinkError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.UserCacheDir
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.UserCacheDir";
    rf.short_name = "UserCacheDir";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.UserConfigDir
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.UserConfigDir";
    rf.short_name = "UserConfigDir";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.UserHomeDir
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.UserHomeDir";
    rf.short_name = "UserHomeDir";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.ProcessState.UserTime
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.ProcessState.UserTime";
    rf.short_name = "UserTime";
    rf.receiver_type = "os.ProcessState";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "time.Duration");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Process.Wait
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Process.Wait";
    rf.short_name = "Wait";
    rf.receiver_type = "os.Process";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "os.ProcessState"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Process.WithHandle
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Process.WithHandle";
    rf.short_name = "WithHandle";
    rf.receiver_type = "os.Process";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.File.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.File.Write";
    rf.short_name = "Write";
    rf.receiver_type = "os.File";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.rawConn.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.rawConn.Write";
    rf.short_name = "Write";
    rf.receiver_type = "os.rawConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.rawConn.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.rawConn.Write";
    rf.short_name = "Write";
    rf.receiver_type = "os.rawConn";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.File.WriteAt
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.File.WriteAt";
    rf.short_name = "WriteAt";
    rf.receiver_type = "os.File";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.WriteFile
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.WriteFile";
    rf.short_name = "WriteFile";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.Root.WriteFile
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.Root.WriteFile";
    rf.short_name = "WriteFile";
    rf.receiver_type = "os.Root";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.File.WriteString
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.File.WriteString";
    rf.short_name = "WriteString";
    rf.receiver_type = "os.File";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.noWriteTo.WriteTo
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.noWriteTo.WriteTo";
    rf.short_name = "WriteTo";
    rf.receiver_type = "os.noWriteTo";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os.File.WriteTo
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os.File.WriteTo";
    rf.short_name = "WriteTo";
    rf.receiver_type = "os.File";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os/exec.prefixSuffixSaver.Bytes
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os/exec.prefixSuffixSaver.Bytes";
    rf.short_name = "Bytes";
    rf.receiver_type = "os/exec.prefixSuffixSaver";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os/exec.Cmd.CombinedOutput
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os/exec.Cmd.CombinedOutput";
    rf.short_name = "CombinedOutput";
    rf.receiver_type = "os/exec.Cmd";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os/exec.Command
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os/exec.Command";
    rf.short_name = "Command";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "os/exec.Cmd"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os/exec.CommandContext
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os/exec.CommandContext";
    rf.short_name = "CommandContext";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "os/exec.Cmd"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os/exec.Cmd.Environ
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os/exec.Cmd.Environ";
    rf.short_name = "Environ";
    rf.receiver_type = "os/exec.Cmd";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "string"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os/exec.wrappedError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os/exec.wrappedError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "os/exec.wrappedError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os/exec.ExitError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os/exec.ExitError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "os/exec.ExitError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os/exec.Error.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os/exec.Error.Error";
    rf.short_name = "Error";
    rf.receiver_type = "os/exec.Error";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os/exec.LookPath
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os/exec.LookPath";
    rf.short_name = "LookPath";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os/exec.Cmd.Output
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os/exec.Cmd.Output";
    rf.short_name = "Output";
    rf.receiver_type = "os/exec.Cmd";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os/exec.Cmd.Run
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os/exec.Cmd.Run";
    rf.short_name = "Run";
    rf.receiver_type = "os/exec.Cmd";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os/exec.Cmd.Start
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os/exec.Cmd.Start";
    rf.short_name = "Start";
    rf.receiver_type = "os/exec.Cmd";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os/exec.Cmd.StderrPipe
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os/exec.Cmd.StderrPipe";
    rf.short_name = "StderrPipe";
    rf.receiver_type = "os/exec.Cmd";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "io.ReadCloser");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os/exec.Cmd.StdinPipe
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os/exec.Cmd.StdinPipe";
    rf.short_name = "StdinPipe";
    rf.receiver_type = "os/exec.Cmd";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "io.WriteCloser");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os/exec.Cmd.StdoutPipe
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os/exec.Cmd.StdoutPipe";
    rf.short_name = "StdoutPipe";
    rf.receiver_type = "os/exec.Cmd";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "io.ReadCloser");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os/exec.Cmd.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os/exec.Cmd.String";
    rf.short_name = "String";
    rf.receiver_type = "os/exec.Cmd";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os/exec.wrappedError.Unwrap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os/exec.wrappedError.Unwrap";
    rf.short_name = "Unwrap";
    rf.receiver_type = "os/exec.wrappedError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os/exec.Error.Unwrap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os/exec.Error.Unwrap";
    rf.short_name = "Unwrap";
    rf.receiver_type = "os/exec.Error";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os/exec.Cmd.Wait
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os/exec.Cmd.Wait";
    rf.short_name = "Wait";
    rf.receiver_type = "os/exec.Cmd";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // os/exec.prefixSuffixSaver.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "os/exec.prefixSuffixSaver.Write";
    rf.short_name = "Write";
    rf.receiver_type = "os/exec.prefixSuffixSaver";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // path.Base
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "path.Base";
    rf.short_name = "Base";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // path.Clean
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "path.Clean";
    rf.short_name = "Clean";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // path.Dir
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "path.Dir";
    rf.short_name = "Dir";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // path.Ext
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "path.Ext";
    rf.short_name = "Ext";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // path.IsAbs
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "path.IsAbs";
    rf.short_name = "IsAbs";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // path.Join
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "path.Join";
    rf.short_name = "Join";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // path.Match
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "path.Match";
    rf.short_name = "Match";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // path.Split
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "path.Split";
    rf.short_name = "Split";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_builtin(arena, "string");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // path/filepath.Abs
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "path/filepath.Abs";
    rf.short_name = "Abs";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // path/filepath.Base
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "path/filepath.Base";
    rf.short_name = "Base";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // path/filepath.Clean
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "path/filepath.Clean";
    rf.short_name = "Clean";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // path/filepath.Dir
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "path/filepath.Dir";
    rf.short_name = "Dir";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // path/filepath.EvalSymlinks
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "path/filepath.EvalSymlinks";
    rf.short_name = "EvalSymlinks";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // path/filepath.Ext
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "path/filepath.Ext";
    rf.short_name = "Ext";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // path/filepath.FromSlash
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "path/filepath.FromSlash";
    rf.short_name = "FromSlash";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // path/filepath.Glob
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "path/filepath.Glob";
    rf.short_name = "Glob";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "string"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // path/filepath.HasPrefix
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "path/filepath.HasPrefix";
    rf.short_name = "HasPrefix";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // path/filepath.HasPrefix
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "path/filepath.HasPrefix";
    rf.short_name = "HasPrefix";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // path/filepath.HasPrefix
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "path/filepath.HasPrefix";
    rf.short_name = "HasPrefix";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // path/filepath.IsAbs
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "path/filepath.IsAbs";
    rf.short_name = "IsAbs";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // path/filepath.IsLocal
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "path/filepath.IsLocal";
    rf.short_name = "IsLocal";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // path/filepath.Join
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "path/filepath.Join";
    rf.short_name = "Join";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // path/filepath.Localize
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "path/filepath.Localize";
    rf.short_name = "Localize";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // path/filepath.Match
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "path/filepath.Match";
    rf.short_name = "Match";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // path/filepath.Rel
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "path/filepath.Rel";
    rf.short_name = "Rel";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // path/filepath.Split
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "path/filepath.Split";
    rf.short_name = "Split";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_builtin(arena, "string");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // path/filepath.SplitList
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "path/filepath.SplitList";
    rf.short_name = "SplitList";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "string"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // path/filepath.ToSlash
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "path/filepath.ToSlash";
    rf.short_name = "ToSlash";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // path/filepath.VolumeName
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "path/filepath.VolumeName";
    rf.short_name = "VolumeName";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // path/filepath.Walk
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "path/filepath.Walk";
    rf.short_name = "Walk";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // path/filepath.WalkDir
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "path/filepath.WalkDir";
    rf.short_name = "WalkDir";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.Regexp.AppendText
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.Regexp.AppendText";
    rf.short_name = "AppendText";
    rf.receiver_type = "regexp.Regexp";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.Compile
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.Compile";
    rf.short_name = "Compile";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "regexp.Regexp"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.CompilePOSIX
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.CompilePOSIX";
    rf.short_name = "CompilePOSIX";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "regexp.Regexp"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.Regexp.Copy
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.Regexp.Copy";
    rf.short_name = "Copy";
    rf.receiver_type = "regexp.Regexp";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "regexp.Regexp"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.Regexp.Expand
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.Regexp.Expand";
    rf.short_name = "Expand";
    rf.receiver_type = "regexp.Regexp";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.Regexp.ExpandString
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.Regexp.ExpandString";
    rf.short_name = "ExpandString";
    rf.receiver_type = "regexp.Regexp";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.Regexp.Find
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.Regexp.Find";
    rf.short_name = "Find";
    rf.receiver_type = "regexp.Regexp";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.Regexp.FindAll
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.Regexp.FindAll";
    rf.short_name = "FindAll";
    rf.receiver_type = "regexp.Regexp";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "regexp.[]byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.Regexp.FindAllIndex
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.Regexp.FindAllIndex";
    rf.short_name = "FindAllIndex";
    rf.receiver_type = "regexp.Regexp";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "regexp.[]int"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.Regexp.FindAllString
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.Regexp.FindAllString";
    rf.short_name = "FindAllString";
    rf.receiver_type = "regexp.Regexp";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "string"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.Regexp.FindAllStringIndex
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.Regexp.FindAllStringIndex";
    rf.short_name = "FindAllStringIndex";
    rf.receiver_type = "regexp.Regexp";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "regexp.[]int"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.Regexp.FindAllStringSubmatch
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.Regexp.FindAllStringSubmatch";
    rf.short_name = "FindAllStringSubmatch";
    rf.receiver_type = "regexp.Regexp";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "regexp.[]string"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.Regexp.FindAllStringSubmatchIndex
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.Regexp.FindAllStringSubmatchIndex";
    rf.short_name = "FindAllStringSubmatchIndex";
    rf.receiver_type = "regexp.Regexp";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "regexp.[]int"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.Regexp.FindAllSubmatch
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.Regexp.FindAllSubmatch";
    rf.short_name = "FindAllSubmatch";
    rf.receiver_type = "regexp.Regexp";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "regexp.[][]byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.Regexp.FindAllSubmatchIndex
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.Regexp.FindAllSubmatchIndex";
    rf.short_name = "FindAllSubmatchIndex";
    rf.receiver_type = "regexp.Regexp";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "regexp.[]int"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.Regexp.FindIndex
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.Regexp.FindIndex";
    rf.short_name = "FindIndex";
    rf.receiver_type = "regexp.Regexp";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "int"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.Regexp.FindReaderIndex
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.Regexp.FindReaderIndex";
    rf.short_name = "FindReaderIndex";
    rf.receiver_type = "regexp.Regexp";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "int"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.Regexp.FindReaderSubmatchIndex
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.Regexp.FindReaderSubmatchIndex";
    rf.short_name = "FindReaderSubmatchIndex";
    rf.receiver_type = "regexp.Regexp";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "int"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.Regexp.FindString
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.Regexp.FindString";
    rf.short_name = "FindString";
    rf.receiver_type = "regexp.Regexp";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.Regexp.FindStringIndex
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.Regexp.FindStringIndex";
    rf.short_name = "FindStringIndex";
    rf.receiver_type = "regexp.Regexp";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "int"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.Regexp.FindStringSubmatch
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.Regexp.FindStringSubmatch";
    rf.short_name = "FindStringSubmatch";
    rf.receiver_type = "regexp.Regexp";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "string"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.Regexp.FindStringSubmatchIndex
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.Regexp.FindStringSubmatchIndex";
    rf.short_name = "FindStringSubmatchIndex";
    rf.receiver_type = "regexp.Regexp";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "int"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.Regexp.FindSubmatch
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.Regexp.FindSubmatch";
    rf.short_name = "FindSubmatch";
    rf.receiver_type = "regexp.Regexp";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "regexp.[]byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.Regexp.FindSubmatchIndex
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.Regexp.FindSubmatchIndex";
    rf.short_name = "FindSubmatchIndex";
    rf.receiver_type = "regexp.Regexp";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "int"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.Regexp.LiteralPrefix
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.Regexp.LiteralPrefix";
    rf.short_name = "LiteralPrefix";
    rf.receiver_type = "regexp.Regexp";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_builtin(arena, "bool");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.Regexp.Longest
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.Regexp.Longest";
    rf.short_name = "Longest";
    rf.receiver_type = "regexp.Regexp";
    cbm_registry_add_func(reg, rf);

    // regexp.Regexp.MarshalText
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.Regexp.MarshalText";
    rf.short_name = "MarshalText";
    rf.receiver_type = "regexp.Regexp";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.Regexp.Match
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.Regexp.Match";
    rf.short_name = "Match";
    rf.receiver_type = "regexp.Regexp";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.Match
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.Match";
    rf.short_name = "Match";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.Regexp.MatchReader
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.Regexp.MatchReader";
    rf.short_name = "MatchReader";
    rf.receiver_type = "regexp.Regexp";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.MatchReader
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.MatchReader";
    rf.short_name = "MatchReader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.Regexp.MatchString
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.Regexp.MatchString";
    rf.short_name = "MatchString";
    rf.receiver_type = "regexp.Regexp";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.MatchString
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.MatchString";
    rf.short_name = "MatchString";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.MustCompile
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.MustCompile";
    rf.short_name = "MustCompile";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "regexp.Regexp"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.MustCompilePOSIX
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.MustCompilePOSIX";
    rf.short_name = "MustCompilePOSIX";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "regexp.Regexp"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.Regexp.NumSubexp
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.Regexp.NumSubexp";
    rf.short_name = "NumSubexp";
    rf.receiver_type = "regexp.Regexp";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.QuoteMeta
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.QuoteMeta";
    rf.short_name = "QuoteMeta";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.Regexp.ReplaceAll
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.Regexp.ReplaceAll";
    rf.short_name = "ReplaceAll";
    rf.receiver_type = "regexp.Regexp";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.Regexp.ReplaceAllFunc
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.Regexp.ReplaceAllFunc";
    rf.short_name = "ReplaceAllFunc";
    rf.receiver_type = "regexp.Regexp";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.Regexp.ReplaceAllLiteral
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.Regexp.ReplaceAllLiteral";
    rf.short_name = "ReplaceAllLiteral";
    rf.receiver_type = "regexp.Regexp";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.Regexp.ReplaceAllLiteralString
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.Regexp.ReplaceAllLiteralString";
    rf.short_name = "ReplaceAllLiteralString";
    rf.receiver_type = "regexp.Regexp";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.Regexp.ReplaceAllString
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.Regexp.ReplaceAllString";
    rf.short_name = "ReplaceAllString";
    rf.receiver_type = "regexp.Regexp";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.Regexp.ReplaceAllStringFunc
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.Regexp.ReplaceAllStringFunc";
    rf.short_name = "ReplaceAllStringFunc";
    rf.receiver_type = "regexp.Regexp";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.Regexp.Split
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.Regexp.Split";
    rf.short_name = "Split";
    rf.receiver_type = "regexp.Regexp";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "string"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.Regexp.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.Regexp.String";
    rf.short_name = "String";
    rf.receiver_type = "regexp.Regexp";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.Regexp.SubexpIndex
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.Regexp.SubexpIndex";
    rf.short_name = "SubexpIndex";
    rf.receiver_type = "regexp.Regexp";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.Regexp.SubexpNames
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.Regexp.SubexpNames";
    rf.short_name = "SubexpNames";
    rf.receiver_type = "regexp.Regexp";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "string"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // regexp.Regexp.UnmarshalText
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "regexp.Regexp.UnmarshalText";
    rf.short_name = "UnmarshalText";
    rf.receiver_type = "regexp.Regexp";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sort.Find
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sort.Find";
    rf.short_name = "Find";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "bool");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sort.Float64s
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sort.Float64s";
    rf.short_name = "Float64s";
    cbm_registry_add_func(reg, rf);

    // sort.Float64sAreSorted
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sort.Float64sAreSorted";
    rf.short_name = "Float64sAreSorted";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sort.Ints
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sort.Ints";
    rf.short_name = "Ints";
    cbm_registry_add_func(reg, rf);

    // sort.IntsAreSorted
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sort.IntsAreSorted";
    rf.short_name = "IntsAreSorted";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sort.IsSorted
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sort.IsSorted";
    rf.short_name = "IsSorted";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sort.StringSlice.Len
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sort.StringSlice.Len";
    rf.short_name = "Len";
    rf.receiver_type = "sort.StringSlice";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sort.Float64Slice.Len
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sort.Float64Slice.Len";
    rf.short_name = "Len";
    rf.receiver_type = "sort.Float64Slice";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sort.IntSlice.Len
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sort.IntSlice.Len";
    rf.short_name = "Len";
    rf.receiver_type = "sort.IntSlice";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sort.StringSlice.Less
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sort.StringSlice.Less";
    rf.short_name = "Less";
    rf.receiver_type = "sort.StringSlice";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sort.Float64Slice.Less
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sort.Float64Slice.Less";
    rf.short_name = "Less";
    rf.receiver_type = "sort.Float64Slice";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sort.IntSlice.Less
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sort.IntSlice.Less";
    rf.short_name = "Less";
    rf.receiver_type = "sort.IntSlice";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sort.reverse.Less
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sort.reverse.Less";
    rf.short_name = "Less";
    rf.receiver_type = "sort.reverse";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sort.xorshift.Next
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sort.xorshift.Next";
    rf.short_name = "Next";
    rf.receiver_type = "sort.xorshift";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "uint64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sort.Reverse
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sort.Reverse";
    rf.short_name = "Reverse";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "sort.Interface");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sort.Float64Slice.Search
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sort.Float64Slice.Search";
    rf.short_name = "Search";
    rf.receiver_type = "sort.Float64Slice";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sort.StringSlice.Search
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sort.StringSlice.Search";
    rf.short_name = "Search";
    rf.receiver_type = "sort.StringSlice";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sort.IntSlice.Search
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sort.IntSlice.Search";
    rf.short_name = "Search";
    rf.receiver_type = "sort.IntSlice";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sort.Search
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sort.Search";
    rf.short_name = "Search";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sort.SearchFloat64s
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sort.SearchFloat64s";
    rf.short_name = "SearchFloat64s";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sort.SearchInts
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sort.SearchInts";
    rf.short_name = "SearchInts";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sort.SearchStrings
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sort.SearchStrings";
    rf.short_name = "SearchStrings";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sort.Slice
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sort.Slice";
    rf.short_name = "Slice";
    cbm_registry_add_func(reg, rf);

    // sort.SliceIsSorted
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sort.SliceIsSorted";
    rf.short_name = "SliceIsSorted";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sort.SliceStable
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sort.SliceStable";
    rf.short_name = "SliceStable";
    cbm_registry_add_func(reg, rf);

    // sort.Float64Slice.Sort
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sort.Float64Slice.Sort";
    rf.short_name = "Sort";
    rf.receiver_type = "sort.Float64Slice";
    cbm_registry_add_func(reg, rf);

    // sort.IntSlice.Sort
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sort.IntSlice.Sort";
    rf.short_name = "Sort";
    rf.receiver_type = "sort.IntSlice";
    cbm_registry_add_func(reg, rf);

    // sort.Sort
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sort.Sort";
    rf.short_name = "Sort";
    cbm_registry_add_func(reg, rf);

    // sort.StringSlice.Sort
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sort.StringSlice.Sort";
    rf.short_name = "Sort";
    rf.receiver_type = "sort.StringSlice";
    cbm_registry_add_func(reg, rf);

    // sort.Stable
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sort.Stable";
    rf.short_name = "Stable";
    cbm_registry_add_func(reg, rf);

    // sort.Strings
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sort.Strings";
    rf.short_name = "Strings";
    cbm_registry_add_func(reg, rf);

    // sort.StringsAreSorted
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sort.StringsAreSorted";
    rf.short_name = "StringsAreSorted";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sort.StringSlice.Swap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sort.StringSlice.Swap";
    rf.short_name = "Swap";
    rf.receiver_type = "sort.StringSlice";
    cbm_registry_add_func(reg, rf);

    // sort.Float64Slice.Swap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sort.Float64Slice.Swap";
    rf.short_name = "Swap";
    rf.receiver_type = "sort.Float64Slice";
    cbm_registry_add_func(reg, rf);

    // sort.IntSlice.Swap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sort.IntSlice.Swap";
    rf.short_name = "Swap";
    rf.receiver_type = "sort.IntSlice";
    cbm_registry_add_func(reg, rf);

    // strconv.AppendBool
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strconv.AppendBool";
    rf.short_name = "AppendBool";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strconv.AppendFloat
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strconv.AppendFloat";
    rf.short_name = "AppendFloat";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strconv.AppendInt
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strconv.AppendInt";
    rf.short_name = "AppendInt";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strconv.AppendQuote
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strconv.AppendQuote";
    rf.short_name = "AppendQuote";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strconv.AppendQuoteRune
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strconv.AppendQuoteRune";
    rf.short_name = "AppendQuoteRune";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strconv.AppendQuoteRuneToASCII
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strconv.AppendQuoteRuneToASCII";
    rf.short_name = "AppendQuoteRuneToASCII";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strconv.AppendQuoteRuneToGraphic
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strconv.AppendQuoteRuneToGraphic";
    rf.short_name = "AppendQuoteRuneToGraphic";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strconv.AppendQuoteToASCII
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strconv.AppendQuoteToASCII";
    rf.short_name = "AppendQuoteToASCII";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strconv.AppendQuoteToGraphic
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strconv.AppendQuoteToGraphic";
    rf.short_name = "AppendQuoteToGraphic";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strconv.AppendUint
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strconv.AppendUint";
    rf.short_name = "AppendUint";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strconv.Atoi
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strconv.Atoi";
    rf.short_name = "Atoi";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strconv.CanBackquote
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strconv.CanBackquote";
    rf.short_name = "CanBackquote";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strconv.NumError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strconv.NumError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "strconv.NumError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strconv.FormatBool
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strconv.FormatBool";
    rf.short_name = "FormatBool";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strconv.FormatComplex
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strconv.FormatComplex";
    rf.short_name = "FormatComplex";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strconv.FormatFloat
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strconv.FormatFloat";
    rf.short_name = "FormatFloat";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strconv.FormatInt
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strconv.FormatInt";
    rf.short_name = "FormatInt";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strconv.FormatUint
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strconv.FormatUint";
    rf.short_name = "FormatUint";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strconv.IsGraphic
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strconv.IsGraphic";
    rf.short_name = "IsGraphic";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strconv.IsPrint
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strconv.IsPrint";
    rf.short_name = "IsPrint";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strconv.Itoa
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strconv.Itoa";
    rf.short_name = "Itoa";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strconv.ParseBool
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strconv.ParseBool";
    rf.short_name = "ParseBool";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strconv.ParseComplex
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strconv.ParseComplex";
    rf.short_name = "ParseComplex";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "complex128");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strconv.ParseFloat
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strconv.ParseFloat";
    rf.short_name = "ParseFloat";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strconv.ParseInt
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strconv.ParseInt";
    rf.short_name = "ParseInt";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strconv.ParseUint
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strconv.ParseUint";
    rf.short_name = "ParseUint";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "uint64");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strconv.Quote
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strconv.Quote";
    rf.short_name = "Quote";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strconv.QuoteRune
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strconv.QuoteRune";
    rf.short_name = "QuoteRune";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strconv.QuoteRuneToASCII
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strconv.QuoteRuneToASCII";
    rf.short_name = "QuoteRuneToASCII";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strconv.QuoteRuneToGraphic
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strconv.QuoteRuneToGraphic";
    rf.short_name = "QuoteRuneToGraphic";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strconv.QuoteToASCII
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strconv.QuoteToASCII";
    rf.short_name = "QuoteToASCII";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strconv.QuoteToGraphic
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strconv.QuoteToGraphic";
    rf.short_name = "QuoteToGraphic";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strconv.QuotedPrefix
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strconv.QuotedPrefix";
    rf.short_name = "QuotedPrefix";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strconv.Unquote
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strconv.Unquote";
    rf.short_name = "Unquote";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strconv.UnquoteChar
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strconv.UnquoteChar";
    rf.short_name = "UnquoteChar";
    {
        const CBMType* ret[5];
        ret[0] = cbm_type_builtin(arena, "rune");
        ret[1] = cbm_type_builtin(arena, "bool");
        ret[2] = cbm_type_builtin(arena, "string");
        ret[3] = cbm_type_builtin(arena, "error");
        ret[4] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strconv.NumError.Unwrap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strconv.NumError.Unwrap";
    rf.short_name = "Unwrap";
    rf.receiver_type = "strconv.NumError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.Builder.Cap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.Builder.Cap";
    rf.short_name = "Cap";
    rf.receiver_type = "strings.Builder";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.Clone
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.Clone";
    rf.short_name = "Clone";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.Compare
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.Compare";
    rf.short_name = "Compare";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.Contains
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.Contains";
    rf.short_name = "Contains";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.ContainsAny
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.ContainsAny";
    rf.short_name = "ContainsAny";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.ContainsFunc
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.ContainsFunc";
    rf.short_name = "ContainsFunc";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.ContainsRune
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.ContainsRune";
    rf.short_name = "ContainsRune";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.Count
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.Count";
    rf.short_name = "Count";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.Cut
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.Cut";
    rf.short_name = "Cut";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_builtin(arena, "string");
        ret[2] = cbm_type_builtin(arena, "bool");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.CutPrefix
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.CutPrefix";
    rf.short_name = "CutPrefix";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_builtin(arena, "bool");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.CutSuffix
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.CutSuffix";
    rf.short_name = "CutSuffix";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_builtin(arena, "bool");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.EqualFold
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.EqualFold";
    rf.short_name = "EqualFold";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.Fields
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.Fields";
    rf.short_name = "Fields";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "string"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.FieldsFunc
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.FieldsFunc";
    rf.short_name = "FieldsFunc";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "string"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.FieldsFuncSeq
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.FieldsFuncSeq";
    rf.short_name = "FieldsFuncSeq";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "any");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.FieldsSeq
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.FieldsSeq";
    rf.short_name = "FieldsSeq";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "any");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.Builder.Grow
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.Builder.Grow";
    rf.short_name = "Grow";
    rf.receiver_type = "strings.Builder";
    cbm_registry_add_func(reg, rf);

    // strings.HasPrefix
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.HasPrefix";
    rf.short_name = "HasPrefix";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.HasSuffix
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.HasSuffix";
    rf.short_name = "HasSuffix";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.Index
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.Index";
    rf.short_name = "Index";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.IndexAny
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.IndexAny";
    rf.short_name = "IndexAny";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.IndexByte
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.IndexByte";
    rf.short_name = "IndexByte";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.IndexFunc
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.IndexFunc";
    rf.short_name = "IndexFunc";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.IndexRune
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.IndexRune";
    rf.short_name = "IndexRune";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.Join
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.Join";
    rf.short_name = "Join";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.LastIndex
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.LastIndex";
    rf.short_name = "LastIndex";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.LastIndexAny
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.LastIndexAny";
    rf.short_name = "LastIndexAny";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.LastIndexByte
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.LastIndexByte";
    rf.short_name = "LastIndexByte";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.LastIndexFunc
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.LastIndexFunc";
    rf.short_name = "LastIndexFunc";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.Reader.Len
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.Reader.Len";
    rf.short_name = "Len";
    rf.receiver_type = "strings.Reader";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.Builder.Len
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.Builder.Len";
    rf.short_name = "Len";
    rf.receiver_type = "strings.Builder";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.Lines
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.Lines";
    rf.short_name = "Lines";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "any");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.Map
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.Map";
    rf.short_name = "Map";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.NewReader
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.NewReader";
    rf.short_name = "NewReader";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "strings.Reader"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.NewReplacer
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.NewReplacer";
    rf.short_name = "NewReplacer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "strings.Replacer"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.Reader.Read
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.Reader.Read";
    rf.short_name = "Read";
    rf.receiver_type = "strings.Reader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.Reader.ReadAt
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.Reader.ReadAt";
    rf.short_name = "ReadAt";
    rf.receiver_type = "strings.Reader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.Reader.ReadByte
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.Reader.ReadByte";
    rf.short_name = "ReadByte";
    rf.receiver_type = "strings.Reader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "byte");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.Reader.ReadRune
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.Reader.ReadRune";
    rf.short_name = "ReadRune";
    rf.receiver_type = "strings.Reader";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_builtin(arena, "rune");
        ret[1] = cbm_type_builtin(arena, "int");
        ret[2] = cbm_type_builtin(arena, "error");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.Repeat
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.Repeat";
    rf.short_name = "Repeat";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.singleStringReplacer.Replace
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.singleStringReplacer.Replace";
    rf.short_name = "Replace";
    rf.receiver_type = "strings.singleStringReplacer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.Replace
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.Replace";
    rf.short_name = "Replace";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.byteStringReplacer.Replace
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.byteStringReplacer.Replace";
    rf.short_name = "Replace";
    rf.receiver_type = "strings.byteStringReplacer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.byteReplacer.Replace
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.byteReplacer.Replace";
    rf.short_name = "Replace";
    rf.receiver_type = "strings.byteReplacer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.genericReplacer.Replace
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.genericReplacer.Replace";
    rf.short_name = "Replace";
    rf.receiver_type = "strings.genericReplacer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.Replacer.Replace
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.Replacer.Replace";
    rf.short_name = "Replace";
    rf.receiver_type = "strings.Replacer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.ReplaceAll
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.ReplaceAll";
    rf.short_name = "ReplaceAll";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.Reader.Reset
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.Reader.Reset";
    rf.short_name = "Reset";
    rf.receiver_type = "strings.Reader";
    cbm_registry_add_func(reg, rf);

    // strings.Builder.Reset
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.Builder.Reset";
    rf.short_name = "Reset";
    rf.receiver_type = "strings.Builder";
    cbm_registry_add_func(reg, rf);

    // strings.Reader.Seek
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.Reader.Seek";
    rf.short_name = "Seek";
    rf.receiver_type = "strings.Reader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.Reader.Size
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.Reader.Size";
    rf.short_name = "Size";
    rf.receiver_type = "strings.Reader";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.Split
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.Split";
    rf.short_name = "Split";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "string"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.SplitAfter
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.SplitAfter";
    rf.short_name = "SplitAfter";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "string"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.SplitAfterN
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.SplitAfterN";
    rf.short_name = "SplitAfterN";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "string"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.SplitAfterSeq
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.SplitAfterSeq";
    rf.short_name = "SplitAfterSeq";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "any");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.SplitN
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.SplitN";
    rf.short_name = "SplitN";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "string"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.SplitSeq
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.SplitSeq";
    rf.short_name = "SplitSeq";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "any");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.Builder.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.Builder.String";
    rf.short_name = "String";
    rf.receiver_type = "strings.Builder";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.Title
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.Title";
    rf.short_name = "Title";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.ToLower
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.ToLower";
    rf.short_name = "ToLower";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.ToLowerSpecial
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.ToLowerSpecial";
    rf.short_name = "ToLowerSpecial";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.ToTitle
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.ToTitle";
    rf.short_name = "ToTitle";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.ToTitleSpecial
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.ToTitleSpecial";
    rf.short_name = "ToTitleSpecial";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.ToUpper
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.ToUpper";
    rf.short_name = "ToUpper";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.ToUpperSpecial
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.ToUpperSpecial";
    rf.short_name = "ToUpperSpecial";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.ToValidUTF8
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.ToValidUTF8";
    rf.short_name = "ToValidUTF8";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.Trim
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.Trim";
    rf.short_name = "Trim";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.TrimFunc
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.TrimFunc";
    rf.short_name = "TrimFunc";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.TrimLeft
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.TrimLeft";
    rf.short_name = "TrimLeft";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.TrimLeftFunc
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.TrimLeftFunc";
    rf.short_name = "TrimLeftFunc";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.TrimPrefix
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.TrimPrefix";
    rf.short_name = "TrimPrefix";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.TrimRight
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.TrimRight";
    rf.short_name = "TrimRight";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.TrimRightFunc
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.TrimRightFunc";
    rf.short_name = "TrimRightFunc";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.TrimSpace
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.TrimSpace";
    rf.short_name = "TrimSpace";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.TrimSuffix
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.TrimSuffix";
    rf.short_name = "TrimSuffix";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.Reader.UnreadByte
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.Reader.UnreadByte";
    rf.short_name = "UnreadByte";
    rf.receiver_type = "strings.Reader";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.Reader.UnreadRune
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.Reader.UnreadRune";
    rf.short_name = "UnreadRune";
    rf.receiver_type = "strings.Reader";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.appendSliceWriter.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.appendSliceWriter.Write";
    rf.short_name = "Write";
    rf.receiver_type = "strings.appendSliceWriter";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.Builder.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.Builder.Write";
    rf.short_name = "Write";
    rf.receiver_type = "strings.Builder";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.Builder.WriteByte
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.Builder.WriteByte";
    rf.short_name = "WriteByte";
    rf.receiver_type = "strings.Builder";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.Builder.WriteRune
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.Builder.WriteRune";
    rf.short_name = "WriteRune";
    rf.receiver_type = "strings.Builder";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.Replacer.WriteString
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.Replacer.WriteString";
    rf.short_name = "WriteString";
    rf.receiver_type = "strings.Replacer";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.byteStringReplacer.WriteString
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.byteStringReplacer.WriteString";
    rf.short_name = "WriteString";
    rf.receiver_type = "strings.byteStringReplacer";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.genericReplacer.WriteString
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.genericReplacer.WriteString";
    rf.short_name = "WriteString";
    rf.receiver_type = "strings.genericReplacer";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.stringWriter.WriteString
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.stringWriter.WriteString";
    rf.short_name = "WriteString";
    rf.receiver_type = "strings.stringWriter";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.singleStringReplacer.WriteString
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.singleStringReplacer.WriteString";
    rf.short_name = "WriteString";
    rf.receiver_type = "strings.singleStringReplacer";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.Builder.WriteString
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.Builder.WriteString";
    rf.short_name = "WriteString";
    rf.receiver_type = "strings.Builder";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.appendSliceWriter.WriteString
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.appendSliceWriter.WriteString";
    rf.short_name = "WriteString";
    rf.receiver_type = "strings.appendSliceWriter";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.byteReplacer.WriteString
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.byteReplacer.WriteString";
    rf.short_name = "WriteString";
    rf.receiver_type = "strings.byteReplacer";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // strings.Reader.WriteTo
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "strings.Reader.WriteTo";
    rf.short_name = "WriteTo";
    rf.receiver_type = "strings.Reader";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync.WaitGroup.Add
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync.WaitGroup.Add";
    rf.short_name = "Add";
    rf.receiver_type = "sync.WaitGroup";
    cbm_registry_add_func(reg, rf);

    // sync.Cond.Broadcast
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync.Cond.Broadcast";
    rf.short_name = "Broadcast";
    rf.receiver_type = "sync.Cond";
    cbm_registry_add_func(reg, rf);

    // sync.Map.Clear
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync.Map.Clear";
    rf.short_name = "Clear";
    rf.receiver_type = "sync.Map";
    cbm_registry_add_func(reg, rf);

    // sync.Map.CompareAndDelete
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync.Map.CompareAndDelete";
    rf.short_name = "CompareAndDelete";
    rf.receiver_type = "sync.Map";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync.Map.CompareAndSwap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync.Map.CompareAndSwap";
    rf.short_name = "CompareAndSwap";
    rf.receiver_type = "sync.Map";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync.Map.Delete
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync.Map.Delete";
    rf.short_name = "Delete";
    rf.receiver_type = "sync.Map";
    cbm_registry_add_func(reg, rf);

    // sync.Once.Do
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync.Once.Do";
    rf.short_name = "Do";
    rf.receiver_type = "sync.Once";
    cbm_registry_add_func(reg, rf);

    // sync.WaitGroup.Done
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync.WaitGroup.Done";
    rf.short_name = "Done";
    rf.receiver_type = "sync.WaitGroup";
    cbm_registry_add_func(reg, rf);

    // sync.Pool.Get
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync.Pool.Get";
    rf.short_name = "Get";
    rf.receiver_type = "sync.Pool";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "any");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync.WaitGroup.Go
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync.WaitGroup.Go";
    rf.short_name = "Go";
    rf.receiver_type = "sync.WaitGroup";
    cbm_registry_add_func(reg, rf);

    // sync.Map.Load
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync.Map.Load";
    rf.short_name = "Load";
    rf.receiver_type = "sync.Map";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "any");
        ret[1] = cbm_type_builtin(arena, "bool");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync.Map.LoadAndDelete
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync.Map.LoadAndDelete";
    rf.short_name = "LoadAndDelete";
    rf.receiver_type = "sync.Map";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "any");
        ret[1] = cbm_type_builtin(arena, "bool");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync.Map.LoadOrStore
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync.Map.LoadOrStore";
    rf.short_name = "LoadOrStore";
    rf.receiver_type = "sync.Map";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "any");
        ret[1] = cbm_type_builtin(arena, "bool");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync.noCopy.Lock
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync.noCopy.Lock";
    rf.short_name = "Lock";
    rf.receiver_type = "sync.noCopy";
    cbm_registry_add_func(reg, rf);

    // sync.Mutex.Lock
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync.Mutex.Lock";
    rf.short_name = "Lock";
    rf.receiver_type = "sync.Mutex";
    cbm_registry_add_func(reg, rf);

    // sync.rlocker.Lock
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync.rlocker.Lock";
    rf.short_name = "Lock";
    rf.receiver_type = "sync.rlocker";
    cbm_registry_add_func(reg, rf);

    // sync.RWMutex.Lock
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync.RWMutex.Lock";
    rf.short_name = "Lock";
    rf.receiver_type = "sync.RWMutex";
    cbm_registry_add_func(reg, rf);

    // sync.NewCond
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync.NewCond";
    rf.short_name = "NewCond";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "sync.Cond"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync.OnceFunc
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync.OnceFunc";
    rf.short_name = "OnceFunc";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "sync.func()");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync.OnceValue
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync.OnceValue";
    rf.short_name = "OnceValue";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "sync.func()");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync.OnceValues
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync.OnceValues";
    rf.short_name = "OnceValues";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "sync.func()");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync.Pool.Put
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync.Pool.Put";
    rf.short_name = "Put";
    rf.receiver_type = "sync.Pool";
    cbm_registry_add_func(reg, rf);

    // sync.RWMutex.RLock
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync.RWMutex.RLock";
    rf.short_name = "RLock";
    rf.receiver_type = "sync.RWMutex";
    cbm_registry_add_func(reg, rf);

    // sync.RWMutex.RLocker
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync.RWMutex.RLocker";
    rf.short_name = "RLocker";
    rf.receiver_type = "sync.RWMutex";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "sync.Locker");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync.RWMutex.RUnlock
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync.RWMutex.RUnlock";
    rf.short_name = "RUnlock";
    rf.receiver_type = "sync.RWMutex";
    cbm_registry_add_func(reg, rf);

    // sync.Map.Range
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync.Map.Range";
    rf.short_name = "Range";
    rf.receiver_type = "sync.Map";
    cbm_registry_add_func(reg, rf);

    // sync.Cond.Signal
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync.Cond.Signal";
    rf.short_name = "Signal";
    rf.receiver_type = "sync.Cond";
    cbm_registry_add_func(reg, rf);

    // sync.Map.Store
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync.Map.Store";
    rf.short_name = "Store";
    rf.receiver_type = "sync.Map";
    cbm_registry_add_func(reg, rf);

    // sync.Map.Swap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync.Map.Swap";
    rf.short_name = "Swap";
    rf.receiver_type = "sync.Map";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "any");
        ret[1] = cbm_type_builtin(arena, "bool");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync.RWMutex.TryLock
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync.RWMutex.TryLock";
    rf.short_name = "TryLock";
    rf.receiver_type = "sync.RWMutex";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync.Mutex.TryLock
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync.Mutex.TryLock";
    rf.short_name = "TryLock";
    rf.receiver_type = "sync.Mutex";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync.RWMutex.TryRLock
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync.RWMutex.TryRLock";
    rf.short_name = "TryRLock";
    rf.receiver_type = "sync.RWMutex";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync.Mutex.Unlock
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync.Mutex.Unlock";
    rf.short_name = "Unlock";
    rf.receiver_type = "sync.Mutex";
    cbm_registry_add_func(reg, rf);

    // sync.noCopy.Unlock
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync.noCopy.Unlock";
    rf.short_name = "Unlock";
    rf.receiver_type = "sync.noCopy";
    cbm_registry_add_func(reg, rf);

    // sync.rlocker.Unlock
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync.rlocker.Unlock";
    rf.short_name = "Unlock";
    rf.receiver_type = "sync.rlocker";
    cbm_registry_add_func(reg, rf);

    // sync.RWMutex.Unlock
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync.RWMutex.Unlock";
    rf.short_name = "Unlock";
    rf.receiver_type = "sync.RWMutex";
    cbm_registry_add_func(reg, rf);

    // sync.Cond.Wait
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync.Cond.Wait";
    rf.short_name = "Wait";
    rf.receiver_type = "sync.Cond";
    cbm_registry_add_func(reg, rf);

    // sync.WaitGroup.Wait
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync.WaitGroup.Wait";
    rf.short_name = "Wait";
    rf.receiver_type = "sync.WaitGroup";
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Uintptr.Add
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Uintptr.Add";
    rf.short_name = "Add";
    rf.receiver_type = "sync/atomic.Uintptr";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "uintptr");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Uint32.Add
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Uint32.Add";
    rf.short_name = "Add";
    rf.receiver_type = "sync/atomic.Uint32";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "uint32");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Int32.Add
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Int32.Add";
    rf.short_name = "Add";
    rf.receiver_type = "sync/atomic.Int32";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int32");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Int64.Add
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Int64.Add";
    rf.short_name = "Add";
    rf.receiver_type = "sync/atomic.Int64";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Uint64.Add
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Uint64.Add";
    rf.short_name = "Add";
    rf.receiver_type = "sync/atomic.Uint64";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "uint64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.AddInt32
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.AddInt32";
    rf.short_name = "AddInt32";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int32");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.AddInt64
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.AddInt64";
    rf.short_name = "AddInt64";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.AddInt64
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.AddInt64";
    rf.short_name = "AddInt64";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.AddUint32
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.AddUint32";
    rf.short_name = "AddUint32";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "uint32");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.AddUint64
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.AddUint64";
    rf.short_name = "AddUint64";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "uint64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.AddUint64
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.AddUint64";
    rf.short_name = "AddUint64";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "uint64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.AddUintptr
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.AddUintptr";
    rf.short_name = "AddUintptr";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "uintptr");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Uintptr.And
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Uintptr.And";
    rf.short_name = "And";
    rf.receiver_type = "sync/atomic.Uintptr";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "uintptr");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Int64.And
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Int64.And";
    rf.short_name = "And";
    rf.receiver_type = "sync/atomic.Int64";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Int32.And
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Int32.And";
    rf.short_name = "And";
    rf.receiver_type = "sync/atomic.Int32";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int32");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Uint32.And
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Uint32.And";
    rf.short_name = "And";
    rf.receiver_type = "sync/atomic.Uint32";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "uint32");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Uint64.And
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Uint64.And";
    rf.short_name = "And";
    rf.receiver_type = "sync/atomic.Uint64";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "uint64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.AndInt32
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.AndInt32";
    rf.short_name = "AndInt32";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int32");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.AndInt64
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.AndInt64";
    rf.short_name = "AndInt64";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.AndInt64
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.AndInt64";
    rf.short_name = "AndInt64";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.AndUint32
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.AndUint32";
    rf.short_name = "AndUint32";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "uint32");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.AndUint64
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.AndUint64";
    rf.short_name = "AndUint64";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "uint64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.AndUint64
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.AndUint64";
    rf.short_name = "AndUint64";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "uint64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.AndUintptr
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.AndUintptr";
    rf.short_name = "AndUintptr";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "uintptr");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Uint32.CompareAndSwap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Uint32.CompareAndSwap";
    rf.short_name = "CompareAndSwap";
    rf.receiver_type = "sync/atomic.Uint32";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Value.CompareAndSwap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Value.CompareAndSwap";
    rf.short_name = "CompareAndSwap";
    rf.receiver_type = "sync/atomic.Value";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Uint64.CompareAndSwap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Uint64.CompareAndSwap";
    rf.short_name = "CompareAndSwap";
    rf.receiver_type = "sync/atomic.Uint64";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Int32.CompareAndSwap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Int32.CompareAndSwap";
    rf.short_name = "CompareAndSwap";
    rf.receiver_type = "sync/atomic.Int32";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Bool.CompareAndSwap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Bool.CompareAndSwap";
    rf.short_name = "CompareAndSwap";
    rf.receiver_type = "sync/atomic.Bool";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Uintptr.CompareAndSwap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Uintptr.CompareAndSwap";
    rf.short_name = "CompareAndSwap";
    rf.receiver_type = "sync/atomic.Uintptr";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.any.CompareAndSwap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.any.CompareAndSwap";
    rf.short_name = "CompareAndSwap";
    rf.receiver_type = "sync/atomic.any";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Int64.CompareAndSwap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Int64.CompareAndSwap";
    rf.short_name = "CompareAndSwap";
    rf.receiver_type = "sync/atomic.Int64";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.CompareAndSwapInt32
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.CompareAndSwapInt32";
    rf.short_name = "CompareAndSwapInt32";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.CompareAndSwapInt64
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.CompareAndSwapInt64";
    rf.short_name = "CompareAndSwapInt64";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.CompareAndSwapInt64
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.CompareAndSwapInt64";
    rf.short_name = "CompareAndSwapInt64";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.CompareAndSwapPointer
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.CompareAndSwapPointer";
    rf.short_name = "CompareAndSwapPointer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.CompareAndSwapUint32
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.CompareAndSwapUint32";
    rf.short_name = "CompareAndSwapUint32";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.CompareAndSwapUint64
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.CompareAndSwapUint64";
    rf.short_name = "CompareAndSwapUint64";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.CompareAndSwapUint64
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.CompareAndSwapUint64";
    rf.short_name = "CompareAndSwapUint64";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.CompareAndSwapUintptr
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.CompareAndSwapUintptr";
    rf.short_name = "CompareAndSwapUintptr";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Uintptr.Load
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Uintptr.Load";
    rf.short_name = "Load";
    rf.receiver_type = "sync/atomic.Uintptr";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "uintptr");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Bool.Load
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Bool.Load";
    rf.short_name = "Load";
    rf.receiver_type = "sync/atomic.Bool";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Uint64.Load
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Uint64.Load";
    rf.short_name = "Load";
    rf.receiver_type = "sync/atomic.Uint64";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "uint64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Int64.Load
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Int64.Load";
    rf.short_name = "Load";
    rf.receiver_type = "sync/atomic.Int64";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Value.Load
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Value.Load";
    rf.short_name = "Load";
    rf.receiver_type = "sync/atomic.Value";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "any");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Int32.Load
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Int32.Load";
    rf.short_name = "Load";
    rf.receiver_type = "sync/atomic.Int32";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int32");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.any.Load
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.any.Load";
    rf.short_name = "Load";
    rf.receiver_type = "sync/atomic.any";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "sync/atomic.T"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Uint32.Load
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Uint32.Load";
    rf.short_name = "Load";
    rf.receiver_type = "sync/atomic.Uint32";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "uint32");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.LoadInt32
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.LoadInt32";
    rf.short_name = "LoadInt32";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int32");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.LoadInt64
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.LoadInt64";
    rf.short_name = "LoadInt64";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.LoadInt64
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.LoadInt64";
    rf.short_name = "LoadInt64";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.LoadPointer
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.LoadPointer";
    rf.short_name = "LoadPointer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "unsafe.Pointer");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.LoadUint32
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.LoadUint32";
    rf.short_name = "LoadUint32";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "uint32");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.LoadUint64
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.LoadUint64";
    rf.short_name = "LoadUint64";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "uint64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.LoadUint64
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.LoadUint64";
    rf.short_name = "LoadUint64";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "uint64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.LoadUintptr
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.LoadUintptr";
    rf.short_name = "LoadUintptr";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "uintptr");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.noCopy.Lock
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.noCopy.Lock";
    rf.short_name = "Lock";
    rf.receiver_type = "sync/atomic.noCopy";
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Int32.Or
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Int32.Or";
    rf.short_name = "Or";
    rf.receiver_type = "sync/atomic.Int32";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int32");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Uint32.Or
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Uint32.Or";
    rf.short_name = "Or";
    rf.receiver_type = "sync/atomic.Uint32";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "uint32");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Int64.Or
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Int64.Or";
    rf.short_name = "Or";
    rf.receiver_type = "sync/atomic.Int64";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Uintptr.Or
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Uintptr.Or";
    rf.short_name = "Or";
    rf.receiver_type = "sync/atomic.Uintptr";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "uintptr");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Uint64.Or
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Uint64.Or";
    rf.short_name = "Or";
    rf.receiver_type = "sync/atomic.Uint64";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "uint64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.OrInt32
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.OrInt32";
    rf.short_name = "OrInt32";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int32");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.OrInt64
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.OrInt64";
    rf.short_name = "OrInt64";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.OrInt64
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.OrInt64";
    rf.short_name = "OrInt64";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.OrUint32
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.OrUint32";
    rf.short_name = "OrUint32";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "uint32");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.OrUint64
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.OrUint64";
    rf.short_name = "OrUint64";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "uint64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.OrUint64
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.OrUint64";
    rf.short_name = "OrUint64";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "uint64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.OrUintptr
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.OrUintptr";
    rf.short_name = "OrUintptr";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "uintptr");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Int32.Store
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Int32.Store";
    rf.short_name = "Store";
    rf.receiver_type = "sync/atomic.Int32";
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Bool.Store
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Bool.Store";
    rf.short_name = "Store";
    rf.receiver_type = "sync/atomic.Bool";
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Int64.Store
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Int64.Store";
    rf.short_name = "Store";
    rf.receiver_type = "sync/atomic.Int64";
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Uintptr.Store
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Uintptr.Store";
    rf.short_name = "Store";
    rf.receiver_type = "sync/atomic.Uintptr";
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Value.Store
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Value.Store";
    rf.short_name = "Store";
    rf.receiver_type = "sync/atomic.Value";
    cbm_registry_add_func(reg, rf);

    // sync/atomic.any.Store
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.any.Store";
    rf.short_name = "Store";
    rf.receiver_type = "sync/atomic.any";
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Uint64.Store
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Uint64.Store";
    rf.short_name = "Store";
    rf.receiver_type = "sync/atomic.Uint64";
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Uint32.Store
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Uint32.Store";
    rf.short_name = "Store";
    rf.receiver_type = "sync/atomic.Uint32";
    cbm_registry_add_func(reg, rf);

    // sync/atomic.StoreInt32
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.StoreInt32";
    rf.short_name = "StoreInt32";
    cbm_registry_add_func(reg, rf);

    // sync/atomic.StoreInt64
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.StoreInt64";
    rf.short_name = "StoreInt64";
    cbm_registry_add_func(reg, rf);

    // sync/atomic.StoreInt64
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.StoreInt64";
    rf.short_name = "StoreInt64";
    cbm_registry_add_func(reg, rf);

    // sync/atomic.StorePointer
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.StorePointer";
    rf.short_name = "StorePointer";
    cbm_registry_add_func(reg, rf);

    // sync/atomic.StoreUint32
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.StoreUint32";
    rf.short_name = "StoreUint32";
    cbm_registry_add_func(reg, rf);

    // sync/atomic.StoreUint64
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.StoreUint64";
    rf.short_name = "StoreUint64";
    cbm_registry_add_func(reg, rf);

    // sync/atomic.StoreUint64
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.StoreUint64";
    rf.short_name = "StoreUint64";
    cbm_registry_add_func(reg, rf);

    // sync/atomic.StoreUintptr
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.StoreUintptr";
    rf.short_name = "StoreUintptr";
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Uint64.Swap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Uint64.Swap";
    rf.short_name = "Swap";
    rf.receiver_type = "sync/atomic.Uint64";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "uint64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Uint32.Swap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Uint32.Swap";
    rf.short_name = "Swap";
    rf.receiver_type = "sync/atomic.Uint32";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "uint32");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Bool.Swap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Bool.Swap";
    rf.short_name = "Swap";
    rf.receiver_type = "sync/atomic.Bool";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Int64.Swap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Int64.Swap";
    rf.short_name = "Swap";
    rf.receiver_type = "sync/atomic.Int64";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.any.Swap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.any.Swap";
    rf.short_name = "Swap";
    rf.receiver_type = "sync/atomic.any";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "sync/atomic.T"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Int32.Swap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Int32.Swap";
    rf.short_name = "Swap";
    rf.receiver_type = "sync/atomic.Int32";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int32");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Uintptr.Swap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Uintptr.Swap";
    rf.short_name = "Swap";
    rf.receiver_type = "sync/atomic.Uintptr";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "uintptr");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.Value.Swap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.Value.Swap";
    rf.short_name = "Swap";
    rf.receiver_type = "sync/atomic.Value";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "any");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.SwapInt32
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.SwapInt32";
    rf.short_name = "SwapInt32";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int32");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.SwapInt64
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.SwapInt64";
    rf.short_name = "SwapInt64";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.SwapInt64
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.SwapInt64";
    rf.short_name = "SwapInt64";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.SwapPointer
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.SwapPointer";
    rf.short_name = "SwapPointer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "unsafe.Pointer");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.SwapUint32
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.SwapUint32";
    rf.short_name = "SwapUint32";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "uint32");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.SwapUint64
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.SwapUint64";
    rf.short_name = "SwapUint64";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "uint64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.SwapUint64
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.SwapUint64";
    rf.short_name = "SwapUint64";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "uint64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.SwapUintptr
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.SwapUintptr";
    rf.short_name = "SwapUintptr";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "uintptr");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // sync/atomic.noCopy.Unlock
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "sync/atomic.noCopy.Unlock";
    rf.short_name = "Unlock";
    rf.receiver_type = "sync/atomic.noCopy";
    cbm_registry_add_func(reg, rf);

    // testing.F.Add
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.F.Add";
    rf.short_name = "Add";
    rf.receiver_type = "testing.F";
    cbm_registry_add_func(reg, rf);

    // testing.BenchmarkResult.AllocedBytesPerOp
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.BenchmarkResult.AllocedBytesPerOp";
    rf.short_name = "AllocedBytesPerOp";
    rf.receiver_type = "testing.BenchmarkResult";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.BenchmarkResult.AllocsPerOp
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.BenchmarkResult.AllocsPerOp";
    rf.short_name = "AllocsPerOp";
    rf.receiver_type = "testing.BenchmarkResult";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.AllocsPerRun
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.AllocsPerRun";
    rf.short_name = "AllocsPerRun";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.common.ArtifactDir
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.common.ArtifactDir";
    rf.short_name = "ArtifactDir";
    rf.receiver_type = "testing.common";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.common.Attr
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.common.Attr";
    rf.short_name = "Attr";
    rf.receiver_type = "testing.common";
    cbm_registry_add_func(reg, rf);

    // testing.Benchmark
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.Benchmark";
    rf.short_name = "Benchmark";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "testing.BenchmarkResult");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.T.Chdir
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.T.Chdir";
    rf.short_name = "Chdir";
    rf.receiver_type = "testing.T";
    cbm_registry_add_func(reg, rf);

    // testing.common.Chdir
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.common.Chdir";
    rf.short_name = "Chdir";
    rf.receiver_type = "testing.common";
    cbm_registry_add_func(reg, rf);

    // testing.matchStringOnly.CheckCorpus
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.matchStringOnly.CheckCorpus";
    rf.short_name = "CheckCorpus";
    rf.receiver_type = "testing.matchStringOnly";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.common.Cleanup
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.common.Cleanup";
    rf.short_name = "Cleanup";
    rf.receiver_type = "testing.common";
    cbm_registry_add_func(reg, rf);

    // testing.common.Context
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.common.Context";
    rf.short_name = "Context";
    rf.receiver_type = "testing.common";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "context.Context");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.matchStringOnly.CoordinateFuzzing
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.matchStringOnly.CoordinateFuzzing";
    rf.short_name = "CoordinateFuzzing";
    rf.receiver_type = "testing.matchStringOnly";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.CoverMode
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.CoverMode";
    rf.short_name = "CoverMode";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.Coverage
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.Coverage";
    rf.short_name = "Coverage";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.T.Deadline
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.T.Deadline";
    rf.short_name = "Deadline";
    rf.receiver_type = "testing.T";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "time.Time");
        ret[1] = cbm_type_builtin(arena, "bool");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.B.Elapsed
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.B.Elapsed";
    rf.short_name = "Elapsed";
    rf.receiver_type = "testing.B";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "time.Duration");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.common.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.common.Error";
    rf.short_name = "Error";
    rf.receiver_type = "testing.common";
    cbm_registry_add_func(reg, rf);

    // testing.common.Errorf
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.common.Errorf";
    rf.short_name = "Errorf";
    rf.receiver_type = "testing.common";
    cbm_registry_add_func(reg, rf);

    // testing.common.Fail
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.common.Fail";
    rf.short_name = "Fail";
    rf.receiver_type = "testing.common";
    cbm_registry_add_func(reg, rf);

    // testing.F.Fail
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.F.Fail";
    rf.short_name = "Fail";
    rf.receiver_type = "testing.F";
    cbm_registry_add_func(reg, rf);

    // testing.common.FailNow
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.common.FailNow";
    rf.short_name = "FailNow";
    rf.receiver_type = "testing.common";
    cbm_registry_add_func(reg, rf);

    // testing.common.Failed
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.common.Failed";
    rf.short_name = "Failed";
    rf.receiver_type = "testing.common";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.common.Fatal
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.common.Fatal";
    rf.short_name = "Fatal";
    rf.receiver_type = "testing.common";
    cbm_registry_add_func(reg, rf);

    // testing.common.Fatalf
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.common.Fatalf";
    rf.short_name = "Fatalf";
    rf.receiver_type = "testing.common";
    cbm_registry_add_func(reg, rf);

    // testing.F.Fuzz
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.F.Fuzz";
    rf.short_name = "Fuzz";
    rf.receiver_type = "testing.F";
    cbm_registry_add_func(reg, rf);

    // testing.chattyFlag.Get
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.chattyFlag.Get";
    rf.short_name = "Get";
    rf.receiver_type = "testing.chattyFlag";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "any");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.common.Helper
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.common.Helper";
    rf.short_name = "Helper";
    rf.receiver_type = "testing.common";
    cbm_registry_add_func(reg, rf);

    // testing.F.Helper
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.F.Helper";
    rf.short_name = "Helper";
    rf.receiver_type = "testing.F";
    cbm_registry_add_func(reg, rf);

    // testing.matchStringOnly.ImportPath
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.matchStringOnly.ImportPath";
    rf.short_name = "ImportPath";
    rf.receiver_type = "testing.matchStringOnly";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.Init
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.Init";
    rf.short_name = "Init";
    cbm_registry_add_func(reg, rf);

    // testing.matchStringOnly.InitRuntimeCoverage
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.matchStringOnly.InitRuntimeCoverage";
    rf.short_name = "InitRuntimeCoverage";
    rf.receiver_type = "testing.matchStringOnly";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_named(arena, "testing.func()");
        ret[2] = cbm_type_named(arena, "testing.func()");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.chattyFlag.IsBoolFlag
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.chattyFlag.IsBoolFlag";
    rf.short_name = "IsBoolFlag";
    rf.receiver_type = "testing.chattyFlag";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.common.Log
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.common.Log";
    rf.short_name = "Log";
    rf.receiver_type = "testing.common";
    cbm_registry_add_func(reg, rf);

    // testing.common.Logf
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.common.Logf";
    rf.short_name = "Logf";
    rf.receiver_type = "testing.common";
    cbm_registry_add_func(reg, rf);

    // testing.B.Loop
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.B.Loop";
    rf.short_name = "Loop";
    rf.receiver_type = "testing.B";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.Main
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.Main";
    rf.short_name = "Main";
    cbm_registry_add_func(reg, rf);

    // testing.MainStart
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.MainStart";
    rf.short_name = "MainStart";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "testing.M"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.matchStringOnly.MatchString
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.matchStringOnly.MatchString";
    rf.short_name = "MatchString";
    rf.receiver_type = "testing.matchStringOnly";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.BenchmarkResult.MemString
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.BenchmarkResult.MemString";
    rf.short_name = "MemString";
    rf.receiver_type = "testing.BenchmarkResult";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.matchStringOnly.ModulePath
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.matchStringOnly.ModulePath";
    rf.short_name = "ModulePath";
    rf.receiver_type = "testing.matchStringOnly";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.common.Name
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.common.Name";
    rf.short_name = "Name";
    rf.receiver_type = "testing.common";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.PB.Next
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.PB.Next";
    rf.short_name = "Next";
    rf.receiver_type = "testing.PB";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.BenchmarkResult.NsPerOp
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.BenchmarkResult.NsPerOp";
    rf.short_name = "NsPerOp";
    rf.receiver_type = "testing.BenchmarkResult";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.common.Output
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.common.Output";
    rf.short_name = "Output";
    rf.receiver_type = "testing.common";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "io.Writer");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.T.Parallel
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.T.Parallel";
    rf.short_name = "Parallel";
    rf.receiver_type = "testing.T";
    cbm_registry_add_func(reg, rf);

    // testing.chattyPrinter.Printf
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.chattyPrinter.Printf";
    rf.short_name = "Printf";
    rf.receiver_type = "testing.chattyPrinter";
    cbm_registry_add_func(reg, rf);

    // testing.matchStringOnly.ReadCorpus
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.matchStringOnly.ReadCorpus";
    rf.short_name = "ReadCorpus";
    rf.receiver_type = "testing.matchStringOnly";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "testing.corpusEntry"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.RegisterCover
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.RegisterCover";
    rf.short_name = "RegisterCover";
    cbm_registry_add_func(reg, rf);

    // testing.B.ReportAllocs
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.B.ReportAllocs";
    rf.short_name = "ReportAllocs";
    rf.receiver_type = "testing.B";
    cbm_registry_add_func(reg, rf);

    // testing.B.ReportMetric
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.B.ReportMetric";
    rf.short_name = "ReportMetric";
    rf.receiver_type = "testing.B";
    cbm_registry_add_func(reg, rf);

    // testing.matchStringOnly.ResetCoverage
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.matchStringOnly.ResetCoverage";
    rf.short_name = "ResetCoverage";
    rf.receiver_type = "testing.matchStringOnly";
    cbm_registry_add_func(reg, rf);

    // testing.B.ResetTimer
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.B.ResetTimer";
    rf.short_name = "ResetTimer";
    rf.receiver_type = "testing.B";
    cbm_registry_add_func(reg, rf);

    // testing.M.Run
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.M.Run";
    rf.short_name = "Run";
    rf.receiver_type = "testing.M";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.T.Run
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.T.Run";
    rf.short_name = "Run";
    rf.receiver_type = "testing.T";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.B.Run
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.B.Run";
    rf.short_name = "Run";
    rf.receiver_type = "testing.B";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.RunBenchmarks
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.RunBenchmarks";
    rf.short_name = "RunBenchmarks";
    cbm_registry_add_func(reg, rf);

    // testing.RunExamples
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.RunExamples";
    rf.short_name = "RunExamples";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.matchStringOnly.RunFuzzWorker
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.matchStringOnly.RunFuzzWorker";
    rf.short_name = "RunFuzzWorker";
    rf.receiver_type = "testing.matchStringOnly";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.B.RunParallel
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.B.RunParallel";
    rf.short_name = "RunParallel";
    rf.receiver_type = "testing.B";
    cbm_registry_add_func(reg, rf);

    // testing.RunTests
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.RunTests";
    rf.short_name = "RunTests";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.chattyFlag.Set
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.chattyFlag.Set";
    rf.short_name = "Set";
    rf.receiver_type = "testing.chattyFlag";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.durationOrCountFlag.Set
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.durationOrCountFlag.Set";
    rf.short_name = "Set";
    rf.receiver_type = "testing.durationOrCountFlag";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.B.SetBytes
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.B.SetBytes";
    rf.short_name = "SetBytes";
    rf.receiver_type = "testing.B";
    cbm_registry_add_func(reg, rf);

    // testing.matchStringOnly.SetPanicOnExit0
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.matchStringOnly.SetPanicOnExit0";
    rf.short_name = "SetPanicOnExit0";
    rf.receiver_type = "testing.matchStringOnly";
    cbm_registry_add_func(reg, rf);

    // testing.B.SetParallelism
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.B.SetParallelism";
    rf.short_name = "SetParallelism";
    rf.receiver_type = "testing.B";
    cbm_registry_add_func(reg, rf);

    // testing.common.Setenv
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.common.Setenv";
    rf.short_name = "Setenv";
    rf.receiver_type = "testing.common";
    cbm_registry_add_func(reg, rf);

    // testing.T.Setenv
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.T.Setenv";
    rf.short_name = "Setenv";
    rf.receiver_type = "testing.T";
    cbm_registry_add_func(reg, rf);

    // testing.Short
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.Short";
    rf.short_name = "Short";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.common.Skip
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.common.Skip";
    rf.short_name = "Skip";
    rf.receiver_type = "testing.common";
    cbm_registry_add_func(reg, rf);

    // testing.common.SkipNow
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.common.SkipNow";
    rf.short_name = "SkipNow";
    rf.receiver_type = "testing.common";
    cbm_registry_add_func(reg, rf);

    // testing.common.Skipf
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.common.Skipf";
    rf.short_name = "Skipf";
    rf.receiver_type = "testing.common";
    cbm_registry_add_func(reg, rf);

    // testing.common.Skipped
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.common.Skipped";
    rf.short_name = "Skipped";
    rf.receiver_type = "testing.common";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.F.Skipped
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.F.Skipped";
    rf.short_name = "Skipped";
    rf.receiver_type = "testing.F";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.matchStringOnly.SnapshotCoverage
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.matchStringOnly.SnapshotCoverage";
    rf.short_name = "SnapshotCoverage";
    rf.receiver_type = "testing.matchStringOnly";
    cbm_registry_add_func(reg, rf);

    // testing.matchStringOnly.StartCPUProfile
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.matchStringOnly.StartCPUProfile";
    rf.short_name = "StartCPUProfile";
    rf.receiver_type = "testing.matchStringOnly";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.matchStringOnly.StartTestLog
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.matchStringOnly.StartTestLog";
    rf.short_name = "StartTestLog";
    rf.receiver_type = "testing.matchStringOnly";
    cbm_registry_add_func(reg, rf);

    // testing.B.StartTimer
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.B.StartTimer";
    rf.short_name = "StartTimer";
    rf.receiver_type = "testing.B";
    cbm_registry_add_func(reg, rf);

    // testing.matchStringOnly.StopCPUProfile
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.matchStringOnly.StopCPUProfile";
    rf.short_name = "StopCPUProfile";
    rf.receiver_type = "testing.matchStringOnly";
    cbm_registry_add_func(reg, rf);

    // testing.matchStringOnly.StopTestLog
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.matchStringOnly.StopTestLog";
    rf.short_name = "StopTestLog";
    rf.receiver_type = "testing.matchStringOnly";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.B.StopTimer
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.B.StopTimer";
    rf.short_name = "StopTimer";
    rf.receiver_type = "testing.B";
    cbm_registry_add_func(reg, rf);

    // testing.fuzzResult.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.fuzzResult.String";
    rf.short_name = "String";
    rf.receiver_type = "testing.fuzzResult";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.durationOrCountFlag.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.durationOrCountFlag.String";
    rf.short_name = "String";
    rf.receiver_type = "testing.durationOrCountFlag";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.BenchmarkResult.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.BenchmarkResult.String";
    rf.short_name = "String";
    rf.receiver_type = "testing.BenchmarkResult";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.chattyFlag.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.chattyFlag.String";
    rf.short_name = "String";
    rf.receiver_type = "testing.chattyFlag";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.common.TempDir
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.common.TempDir";
    rf.short_name = "TempDir";
    rf.receiver_type = "testing.common";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.Testing
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.Testing";
    rf.short_name = "Testing";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.chattyPrinter.Updatef
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.chattyPrinter.Updatef";
    rf.short_name = "Updatef";
    rf.receiver_type = "testing.chattyPrinter";
    cbm_registry_add_func(reg, rf);

    // testing.Verbose
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.Verbose";
    rf.short_name = "Verbose";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.outputWriter.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.outputWriter.Write";
    rf.short_name = "Write";
    rf.receiver_type = "testing.outputWriter";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.discard.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.discard.Write";
    rf.short_name = "Write";
    rf.receiver_type = "testing.discard";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.indenter.Write
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.indenter.Write";
    rf.short_name = "Write";
    rf.receiver_type = "testing.indenter";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // testing.matchStringOnly.WriteProfileTo
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "testing.matchStringOnly.WriteProfileTo";
    rf.short_name = "WriteProfileTo";
    rf.receiver_type = "testing.matchStringOnly";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // text/template.Template.AddParseTree
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "text/template.Template.AddParseTree";
    rf.short_name = "AddParseTree";
    rf.receiver_type = "text/template.Template";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "text/template.Template"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // text/template.Template.Clone
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "text/template.Template.Clone";
    rf.short_name = "Clone";
    rf.receiver_type = "text/template.Template";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "text/template.Template"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // text/template.Template.DefinedTemplates
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "text/template.Template.DefinedTemplates";
    rf.short_name = "DefinedTemplates";
    rf.receiver_type = "text/template.Template";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // text/template.Template.Delims
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "text/template.Template.Delims";
    rf.short_name = "Delims";
    rf.receiver_type = "text/template.Template";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "text/template.Template"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // text/template.ExecError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "text/template.ExecError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "text/template.ExecError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // text/template.Template.Execute
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "text/template.Template.Execute";
    rf.short_name = "Execute";
    rf.receiver_type = "text/template.Template";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // text/template.Template.ExecuteTemplate
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "text/template.Template.ExecuteTemplate";
    rf.short_name = "ExecuteTemplate";
    rf.receiver_type = "text/template.Template";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // text/template.Template.Funcs
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "text/template.Template.Funcs";
    rf.short_name = "Funcs";
    rf.receiver_type = "text/template.Template";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "text/template.Template"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // text/template.HTMLEscape
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "text/template.HTMLEscape";
    rf.short_name = "HTMLEscape";
    cbm_registry_add_func(reg, rf);

    // text/template.HTMLEscapeString
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "text/template.HTMLEscapeString";
    rf.short_name = "HTMLEscapeString";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // text/template.HTMLEscaper
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "text/template.HTMLEscaper";
    rf.short_name = "HTMLEscaper";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // text/template.IsTrue
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "text/template.IsTrue";
    rf.short_name = "IsTrue";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = cbm_type_builtin(arena, "bool");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // text/template.JSEscape
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "text/template.JSEscape";
    rf.short_name = "JSEscape";
    cbm_registry_add_func(reg, rf);

    // text/template.JSEscapeString
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "text/template.JSEscapeString";
    rf.short_name = "JSEscapeString";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // text/template.JSEscaper
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "text/template.JSEscaper";
    rf.short_name = "JSEscaper";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // text/template.Template.Lookup
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "text/template.Template.Lookup";
    rf.short_name = "Lookup";
    rf.receiver_type = "text/template.Template";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "text/template.Template"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // text/template.Must
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "text/template.Must";
    rf.short_name = "Must";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "text/template.Template"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // text/template.Template.Name
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "text/template.Template.Name";
    rf.short_name = "Name";
    rf.receiver_type = "text/template.Template";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // text/template.New
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "text/template.New";
    rf.short_name = "New";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "text/template.Template"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // text/template.Template.New
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "text/template.Template.New";
    rf.short_name = "New";
    rf.receiver_type = "text/template.Template";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "text/template.Template"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // text/template.Template.Option
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "text/template.Template.Option";
    rf.short_name = "Option";
    rf.receiver_type = "text/template.Template";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "text/template.Template"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // text/template.Template.Parse
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "text/template.Template.Parse";
    rf.short_name = "Parse";
    rf.receiver_type = "text/template.Template";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "text/template.Template"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // text/template.Template.ParseFS
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "text/template.Template.ParseFS";
    rf.short_name = "ParseFS";
    rf.receiver_type = "text/template.Template";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "text/template.Template"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // text/template.ParseFS
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "text/template.ParseFS";
    rf.short_name = "ParseFS";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "text/template.Template"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // text/template.Template.ParseFiles
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "text/template.Template.ParseFiles";
    rf.short_name = "ParseFiles";
    rf.receiver_type = "text/template.Template";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "text/template.Template"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // text/template.ParseFiles
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "text/template.ParseFiles";
    rf.short_name = "ParseFiles";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "text/template.Template"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // text/template.Template.ParseGlob
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "text/template.Template.ParseGlob";
    rf.short_name = "ParseGlob";
    rf.receiver_type = "text/template.Template";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "text/template.Template"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // text/template.ParseGlob
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "text/template.ParseGlob";
    rf.short_name = "ParseGlob";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "text/template.Template"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // text/template.Template.Templates
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "text/template.Template.Templates";
    rf.short_name = "Templates";
    rf.receiver_type = "text/template.Template";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_named(arena, "text/template.*Template"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // text/template.URLQueryEscaper
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "text/template.URLQueryEscaper";
    rf.short_name = "URLQueryEscaper";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // text/template.ExecError.Unwrap
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "text/template.ExecError.Unwrap";
    rf.short_name = "Unwrap";
    rf.receiver_type = "text/template.ExecError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Duration.Abs
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Duration.Abs";
    rf.short_name = "Abs";
    rf.receiver_type = "time.Duration";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "time.Duration");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.Add
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.Add";
    rf.short_name = "Add";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "time.Time");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.AddDate
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.AddDate";
    rf.short_name = "AddDate";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "time.Time");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.After
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.After";
    rf.short_name = "After";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.After
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.After";
    rf.short_name = "After";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "time.chan Time");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.AfterFunc
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.AfterFunc";
    rf.short_name = "AfterFunc";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "time.Timer"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.AppendBinary
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.AppendBinary";
    rf.short_name = "AppendBinary";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.AppendFormat
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.AppendFormat";
    rf.short_name = "AppendFormat";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.AppendText
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.AppendText";
    rf.short_name = "AppendText";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.Before
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.Before";
    rf.short_name = "Before";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.Clock
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.Clock";
    rf.short_name = "Clock";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "int");
        ret[2] = cbm_type_builtin(arena, "int");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.Compare
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.Compare";
    rf.short_name = "Compare";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.Date
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.Date";
    rf.short_name = "Date";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[4];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_named(arena, "time.Month");
        ret[2] = cbm_type_builtin(arena, "int");
        ret[3] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Date
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Date";
    rf.short_name = "Date";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "time.Time");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.Day
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.Day";
    rf.short_name = "Day";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.Equal
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.Equal";
    rf.short_name = "Equal";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.fileSizeError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.fileSizeError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "time.fileSizeError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.parseDurationError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.parseDurationError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "time.parseDurationError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.ParseError.Error
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.ParseError.Error";
    rf.short_name = "Error";
    rf.receiver_type = "time.ParseError";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.FixedZone
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.FixedZone";
    rf.short_name = "FixedZone";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "time.Location"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.Format
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.Format";
    rf.short_name = "Format";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.GoString
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.GoString";
    rf.short_name = "GoString";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.GobDecode
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.GobDecode";
    rf.short_name = "GobDecode";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.GobEncode
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.GobEncode";
    rf.short_name = "GobEncode";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.Hour
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.Hour";
    rf.short_name = "Hour";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Duration.Hours
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Duration.Hours";
    rf.short_name = "Hours";
    rf.receiver_type = "time.Duration";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.ISOWeek
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.ISOWeek";
    rf.short_name = "ISOWeek";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = cbm_type_builtin(arena, "int");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.In
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.In";
    rf.short_name = "In";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "time.Time");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.IsDST
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.IsDST";
    rf.short_name = "IsDST";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.IsZero
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.IsZero";
    rf.short_name = "IsZero";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.LoadLocation
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.LoadLocation";
    rf.short_name = "LoadLocation";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "time.Location"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.LoadLocationFromTZData
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.LoadLocationFromTZData";
    rf.short_name = "LoadLocationFromTZData";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "time.Location"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.Local
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.Local";
    rf.short_name = "Local";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "time.Time");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.Location
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.Location";
    rf.short_name = "Location";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "time.Location"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.MarshalBinary
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.MarshalBinary";
    rf.short_name = "MarshalBinary";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.MarshalJSON
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.MarshalJSON";
    rf.short_name = "MarshalJSON";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.MarshalText
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.MarshalText";
    rf.short_name = "MarshalText";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_slice(arena, cbm_type_builtin(arena, "byte"));
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Duration.Microseconds
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Duration.Microseconds";
    rf.short_name = "Microseconds";
    rf.receiver_type = "time.Duration";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Duration.Milliseconds
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Duration.Milliseconds";
    rf.short_name = "Milliseconds";
    rf.receiver_type = "time.Duration";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.Minute
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.Minute";
    rf.short_name = "Minute";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Duration.Minutes
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Duration.Minutes";
    rf.short_name = "Minutes";
    rf.receiver_type = "time.Duration";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.Month
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.Month";
    rf.short_name = "Month";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "time.Month");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.Nanosecond
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.Nanosecond";
    rf.short_name = "Nanosecond";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Duration.Nanoseconds
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Duration.Nanoseconds";
    rf.short_name = "Nanoseconds";
    rf.receiver_type = "time.Duration";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.NewTicker
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.NewTicker";
    rf.short_name = "NewTicker";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "time.Ticker"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.NewTimer
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.NewTimer";
    rf.short_name = "NewTimer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_pointer(arena, cbm_type_named(arena, "time.Timer"));
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Now
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Now";
    rf.short_name = "Now";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "time.Time");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Parse
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Parse";
    rf.short_name = "Parse";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "time.Time");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.ParseDuration
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.ParseDuration";
    rf.short_name = "ParseDuration";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "time.Duration");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.ParseInLocation
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.ParseInLocation";
    rf.short_name = "ParseInLocation";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "time.Time");
        ret[1] = cbm_type_builtin(arena, "error");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Ticker.Reset
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Ticker.Reset";
    rf.short_name = "Reset";
    rf.receiver_type = "time.Ticker";
    cbm_registry_add_func(reg, rf);

    // time.Timer.Reset
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Timer.Reset";
    rf.short_name = "Reset";
    rf.receiver_type = "time.Timer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.Round
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.Round";
    rf.short_name = "Round";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "time.Time");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Duration.Round
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Duration.Round";
    rf.short_name = "Round";
    rf.receiver_type = "time.Duration";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "time.Duration");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.Second
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.Second";
    rf.short_name = "Second";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Duration.Seconds
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Duration.Seconds";
    rf.short_name = "Seconds";
    rf.receiver_type = "time.Duration";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "float64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Since
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Since";
    rf.short_name = "Since";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "time.Duration");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Sleep
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Sleep";
    rf.short_name = "Sleep";
    cbm_registry_add_func(reg, rf);

    // time.Timer.Stop
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Timer.Stop";
    rf.short_name = "Stop";
    rf.receiver_type = "time.Timer";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Ticker.Stop
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Ticker.Stop";
    rf.short_name = "Stop";
    rf.receiver_type = "time.Ticker";
    cbm_registry_add_func(reg, rf);

    // time.Duration.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Duration.String";
    rf.short_name = "String";
    rf.receiver_type = "time.Duration";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Location.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Location.String";
    rf.short_name = "String";
    rf.receiver_type = "time.Location";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Weekday.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Weekday.String";
    rf.short_name = "String";
    rf.receiver_type = "time.Weekday";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.String";
    rf.short_name = "String";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Month.String
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Month.String";
    rf.short_name = "String";
    rf.receiver_type = "time.Month";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.Sub
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.Sub";
    rf.short_name = "Sub";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "time.Duration");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Tick
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Tick";
    rf.short_name = "Tick";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "time.chan Time");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Duration.Truncate
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Duration.Truncate";
    rf.short_name = "Truncate";
    rf.receiver_type = "time.Duration";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "time.Duration");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.Truncate
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.Truncate";
    rf.short_name = "Truncate";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "time.Time");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.UTC
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.UTC";
    rf.short_name = "UTC";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "time.Time");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Unix
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Unix";
    rf.short_name = "Unix";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "time.Time");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.Unix
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.Unix";
    rf.short_name = "Unix";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.UnixMicro
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.UnixMicro";
    rf.short_name = "UnixMicro";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "time.Time");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.UnixMicro
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.UnixMicro";
    rf.short_name = "UnixMicro";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.UnixMilli
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.UnixMilli";
    rf.short_name = "UnixMilli";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.UnixMilli
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.UnixMilli";
    rf.short_name = "UnixMilli";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "time.Time");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.UnixNano
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.UnixNano";
    rf.short_name = "UnixNano";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int64");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.UnmarshalBinary
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.UnmarshalBinary";
    rf.short_name = "UnmarshalBinary";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.UnmarshalJSON
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.UnmarshalJSON";
    rf.short_name = "UnmarshalJSON";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.UnmarshalText
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.UnmarshalText";
    rf.short_name = "UnmarshalText";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "error");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Until
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Until";
    rf.short_name = "Until";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "time.Duration");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.Weekday
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.Weekday";
    rf.short_name = "Weekday";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_named(arena, "time.Weekday");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.Year
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.Year";
    rf.short_name = "Year";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.YearDay
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.YearDay";
    rf.short_name = "YearDay";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "int");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.Zone
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.Zone";
    rf.short_name = "Zone";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_builtin(arena, "string");
        ret[1] = cbm_type_builtin(arena, "int");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // time.Time.ZoneBounds
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "time.Time.ZoneBounds";
    rf.short_name = "ZoneBounds";
    rf.receiver_type = "time.Time";
    {
        const CBMType* ret[3];
        ret[0] = cbm_type_named(arena, "time.Time");
        ret[1] = cbm_type_named(arena, "time.Time");
        ret[2] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // unicode.In
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unicode.In";
    rf.short_name = "In";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // unicode.Is
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unicode.Is";
    rf.short_name = "Is";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // unicode.IsControl
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unicode.IsControl";
    rf.short_name = "IsControl";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // unicode.IsDigit
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unicode.IsDigit";
    rf.short_name = "IsDigit";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // unicode.IsGraphic
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unicode.IsGraphic";
    rf.short_name = "IsGraphic";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // unicode.IsLetter
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unicode.IsLetter";
    rf.short_name = "IsLetter";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // unicode.IsLower
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unicode.IsLower";
    rf.short_name = "IsLower";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // unicode.IsMark
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unicode.IsMark";
    rf.short_name = "IsMark";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // unicode.IsNumber
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unicode.IsNumber";
    rf.short_name = "IsNumber";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // unicode.IsOneOf
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unicode.IsOneOf";
    rf.short_name = "IsOneOf";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // unicode.IsPrint
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unicode.IsPrint";
    rf.short_name = "IsPrint";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // unicode.IsPunct
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unicode.IsPunct";
    rf.short_name = "IsPunct";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // unicode.IsSpace
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unicode.IsSpace";
    rf.short_name = "IsSpace";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // unicode.IsSymbol
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unicode.IsSymbol";
    rf.short_name = "IsSymbol";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // unicode.IsTitle
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unicode.IsTitle";
    rf.short_name = "IsTitle";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // unicode.IsUpper
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unicode.IsUpper";
    rf.short_name = "IsUpper";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "bool");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // unicode.SimpleFold
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unicode.SimpleFold";
    rf.short_name = "SimpleFold";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "rune");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // unicode.To
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unicode.To";
    rf.short_name = "To";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "rune");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // unicode.ToLower
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unicode.ToLower";
    rf.short_name = "ToLower";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "rune");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // unicode.SpecialCase.ToLower
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unicode.SpecialCase.ToLower";
    rf.short_name = "ToLower";
    rf.receiver_type = "unicode.SpecialCase";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "rune");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // unicode.ToTitle
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unicode.ToTitle";
    rf.short_name = "ToTitle";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "rune");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // unicode.SpecialCase.ToTitle
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unicode.SpecialCase.ToTitle";
    rf.short_name = "ToTitle";
    rf.receiver_type = "unicode.SpecialCase";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "rune");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // unicode.ToUpper
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unicode.ToUpper";
    rf.short_name = "ToUpper";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "rune");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

    // unicode.SpecialCase.ToUpper
    memset(&rf, 0, sizeof(rf));
    rf.qualified_name = "unicode.SpecialCase.ToUpper";
    rf.short_name = "ToUpper";
    rf.receiver_type = "unicode.SpecialCase";
    {
        const CBMType* ret[2];
        ret[0] = cbm_type_builtin(arena, "rune");
        ret[1] = NULL;
        rf.signature = cbm_type_func(arena, NULL, NULL, ret);
    }
    cbm_registry_add_func(reg, rf);

}