From cef87c6a932e8e1d82d7d4262efc21a9741a22fd Mon Sep 17 00:00:00 2001 From: James Craig Burley <430319+jcburley@users.noreply.github.com> Date: Fri, 6 Jan 2023 23:08:32 -0500 Subject: [PATCH] Update amd64-windows tests --- .../gold/go1.19/amd64-windows/gosrc.gold | 9466 ++++++++--------- 1 file changed, 4620 insertions(+), 4846 deletions(-) diff --git a/tools/gostd/_tests/gold/go1.19/amd64-windows/gosrc.gold b/tools/gostd/_tests/gold/go1.19/amd64-windows/gosrc.gold index e0e2cb68..1b5d82e4 100644 --- a/tools/gostd/_tests/gold/go1.19/amd64-windows/gosrc.gold +++ b/tools/gostd/_tests/gold/go1.19/amd64-windows/gosrc.gold @@ -2645,14 +2645,14 @@ Processing unicode: Processing unsafe: Adding 150 custom imports to g_custom.go Adding 150 custom loaded libraries to core\data\g_customlibs.joke -Adding only 3097 types (out of 3100) to core\g_goswitch.go +Adding only 3094 types (out of 3097) to core\g_goswitch.go ABENDs: 727(253) 707(213) 708(179) 007(50) 777(41) 122(26) 121(13) 674(8) 171(7) 444(7) 749(4) 049(2) 750(2) 748(1) 787(1) Totals: functions=4781 generated=4538 (94.92%) non-receivers=1653 (34.57%) generated=1463 (88.51%) receivers=2323 (48.59%) generated=2276 (97.98%) methods=805 (16.84%) generated=799 (99.25%) - types=3029 - constructable=853 ctors=724 (84.88%) + types=3026 + constructable=852 ctors=723 (84.86%) constants=3234 generated=3234 (100.00%) variables=445 generated=445 (100.00%) -------- BEGIN _tests/gold/go1.19/amd64-windows/joker/core/data/g_customlibs.joke: @@ -2949,7 +2949,7 @@ import ( "unsafe" ) -var GoTypesVec [3097]*Type +var GoTypesVec [3094]*Type func SwitchGoType(g interface{}) int { switch g.(type) { @@ -4455,4684 +4455,4678 @@ func SwitchGoType(g interface{}) int { return 749 case *atomic.Int64: return 750 - case *atomic.Pointer: - return 751 case *atomic.Uint32: - return 752 + return 751 case *atomic.Uint64: - return 753 + return 752 case *atomic.Uintptr: - return 754 + return 753 case *atomic.Value: - return 755 + return 754 case *syscall.AddrinfoW: - return 756 + return 755 case *syscall.ByHandleFileInformation: - return 757 + return 756 case *syscall.CertChainContext: - return 758 + return 757 case *syscall.CertChainElement: - return 759 + return 758 case *syscall.CertChainPara: - return 760 + return 759 case *syscall.CertChainPolicyPara: - return 761 + return 760 case *syscall.CertChainPolicyStatus: - return 762 + return 761 case *syscall.CertContext: - return 763 + return 762 case *syscall.CertEnhKeyUsage: - return 764 + return 763 case *syscall.CertInfo: - return 765 + return 764 case *syscall.CertRevocationCrlInfo: - return 766 + return 765 case *syscall.CertRevocationInfo: - return 767 + return 766 case *syscall.CertSimpleChain: - return 768 + return 767 case *syscall.CertTrustListInfo: - return 769 + return 768 case *syscall.CertTrustStatus: - return 770 + return 769 case *syscall.CertUsageMatch: - return 771 + return 770 case *syscall.DLL: - return 772 + return 771 case *syscall.DLLError: - return 773 + return 772 case *syscall.DNSMXData: - return 774 + return 773 case *syscall.DNSPTRData: - return 775 + return 774 case *syscall.DNSRecord: - return 776 + return 775 case *syscall.DNSSRVData: - return 777 + return 776 case *syscall.DNSTXTData: - return 778 + return 777 case *syscall.Errno: - return 779 + return 778 case *syscall.FileNotifyInformation: - return 780 + return 779 case *syscall.Filetime: - return 781 + return 780 case *syscall.GUID: - return 782 + return 781 case *syscall.Handle: - return 783 + return 782 case *syscall.Hostent: - return 784 + return 783 case *syscall.IPMreq: - return 785 + return 784 case *syscall.IPv6Mreq: - return 786 + return 785 case *syscall.InterfaceInfo: - return 787 + return 786 case *syscall.IpAdapterInfo: - return 788 + return 787 case *syscall.IpAddrString: - return 789 + return 788 case *syscall.IpAddressString: - return 790 + return 789 case *syscall.IpMaskString: - return 791 + return 790 case *syscall.LazyDLL: - return 792 + return 791 case *syscall.LazyProc: - return 793 + return 792 case *syscall.Linger: - return 794 + return 793 case *syscall.MibIfRow: - return 795 + return 794 case *syscall.Overlapped: - return 796 + return 795 case *syscall.Pointer: - return 797 + return 796 case *syscall.Proc: - return 798 + return 797 case *syscall.ProcAttr: - return 799 + return 798 case *syscall.ProcessEntry32: - return 800 + return 799 case *syscall.ProcessInformation: - return 801 + return 800 case *syscall.Protoent: - return 802 + return 801 case *syscall.RawSockaddr: - return 803 + return 802 case *syscall.RawSockaddrAny: - return 804 + return 803 case *syscall.RawSockaddrInet4: - return 805 + return 804 case *syscall.RawSockaddrInet6: - return 806 + return 805 case *syscall.RawSockaddrUnix: - return 807 + return 806 case *syscall.Rusage: - return 808 + return 807 case *syscall.SID: - return 809 + return 808 case *syscall.SIDAndAttributes: - return 810 + return 809 case *syscall.SSLExtraCertChainPolicyPara: - return 811 + return 810 case *syscall.SecurityAttributes: - return 812 + return 811 case *syscall.Servent: - return 813 + return 812 case *syscall.Signal: - return 814 + return 813 case *syscall.SockaddrGen: - return 815 + return 814 case *syscall.SockaddrInet4: - return 816 + return 815 case *syscall.SockaddrInet6: - return 817 + return 816 case *syscall.SockaddrUnix: - return 818 + return 817 case *syscall.StartupInfo: - return 819 + return 818 case *syscall.SysProcAttr: - return 820 + return 819 case *syscall.Systemtime: - return 821 + return 820 case *syscall.TCPKeepalive: - return 822 + return 821 case *syscall.Timespec: - return 823 + return 822 case *syscall.Timeval: - return 824 + return 823 case *syscall.Timezoneinformation: - return 825 + return 824 case *syscall.Token: - return 826 + return 825 case *syscall.Tokenprimarygroup: - return 827 + return 826 case *syscall.Tokenuser: - return 828 + return 827 case *syscall.TransmitFileBuffers: - return 829 + return 828 case *syscall.UserInfo10: - return 830 + return 829 case *syscall.WSABuf: - return 831 + return 830 case *syscall.WSAData: - return 832 + return 831 case *syscall.WSAProtocolChain: - return 833 + return 832 case *syscall.WSAProtocolInfo: - return 834 + return 833 case *syscall.WaitStatus: - return 835 + return 834 case *syscall.Win32FileAttributeData: - return 836 + return 835 case *syscall.Win32finddata: - return 837 + return 836 case *testing.B: - return 838 + return 837 case *testing.BenchmarkResult: - return 839 + return 838 case *testing.Cover: - return 840 + return 839 case *testing.CoverBlock: - return 841 + return 840 case *testing.F: - return 842 + return 841 case *testing.InternalBenchmark: - return 843 + return 842 case *testing.InternalExample: - return 844 + return 843 case *testing.InternalFuzzTarget: - return 845 + return 844 case *testing.InternalTest: - return 846 + return 845 case *testing.M: - return 847 + return 846 case *testing.PB: - return 848 + return 847 case *testing.T: - return 849 + return 848 case *fstest.MapFS: - return 850 + return 849 case *fstest.MapFile: - return 851 + return 850 case *quick.CheckEqualError: - return 852 + return 851 case *quick.CheckError: - return 853 + return 852 case *quick.Config: - return 854 + return 853 case *quick.SetupError: - return 855 + return 854 case *text_scanner.Position: - return 856 + return 855 case *text_scanner.Scanner: - return 857 + return 856 case *tabwriter.Writer: - return 858 + return 857 case *text_template.ExecError: - return 859 + return 858 case *text_template.FuncMap: - return 860 + return 859 case *text_template.Template: - return 861 + return 860 case *parse.ActionNode: - return 862 + return 861 case *parse.BoolNode: - return 863 + return 862 case *parse.BranchNode: - return 864 + return 863 case *parse.BreakNode: - return 865 + return 864 case *parse.ChainNode: - return 866 + return 865 case *parse.CommandNode: - return 867 + return 866 case *parse.CommentNode: - return 868 + return 867 case *parse.ContinueNode: - return 869 + return 868 case *parse.DotNode: - return 870 + return 869 case *parse.FieldNode: - return 871 + return 870 case *parse.IdentifierNode: - return 872 + return 871 case *parse.IfNode: - return 873 + return 872 case *parse.ListNode: - return 874 + return 873 case *parse.Mode: - return 875 + return 874 case *parse.NilNode: - return 876 + return 875 case *parse.NodeType: - return 877 + return 876 case *parse.NumberNode: - return 878 + return 877 case *parse.PipeNode: - return 879 + return 878 case *parse.Pos: - return 880 + return 879 case *parse.RangeNode: - return 881 + return 880 case *parse.StringNode: - return 882 + return 881 case *parse.TemplateNode: - return 883 + return 882 case *parse.TextNode: - return 884 + return 883 case *parse.Tree: - return 885 + return 884 case *parse.VariableNode: - return 886 + return 885 case *parse.WithNode: - return 887 + return 886 case *time.Duration: - return 888 + return 887 case *time.Location: - return 889 + return 888 case *time.Month: - return 890 + return 889 case *time.ParseError: - return 891 + return 890 case *time.Ticker: - return 892 + return 891 case *time.Time: - return 893 + return 892 case *time.Timer: - return 894 + return 893 case *time.Weekday: - return 895 + return 894 case *unicode.CaseRange: - return 896 + return 895 case *unicode.Range16: - return 897 + return 896 case *unicode.Range32: - return 898 + return 897 case *unicode.RangeTable: - return 899 + return 898 case *unicode.SpecialCase: - return 900 + return 899 case *unsafe.Pointer: - return 901 + return 900 case <-chan time.Time: - return 902 + return 901 case [16]pe.DataDirectory: - return 903 + return 902 case [1]*syntax.Regexp: - return 904 + return 903 case [4]crc32.Table: - return 905 + return 904 case [8]crc32.Table: - return 906 + return 905 case []*zip.File: - return 907 + return 906 case []*tls.CipherSuite: - return 908 + return 907 case []*x509.Certificate: - return 909 + return 908 case []*sql.ColumnType: - return 910 + return 909 case []*dwarf.EnumValue: - return 911 + return 910 case []*dwarf.LineFile: - return 912 + return 911 case []*dwarf.StructField: - return 913 + return 912 case []*elf.Prog: - return 914 + return 913 case []*elf.Section: - return 915 + return 914 case []*gosym.Sym: - return 916 + return 915 case []*macho.Section: - return 917 + return 916 case []*pe.Section: - return 918 + return 917 case []*pe.Symbol: - return 919 + return 918 case []*plan9obj.Section: - return 920 + return 919 case []*ast.Comment: - return 921 + return 920 case []*ast.CommentGroup: - return 922 + return 921 case []*ast.Field: - return 923 + return 922 case []*ast.File: - return 924 + return 923 case []*ast.Ident: - return 925 + return 924 case []*ast.ImportSpec: - return 926 + return 925 case []*doc.Example: - return 927 + return 926 case []*doc.Func: - return 928 + return 927 case []*doc.Note: - return 929 + return 928 case []*doc.Type: - return 930 + return 929 case []*doc.Value: - return 931 + return 930 case []*comment.LinkDef: - return 932 + return 931 case []*comment.ListItem: - return 933 + return 932 case []*scanner.Error: - return 934 + return 933 case []*types.Func: - return 935 + return 934 case []*types.Initializer: - return 936 + return 935 case []*types.Named: - return 937 + return 936 case []*types.Package: - return 938 + return 937 case []*types.Term: - return 939 + return 938 case []*types.TypeParam: - return 940 + return 939 case []*types.Var: - return 941 + return 940 case []*template.Template: - return 942 + return 941 case []*image.Paletted: - return 943 + return 942 case []*big.Int: - return 944 + return 943 case []*multipart.FileHeader: - return 945 + return 944 case []*net.IPNet: - return 946 + return 945 case []*net.MX: - return 947 + return 946 case []*net.NS: - return 948 + return 947 case []*net.SRV: - return 949 + return 948 case []*http.Cookie: - return 950 + return 949 case []*mail.Address: - return 951 + return 950 case []*url.URL: - return 952 + return 951 case []*os.File: - return 953 + return 952 case []*syntax.Regexp: - return 954 + return 953 case []*debug.Module: - return 955 + return 954 case []*pprof.Profile: - return 956 + return 955 case []*text_template.Template: - return 957 + return 956 case []*parse.CommandNode: - return 958 + return 957 case []*parse.VariableNode: - return 959 + return 958 case []*unicode.RangeTable: - return 960 + return 959 case [][]*x509.Certificate: - return 961 + return 960 case [][]pkix.AttributeTypeAndValue: - return 962 + return 961 case []tar.Format: - return 963 + return 962 case []tar.Header: - return 964 + return 963 case []tar.Reader: - return 965 + return 964 case []tar.Writer: - return 966 + return 965 case []zip.Compressor: - return 967 + return 966 case []zip.Decompressor: - return 968 + return 967 case []zip.File: - return 969 + return 968 case []zip.FileHeader: - return 970 + return 969 case []zip.ReadCloser: - return 971 + return 970 case []zip.Reader: - return 972 + return 971 case []zip.Writer: - return 973 + return 972 case []bufio.ReadWriter: - return 974 + return 973 case []bufio.Reader: - return 975 + return 974 case []bufio.Scanner: - return 976 + return 975 case []bufio.SplitFunc: - return 977 + return 976 case []bufio.Writer: - return 978 + return 977 case []bytes.Buffer: - return 979 + return 978 case []bytes.Reader: - return 980 + return 979 case []bzip2.StructuralError: - return 981 + return 980 case []flate.CorruptInputError: - return 982 + return 981 case []flate.InternalError: - return 983 + return 982 case []flate.ReadError: - return 984 + return 983 case []flate.Reader: - return 985 + return 984 case []flate.Resetter: - return 986 + return 985 case []flate.WriteError: - return 987 + return 986 case []flate.Writer: - return 988 + return 987 case []gzip.Header: - return 989 + return 988 case []gzip.Reader: - return 990 + return 989 case []gzip.Writer: - return 991 + return 990 case []lzw.Order: - return 992 + return 991 case []lzw.Reader: - return 993 + return 992 case []lzw.Writer: - return 994 + return 993 case []zlib.Resetter: - return 995 + return 994 case []zlib.Writer: - return 996 + return 995 case []heap.Interface: - return 997 + return 996 case []list.Element: - return 998 + return 997 case []list.List: - return 999 + return 998 case []ring.Ring: - return 1000 + return 999 case []context.CancelFunc: - return 1001 + return 1000 case []context.Context: - return 1002 + return 1001 case []crypto.Decrypter: - return 1003 + return 1002 case []crypto.DecrypterOpts: - return 1004 + return 1003 case []crypto.Hash: - return 1005 + return 1004 case []crypto.PrivateKey: - return 1006 + return 1005 case []crypto.PublicKey: - return 1007 + return 1006 case []crypto.Signer: - return 1008 + return 1007 case []crypto.SignerOpts: - return 1009 + return 1008 case []aes.KeySizeError: - return 1010 + return 1009 case []cipher.AEAD: - return 1011 + return 1010 case []cipher.Block: - return 1012 + return 1011 case []cipher.BlockMode: - return 1013 + return 1012 case []cipher.Stream: - return 1014 + return 1013 case []cipher.StreamReader: - return 1015 + return 1014 case []cipher.StreamWriter: - return 1016 + return 1015 case []des.KeySizeError: - return 1017 + return 1016 case []dsa.ParameterSizes: - return 1018 + return 1017 case []dsa.Parameters: - return 1019 + return 1018 case []dsa.PrivateKey: - return 1020 + return 1019 case []dsa.PublicKey: - return 1021 + return 1020 case []ecdsa.PrivateKey: - return 1022 + return 1021 case []ecdsa.PublicKey: - return 1023 + return 1022 case []ed25519.PrivateKey: - return 1024 + return 1023 case []ed25519.PublicKey: - return 1025 + return 1024 case []elliptic.Curve: - return 1026 + return 1025 case []elliptic.CurveParams: - return 1027 + return 1026 case []rc4.Cipher: - return 1028 + return 1027 case []rc4.KeySizeError: - return 1029 + return 1028 case []rsa.CRTValue: - return 1030 + return 1029 case []rsa.OAEPOptions: - return 1031 + return 1030 case []rsa.PKCS1v15DecryptOptions: - return 1032 + return 1031 case []rsa.PSSOptions: - return 1033 + return 1032 case []rsa.PrecomputedValues: - return 1034 + return 1033 case []rsa.PrivateKey: - return 1035 + return 1034 case []rsa.PublicKey: - return 1036 + return 1035 case []tls.Certificate: - return 1037 + return 1036 case []tls.CertificateRequestInfo: - return 1038 + return 1037 case []tls.CipherSuite: - return 1039 + return 1038 case []tls.ClientAuthType: - return 1040 + return 1039 case []tls.ClientHelloInfo: - return 1041 + return 1040 case []tls.ClientSessionCache: - return 1042 + return 1041 case []tls.ClientSessionState: - return 1043 + return 1042 case []tls.Config: - return 1044 + return 1043 case []tls.Conn: - return 1045 + return 1044 case []tls.ConnectionState: - return 1046 + return 1045 case []tls.CurveID: - return 1047 + return 1046 case []tls.Dialer: - return 1048 + return 1047 case []tls.RecordHeaderError: - return 1049 + return 1048 case []tls.RenegotiationSupport: - return 1050 + return 1049 case []tls.SignatureScheme: - return 1051 + return 1050 case []x509.CertPool: - return 1052 + return 1051 case []x509.Certificate: - return 1053 + return 1052 case []x509.CertificateInvalidError: - return 1054 + return 1053 case []x509.CertificateRequest: - return 1055 + return 1054 case []x509.ConstraintViolationError: - return 1056 + return 1055 case []x509.ExtKeyUsage: - return 1057 + return 1056 case []x509.HostnameError: - return 1058 + return 1057 case []x509.InsecureAlgorithmError: - return 1059 + return 1058 case []x509.InvalidReason: - return 1060 + return 1059 case []x509.KeyUsage: - return 1061 + return 1060 case []x509.PEMCipher: - return 1062 + return 1061 case []x509.PublicKeyAlgorithm: - return 1063 + return 1062 case []x509.RevocationList: - return 1064 + return 1063 case []x509.SignatureAlgorithm: - return 1065 + return 1064 case []x509.SystemRootsError: - return 1066 + return 1065 case []x509.UnhandledCriticalExtension: - return 1067 + return 1066 case []x509.UnknownAuthorityError: - return 1068 + return 1067 case []x509.VerifyOptions: - return 1069 + return 1068 case []pkix.AlgorithmIdentifier: - return 1070 + return 1069 case []pkix.AttributeTypeAndValue: - return 1071 + return 1070 case []pkix.AttributeTypeAndValueSET: - return 1072 + return 1071 case []pkix.CertificateList: - return 1073 + return 1072 case []pkix.Extension: - return 1074 + return 1073 case []pkix.Name: - return 1075 + return 1074 case []pkix.RDNSequence: - return 1076 + return 1075 case []pkix.RelativeDistinguishedNameSET: - return 1077 + return 1076 case []pkix.RevokedCertificate: - return 1078 + return 1077 case []pkix.TBSCertificateList: - return 1079 + return 1078 case []sql.ColumnType: - return 1080 + return 1079 case []sql.Conn: - return 1081 + return 1080 case []sql.DB: - return 1082 + return 1081 case []sql.DBStats: - return 1083 + return 1082 case []sql.IsolationLevel: - return 1084 + return 1083 case []sql.NamedArg: - return 1085 + return 1084 case []sql.NullBool: - return 1086 + return 1085 case []sql.NullByte: - return 1087 + return 1086 case []sql.NullFloat64: - return 1088 + return 1087 case []sql.NullInt16: - return 1089 + return 1088 case []sql.NullInt32: - return 1090 + return 1089 case []sql.NullInt64: - return 1091 + return 1090 case []sql.NullString: - return 1092 + return 1091 case []sql.NullTime: - return 1093 + return 1092 case []sql.Out: - return 1094 + return 1093 case []sql.RawBytes: - return 1095 + return 1094 case []sql.Result: - return 1096 + return 1095 case []sql.Row: - return 1097 + return 1096 case []sql.Rows: - return 1098 + return 1097 case []sql.Scanner: - return 1099 + return 1098 case []sql.Stmt: - return 1100 + return 1099 case []sql.Tx: - return 1101 + return 1100 case []sql.TxOptions: - return 1102 + return 1101 case []driver.ColumnConverter: - return 1103 + return 1102 case []driver.Conn: - return 1104 + return 1103 case []driver.ConnBeginTx: - return 1105 + return 1104 case []driver.ConnPrepareContext: - return 1106 + return 1105 case []driver.Connector: - return 1107 + return 1106 case []driver.Driver: - return 1108 + return 1107 case []driver.DriverContext: - return 1109 + return 1108 case []driver.Execer: - return 1110 + return 1109 case []driver.ExecerContext: - return 1111 + return 1110 case []driver.IsolationLevel: - return 1112 + return 1111 case []driver.NamedValue: - return 1113 + return 1112 case []driver.NamedValueChecker: - return 1114 + return 1113 case []driver.NotNull: - return 1115 + return 1114 case []driver.Null: - return 1116 + return 1115 case []driver.Pinger: - return 1117 + return 1116 case []driver.Queryer: - return 1118 + return 1117 case []driver.QueryerContext: - return 1119 + return 1118 case []driver.Result: - return 1120 + return 1119 case []driver.Rows: - return 1121 + return 1120 case []driver.RowsAffected: - return 1122 + return 1121 case []driver.RowsColumnTypeDatabaseTypeName: - return 1123 + return 1122 case []driver.RowsColumnTypeLength: - return 1124 + return 1123 case []driver.RowsColumnTypeNullable: - return 1125 + return 1124 case []driver.RowsColumnTypePrecisionScale: - return 1126 + return 1125 case []driver.RowsColumnTypeScanType: - return 1127 + return 1126 case []driver.RowsNextResultSet: - return 1128 + return 1127 case []driver.SessionResetter: - return 1129 + return 1128 case []driver.Stmt: - return 1130 + return 1129 case []driver.StmtExecContext: - return 1131 + return 1130 case []driver.StmtQueryContext: - return 1132 + return 1131 case []driver.Tx: - return 1133 + return 1132 case []driver.TxOptions: - return 1134 + return 1133 case []driver.Validator: - return 1135 + return 1134 case []driver.Value: - return 1136 + return 1135 case []driver.ValueConverter: - return 1137 + return 1136 case []driver.Valuer: - return 1138 + return 1137 case []dwarf.AddrType: - return 1139 + return 1138 case []dwarf.ArrayType: - return 1140 + return 1139 case []dwarf.Attr: - return 1141 + return 1140 case []dwarf.BasicType: - return 1142 + return 1141 case []dwarf.BoolType: - return 1143 + return 1142 case []dwarf.CharType: - return 1144 + return 1143 case []dwarf.Class: - return 1145 + return 1144 case []dwarf.CommonType: - return 1146 + return 1145 case []dwarf.ComplexType: - return 1147 + return 1146 case []dwarf.Data: - return 1148 + return 1147 case []dwarf.DecodeError: - return 1149 + return 1148 case []dwarf.DotDotDotType: - return 1150 + return 1149 case []dwarf.Entry: - return 1151 + return 1150 case []dwarf.EnumType: - return 1152 + return 1151 case []dwarf.EnumValue: - return 1153 + return 1152 case []dwarf.Field: - return 1154 + return 1153 case []dwarf.FloatType: - return 1155 + return 1154 case []dwarf.FuncType: - return 1156 + return 1155 case []dwarf.IntType: - return 1157 + return 1156 case []dwarf.LineEntry: - return 1158 + return 1157 case []dwarf.LineFile: - return 1159 + return 1158 case []dwarf.LineReader: - return 1160 + return 1159 case []dwarf.LineReaderPos: - return 1161 + return 1160 case []dwarf.Offset: - return 1162 + return 1161 case []dwarf.PtrType: - return 1163 + return 1162 case []dwarf.QualType: - return 1164 + return 1163 case []dwarf.Reader: - return 1165 + return 1164 case []dwarf.StructField: - return 1166 + return 1165 case []dwarf.StructType: - return 1167 + return 1166 case []dwarf.Tag: - return 1168 + return 1167 case []dwarf.Type: - return 1169 + return 1168 case []dwarf.TypedefType: - return 1170 + return 1169 case []dwarf.UcharType: - return 1171 + return 1170 case []dwarf.UintType: - return 1172 + return 1171 case []dwarf.UnspecifiedType: - return 1173 + return 1172 case []dwarf.UnsupportedType: - return 1174 + return 1173 case []dwarf.VoidType: - return 1175 + return 1174 case []elf.Chdr32: - return 1176 + return 1175 case []elf.Chdr64: - return 1177 + return 1176 case []elf.Class: - return 1178 + return 1177 case []elf.CompressionType: - return 1179 + return 1178 case []elf.Data: - return 1180 + return 1179 case []elf.Dyn32: - return 1181 + return 1180 case []elf.Dyn64: - return 1182 + return 1181 case []elf.DynFlag: - return 1183 + return 1182 case []elf.DynTag: - return 1184 + return 1183 case []elf.File: - return 1185 + return 1184 case []elf.FileHeader: - return 1186 + return 1185 case []elf.FormatError: - return 1187 + return 1186 case []elf.Header32: - return 1188 + return 1187 case []elf.Header64: - return 1189 + return 1188 case []elf.ImportedSymbol: - return 1190 + return 1189 case []elf.Machine: - return 1191 + return 1190 case []elf.NType: - return 1192 + return 1191 case []elf.OSABI: - return 1193 + return 1192 case []elf.Prog: - return 1194 + return 1193 case []elf.Prog32: - return 1195 + return 1194 case []elf.Prog64: - return 1196 + return 1195 case []elf.ProgFlag: - return 1197 + return 1196 case []elf.ProgHeader: - return 1198 + return 1197 case []elf.ProgType: - return 1199 + return 1198 case []elf.R_386: - return 1200 + return 1199 case []elf.R_390: - return 1201 + return 1200 case []elf.R_AARCH64: - return 1202 + return 1201 case []elf.R_ALPHA: - return 1203 + return 1202 case []elf.R_ARM: - return 1204 + return 1203 case []elf.R_LARCH: - return 1205 + return 1204 case []elf.R_MIPS: - return 1206 + return 1205 case []elf.R_PPC: - return 1207 + return 1206 case []elf.R_PPC64: - return 1208 + return 1207 case []elf.R_RISCV: - return 1209 + return 1208 case []elf.R_SPARC: - return 1210 + return 1209 case []elf.R_X86_64: - return 1211 + return 1210 case []elf.Rel32: - return 1212 + return 1211 case []elf.Rel64: - return 1213 + return 1212 case []elf.Rela32: - return 1214 + return 1213 case []elf.Rela64: - return 1215 + return 1214 case []elf.Section: - return 1216 + return 1215 case []elf.Section32: - return 1217 + return 1216 case []elf.Section64: - return 1218 + return 1217 case []elf.SectionFlag: - return 1219 + return 1218 case []elf.SectionHeader: - return 1220 + return 1219 case []elf.SectionIndex: - return 1221 + return 1220 case []elf.SectionType: - return 1222 + return 1221 case []elf.Sym32: - return 1223 + return 1222 case []elf.Sym64: - return 1224 + return 1223 case []elf.SymBind: - return 1225 + return 1224 case []elf.SymType: - return 1226 + return 1225 case []elf.SymVis: - return 1227 + return 1226 case []elf.Symbol: - return 1228 + return 1227 case []elf.Type: - return 1229 + return 1228 case []elf.Version: - return 1230 + return 1229 case []gosym.DecodingError: - return 1231 + return 1230 case []gosym.Func: - return 1232 + return 1231 case []gosym.LineTable: - return 1233 + return 1232 case []gosym.Obj: - return 1234 + return 1233 case []gosym.Sym: - return 1235 + return 1234 case []gosym.Table: - return 1236 + return 1235 case []gosym.UnknownFileError: - return 1237 + return 1236 case []gosym.UnknownLineError: - return 1238 + return 1237 case []macho.Cpu: - return 1239 + return 1238 case []macho.Dylib: - return 1240 + return 1239 case []macho.DylibCmd: - return 1241 + return 1240 case []macho.Dysymtab: - return 1242 + return 1241 case []macho.DysymtabCmd: - return 1243 + return 1242 case []macho.FatArch: - return 1244 + return 1243 case []macho.FatArchHeader: - return 1245 + return 1244 case []macho.FatFile: - return 1246 + return 1245 case []macho.File: - return 1247 + return 1246 case []macho.FileHeader: - return 1248 + return 1247 case []macho.FormatError: - return 1249 + return 1248 case []macho.Load: - return 1250 + return 1249 case []macho.LoadBytes: - return 1251 + return 1250 case []macho.LoadCmd: - return 1252 + return 1251 case []macho.Nlist32: - return 1253 + return 1252 case []macho.Nlist64: - return 1254 + return 1253 case []macho.Regs386: - return 1255 + return 1254 case []macho.RegsAMD64: - return 1256 + return 1255 case []macho.Reloc: - return 1257 + return 1256 case []macho.RelocTypeARM: - return 1258 + return 1257 case []macho.RelocTypeARM64: - return 1259 + return 1258 case []macho.RelocTypeGeneric: - return 1260 + return 1259 case []macho.RelocTypeX86_64: - return 1261 + return 1260 case []macho.Rpath: - return 1262 + return 1261 case []macho.RpathCmd: - return 1263 + return 1262 case []macho.Section: - return 1264 + return 1263 case []macho.Section32: - return 1265 + return 1264 case []macho.Section64: - return 1266 + return 1265 case []macho.SectionHeader: - return 1267 + return 1266 case []macho.Segment: - return 1268 + return 1267 case []macho.Segment32: - return 1269 + return 1268 case []macho.Segment64: - return 1270 + return 1269 case []macho.SegmentHeader: - return 1271 + return 1270 case []macho.Symbol: - return 1272 + return 1271 case []macho.Symtab: - return 1273 + return 1272 case []macho.SymtabCmd: - return 1274 + return 1273 case []macho.Thread: - return 1275 + return 1274 case []macho.Type: - return 1276 + return 1275 case []pe.COFFSymbol: - return 1277 + return 1276 case []pe.COFFSymbolAuxFormat5: - return 1278 + return 1277 case []pe.DataDirectory: - return 1279 + return 1278 case []pe.File: - return 1280 + return 1279 case []pe.FileHeader: - return 1281 + return 1280 case []pe.FormatError: - return 1282 + return 1281 case []pe.ImportDirectory: - return 1283 + return 1282 case []pe.OptionalHeader32: - return 1284 + return 1283 case []pe.OptionalHeader64: - return 1285 + return 1284 case []pe.Reloc: - return 1286 + return 1285 case []pe.Section: - return 1287 + return 1286 case []pe.SectionHeader: - return 1288 + return 1287 case []pe.SectionHeader32: - return 1289 + return 1288 case []pe.StringTable: - return 1290 + return 1289 case []pe.Symbol: - return 1291 + return 1290 case []plan9obj.File: - return 1292 + return 1291 case []plan9obj.FileHeader: - return 1293 + return 1292 case []plan9obj.Section: - return 1294 + return 1293 case []plan9obj.SectionHeader: - return 1295 + return 1294 case []plan9obj.Sym: - return 1296 + return 1295 case []embed.FS: - return 1297 + return 1296 case []encoding.BinaryMarshaler: - return 1298 + return 1297 case []encoding.BinaryUnmarshaler: - return 1299 + return 1298 case []encoding.TextMarshaler: - return 1300 + return 1299 case []encoding.TextUnmarshaler: - return 1301 + return 1300 case []ascii85.CorruptInputError: - return 1302 + return 1301 case []asn1.BitString: - return 1303 + return 1302 case []asn1.Enumerated: - return 1304 + return 1303 case []asn1.Flag: - return 1305 + return 1304 case []asn1.ObjectIdentifier: - return 1306 + return 1305 case []asn1.RawContent: - return 1307 + return 1306 case []asn1.RawValue: - return 1308 + return 1307 case []asn1.StructuralError: - return 1309 + return 1308 case []asn1.SyntaxError: - return 1310 + return 1309 case []base32.CorruptInputError: - return 1311 + return 1310 case []base32.Encoding: - return 1312 + return 1311 case []base64.CorruptInputError: - return 1313 + return 1312 case []base64.Encoding: - return 1314 + return 1313 case []binary.AppendByteOrder: - return 1315 + return 1314 case []binary.ByteOrder: - return 1316 + return 1315 case []csv.ParseError: - return 1317 + return 1316 case []csv.Reader: - return 1318 + return 1317 case []csv.Writer: - return 1319 + return 1318 case []gob.CommonType: - return 1320 + return 1319 case []gob.Decoder: - return 1321 + return 1320 case []gob.Encoder: - return 1322 + return 1321 case []gob.GobDecoder: - return 1323 + return 1322 case []gob.GobEncoder: - return 1324 + return 1323 case []hex.InvalidByteError: - return 1325 + return 1324 case []json.Decoder: - return 1326 + return 1325 case []json.Delim: - return 1327 + return 1326 case []json.Encoder: - return 1328 + return 1327 case []json.InvalidUTF8Error: - return 1329 + return 1328 case []json.InvalidUnmarshalError: - return 1330 + return 1329 case []json.Marshaler: - return 1331 + return 1330 case []json.MarshalerError: - return 1332 + return 1331 case []json.Number: - return 1333 + return 1332 case []json.RawMessage: - return 1334 + return 1333 case []json.SyntaxError: - return 1335 + return 1334 case []json.Token: - return 1336 + return 1335 case []json.UnmarshalFieldError: - return 1337 + return 1336 case []json.UnmarshalTypeError: - return 1338 + return 1337 case []json.Unmarshaler: - return 1339 + return 1338 case []json.UnsupportedTypeError: - return 1340 + return 1339 case []json.UnsupportedValueError: - return 1341 + return 1340 case []pem.Block: - return 1342 + return 1341 case []xml.Attr: - return 1343 + return 1342 case []xml.CharData: - return 1344 + return 1343 case []xml.Comment: - return 1345 + return 1344 case []xml.Decoder: - return 1346 + return 1345 case []xml.Directive: - return 1347 + return 1346 case []xml.Encoder: - return 1348 + return 1347 case []xml.EndElement: - return 1349 + return 1348 case []xml.Marshaler: - return 1350 + return 1349 case []xml.MarshalerAttr: - return 1351 + return 1350 case []xml.Name: - return 1352 + return 1351 case []xml.ProcInst: - return 1353 + return 1352 case []xml.StartElement: - return 1354 + return 1353 case []xml.SyntaxError: - return 1355 + return 1354 case []xml.TagPathError: - return 1356 + return 1355 case []xml.Token: - return 1357 + return 1356 case []xml.TokenReader: - return 1358 + return 1357 case []xml.UnmarshalError: - return 1359 + return 1358 case []xml.Unmarshaler: - return 1360 + return 1359 case []xml.UnmarshalerAttr: - return 1361 + return 1360 case []xml.UnsupportedTypeError: - return 1362 + return 1361 case []expvar.Float: - return 1363 + return 1362 case []expvar.Func: - return 1364 + return 1363 case []expvar.Int: - return 1365 + return 1364 case []expvar.KeyValue: - return 1366 + return 1365 case []expvar.Map: - return 1367 + return 1366 case []expvar.String: - return 1368 + return 1367 case []expvar.Var: - return 1369 + return 1368 case []flag.ErrorHandling: - return 1370 + return 1369 case []flag.Flag: - return 1371 + return 1370 case []flag.FlagSet: - return 1372 + return 1371 case []flag.Getter: - return 1373 + return 1372 case []flag.Value: - return 1374 + return 1373 case []fmt.Formatter: - return 1375 + return 1374 case []fmt.GoStringer: - return 1376 + return 1375 case []fmt.ScanState: - return 1377 + return 1376 case []fmt.Scanner: - return 1378 + return 1377 case []fmt.State: - return 1379 + return 1378 case []fmt.Stringer: - return 1380 + return 1379 case []ast.ArrayType: - return 1381 + return 1380 case []ast.AssignStmt: - return 1382 + return 1381 case []ast.BadDecl: - return 1383 + return 1382 case []ast.BadExpr: - return 1384 + return 1383 case []ast.BadStmt: - return 1385 + return 1384 case []ast.BasicLit: - return 1386 + return 1385 case []ast.BinaryExpr: - return 1387 + return 1386 case []ast.BlockStmt: - return 1388 + return 1387 case []ast.BranchStmt: - return 1389 + return 1388 case []ast.CallExpr: - return 1390 + return 1389 case []ast.CaseClause: - return 1391 + return 1390 case []ast.ChanDir: - return 1392 + return 1391 case []ast.ChanType: - return 1393 + return 1392 case []ast.CommClause: - return 1394 + return 1393 case []ast.Comment: - return 1395 + return 1394 case []ast.CommentGroup: - return 1396 + return 1395 case []ast.CommentMap: - return 1397 + return 1396 case []ast.CompositeLit: - return 1398 + return 1397 case []ast.Decl: - return 1399 + return 1398 case []ast.DeclStmt: - return 1400 + return 1399 case []ast.DeferStmt: - return 1401 + return 1400 case []ast.Ellipsis: - return 1402 + return 1401 case []ast.EmptyStmt: - return 1403 + return 1402 case []ast.Expr: - return 1404 + return 1403 case []ast.ExprStmt: - return 1405 + return 1404 case []ast.Field: - return 1406 + return 1405 case []ast.FieldFilter: - return 1407 + return 1406 case []ast.FieldList: - return 1408 + return 1407 case []ast.File: - return 1409 + return 1408 case []ast.Filter: - return 1410 + return 1409 case []ast.ForStmt: - return 1411 + return 1410 case []ast.FuncDecl: - return 1412 + return 1411 case []ast.FuncLit: - return 1413 + return 1412 case []ast.FuncType: - return 1414 + return 1413 case []ast.GenDecl: - return 1415 + return 1414 case []ast.GoStmt: - return 1416 + return 1415 case []ast.Ident: - return 1417 + return 1416 case []ast.IfStmt: - return 1418 + return 1417 case []ast.ImportSpec: - return 1419 + return 1418 case []ast.Importer: - return 1420 + return 1419 case []ast.IncDecStmt: - return 1421 + return 1420 case []ast.IndexExpr: - return 1422 + return 1421 case []ast.IndexListExpr: - return 1423 + return 1422 case []ast.InterfaceType: - return 1424 + return 1423 case []ast.KeyValueExpr: - return 1425 + return 1424 case []ast.LabeledStmt: - return 1426 + return 1425 case []ast.MapType: - return 1427 + return 1426 case []ast.MergeMode: - return 1428 + return 1427 case []ast.Node: - return 1429 + return 1428 case []ast.ObjKind: - return 1430 + return 1429 case []ast.Object: - return 1431 + return 1430 case []ast.Package: - return 1432 + return 1431 case []ast.ParenExpr: - return 1433 + return 1432 case []ast.RangeStmt: - return 1434 + return 1433 case []ast.ReturnStmt: - return 1435 + return 1434 case []ast.Scope: - return 1436 + return 1435 case []ast.SelectStmt: - return 1437 + return 1436 case []ast.SelectorExpr: - return 1438 + return 1437 case []ast.SendStmt: - return 1439 + return 1438 case []ast.SliceExpr: - return 1440 + return 1439 case []ast.Spec: - return 1441 + return 1440 case []ast.StarExpr: - return 1442 + return 1441 case []ast.Stmt: - return 1443 + return 1442 case []ast.StructType: - return 1444 + return 1443 case []ast.SwitchStmt: - return 1445 + return 1444 case []ast.TypeAssertExpr: - return 1446 + return 1445 case []ast.TypeSpec: - return 1447 + return 1446 case []ast.TypeSwitchStmt: - return 1448 + return 1447 case []ast.UnaryExpr: - return 1449 + return 1448 case []ast.ValueSpec: - return 1450 + return 1449 case []ast.Visitor: - return 1451 + return 1450 case []build.Context: - return 1452 + return 1451 case []build.ImportMode: - return 1453 + return 1452 case []build.MultiplePackageError: - return 1454 + return 1453 case []build.NoGoError: - return 1455 + return 1454 case []build.Package: - return 1456 + return 1455 case []constraint.AndExpr: - return 1457 + return 1456 case []constraint.Expr: - return 1458 + return 1457 case []constraint.NotExpr: - return 1459 + return 1458 case []constraint.OrExpr: - return 1460 + return 1459 case []constraint.SyntaxError: - return 1461 + return 1460 case []constraint.TagExpr: - return 1462 + return 1461 case []constant.Kind: - return 1463 + return 1462 case []constant.Value: - return 1464 + return 1463 case []doc.Example: - return 1465 + return 1464 case []doc.Filter: - return 1466 + return 1465 case []doc.Func: - return 1467 + return 1466 case []doc.Mode: - return 1468 + return 1467 case []doc.Note: - return 1469 + return 1468 case []doc.Package: - return 1470 + return 1469 case []doc.Type: - return 1471 + return 1470 case []doc.Value: - return 1472 + return 1471 case []comment.Block: - return 1473 + return 1472 case []comment.Code: - return 1474 + return 1473 case []comment.Doc: - return 1475 + return 1474 case []comment.DocLink: - return 1476 + return 1475 case []comment.Heading: - return 1477 + return 1476 case []comment.Italic: - return 1478 + return 1477 case []comment.Link: - return 1479 + return 1478 case []comment.LinkDef: - return 1480 + return 1479 case []comment.List: - return 1481 + return 1480 case []comment.ListItem: - return 1482 + return 1481 case []comment.Paragraph: - return 1483 + return 1482 case []comment.Parser: - return 1484 + return 1483 case []comment.Plain: - return 1485 + return 1484 case []comment.Printer: - return 1486 + return 1485 case []comment.Text: - return 1487 + return 1486 case []importer.Lookup: - return 1488 + return 1487 case []parser.Mode: - return 1489 + return 1488 case []printer.CommentedNode: - return 1490 + return 1489 case []printer.Config: - return 1491 + return 1490 case []printer.Mode: - return 1492 + return 1491 case []scanner.Error: - return 1493 + return 1492 case []scanner.ErrorHandler: - return 1494 + return 1493 case []scanner.ErrorList: - return 1495 + return 1494 case []scanner.Mode: - return 1496 + return 1495 case []scanner.Scanner: - return 1497 + return 1496 case []token.File: - return 1498 + return 1497 case []token.FileSet: - return 1499 + return 1498 case []token.Pos: - return 1500 + return 1499 case []token.Position: - return 1501 + return 1500 case []token.Token: - return 1502 + return 1501 case []types.ArgumentError: - return 1503 + return 1502 case []types.Array: - return 1504 + return 1503 case []types.Basic: - return 1505 + return 1504 case []types.BasicInfo: - return 1506 + return 1505 case []types.BasicKind: - return 1507 + return 1506 case []types.Builtin: - return 1508 + return 1507 case []types.Chan: - return 1509 + return 1508 case []types.ChanDir: - return 1510 + return 1509 case []types.Checker: - return 1511 + return 1510 case []types.Config: - return 1512 + return 1511 case []types.Const: - return 1513 + return 1512 case []types.Context: - return 1514 + return 1513 case []types.Error: - return 1515 + return 1514 case []types.Func: - return 1516 + return 1515 case []types.ImportMode: - return 1517 + return 1516 case []types.Importer: - return 1518 + return 1517 case []types.ImporterFrom: - return 1519 + return 1518 case []types.Info: - return 1520 + return 1519 case []types.Initializer: - return 1521 + return 1520 case []types.Instance: - return 1522 + return 1521 case []types.Interface: - return 1523 + return 1522 case []types.Label: - return 1524 + return 1523 case []types.Map: - return 1525 + return 1524 case []types.MethodSet: - return 1526 + return 1525 case []types.Named: - return 1527 + return 1526 case []types.Nil: - return 1528 + return 1527 case []types.Object: - return 1529 + return 1528 case []types.Package: - return 1530 + return 1529 case []types.PkgName: - return 1531 + return 1530 case []types.Pointer: - return 1532 + return 1531 case []types.Qualifier: - return 1533 + return 1532 case []types.Scope: - return 1534 + return 1533 case []types.Selection: - return 1535 + return 1534 case []types.SelectionKind: - return 1536 + return 1535 case []types.Signature: - return 1537 + return 1536 case []types.Sizes: - return 1538 + return 1537 case []types.Slice: - return 1539 + return 1538 case []types.StdSizes: - return 1540 + return 1539 case []types.Struct: - return 1541 + return 1540 case []types.Term: - return 1542 + return 1541 case []types.Tuple: - return 1543 + return 1542 case []types.Type: - return 1544 + return 1543 case []types.TypeAndValue: - return 1545 + return 1544 case []types.TypeList: - return 1546 + return 1545 case []types.TypeName: - return 1547 + return 1546 case []types.TypeParam: - return 1548 + return 1547 case []types.TypeParamList: - return 1549 + return 1548 case []types.Union: - return 1550 + return 1549 case []types.Var: - return 1551 + return 1550 case []hash.Hash: - return 1552 + return 1551 case []hash.Hash32: - return 1553 + return 1552 case []hash.Hash64: - return 1554 + return 1553 case []crc32.Table: - return 1555 + return 1554 case []crc64.Table: - return 1556 + return 1555 case []maphash.Hash: - return 1557 + return 1556 case []maphash.Seed: - return 1558 + return 1557 case []template.CSS: - return 1559 + return 1558 case []template.Error: - return 1560 + return 1559 case []template.ErrorCode: - return 1561 + return 1560 case []template.HTML: - return 1562 + return 1561 case []template.HTMLAttr: - return 1563 + return 1562 case []template.JS: - return 1564 + return 1563 case []template.JSStr: - return 1565 + return 1564 case []template.Srcset: - return 1566 + return 1565 case []template.Template: - return 1567 + return 1566 case []template.URL: - return 1568 + return 1567 case []image.Alpha: - return 1569 + return 1568 case []image.Alpha16: - return 1570 + return 1569 case []image.CMYK: - return 1571 + return 1570 case []image.Config: - return 1572 + return 1571 case []image.Gray: - return 1573 + return 1572 case []image.Gray16: - return 1574 + return 1573 case []image.Image: - return 1575 + return 1574 case []image.NRGBA: - return 1576 + return 1575 case []image.NRGBA64: - return 1577 + return 1576 case []image.NYCbCrA: - return 1578 + return 1577 case []image.Paletted: - return 1579 + return 1578 case []image.PalettedImage: - return 1580 + return 1579 case []image.Point: - return 1581 + return 1580 case []image.RGBA: - return 1582 + return 1581 case []image.RGBA64: - return 1583 + return 1582 case []image.RGBA64Image: - return 1584 + return 1583 case []image.Rectangle: - return 1585 + return 1584 case []image.Uniform: - return 1586 + return 1585 case []image.YCbCr: - return 1587 + return 1586 case []image.YCbCrSubsampleRatio: - return 1588 + return 1587 case []color.Alpha: - return 1589 + return 1588 case []color.Alpha16: - return 1590 + return 1589 case []color.CMYK: - return 1591 + return 1590 case []color.Color: - return 1592 + return 1591 case []color.Gray: - return 1593 + return 1592 case []color.Gray16: - return 1594 + return 1593 case []color.Model: - return 1595 + return 1594 case []color.NRGBA: - return 1596 + return 1595 case []color.NRGBA64: - return 1597 + return 1596 case []color.NYCbCrA: - return 1598 + return 1597 case []color.Palette: - return 1599 + return 1598 case []color.RGBA: - return 1600 + return 1599 case []color.RGBA64: - return 1601 + return 1600 case []color.YCbCr: - return 1602 + return 1601 case []draw.Drawer: - return 1603 + return 1602 case []draw.Image: - return 1604 + return 1603 case []draw.Op: - return 1605 + return 1604 case []draw.Quantizer: - return 1606 + return 1605 case []draw.RGBA64Image: - return 1607 + return 1606 case []gif.GIF: - return 1608 + return 1607 case []gif.Options: - return 1609 + return 1608 case []jpeg.FormatError: - return 1610 + return 1609 case []jpeg.Options: - return 1611 + return 1610 case []jpeg.Reader: - return 1612 + return 1611 case []jpeg.UnsupportedError: - return 1613 + return 1612 case []png.CompressionLevel: - return 1614 + return 1613 case []png.Encoder: - return 1615 + return 1614 case []png.EncoderBuffer: - return 1616 + return 1615 case []png.EncoderBufferPool: - return 1617 + return 1616 case []png.FormatError: - return 1618 + return 1617 case []png.UnsupportedError: - return 1619 + return 1618 case []suffixarray.Index: - return 1620 + return 1619 case []io.ByteReader: - return 1621 + return 1620 case []io.ByteScanner: - return 1622 + return 1621 case []io.ByteWriter: - return 1623 + return 1622 case []io.Closer: - return 1624 + return 1623 case []io.LimitedReader: - return 1625 + return 1624 case []io.PipeReader: - return 1626 + return 1625 case []io.PipeWriter: - return 1627 + return 1626 case []io.ReadCloser: - return 1628 + return 1627 case []io.ReadSeekCloser: - return 1629 + return 1628 case []io.ReadSeeker: - return 1630 + return 1629 case []io.ReadWriteCloser: - return 1631 + return 1630 case []io.ReadWriteSeeker: - return 1632 + return 1631 case []io.ReadWriter: - return 1633 + return 1632 case []io.Reader: - return 1634 + return 1633 case []io.ReaderAt: - return 1635 + return 1634 case []io.ReaderFrom: - return 1636 + return 1635 case []io.RuneReader: - return 1637 + return 1636 case []io.RuneScanner: - return 1638 + return 1637 case []io.SectionReader: - return 1639 + return 1638 case []io.Seeker: - return 1640 + return 1639 case []io.StringWriter: - return 1641 + return 1640 case []io.WriteCloser: - return 1642 + return 1641 case []io.WriteSeeker: - return 1643 + return 1642 case []io.Writer: - return 1644 + return 1643 case []io.WriterAt: - return 1645 + return 1644 case []io.WriterTo: - return 1646 + return 1645 case []fs.DirEntry: - return 1647 + return 1646 case []fs.FS: - return 1648 + return 1647 case []fs.File: - return 1649 + return 1648 case []fs.FileInfo: - return 1650 + return 1649 case []fs.FileMode: - return 1651 + return 1650 case []fs.GlobFS: - return 1652 + return 1651 case []fs.PathError: - return 1653 + return 1652 case []fs.ReadDirFS: - return 1654 + return 1653 case []fs.ReadDirFile: - return 1655 + return 1654 case []fs.ReadFileFS: - return 1656 + return 1655 case []fs.StatFS: - return 1657 + return 1656 case []fs.SubFS: - return 1658 + return 1657 case []fs.WalkDirFunc: - return 1659 + return 1658 case []log.Logger: - return 1660 + return 1659 case []big.Accuracy: - return 1661 + return 1660 case []big.ErrNaN: - return 1662 + return 1661 case []big.Float: - return 1663 + return 1662 case []big.Int: - return 1664 + return 1663 case []big.Rat: - return 1665 + return 1664 case []big.RoundingMode: - return 1666 + return 1665 case []big.Word: - return 1667 + return 1666 case []rand.Rand: - return 1668 + return 1667 case []rand.Source: - return 1669 + return 1668 case []rand.Source64: - return 1670 + return 1669 case []rand.Zipf: - return 1671 + return 1670 case []mime.WordDecoder: - return 1672 + return 1671 case []mime.WordEncoder: - return 1673 + return 1672 case []multipart.File: - return 1674 + return 1673 case []multipart.FileHeader: - return 1675 + return 1674 case []multipart.Form: - return 1676 + return 1675 case []multipart.Part: - return 1677 + return 1676 case []multipart.Reader: - return 1678 + return 1677 case []multipart.Writer: - return 1679 + return 1678 case []quotedprintable.Reader: - return 1680 + return 1679 case []quotedprintable.Writer: - return 1681 + return 1680 case []net.Addr: - return 1682 + return 1681 case []net.AddrError: - return 1683 + return 1682 case []net.Buffers: - return 1684 + return 1683 case []net.Conn: - return 1685 + return 1684 case []net.DNSConfigError: - return 1686 + return 1685 case []net.DNSError: - return 1687 + return 1686 case []net.Dialer: - return 1688 + return 1687 case []net.Error: - return 1689 + return 1688 case []net.Flags: - return 1690 + return 1689 case []net.HardwareAddr: - return 1691 + return 1690 case []net.IP: - return 1692 + return 1691 case []net.IPAddr: - return 1693 + return 1692 case []net.IPConn: - return 1694 + return 1693 case []net.IPMask: - return 1695 + return 1694 case []net.IPNet: - return 1696 + return 1695 case []net.Interface: - return 1697 + return 1696 case []net.InvalidAddrError: - return 1698 + return 1697 case []net.ListenConfig: - return 1699 + return 1698 case []net.Listener: - return 1700 + return 1699 case []net.MX: - return 1701 + return 1700 case []net.NS: - return 1702 + return 1701 case []net.OpError: - return 1703 + return 1702 case []net.PacketConn: - return 1704 + return 1703 case []net.ParseError: - return 1705 + return 1704 case []net.Resolver: - return 1706 + return 1705 case []net.SRV: - return 1707 + return 1706 case []net.TCPAddr: - return 1708 + return 1707 case []net.TCPConn: - return 1709 + return 1708 case []net.TCPListener: - return 1710 + return 1709 case []net.UDPAddr: - return 1711 + return 1710 case []net.UDPConn: - return 1712 + return 1711 case []net.UnixAddr: - return 1713 + return 1712 case []net.UnixConn: - return 1714 + return 1713 case []net.UnixListener: - return 1715 + return 1714 case []net.UnknownNetworkError: - return 1716 + return 1715 case []http.Client: - return 1717 + return 1716 case []http.CloseNotifier: - return 1718 + return 1717 case []http.ConnState: - return 1719 + return 1718 case []http.Cookie: - return 1720 + return 1719 case []http.CookieJar: - return 1721 + return 1720 case []http.Dir: - return 1722 + return 1721 case []http.File: - return 1723 + return 1722 case []http.FileSystem: - return 1724 + return 1723 case []http.Flusher: - return 1725 + return 1724 case []http.Handler: - return 1726 + return 1725 case []http.HandlerFunc: - return 1727 + return 1726 case []http.Header: - return 1728 + return 1727 case []http.Hijacker: - return 1729 + return 1728 case []http.MaxBytesError: - return 1730 + return 1729 case []http.ProtocolError: - return 1731 + return 1730 case []http.PushOptions: - return 1732 + return 1731 case []http.Pusher: - return 1733 + return 1732 case []http.Request: - return 1734 + return 1733 case []http.Response: - return 1735 + return 1734 case []http.ResponseWriter: - return 1736 + return 1735 case []http.RoundTripper: - return 1737 + return 1736 case []http.SameSite: - return 1738 + return 1737 case []http.ServeMux: - return 1739 + return 1738 case []http.Server: - return 1740 + return 1739 case []http.Transport: - return 1741 + return 1740 case []cgi.Handler: - return 1742 + return 1741 case []cookiejar.Jar: - return 1743 + return 1742 case []cookiejar.Options: - return 1744 + return 1743 case []cookiejar.PublicSuffixList: - return 1745 + return 1744 case []httptest.ResponseRecorder: - return 1746 + return 1745 case []httptest.Server: - return 1747 + return 1746 case []httptrace.ClientTrace: - return 1748 + return 1747 case []httptrace.DNSDoneInfo: - return 1749 + return 1748 case []httptrace.DNSStartInfo: - return 1750 + return 1749 case []httptrace.GotConnInfo: - return 1751 + return 1750 case []httptrace.WroteRequestInfo: - return 1752 + return 1751 case []httputil.BufferPool: - return 1753 + return 1752 case []httputil.ClientConn: - return 1754 + return 1753 case []httputil.ReverseProxy: - return 1755 + return 1754 case []httputil.ServerConn: - return 1756 + return 1755 case []mail.Address: - return 1757 + return 1756 case []mail.AddressParser: - return 1758 + return 1757 case []mail.Header: - return 1759 + return 1758 case []mail.Message: - return 1760 + return 1759 case []netip.Addr: - return 1761 + return 1760 case []netip.AddrPort: - return 1762 + return 1761 case []netip.Prefix: - return 1763 + return 1762 case []rpc.Call: - return 1764 + return 1763 case []rpc.Client: - return 1765 + return 1764 case []rpc.ClientCodec: - return 1766 + return 1765 case []rpc.Request: - return 1767 + return 1766 case []rpc.Response: - return 1768 + return 1767 case []rpc.Server: - return 1769 + return 1768 case []rpc.ServerCodec: - return 1770 + return 1769 case []rpc.ServerError: - return 1771 + return 1770 case []smtp.Auth: - return 1772 + return 1771 case []smtp.Client: - return 1773 + return 1772 case []smtp.ServerInfo: - return 1774 + return 1773 case []textproto.Conn: - return 1775 + return 1774 case []textproto.Error: - return 1776 + return 1775 case []textproto.MIMEHeader: - return 1777 + return 1776 case []textproto.Pipeline: - return 1778 + return 1777 case []textproto.ProtocolError: - return 1779 + return 1778 case []textproto.Reader: - return 1780 + return 1779 case []textproto.Writer: - return 1781 + return 1780 case []url.Error: - return 1782 + return 1781 case []url.EscapeError: - return 1783 + return 1782 case []url.InvalidHostError: - return 1784 + return 1783 case []url.URL: - return 1785 + return 1784 case []url.Userinfo: - return 1786 + return 1785 case []url.Values: - return 1787 + return 1786 case []os.File: - return 1788 + return 1787 case []os.LinkError: - return 1789 + return 1788 case []os.ProcAttr: - return 1790 + return 1789 case []os.Process: - return 1791 + return 1790 case []os.ProcessState: - return 1792 + return 1791 case []os.Signal: - return 1793 + return 1792 case []os.SyscallError: - return 1794 + return 1793 case []exec.Cmd: - return 1795 + return 1794 case []exec.Error: - return 1796 + return 1795 case []exec.ExitError: - return 1797 + return 1796 case []user.Group: - return 1798 + return 1797 case []user.UnknownGroupError: - return 1799 + return 1798 case []user.UnknownGroupIdError: - return 1800 + return 1799 case []user.UnknownUserError: - return 1801 + return 1800 case []user.UnknownUserIdError: - return 1802 + return 1801 case []user.User: - return 1803 + return 1802 case []filepath.WalkFunc: - return 1804 + return 1803 case []plugin.Plugin: - return 1805 + return 1804 case []plugin.Symbol: - return 1806 + return 1805 case []reflect.ChanDir: - return 1807 + return 1806 case []reflect.Kind: - return 1808 + return 1807 case []reflect.MapIter: - return 1809 + return 1808 case []reflect.Method: - return 1810 + return 1809 case []reflect.SelectCase: - return 1811 + return 1810 case []reflect.SelectDir: - return 1812 + return 1811 case []reflect.SliceHeader: - return 1813 + return 1812 case []reflect.StringHeader: - return 1814 + return 1813 case []reflect.StructField: - return 1815 + return 1814 case []reflect.StructTag: - return 1816 + return 1815 case []reflect.Type: - return 1817 + return 1816 case []reflect.Value: - return 1818 + return 1817 case []reflect.ValueError: - return 1819 + return 1818 case []regexp.Regexp: - return 1820 + return 1819 case []syntax.EmptyOp: - return 1821 + return 1820 case []syntax.Error: - return 1822 + return 1821 case []syntax.ErrorCode: - return 1823 + return 1822 case []syntax.Flags: - return 1824 + return 1823 case []syntax.Inst: - return 1825 + return 1824 case []syntax.InstOp: - return 1826 + return 1825 case []syntax.Op: - return 1827 + return 1826 case []syntax.Prog: - return 1828 + return 1827 case []syntax.Regexp: - return 1829 + return 1828 case []runtime.BlockProfileRecord: - return 1830 + return 1829 case []runtime.Error: - return 1831 + return 1830 case []runtime.Frame: - return 1832 + return 1831 case []runtime.Frames: - return 1833 + return 1832 case []runtime.Func: - return 1834 + return 1833 case []runtime.MemProfileRecord: - return 1835 + return 1834 case []runtime.MemStats: - return 1836 + return 1835 case []runtime.StackRecord: - return 1837 + return 1836 case []runtime.TypeAssertionError: - return 1838 + return 1837 case []cgo.Handle: - return 1839 + return 1838 case []debug.BuildInfo: - return 1840 + return 1839 case []debug.BuildSetting: - return 1841 + return 1840 case []debug.GCStats: - return 1842 + return 1841 case []debug.Module: - return 1843 + return 1842 case []metrics.Description: - return 1844 + return 1843 case []metrics.Float64Histogram: - return 1845 + return 1844 case []metrics.Sample: - return 1846 + return 1845 case []metrics.Value: - return 1847 + return 1846 case []metrics.ValueKind: - return 1848 + return 1847 case []pprof.LabelSet: - return 1849 + return 1848 case []pprof.Profile: - return 1850 + return 1849 case []trace.Region: - return 1851 + return 1850 case []trace.Task: - return 1852 + return 1851 case []sort.Float64Slice: - return 1853 + return 1852 case []sort.IntSlice: - return 1854 + return 1853 case []sort.Interface: - return 1855 + return 1854 case []sort.StringSlice: - return 1856 + return 1855 case []strconv.NumError: - return 1857 + return 1856 case []strings.Builder: - return 1858 + return 1857 case []strings.Reader: - return 1859 + return 1858 case []strings.Replacer: - return 1860 + return 1859 case []sync.Cond: - return 1861 + return 1860 case []sync.Locker: - return 1862 + return 1861 case []sync.Map: - return 1863 + return 1862 case []sync.Mutex: - return 1864 + return 1863 case []sync.Once: - return 1865 + return 1864 case []sync.Pool: - return 1866 + return 1865 case []sync.RWMutex: - return 1867 + return 1866 case []sync.WaitGroup: - return 1868 + return 1867 case []atomic.Bool: - return 1869 + return 1868 case []atomic.Int32: - return 1870 + return 1869 case []atomic.Int64: - return 1871 - case []atomic.Pointer: - return 1872 + return 1870 case []atomic.Uint32: - return 1873 + return 1871 case []atomic.Uint64: - return 1874 + return 1872 case []atomic.Uintptr: - return 1875 + return 1873 case []atomic.Value: - return 1876 + return 1874 case []syscall.AddrinfoW: - return 1877 + return 1875 case []syscall.ByHandleFileInformation: - return 1878 + return 1876 case []syscall.CertChainContext: - return 1879 + return 1877 case []syscall.CertChainElement: - return 1880 + return 1878 case []syscall.CertChainPara: - return 1881 + return 1879 case []syscall.CertChainPolicyPara: - return 1882 + return 1880 case []syscall.CertChainPolicyStatus: - return 1883 + return 1881 case []syscall.CertContext: - return 1884 + return 1882 case []syscall.CertEnhKeyUsage: - return 1885 + return 1883 case []syscall.CertInfo: - return 1886 + return 1884 case []syscall.CertRevocationCrlInfo: - return 1887 + return 1885 case []syscall.CertRevocationInfo: - return 1888 + return 1886 case []syscall.CertSimpleChain: - return 1889 + return 1887 case []syscall.CertTrustListInfo: - return 1890 + return 1888 case []syscall.CertTrustStatus: - return 1891 + return 1889 case []syscall.CertUsageMatch: - return 1892 + return 1890 case []syscall.Conn: - return 1893 + return 1891 case []syscall.DLL: - return 1894 + return 1892 case []syscall.DLLError: - return 1895 + return 1893 case []syscall.DNSMXData: - return 1896 + return 1894 case []syscall.DNSPTRData: - return 1897 + return 1895 case []syscall.DNSRecord: - return 1898 + return 1896 case []syscall.DNSSRVData: - return 1899 + return 1897 case []syscall.DNSTXTData: - return 1900 + return 1898 case []syscall.Errno: - return 1901 + return 1899 case []syscall.FileNotifyInformation: - return 1902 + return 1900 case []syscall.Filetime: - return 1903 + return 1901 case []syscall.GUID: - return 1904 + return 1902 case []syscall.Handle: - return 1905 + return 1903 case []syscall.Hostent: - return 1906 + return 1904 case []syscall.IPMreq: - return 1907 + return 1905 case []syscall.IPv6Mreq: - return 1908 + return 1906 case []syscall.InterfaceInfo: - return 1909 + return 1907 case []syscall.IpAdapterInfo: - return 1910 + return 1908 case []syscall.IpAddrString: - return 1911 + return 1909 case []syscall.IpAddressString: - return 1912 + return 1910 case []syscall.IpMaskString: - return 1913 + return 1911 case []syscall.LazyDLL: - return 1914 + return 1912 case []syscall.LazyProc: - return 1915 + return 1913 case []syscall.Linger: - return 1916 + return 1914 case []syscall.MibIfRow: - return 1917 + return 1915 case []syscall.Overlapped: - return 1918 + return 1916 case []syscall.Pointer: - return 1919 + return 1917 case []syscall.Proc: - return 1920 + return 1918 case []syscall.ProcAttr: - return 1921 + return 1919 case []syscall.ProcessEntry32: - return 1922 + return 1920 case []syscall.ProcessInformation: - return 1923 + return 1921 case []syscall.Protoent: - return 1924 + return 1922 case []syscall.RawConn: - return 1925 + return 1923 case []syscall.RawSockaddr: - return 1926 + return 1924 case []syscall.RawSockaddrAny: - return 1927 + return 1925 case []syscall.RawSockaddrInet4: - return 1928 + return 1926 case []syscall.RawSockaddrInet6: - return 1929 + return 1927 case []syscall.RawSockaddrUnix: - return 1930 + return 1928 case []syscall.Rusage: - return 1931 + return 1929 case []syscall.SID: - return 1932 + return 1930 case []syscall.SIDAndAttributes: - return 1933 + return 1931 case []syscall.SSLExtraCertChainPolicyPara: - return 1934 + return 1932 case []syscall.SecurityAttributes: - return 1935 + return 1933 case []syscall.Servent: - return 1936 + return 1934 case []syscall.Signal: - return 1937 + return 1935 case []syscall.Sockaddr: - return 1938 + return 1936 case []syscall.SockaddrGen: - return 1939 + return 1937 case []syscall.SockaddrInet4: - return 1940 + return 1938 case []syscall.SockaddrInet6: - return 1941 + return 1939 case []syscall.SockaddrUnix: - return 1942 + return 1940 case []syscall.StartupInfo: - return 1943 + return 1941 case []syscall.SysProcAttr: - return 1944 + return 1942 case []syscall.Systemtime: - return 1945 + return 1943 case []syscall.TCPKeepalive: - return 1946 + return 1944 case []syscall.Timespec: - return 1947 + return 1945 case []syscall.Timeval: - return 1948 + return 1946 case []syscall.Timezoneinformation: - return 1949 + return 1947 case []syscall.Token: - return 1950 + return 1948 case []syscall.Tokenprimarygroup: - return 1951 + return 1949 case []syscall.Tokenuser: - return 1952 + return 1950 case []syscall.TransmitFileBuffers: - return 1953 + return 1951 case []syscall.UserInfo10: - return 1954 + return 1952 case []syscall.WSABuf: - return 1955 + return 1953 case []syscall.WSAData: - return 1956 + return 1954 case []syscall.WSAProtocolChain: - return 1957 + return 1955 case []syscall.WSAProtocolInfo: - return 1958 + return 1956 case []syscall.WaitStatus: - return 1959 + return 1957 case []syscall.Win32FileAttributeData: - return 1960 + return 1958 case []syscall.Win32finddata: - return 1961 + return 1959 case []testing.B: - return 1962 + return 1960 case []testing.BenchmarkResult: - return 1963 + return 1961 case []testing.Cover: - return 1964 + return 1962 case []testing.CoverBlock: - return 1965 + return 1963 case []testing.F: - return 1966 + return 1964 case []testing.InternalBenchmark: - return 1967 + return 1965 case []testing.InternalExample: - return 1968 + return 1966 case []testing.InternalFuzzTarget: - return 1969 + return 1967 case []testing.InternalTest: - return 1970 + return 1968 case []testing.M: - return 1971 + return 1969 case []testing.PB: - return 1972 + return 1970 case []testing.T: - return 1973 + return 1971 case []testing.TB: - return 1974 + return 1972 case []fstest.MapFS: - return 1975 + return 1973 case []fstest.MapFile: - return 1976 + return 1974 case []quick.CheckEqualError: - return 1977 + return 1975 case []quick.CheckError: - return 1978 + return 1976 case []quick.Config: - return 1979 + return 1977 case []quick.Generator: - return 1980 + return 1978 case []quick.SetupError: - return 1981 + return 1979 case []text_scanner.Position: - return 1982 + return 1980 case []text_scanner.Scanner: - return 1983 + return 1981 case []tabwriter.Writer: - return 1984 + return 1982 case []text_template.ExecError: - return 1985 + return 1983 case []text_template.FuncMap: - return 1986 + return 1984 case []text_template.Template: - return 1987 + return 1985 case []parse.ActionNode: - return 1988 + return 1986 case []parse.BoolNode: - return 1989 + return 1987 case []parse.BranchNode: - return 1990 + return 1988 case []parse.BreakNode: - return 1991 + return 1989 case []parse.ChainNode: - return 1992 + return 1990 case []parse.CommandNode: - return 1993 + return 1991 case []parse.CommentNode: - return 1994 + return 1992 case []parse.ContinueNode: - return 1995 + return 1993 case []parse.DotNode: - return 1996 + return 1994 case []parse.FieldNode: - return 1997 + return 1995 case []parse.IdentifierNode: - return 1998 + return 1996 case []parse.IfNode: - return 1999 + return 1997 case []parse.ListNode: - return 2000 + return 1998 case []parse.Mode: - return 2001 + return 1999 case []parse.NilNode: - return 2002 + return 2000 case []parse.Node: - return 2003 + return 2001 case []parse.NodeType: - return 2004 + return 2002 case []parse.NumberNode: - return 2005 + return 2003 case []parse.PipeNode: - return 2006 + return 2004 case []parse.Pos: - return 2007 + return 2005 case []parse.RangeNode: - return 2008 + return 2006 case []parse.StringNode: - return 2009 + return 2007 case []parse.TemplateNode: - return 2010 + return 2008 case []parse.TextNode: - return 2011 + return 2009 case []parse.Tree: - return 2012 + return 2010 case []parse.VariableNode: - return 2013 + return 2011 case []parse.WithNode: - return 2014 + return 2012 case []time.Duration: - return 2015 + return 2013 case []time.Location: - return 2016 + return 2014 case []time.Month: - return 2017 + return 2015 case []time.ParseError: - return 2018 + return 2016 case []time.Ticker: - return 2019 + return 2017 case []time.Time: - return 2020 + return 2018 case []time.Timer: - return 2021 + return 2019 case []time.Weekday: - return 2022 + return 2020 case []unicode.CaseRange: - return 2023 + return 2021 case []unicode.Range16: - return 2024 + return 2022 case []unicode.Range32: - return 2025 + return 2023 case []unicode.RangeTable: - return 2026 + return 2024 case []unicode.SpecialCase: - return 2027 + return 2025 case []unsafe.Pointer: - return 2028 + return 2026 case tar.Format: - return 2029 + return 2027 case tar.Header: - return 2030 + return 2028 case tar.Reader: - return 2031 + return 2029 case tar.Writer: - return 2032 + return 2030 case zip.Compressor: - return 2033 + return 2031 case zip.Decompressor: - return 2034 + return 2032 case zip.File: - return 2035 + return 2033 case zip.FileHeader: - return 2036 + return 2034 case zip.ReadCloser: - return 2037 + return 2035 case zip.Reader: - return 2038 + return 2036 case zip.Writer: - return 2039 + return 2037 case bufio.ReadWriter: - return 2040 + return 2038 case bufio.Reader: - return 2041 + return 2039 case bufio.Scanner: - return 2042 + return 2040 case bufio.SplitFunc: - return 2043 + return 2041 case bufio.Writer: - return 2044 + return 2042 case bytes.Buffer: - return 2045 + return 2043 case bytes.Reader: - return 2046 + return 2044 case chan *rpc.Call: - return 2047 + return 2045 case chan<- os.Signal: - return 2048 + return 2046 case bzip2.StructuralError: - return 2049 + return 2047 case flate.CorruptInputError: - return 2050 + return 2048 case flate.InternalError: - return 2051 + return 2049 case flate.ReadError: - return 2052 + return 2050 case flate.WriteError: - return 2053 + return 2051 case flate.Writer: - return 2054 + return 2052 case gzip.Header: - return 2055 + return 2053 case gzip.Reader: - return 2056 + return 2054 case gzip.Writer: - return 2057 + return 2055 case lzw.Order: - return 2058 + return 2056 case lzw.Reader: - return 2059 + return 2057 case lzw.Writer: - return 2060 + return 2058 case zlib.Writer: - return 2061 + return 2059 case list.Element: - return 2062 + return 2060 case list.List: - return 2063 + return 2061 case ring.Ring: - return 2064 + return 2062 case context.CancelFunc: - return 2065 + return 2063 case crypto.Hash: - return 2066 + return 2064 case aes.KeySizeError: - return 2067 + return 2065 case cipher.StreamReader: - return 2068 + return 2066 case cipher.StreamWriter: - return 2069 + return 2067 case des.KeySizeError: - return 2070 + return 2068 case dsa.ParameterSizes: - return 2071 + return 2069 case dsa.Parameters: - return 2072 + return 2070 case dsa.PrivateKey: - return 2073 + return 2071 case dsa.PublicKey: - return 2074 + return 2072 case ecdsa.PrivateKey: - return 2075 + return 2073 case ecdsa.PublicKey: - return 2076 + return 2074 case ed25519.PrivateKey: - return 2077 + return 2075 case ed25519.PublicKey: - return 2078 + return 2076 case elliptic.CurveParams: - return 2079 + return 2077 case rc4.Cipher: - return 2080 + return 2078 case rc4.KeySizeError: - return 2081 + return 2079 case rsa.CRTValue: - return 2082 + return 2080 case rsa.OAEPOptions: - return 2083 + return 2081 case rsa.PKCS1v15DecryptOptions: - return 2084 + return 2082 case rsa.PSSOptions: - return 2085 + return 2083 case rsa.PrecomputedValues: - return 2086 + return 2084 case rsa.PrivateKey: - return 2087 + return 2085 case rsa.PublicKey: - return 2088 + return 2086 case tls.Certificate: - return 2089 + return 2087 case tls.CertificateRequestInfo: - return 2090 + return 2088 case tls.CipherSuite: - return 2091 + return 2089 case tls.ClientAuthType: - return 2092 + return 2090 case tls.ClientHelloInfo: - return 2093 + return 2091 case tls.ClientSessionState: - return 2094 + return 2092 case tls.Config: - return 2095 + return 2093 case tls.Conn: - return 2096 + return 2094 case tls.ConnectionState: - return 2097 + return 2095 case tls.CurveID: - return 2098 + return 2096 case tls.Dialer: - return 2099 + return 2097 case tls.RecordHeaderError: - return 2100 + return 2098 case tls.RenegotiationSupport: - return 2101 + return 2099 case tls.SignatureScheme: - return 2102 + return 2100 case x509.CertPool: - return 2103 + return 2101 case x509.Certificate: - return 2104 + return 2102 case x509.CertificateInvalidError: - return 2105 + return 2103 case x509.CertificateRequest: - return 2106 + return 2104 case x509.ConstraintViolationError: - return 2107 + return 2105 case x509.ExtKeyUsage: - return 2108 + return 2106 case x509.HostnameError: - return 2109 + return 2107 case x509.InsecureAlgorithmError: - return 2110 + return 2108 case x509.InvalidReason: - return 2111 + return 2109 case x509.KeyUsage: - return 2112 + return 2110 case x509.PEMCipher: - return 2113 + return 2111 case x509.PublicKeyAlgorithm: - return 2114 + return 2112 case x509.RevocationList: - return 2115 + return 2113 case x509.SignatureAlgorithm: - return 2116 + return 2114 case x509.SystemRootsError: - return 2117 + return 2115 case x509.UnhandledCriticalExtension: - return 2118 + return 2116 case x509.UnknownAuthorityError: - return 2119 + return 2117 case x509.VerifyOptions: - return 2120 + return 2118 case pkix.AlgorithmIdentifier: - return 2121 + return 2119 case pkix.AttributeTypeAndValue: - return 2122 + return 2120 case pkix.AttributeTypeAndValueSET: - return 2123 + return 2121 case pkix.CertificateList: - return 2124 + return 2122 case pkix.Extension: - return 2125 + return 2123 case pkix.Name: - return 2126 + return 2124 case pkix.RDNSequence: - return 2127 + return 2125 case pkix.RelativeDistinguishedNameSET: - return 2128 + return 2126 case pkix.RevokedCertificate: - return 2129 + return 2127 case pkix.TBSCertificateList: - return 2130 + return 2128 case sql.ColumnType: - return 2131 + return 2129 case sql.Conn: - return 2132 + return 2130 case sql.DB: - return 2133 + return 2131 case sql.DBStats: - return 2134 + return 2132 case sql.IsolationLevel: - return 2135 + return 2133 case sql.NamedArg: - return 2136 + return 2134 case sql.NullBool: - return 2137 + return 2135 case sql.NullByte: - return 2138 + return 2136 case sql.NullFloat64: - return 2139 + return 2137 case sql.NullInt16: - return 2140 + return 2138 case sql.NullInt32: - return 2141 + return 2139 case sql.NullInt64: - return 2142 + return 2140 case sql.NullString: - return 2143 + return 2141 case sql.NullTime: - return 2144 + return 2142 case sql.Out: - return 2145 + return 2143 case sql.RawBytes: - return 2146 + return 2144 case sql.Row: - return 2147 + return 2145 case sql.Rows: - return 2148 + return 2146 case sql.Stmt: - return 2149 + return 2147 case sql.Tx: - return 2150 + return 2148 case sql.TxOptions: - return 2151 + return 2149 case driver.IsolationLevel: - return 2152 + return 2150 case driver.NamedValue: - return 2153 + return 2151 case driver.NotNull: - return 2154 + return 2152 case driver.Null: - return 2155 + return 2153 case driver.RowsAffected: - return 2156 + return 2154 case driver.TxOptions: - return 2157 + return 2155 case dwarf.AddrType: - return 2158 + return 2156 case dwarf.ArrayType: - return 2159 + return 2157 case dwarf.Attr: - return 2160 + return 2158 case dwarf.BasicType: - return 2161 + return 2159 case dwarf.BoolType: - return 2162 + return 2160 case dwarf.CharType: - return 2163 + return 2161 case dwarf.Class: - return 2164 + return 2162 case dwarf.CommonType: - return 2165 + return 2163 case dwarf.ComplexType: - return 2166 + return 2164 case dwarf.Data: - return 2167 + return 2165 case dwarf.DecodeError: - return 2168 + return 2166 case dwarf.DotDotDotType: - return 2169 + return 2167 case dwarf.Entry: - return 2170 + return 2168 case dwarf.EnumType: - return 2171 + return 2169 case dwarf.EnumValue: - return 2172 + return 2170 case dwarf.Field: - return 2173 + return 2171 case dwarf.FloatType: - return 2174 + return 2172 case dwarf.FuncType: - return 2175 + return 2173 case dwarf.IntType: - return 2176 + return 2174 case dwarf.LineEntry: - return 2177 + return 2175 case dwarf.LineFile: - return 2178 + return 2176 case dwarf.LineReader: - return 2179 + return 2177 case dwarf.LineReaderPos: - return 2180 + return 2178 case dwarf.Offset: - return 2181 + return 2179 case dwarf.PtrType: - return 2182 + return 2180 case dwarf.QualType: - return 2183 + return 2181 case dwarf.Reader: - return 2184 + return 2182 case dwarf.StructField: - return 2185 + return 2183 case dwarf.StructType: - return 2186 + return 2184 case dwarf.Tag: - return 2187 + return 2185 case dwarf.TypedefType: - return 2188 + return 2186 case dwarf.UcharType: - return 2189 + return 2187 case dwarf.UintType: - return 2190 + return 2188 case dwarf.UnspecifiedType: - return 2191 + return 2189 case dwarf.UnsupportedType: - return 2192 + return 2190 case dwarf.VoidType: - return 2193 + return 2191 case elf.Chdr32: - return 2194 + return 2192 case elf.Chdr64: - return 2195 + return 2193 case elf.Class: - return 2196 + return 2194 case elf.CompressionType: - return 2197 + return 2195 case elf.Data: - return 2198 + return 2196 case elf.Dyn32: - return 2199 + return 2197 case elf.Dyn64: - return 2200 + return 2198 case elf.DynFlag: - return 2201 + return 2199 case elf.DynTag: - return 2202 + return 2200 case elf.File: - return 2203 + return 2201 case elf.FileHeader: - return 2204 + return 2202 case elf.FormatError: - return 2205 + return 2203 case elf.Header32: - return 2206 + return 2204 case elf.Header64: - return 2207 + return 2205 case elf.ImportedSymbol: - return 2208 + return 2206 case elf.Machine: - return 2209 + return 2207 case elf.NType: - return 2210 + return 2208 case elf.OSABI: - return 2211 + return 2209 case elf.Prog: - return 2212 + return 2210 case elf.Prog32: - return 2213 + return 2211 case elf.Prog64: - return 2214 + return 2212 case elf.ProgFlag: - return 2215 + return 2213 case elf.ProgHeader: - return 2216 + return 2214 case elf.ProgType: - return 2217 + return 2215 case elf.R_386: - return 2218 + return 2216 case elf.R_390: - return 2219 + return 2217 case elf.R_AARCH64: - return 2220 + return 2218 case elf.R_ALPHA: - return 2221 + return 2219 case elf.R_ARM: - return 2222 + return 2220 case elf.R_LARCH: - return 2223 + return 2221 case elf.R_MIPS: - return 2224 + return 2222 case elf.R_PPC: - return 2225 + return 2223 case elf.R_PPC64: - return 2226 + return 2224 case elf.R_RISCV: - return 2227 + return 2225 case elf.R_SPARC: - return 2228 + return 2226 case elf.R_X86_64: - return 2229 + return 2227 case elf.Rel32: - return 2230 + return 2228 case elf.Rel64: - return 2231 + return 2229 case elf.Rela32: - return 2232 + return 2230 case elf.Rela64: - return 2233 + return 2231 case elf.Section: - return 2234 + return 2232 case elf.Section32: - return 2235 + return 2233 case elf.Section64: - return 2236 + return 2234 case elf.SectionFlag: - return 2237 + return 2235 case elf.SectionHeader: - return 2238 + return 2236 case elf.SectionIndex: - return 2239 + return 2237 case elf.SectionType: - return 2240 + return 2238 case elf.Sym32: - return 2241 + return 2239 case elf.Sym64: - return 2242 + return 2240 case elf.SymBind: - return 2243 + return 2241 case elf.SymType: - return 2244 + return 2242 case elf.SymVis: - return 2245 + return 2243 case elf.Symbol: - return 2246 + return 2244 case elf.Type: - return 2247 + return 2245 case elf.Version: - return 2248 + return 2246 case gosym.DecodingError: - return 2249 + return 2247 case gosym.Func: - return 2250 + return 2248 case gosym.LineTable: - return 2251 + return 2249 case gosym.Obj: - return 2252 + return 2250 case gosym.Sym: - return 2253 + return 2251 case gosym.Table: - return 2254 + return 2252 case gosym.UnknownFileError: - return 2255 + return 2253 case gosym.UnknownLineError: - return 2256 + return 2254 case macho.Cpu: - return 2257 + return 2255 case macho.Dylib: - return 2258 + return 2256 case macho.DylibCmd: - return 2259 + return 2257 case macho.Dysymtab: - return 2260 + return 2258 case macho.DysymtabCmd: - return 2261 + return 2259 case macho.FatArch: - return 2262 + return 2260 case macho.FatArchHeader: - return 2263 + return 2261 case macho.FatFile: - return 2264 + return 2262 case macho.File: - return 2265 + return 2263 case macho.FileHeader: - return 2266 + return 2264 case macho.FormatError: - return 2267 + return 2265 case macho.LoadBytes: - return 2268 + return 2266 case macho.LoadCmd: - return 2269 + return 2267 case macho.Nlist32: - return 2270 + return 2268 case macho.Nlist64: - return 2271 + return 2269 case macho.Regs386: - return 2272 + return 2270 case macho.RegsAMD64: - return 2273 + return 2271 case macho.Reloc: - return 2274 + return 2272 case macho.RelocTypeARM: - return 2275 + return 2273 case macho.RelocTypeARM64: - return 2276 + return 2274 case macho.RelocTypeGeneric: - return 2277 + return 2275 case macho.RelocTypeX86_64: - return 2278 + return 2276 case macho.Rpath: - return 2279 + return 2277 case macho.RpathCmd: - return 2280 + return 2278 case macho.Section: - return 2281 + return 2279 case macho.Section32: - return 2282 + return 2280 case macho.Section64: - return 2283 + return 2281 case macho.SectionHeader: - return 2284 + return 2282 case macho.Segment: - return 2285 + return 2283 case macho.Segment32: - return 2286 + return 2284 case macho.Segment64: - return 2287 + return 2285 case macho.SegmentHeader: - return 2288 + return 2286 case macho.Symbol: - return 2289 + return 2287 case macho.Symtab: - return 2290 + return 2288 case macho.SymtabCmd: - return 2291 + return 2289 case macho.Thread: - return 2292 + return 2290 case macho.Type: - return 2293 + return 2291 case pe.COFFSymbol: - return 2294 + return 2292 case pe.COFFSymbolAuxFormat5: - return 2295 + return 2293 case pe.DataDirectory: - return 2296 + return 2294 case pe.File: - return 2297 + return 2295 case pe.FileHeader: - return 2298 + return 2296 case pe.FormatError: - return 2299 + return 2297 case pe.ImportDirectory: - return 2300 + return 2298 case pe.OptionalHeader32: - return 2301 + return 2299 case pe.OptionalHeader64: - return 2302 + return 2300 case pe.Reloc: - return 2303 + return 2301 case pe.Section: - return 2304 + return 2302 case pe.SectionHeader: - return 2305 + return 2303 case pe.SectionHeader32: - return 2306 + return 2304 case pe.StringTable: - return 2307 + return 2305 case pe.Symbol: - return 2308 + return 2306 case plan9obj.File: - return 2309 + return 2307 case plan9obj.FileHeader: - return 2310 + return 2308 case plan9obj.Section: - return 2311 + return 2309 case plan9obj.SectionHeader: - return 2312 + return 2310 case plan9obj.Sym: - return 2313 + return 2311 case embed.FS: - return 2314 + return 2312 case ascii85.CorruptInputError: - return 2315 + return 2313 case asn1.BitString: - return 2316 + return 2314 case asn1.Enumerated: - return 2317 + return 2315 case asn1.Flag: - return 2318 + return 2316 case asn1.ObjectIdentifier: - return 2319 + return 2317 case asn1.RawContent: - return 2320 + return 2318 case asn1.RawValue: - return 2321 + return 2319 case asn1.StructuralError: - return 2322 + return 2320 case asn1.SyntaxError: - return 2323 + return 2321 case base32.CorruptInputError: - return 2324 + return 2322 case base32.Encoding: - return 2325 + return 2323 case base64.CorruptInputError: - return 2326 + return 2324 case base64.Encoding: - return 2327 + return 2325 case csv.ParseError: - return 2328 + return 2326 case csv.Reader: - return 2329 + return 2327 case csv.Writer: - return 2330 + return 2328 case gob.CommonType: - return 2331 + return 2329 case gob.Decoder: - return 2332 + return 2330 case gob.Encoder: - return 2333 + return 2331 case hex.InvalidByteError: - return 2334 + return 2332 case json.Decoder: - return 2335 + return 2333 case json.Delim: - return 2336 + return 2334 case json.Encoder: - return 2337 + return 2335 case json.InvalidUTF8Error: - return 2338 + return 2336 case json.InvalidUnmarshalError: - return 2339 + return 2337 case json.MarshalerError: - return 2340 + return 2338 case json.Number: - return 2341 + return 2339 case json.RawMessage: - return 2342 + return 2340 case json.SyntaxError: - return 2343 + return 2341 case json.UnmarshalFieldError: - return 2344 + return 2342 case json.UnmarshalTypeError: - return 2345 + return 2343 case json.UnsupportedTypeError: - return 2346 + return 2344 case json.UnsupportedValueError: - return 2347 + return 2345 case pem.Block: - return 2348 + return 2346 case xml.Attr: - return 2349 + return 2347 case xml.CharData: - return 2350 + return 2348 case xml.Comment: - return 2351 + return 2349 case xml.Decoder: - return 2352 + return 2350 case xml.Directive: - return 2353 + return 2351 case xml.Encoder: - return 2354 + return 2352 case xml.EndElement: - return 2355 + return 2353 case xml.Name: - return 2356 + return 2354 case xml.ProcInst: - return 2357 + return 2355 case xml.StartElement: - return 2358 + return 2356 case xml.SyntaxError: - return 2359 + return 2357 case xml.TagPathError: - return 2360 + return 2358 case xml.UnmarshalError: - return 2361 + return 2359 case xml.UnsupportedTypeError: - return 2362 + return 2360 case expvar.Float: - return 2363 + return 2361 case expvar.Func: - return 2364 + return 2362 case expvar.Int: - return 2365 + return 2363 case expvar.KeyValue: - return 2366 + return 2364 case expvar.Map: - return 2367 + return 2365 case expvar.String: - return 2368 + return 2366 case flag.ErrorHandling: - return 2369 + return 2367 case flag.Flag: - return 2370 + return 2368 case flag.FlagSet: - return 2371 + return 2369 case ast.ArrayType: - return 2372 + return 2370 case ast.AssignStmt: - return 2373 + return 2371 case ast.BadDecl: - return 2374 + return 2372 case ast.BadExpr: - return 2375 + return 2373 case ast.BadStmt: - return 2376 + return 2374 case ast.BasicLit: - return 2377 + return 2375 case ast.BinaryExpr: - return 2378 + return 2376 case ast.BlockStmt: - return 2379 + return 2377 case ast.BranchStmt: - return 2380 + return 2378 case ast.CallExpr: - return 2381 + return 2379 case ast.CaseClause: - return 2382 + return 2380 case ast.ChanDir: - return 2383 + return 2381 case ast.ChanType: - return 2384 + return 2382 case ast.CommClause: - return 2385 + return 2383 case ast.Comment: - return 2386 + return 2384 case ast.CommentGroup: - return 2387 + return 2385 case ast.CommentMap: - return 2388 + return 2386 case ast.CompositeLit: - return 2389 + return 2387 case ast.DeclStmt: - return 2390 + return 2388 case ast.DeferStmt: - return 2391 + return 2389 case ast.Ellipsis: - return 2392 + return 2390 case ast.EmptyStmt: - return 2393 + return 2391 case ast.ExprStmt: - return 2394 + return 2392 case ast.Field: - return 2395 + return 2393 case ast.FieldFilter: - return 2396 + return 2394 case ast.FieldList: - return 2397 + return 2395 case ast.File: - return 2398 + return 2396 case ast.Filter: - return 2399 + return 2397 case ast.ForStmt: - return 2400 + return 2398 case ast.FuncDecl: - return 2401 + return 2399 case ast.FuncLit: - return 2402 + return 2400 case ast.FuncType: - return 2403 + return 2401 case ast.GenDecl: - return 2404 + return 2402 case ast.GoStmt: - return 2405 + return 2403 case ast.Ident: - return 2406 + return 2404 case ast.IfStmt: - return 2407 + return 2405 case ast.ImportSpec: - return 2408 + return 2406 case ast.Importer: - return 2409 + return 2407 case ast.IncDecStmt: - return 2410 + return 2408 case ast.IndexExpr: - return 2411 + return 2409 case ast.IndexListExpr: - return 2412 + return 2410 case ast.InterfaceType: - return 2413 + return 2411 case ast.KeyValueExpr: - return 2414 + return 2412 case ast.LabeledStmt: - return 2415 + return 2413 case ast.MapType: - return 2416 + return 2414 case ast.MergeMode: - return 2417 + return 2415 case ast.ObjKind: - return 2418 + return 2416 case ast.Object: - return 2419 + return 2417 case ast.Package: - return 2420 + return 2418 case ast.ParenExpr: - return 2421 + return 2419 case ast.RangeStmt: - return 2422 + return 2420 case ast.ReturnStmt: - return 2423 + return 2421 case ast.Scope: - return 2424 + return 2422 case ast.SelectStmt: - return 2425 + return 2423 case ast.SelectorExpr: - return 2426 + return 2424 case ast.SendStmt: - return 2427 + return 2425 case ast.SliceExpr: - return 2428 + return 2426 case ast.StarExpr: - return 2429 + return 2427 case ast.StructType: - return 2430 + return 2428 case ast.SwitchStmt: - return 2431 + return 2429 case ast.TypeAssertExpr: - return 2432 + return 2430 case ast.TypeSpec: - return 2433 + return 2431 case ast.TypeSwitchStmt: - return 2434 + return 2432 case ast.UnaryExpr: - return 2435 + return 2433 case ast.ValueSpec: - return 2436 + return 2434 case build.Context: - return 2437 + return 2435 case build.ImportMode: - return 2438 + return 2436 case build.MultiplePackageError: - return 2439 + return 2437 case build.NoGoError: - return 2440 + return 2438 case build.Package: - return 2441 + return 2439 case constraint.AndExpr: - return 2442 + return 2440 case constraint.NotExpr: - return 2443 + return 2441 case constraint.OrExpr: - return 2444 + return 2442 case constraint.SyntaxError: - return 2445 + return 2443 case constraint.TagExpr: - return 2446 + return 2444 case constant.Kind: - return 2447 + return 2445 case doc.Example: - return 2448 + return 2446 case doc.Filter: - return 2449 + return 2447 case doc.Func: - return 2450 + return 2448 case doc.Mode: - return 2451 + return 2449 case doc.Note: - return 2452 + return 2450 case doc.Package: - return 2453 + return 2451 case doc.Type: - return 2454 + return 2452 case doc.Value: - return 2455 + return 2453 case comment.Code: - return 2456 + return 2454 case comment.Doc: - return 2457 + return 2455 case comment.DocLink: - return 2458 + return 2456 case comment.Heading: - return 2459 + return 2457 case comment.Italic: - return 2460 + return 2458 case comment.Link: - return 2461 + return 2459 case comment.LinkDef: - return 2462 + return 2460 case comment.List: - return 2463 + return 2461 case comment.ListItem: - return 2464 + return 2462 case comment.Paragraph: - return 2465 + return 2463 case comment.Parser: - return 2466 + return 2464 case comment.Plain: - return 2467 + return 2465 case comment.Printer: - return 2468 + return 2466 case importer.Lookup: - return 2469 + return 2467 case parser.Mode: - return 2470 + return 2468 case printer.CommentedNode: - return 2471 + return 2469 case printer.Config: - return 2472 + return 2470 case printer.Mode: - return 2473 + return 2471 case scanner.Error: - return 2474 + return 2472 case scanner.ErrorHandler: - return 2475 + return 2473 case scanner.ErrorList: - return 2476 + return 2474 case scanner.Mode: - return 2477 + return 2475 case scanner.Scanner: - return 2478 + return 2476 case token.File: - return 2479 + return 2477 case token.FileSet: - return 2480 + return 2478 case token.Pos: - return 2481 + return 2479 case token.Position: - return 2482 + return 2480 case token.Token: - return 2483 + return 2481 case types.ArgumentError: - return 2484 + return 2482 case types.Array: - return 2485 + return 2483 case types.Basic: - return 2486 + return 2484 case types.BasicInfo: - return 2487 + return 2485 case types.BasicKind: - return 2488 + return 2486 case types.Builtin: - return 2489 + return 2487 case types.Chan: - return 2490 + return 2488 case types.ChanDir: - return 2491 + return 2489 case types.Checker: - return 2492 + return 2490 case types.Config: - return 2493 + return 2491 case types.Const: - return 2494 + return 2492 case types.Context: - return 2495 + return 2493 case types.Error: - return 2496 + return 2494 case types.Func: - return 2497 + return 2495 case types.ImportMode: - return 2498 + return 2496 case types.Info: - return 2499 + return 2497 case types.Initializer: - return 2500 + return 2498 case types.Instance: - return 2501 + return 2499 case types.Interface: - return 2502 + return 2500 case types.Label: - return 2503 + return 2501 case types.Map: - return 2504 + return 2502 case types.MethodSet: - return 2505 + return 2503 case types.Named: - return 2506 + return 2504 case types.Nil: - return 2507 + return 2505 case types.Package: - return 2508 + return 2506 case types.PkgName: - return 2509 + return 2507 case types.Pointer: - return 2510 + return 2508 case types.Qualifier: - return 2511 + return 2509 case types.Scope: - return 2512 + return 2510 case types.Selection: - return 2513 + return 2511 case types.SelectionKind: - return 2514 + return 2512 case types.Signature: - return 2515 + return 2513 case types.Slice: - return 2516 + return 2514 case types.StdSizes: - return 2517 + return 2515 case types.Struct: - return 2518 + return 2516 case types.Term: - return 2519 + return 2517 case types.Tuple: - return 2520 + return 2518 case types.TypeAndValue: - return 2521 + return 2519 case types.TypeList: - return 2522 + return 2520 case types.TypeName: - return 2523 + return 2521 case types.TypeParam: - return 2524 + return 2522 case types.TypeParamList: - return 2525 + return 2523 case types.Union: - return 2526 + return 2524 case types.Var: - return 2527 + return 2525 case crc32.Table: - return 2528 + return 2526 case crc64.Table: - return 2529 + return 2527 case maphash.Hash: - return 2530 + return 2528 case maphash.Seed: - return 2531 + return 2529 case template.CSS: - return 2532 + return 2530 case template.Error: - return 2533 + return 2531 case template.ErrorCode: - return 2534 + return 2532 case template.HTML: - return 2535 + return 2533 case template.HTMLAttr: - return 2536 + return 2534 case template.JS: - return 2537 + return 2535 case template.JSStr: - return 2538 + return 2536 case template.Srcset: - return 2539 + return 2537 case template.Template: - return 2540 + return 2538 case template.URL: - return 2541 + return 2539 case image.Alpha: - return 2542 + return 2540 case image.Alpha16: - return 2543 + return 2541 case image.CMYK: - return 2544 + return 2542 case image.Config: - return 2545 + return 2543 case image.Gray: - return 2546 + return 2544 case image.Gray16: - return 2547 + return 2545 case image.NRGBA: - return 2548 + return 2546 case image.NRGBA64: - return 2549 + return 2547 case image.NYCbCrA: - return 2550 + return 2548 case image.Paletted: - return 2551 + return 2549 case image.Point: - return 2552 + return 2550 case image.RGBA: - return 2553 + return 2551 case image.RGBA64: - return 2554 + return 2552 case image.Rectangle: - return 2555 + return 2553 case image.Uniform: - return 2556 + return 2554 case image.YCbCr: - return 2557 + return 2555 case image.YCbCrSubsampleRatio: - return 2558 + return 2556 case color.Alpha: - return 2559 + return 2557 case color.Alpha16: - return 2560 + return 2558 case color.CMYK: - return 2561 + return 2559 case color.Gray: - return 2562 + return 2560 case color.Gray16: - return 2563 + return 2561 case color.NRGBA: - return 2564 + return 2562 case color.NRGBA64: - return 2565 + return 2563 case color.NYCbCrA: - return 2566 + return 2564 case color.Palette: - return 2567 + return 2565 case color.RGBA: - return 2568 + return 2566 case color.RGBA64: - return 2569 + return 2567 case color.YCbCr: - return 2570 + return 2568 case draw.Op: - return 2571 + return 2569 case gif.GIF: - return 2572 + return 2570 case gif.Options: - return 2573 + return 2571 case jpeg.FormatError: - return 2574 + return 2572 case jpeg.Options: - return 2575 + return 2573 case jpeg.UnsupportedError: - return 2576 + return 2574 case png.CompressionLevel: - return 2577 + return 2575 case png.Encoder: - return 2578 + return 2576 case png.EncoderBuffer: - return 2579 + return 2577 case png.FormatError: - return 2580 + return 2578 case png.UnsupportedError: - return 2581 + return 2579 case suffixarray.Index: - return 2582 + return 2580 case io.LimitedReader: - return 2583 + return 2581 case io.PipeReader: - return 2584 + return 2582 case io.PipeWriter: - return 2585 + return 2583 case io.SectionReader: - return 2586 + return 2584 case fs.FileMode: - return 2587 + return 2585 case fs.PathError: - return 2588 + return 2586 case fs.WalkDirFunc: - return 2589 + return 2587 case log.Logger: - return 2590 + return 2588 case big.Accuracy: - return 2591 + return 2589 case big.ErrNaN: - return 2592 + return 2590 case big.Float: - return 2593 + return 2591 case big.Int: - return 2594 + return 2592 case big.Rat: - return 2595 + return 2593 case big.RoundingMode: - return 2596 + return 2594 case big.Word: - return 2597 + return 2595 case rand.Rand: - return 2598 + return 2596 case rand.Zipf: - return 2599 + return 2597 case mime.WordDecoder: - return 2600 + return 2598 case mime.WordEncoder: - return 2601 + return 2599 case multipart.FileHeader: - return 2602 + return 2600 case multipart.Form: - return 2603 + return 2601 case multipart.Part: - return 2604 + return 2602 case multipart.Reader: - return 2605 + return 2603 case multipart.Writer: - return 2606 + return 2604 case quotedprintable.Reader: - return 2607 + return 2605 case quotedprintable.Writer: - return 2608 + return 2606 case net.AddrError: - return 2609 + return 2607 case net.Buffers: - return 2610 + return 2608 case net.DNSConfigError: - return 2611 + return 2609 case net.DNSError: - return 2612 + return 2610 case net.Dialer: - return 2613 + return 2611 case net.Flags: - return 2614 + return 2612 case net.HardwareAddr: - return 2615 + return 2613 case net.IP: - return 2616 + return 2614 case net.IPAddr: - return 2617 + return 2615 case net.IPConn: - return 2618 + return 2616 case net.IPMask: - return 2619 + return 2617 case net.IPNet: - return 2620 + return 2618 case net.Interface: - return 2621 + return 2619 case net.InvalidAddrError: - return 2622 + return 2620 case net.ListenConfig: - return 2623 + return 2621 case net.MX: - return 2624 + return 2622 case net.NS: - return 2625 + return 2623 case net.OpError: - return 2626 + return 2624 case net.ParseError: - return 2627 + return 2625 case net.Resolver: - return 2628 + return 2626 case net.SRV: - return 2629 + return 2627 case net.TCPAddr: - return 2630 + return 2628 case net.TCPConn: - return 2631 + return 2629 case net.TCPListener: - return 2632 + return 2630 case net.UDPAddr: - return 2633 + return 2631 case net.UDPConn: - return 2634 + return 2632 case net.UnixAddr: - return 2635 + return 2633 case net.UnixConn: - return 2636 + return 2634 case net.UnixListener: - return 2637 + return 2635 case net.UnknownNetworkError: - return 2638 + return 2636 case http.Client: - return 2639 + return 2637 case http.ConnState: - return 2640 + return 2638 case http.Cookie: - return 2641 + return 2639 case http.Dir: - return 2642 + return 2640 case http.HandlerFunc: - return 2643 + return 2641 case http.Header: - return 2644 + return 2642 case http.MaxBytesError: - return 2645 + return 2643 case http.ProtocolError: - return 2646 + return 2644 case http.PushOptions: - return 2647 + return 2645 case http.Request: - return 2648 + return 2646 case http.Response: - return 2649 + return 2647 case http.SameSite: - return 2650 + return 2648 case http.ServeMux: - return 2651 + return 2649 case http.Server: - return 2652 + return 2650 case http.Transport: - return 2653 + return 2651 case cgi.Handler: - return 2654 + return 2652 case cookiejar.Jar: - return 2655 + return 2653 case cookiejar.Options: - return 2656 + return 2654 case httptest.ResponseRecorder: - return 2657 + return 2655 case httptest.Server: - return 2658 + return 2656 case httptrace.ClientTrace: - return 2659 + return 2657 case httptrace.DNSDoneInfo: - return 2660 + return 2658 case httptrace.DNSStartInfo: - return 2661 + return 2659 case httptrace.GotConnInfo: - return 2662 + return 2660 case httptrace.WroteRequestInfo: - return 2663 + return 2661 case httputil.ClientConn: - return 2664 + return 2662 case httputil.ReverseProxy: - return 2665 + return 2663 case httputil.ServerConn: - return 2666 + return 2664 case mail.Address: - return 2667 + return 2665 case mail.AddressParser: - return 2668 + return 2666 case mail.Header: - return 2669 + return 2667 case mail.Message: - return 2670 + return 2668 case netip.Addr: - return 2671 + return 2669 case netip.AddrPort: - return 2672 + return 2670 case netip.Prefix: - return 2673 + return 2671 case rpc.Call: - return 2674 + return 2672 case rpc.Client: - return 2675 + return 2673 case rpc.Request: - return 2676 + return 2674 case rpc.Response: - return 2677 + return 2675 case rpc.Server: - return 2678 + return 2676 case rpc.ServerError: - return 2679 + return 2677 case smtp.Client: - return 2680 + return 2678 case smtp.ServerInfo: - return 2681 + return 2679 case textproto.Conn: - return 2682 + return 2680 case textproto.Error: - return 2683 + return 2681 case textproto.MIMEHeader: - return 2684 + return 2682 case textproto.Pipeline: - return 2685 + return 2683 case textproto.ProtocolError: - return 2686 + return 2684 case textproto.Reader: - return 2687 + return 2685 case textproto.Writer: - return 2688 + return 2686 case url.Error: - return 2689 + return 2687 case url.EscapeError: - return 2690 + return 2688 case url.InvalidHostError: - return 2691 + return 2689 case url.URL: - return 2692 + return 2690 case url.Userinfo: - return 2693 + return 2691 case url.Values: - return 2694 + return 2692 case os.File: - return 2695 + return 2693 case os.LinkError: - return 2696 + return 2694 case os.ProcAttr: - return 2697 + return 2695 case os.Process: - return 2698 + return 2696 case os.ProcessState: - return 2699 + return 2697 case os.SyscallError: - return 2700 + return 2698 case exec.Cmd: - return 2701 + return 2699 case exec.Error: - return 2702 + return 2700 case exec.ExitError: - return 2703 + return 2701 case user.Group: - return 2704 + return 2702 case user.UnknownGroupError: - return 2705 + return 2703 case user.UnknownGroupIdError: - return 2706 + return 2704 case user.UnknownUserError: - return 2707 + return 2705 case user.UnknownUserIdError: - return 2708 + return 2706 case user.User: - return 2709 + return 2707 case filepath.WalkFunc: - return 2710 + return 2708 case plugin.Plugin: - return 2711 + return 2709 case reflect.ChanDir: - return 2712 + return 2710 case reflect.Kind: - return 2713 + return 2711 case reflect.MapIter: - return 2714 + return 2712 case reflect.Method: - return 2715 + return 2713 case reflect.SelectCase: - return 2716 + return 2714 case reflect.SelectDir: - return 2717 + return 2715 case reflect.SliceHeader: - return 2718 + return 2716 case reflect.StringHeader: - return 2719 + return 2717 case reflect.StructField: - return 2720 + return 2718 case reflect.StructTag: - return 2721 + return 2719 case reflect.Value: - return 2722 + return 2720 case reflect.ValueError: - return 2723 + return 2721 case regexp.Regexp: - return 2724 + return 2722 case syntax.EmptyOp: - return 2725 + return 2723 case syntax.Error: - return 2726 + return 2724 case syntax.ErrorCode: - return 2727 + return 2725 case syntax.Flags: - return 2728 + return 2726 case syntax.Inst: - return 2729 + return 2727 case syntax.InstOp: - return 2730 + return 2728 case syntax.Op: - return 2731 + return 2729 case syntax.Prog: - return 2732 + return 2730 case syntax.Regexp: - return 2733 + return 2731 case runtime.BlockProfileRecord: - return 2734 + return 2732 case runtime.Frame: - return 2735 + return 2733 case runtime.Frames: - return 2736 + return 2734 case runtime.Func: - return 2737 + return 2735 case runtime.MemProfileRecord: - return 2738 + return 2736 case runtime.MemStats: - return 2739 + return 2737 case runtime.StackRecord: - return 2740 + return 2738 case runtime.TypeAssertionError: - return 2741 + return 2739 case cgo.Handle: - return 2742 + return 2740 case debug.BuildInfo: - return 2743 + return 2741 case debug.BuildSetting: - return 2744 + return 2742 case debug.GCStats: - return 2745 + return 2743 case debug.Module: - return 2746 + return 2744 case metrics.Description: - return 2747 + return 2745 case metrics.Float64Histogram: - return 2748 + return 2746 case metrics.Sample: - return 2749 + return 2747 case metrics.Value: - return 2750 + return 2748 case metrics.ValueKind: - return 2751 + return 2749 case pprof.LabelSet: - return 2752 + return 2750 case pprof.Profile: - return 2753 + return 2751 case trace.Region: - return 2754 + return 2752 case trace.Task: - return 2755 + return 2753 case sort.Float64Slice: - return 2756 + return 2754 case sort.IntSlice: - return 2757 + return 2755 case sort.StringSlice: - return 2758 + return 2756 case strconv.NumError: - return 2759 + return 2757 case strings.Builder: - return 2760 + return 2758 case strings.Reader: - return 2761 + return 2759 case strings.Replacer: - return 2762 + return 2760 case sync.Cond: - return 2763 + return 2761 case sync.Map: - return 2764 + return 2762 case sync.Mutex: - return 2765 + return 2763 case sync.Once: - return 2766 + return 2764 case sync.Pool: - return 2767 + return 2765 case sync.RWMutex: - return 2768 + return 2766 case sync.WaitGroup: - return 2769 + return 2767 case atomic.Bool: - return 2770 + return 2768 case atomic.Int32: - return 2771 + return 2769 case atomic.Int64: - return 2772 - case atomic.Pointer: - return 2773 + return 2770 case atomic.Uint32: - return 2774 + return 2771 case atomic.Uint64: - return 2775 + return 2772 case atomic.Uintptr: - return 2776 + return 2773 case atomic.Value: - return 2777 + return 2774 case syscall.AddrinfoW: - return 2778 + return 2775 case syscall.ByHandleFileInformation: - return 2779 + return 2776 case syscall.CertChainContext: - return 2780 + return 2777 case syscall.CertChainElement: - return 2781 + return 2778 case syscall.CertChainPara: - return 2782 + return 2779 case syscall.CertChainPolicyPara: - return 2783 + return 2780 case syscall.CertChainPolicyStatus: - return 2784 + return 2781 case syscall.CertContext: - return 2785 + return 2782 case syscall.CertEnhKeyUsage: - return 2786 + return 2783 case syscall.CertInfo: - return 2787 + return 2784 case syscall.CertRevocationCrlInfo: - return 2788 + return 2785 case syscall.CertRevocationInfo: - return 2789 + return 2786 case syscall.CertSimpleChain: - return 2790 + return 2787 case syscall.CertTrustListInfo: - return 2791 + return 2788 case syscall.CertTrustStatus: - return 2792 + return 2789 case syscall.CertUsageMatch: - return 2793 + return 2790 case syscall.DLL: - return 2794 + return 2791 case syscall.DLLError: - return 2795 + return 2792 case syscall.DNSMXData: - return 2796 + return 2793 case syscall.DNSPTRData: - return 2797 + return 2794 case syscall.DNSRecord: - return 2798 + return 2795 case syscall.DNSSRVData: - return 2799 + return 2796 case syscall.DNSTXTData: - return 2800 + return 2797 case syscall.Errno: - return 2801 + return 2798 case syscall.FileNotifyInformation: - return 2802 + return 2799 case syscall.Filetime: - return 2803 + return 2800 case syscall.GUID: - return 2804 + return 2801 case syscall.Handle: - return 2805 + return 2802 case syscall.Hostent: - return 2806 + return 2803 case syscall.IPMreq: - return 2807 + return 2804 case syscall.IPv6Mreq: - return 2808 + return 2805 case syscall.InterfaceInfo: - return 2809 + return 2806 case syscall.IpAdapterInfo: - return 2810 + return 2807 case syscall.IpAddrString: - return 2811 + return 2808 case syscall.IpAddressString: - return 2812 + return 2809 case syscall.IpMaskString: - return 2813 + return 2810 case syscall.LazyDLL: - return 2814 + return 2811 case syscall.LazyProc: - return 2815 + return 2812 case syscall.Linger: - return 2816 + return 2813 case syscall.MibIfRow: - return 2817 + return 2814 case syscall.Overlapped: - return 2818 + return 2815 case syscall.Pointer: - return 2819 + return 2816 case syscall.Proc: - return 2820 + return 2817 case syscall.ProcAttr: - return 2821 + return 2818 case syscall.ProcessEntry32: - return 2822 + return 2819 case syscall.ProcessInformation: - return 2823 + return 2820 case syscall.Protoent: - return 2824 + return 2821 case syscall.RawSockaddr: - return 2825 + return 2822 case syscall.RawSockaddrAny: - return 2826 + return 2823 case syscall.RawSockaddrInet4: - return 2827 + return 2824 case syscall.RawSockaddrInet6: - return 2828 + return 2825 case syscall.RawSockaddrUnix: - return 2829 + return 2826 case syscall.Rusage: - return 2830 + return 2827 case syscall.SID: - return 2831 + return 2828 case syscall.SIDAndAttributes: - return 2832 + return 2829 case syscall.SSLExtraCertChainPolicyPara: - return 2833 + return 2830 case syscall.SecurityAttributes: - return 2834 + return 2831 case syscall.Servent: - return 2835 + return 2832 case syscall.Signal: - return 2836 + return 2833 case syscall.SockaddrGen: - return 2837 + return 2834 case syscall.SockaddrInet4: - return 2838 + return 2835 case syscall.SockaddrInet6: - return 2839 + return 2836 case syscall.SockaddrUnix: - return 2840 + return 2837 case syscall.StartupInfo: - return 2841 + return 2838 case syscall.SysProcAttr: - return 2842 + return 2839 case syscall.Systemtime: - return 2843 + return 2840 case syscall.TCPKeepalive: - return 2844 + return 2841 case syscall.Timespec: - return 2845 + return 2842 case syscall.Timeval: - return 2846 + return 2843 case syscall.Timezoneinformation: - return 2847 + return 2844 case syscall.Token: - return 2848 + return 2845 case syscall.Tokenprimarygroup: - return 2849 + return 2846 case syscall.Tokenuser: - return 2850 + return 2847 case syscall.TransmitFileBuffers: - return 2851 + return 2848 case syscall.UserInfo10: - return 2852 + return 2849 case syscall.WSABuf: - return 2853 + return 2850 case syscall.WSAData: - return 2854 + return 2851 case syscall.WSAProtocolChain: - return 2855 + return 2852 case syscall.WSAProtocolInfo: - return 2856 + return 2853 case syscall.WaitStatus: - return 2857 + return 2854 case syscall.Win32FileAttributeData: - return 2858 + return 2855 case syscall.Win32finddata: - return 2859 + return 2856 case testing.B: - return 2860 + return 2857 case testing.BenchmarkResult: - return 2861 + return 2858 case testing.Cover: - return 2862 + return 2859 case testing.CoverBlock: - return 2863 + return 2860 case testing.F: - return 2864 + return 2861 case testing.InternalBenchmark: - return 2865 + return 2862 case testing.InternalExample: - return 2866 + return 2863 case testing.InternalFuzzTarget: - return 2867 + return 2864 case testing.InternalTest: - return 2868 + return 2865 case testing.M: - return 2869 + return 2866 case testing.PB: - return 2870 + return 2867 case testing.T: - return 2871 + return 2868 case fstest.MapFS: - return 2872 + return 2869 case fstest.MapFile: - return 2873 + return 2870 case quick.CheckEqualError: - return 2874 + return 2871 case quick.CheckError: - return 2875 + return 2872 case quick.Config: - return 2876 + return 2873 case quick.SetupError: - return 2877 + return 2874 case text_scanner.Position: - return 2878 + return 2875 case text_scanner.Scanner: - return 2879 + return 2876 case tabwriter.Writer: - return 2880 + return 2877 case text_template.ExecError: - return 2881 + return 2878 case text_template.FuncMap: - return 2882 + return 2879 case text_template.Template: - return 2883 + return 2880 case parse.ActionNode: - return 2884 + return 2881 case parse.BoolNode: - return 2885 + return 2882 case parse.BranchNode: - return 2886 + return 2883 case parse.BreakNode: - return 2887 + return 2884 case parse.ChainNode: - return 2888 + return 2885 case parse.CommandNode: - return 2889 + return 2886 case parse.CommentNode: - return 2890 + return 2887 case parse.ContinueNode: - return 2891 + return 2888 case parse.DotNode: - return 2892 + return 2889 case parse.FieldNode: - return 2893 + return 2890 case parse.IdentifierNode: - return 2894 + return 2891 case parse.IfNode: - return 2895 + return 2892 case parse.ListNode: - return 2896 + return 2893 case parse.Mode: - return 2897 + return 2894 case parse.NilNode: - return 2898 + return 2895 case parse.NodeType: - return 2899 + return 2896 case parse.NumberNode: - return 2900 + return 2897 case parse.PipeNode: - return 2901 + return 2898 case parse.Pos: - return 2902 + return 2899 case parse.RangeNode: - return 2903 + return 2900 case parse.StringNode: - return 2904 + return 2901 case parse.TemplateNode: - return 2905 + return 2902 case parse.TextNode: - return 2906 + return 2903 case parse.Tree: - return 2907 + return 2904 case parse.VariableNode: - return 2908 + return 2905 case parse.WithNode: - return 2909 + return 2906 case time.Duration: - return 2910 + return 2907 case time.Location: - return 2911 + return 2908 case time.Month: - return 2912 + return 2909 case time.ParseError: - return 2913 + return 2910 case time.Ticker: - return 2914 + return 2911 case time.Time: - return 2915 + return 2912 case time.Timer: - return 2916 + return 2913 case time.Weekday: - return 2917 + return 2914 case unicode.CaseRange: - return 2918 + return 2915 case unicode.Range16: - return 2919 + return 2916 case unicode.Range32: - return 2920 + return 2917 case unicode.RangeTable: - return 2921 + return 2918 case unicode.SpecialCase: - return 2922 + return 2919 case unsafe.Pointer: - return 2923 + return 2920 case reflect.Type: // Specificity=31 - return 2924 + return 2921 case testing.TB: // Specificity=19 - return 2925 + return 2922 case types.Object: // Specificity=17 - return 2926 + return 2923 case net.Conn: // Specificity=8 - return 2927 + return 2924 case binary.ByteOrder: // Specificity=7 - return 2928 + return 2925 case net.PacketConn: // Specificity=7 - return 2929 + return 2926 case elliptic.Curve: // Specificity=6 - return 2930 + return 2927 case fmt.ScanState: // Specificity=6 - return 2931 + return 2928 case hash.Hash32: // Specificity=6 - return 2932 + return 2929 case hash.Hash64: // Specificity=6 - return 2933 + return 2930 case draw.RGBA64Image: // Specificity=6 - return 2934 + return 2931 case fs.FileInfo: // Specificity=6 - return 2935 + return 2932 case parse.Node: // Specificity=6 - return 2936 + return 2933 case heap.Interface: // Specificity=5 - return 2937 + return 2934 case driver.RowsNextResultSet: // Specificity=5 - return 2938 + return 2935 case hash.Hash: // Specificity=5 - return 2939 + return 2936 case http.File: // Specificity=5 - return 2940 + return 2937 case context.Context: // Specificity=4 - return 2941 + return 2938 case cipher.AEAD: // Specificity=4 - return 2942 + return 2939 case driver.RowsColumnTypeDatabaseTypeName: // Specificity=4 - return 2943 + return 2940 case driver.RowsColumnTypeLength: // Specificity=4 - return 2944 + return 2941 case driver.RowsColumnTypeNullable: // Specificity=4 - return 2945 + return 2942 case driver.RowsColumnTypePrecisionScale: // Specificity=4 - return 2946 + return 2943 case driver.RowsColumnTypeScanType: // Specificity=4 - return 2947 + return 2944 case driver.Stmt: // Specificity=4 - return 2948 + return 2945 case binary.AppendByteOrder: // Specificity=4 - return 2949 + return 2946 case fmt.State: // Specificity=4 - return 2950 + return 2947 case constant.Value: // Specificity=4 - return 2951 + return 2948 case image.PalettedImage: // Specificity=4 - return 2952 + return 2949 case image.RGBA64Image: // Specificity=4 - return 2953 + return 2950 case draw.Image: // Specificity=4 - return 2954 + return 2951 case fs.DirEntry: // Specificity=4 - return 2955 + return 2952 case fs.ReadDirFile: // Specificity=4 - return 2956 + return 2953 case multipart.File: // Specificity=4 - return 2957 + return 2954 case rpc.ClientCodec: // Specificity=4 - return 2958 + return 2955 case rpc.ServerCodec: // Specificity=4 - return 2959 + return 2956 case cipher.Block: // Specificity=3 - return 2960 + return 2957 case driver.Conn: // Specificity=3 - return 2961 + return 2958 case driver.Rows: // Specificity=3 - return 2962 + return 2959 case dwarf.Type: // Specificity=3 - return 2963 + return 2960 case flag.Getter: // Specificity=3 - return 2964 + return 2961 case ast.Decl: // Specificity=3 - return 2965 + return 2962 case ast.Expr: // Specificity=3 - return 2966 + return 2963 case ast.Spec: // Specificity=3 - return 2967 + return 2964 case ast.Stmt: // Specificity=3 - return 2968 + return 2965 case constraint.Expr: // Specificity=3 - return 2969 + return 2966 case types.Sizes: // Specificity=3 - return 2970 + return 2967 case image.Image: // Specificity=3 - return 2971 + return 2968 case io.ReadSeekCloser: // Specificity=3 - return 2972 + return 2969 case io.ReadWriteCloser: // Specificity=3 - return 2973 + return 2970 case io.ReadWriteSeeker: // Specificity=3 - return 2974 + return 2971 case fs.File: // Specificity=3 - return 2975 + return 2972 case rand.Source64: // Specificity=3 - return 2976 + return 2973 case net.Error: // Specificity=3 - return 2977 + return 2974 case net.Listener: // Specificity=3 - return 2978 + return 2975 case http.ResponseWriter: // Specificity=3 - return 2979 + return 2976 case sort.Interface: // Specificity=3 - return 2980 + return 2977 case syscall.RawConn: // Specificity=3 - return 2981 + return 2978 case flate.Reader: // Specificity=2 - return 2982 + return 2979 case crypto.Decrypter: // Specificity=2 - return 2983 + return 2980 case crypto.Signer: // Specificity=2 - return 2984 + return 2981 case cipher.BlockMode: // Specificity=2 - return 2985 + return 2982 case tls.ClientSessionCache: // Specificity=2 - return 2986 + return 2983 case sql.Result: // Specificity=2 - return 2987 + return 2984 case driver.Connector: // Specificity=2 - return 2988 + return 2985 case driver.Result: // Specificity=2 - return 2989 + return 2986 case driver.Tx: // Specificity=2 - return 2990 + return 2987 case flag.Value: // Specificity=2 - return 2991 + return 2988 case ast.Node: // Specificity=2 - return 2992 + return 2989 case types.ImporterFrom: // Specificity=2 - return 2993 + return 2990 case types.Type: // Specificity=2 - return 2994 + return 2991 case jpeg.Reader: // Specificity=2 - return 2995 + return 2992 case png.EncoderBufferPool: // Specificity=2 - return 2996 + return 2993 case io.ByteScanner: // Specificity=2 - return 2997 + return 2994 case io.ReadCloser: // Specificity=2 - return 2998 + return 2995 case io.ReadSeeker: // Specificity=2 - return 2999 + return 2996 case io.ReadWriter: // Specificity=2 - return 3000 + return 2997 case io.RuneScanner: // Specificity=2 - return 3001 + return 2998 case io.WriteCloser: // Specificity=2 - return 3002 + return 2999 case io.WriteSeeker: // Specificity=2 - return 3003 + return 3000 case fs.GlobFS: // Specificity=2 - return 3004 + return 3001 case fs.ReadDirFS: // Specificity=2 - return 3005 + return 3002 case fs.ReadFileFS: // Specificity=2 - return 3006 + return 3003 case fs.StatFS: // Specificity=2 - return 3007 + return 3004 case fs.SubFS: // Specificity=2 - return 3008 + return 3005 case rand.Source: // Specificity=2 - return 3009 + return 3006 case net.Addr: // Specificity=2 - return 3010 + return 3007 case http.CookieJar: // Specificity=2 - return 3011 + return 3008 case cookiejar.PublicSuffixList: // Specificity=2 - return 3012 + return 3009 case httputil.BufferPool: // Specificity=2 - return 3013 + return 3010 case smtp.Auth: // Specificity=2 - return 3014 + return 3011 case os.Signal: // Specificity=2 - return 3015 + return 3012 case runtime.Error: // Specificity=2 - return 3016 + return 3013 case sync.Locker: // Specificity=2 - return 3017 + return 3014 case flate.Resetter: // Specificity=1 - return 3018 + return 3015 case zlib.Resetter: // Specificity=1 - return 3019 + return 3016 case crypto.SignerOpts: // Specificity=1 - return 3020 + return 3017 case cipher.Stream: // Specificity=1 - return 3021 + return 3018 case sql.Scanner: // Specificity=1 - return 3022 + return 3019 case driver.ColumnConverter: // Specificity=1 - return 3023 + return 3020 case driver.ConnBeginTx: // Specificity=1 - return 3024 + return 3021 case driver.ConnPrepareContext: // Specificity=1 - return 3025 + return 3022 case driver.Driver: // Specificity=1 - return 3026 + return 3023 case driver.DriverContext: // Specificity=1 - return 3027 + return 3024 case driver.Execer: // Specificity=1 - return 3028 + return 3025 case driver.ExecerContext: // Specificity=1 - return 3029 + return 3026 case driver.NamedValueChecker: // Specificity=1 - return 3030 + return 3027 case driver.Pinger: // Specificity=1 - return 3031 + return 3028 case driver.Queryer: // Specificity=1 - return 3032 + return 3029 case driver.QueryerContext: // Specificity=1 - return 3033 + return 3030 case driver.SessionResetter: // Specificity=1 - return 3034 + return 3031 case driver.StmtExecContext: // Specificity=1 - return 3035 + return 3032 case driver.StmtQueryContext: // Specificity=1 - return 3036 + return 3033 case driver.Validator: // Specificity=1 - return 3037 + return 3034 case driver.ValueConverter: // Specificity=1 - return 3038 + return 3035 case driver.Valuer: // Specificity=1 - return 3039 + return 3036 case macho.Load: // Specificity=1 - return 3040 + return 3037 case encoding.BinaryMarshaler: // Specificity=1 - return 3041 + return 3038 case encoding.BinaryUnmarshaler: // Specificity=1 - return 3042 + return 3039 case encoding.TextMarshaler: // Specificity=1 - return 3043 + return 3040 case encoding.TextUnmarshaler: // Specificity=1 - return 3044 + return 3041 case gob.GobDecoder: // Specificity=1 - return 3045 + return 3042 case gob.GobEncoder: // Specificity=1 - return 3046 + return 3043 case json.Marshaler: // Specificity=1 - return 3047 + return 3044 case json.Unmarshaler: // Specificity=1 - return 3048 + return 3045 case xml.Marshaler: // Specificity=1 - return 3049 + return 3046 case xml.MarshalerAttr: // Specificity=1 - return 3050 + return 3047 case xml.TokenReader: // Specificity=1 - return 3051 + return 3048 case xml.Unmarshaler: // Specificity=1 - return 3052 + return 3049 case xml.UnmarshalerAttr: // Specificity=1 - return 3053 + return 3050 case expvar.Var: // Specificity=1 - return 3054 + return 3051 case fmt.Formatter: // Specificity=1 - return 3055 + return 3052 case fmt.GoStringer: // Specificity=1 - return 3056 + return 3053 case fmt.Scanner: // Specificity=1 - return 3057 + return 3054 case fmt.Stringer: // Specificity=1 - return 3058 + return 3055 case ast.Visitor: // Specificity=1 - return 3059 + return 3056 case comment.Block: // Specificity=1 - return 3060 + return 3057 case comment.Text: // Specificity=1 - return 3061 + return 3058 case types.Importer: // Specificity=1 - return 3062 + return 3059 case color.Color: // Specificity=1 - return 3063 + return 3060 case color.Model: // Specificity=1 - return 3064 + return 3061 case draw.Drawer: // Specificity=1 - return 3065 + return 3062 case draw.Quantizer: // Specificity=1 - return 3066 + return 3063 case io.ByteReader: // Specificity=1 - return 3067 + return 3064 case io.ByteWriter: // Specificity=1 - return 3068 + return 3065 case io.Closer: // Specificity=1 - return 3069 + return 3066 case io.Reader: // Specificity=1 - return 3070 + return 3067 case io.ReaderAt: // Specificity=1 - return 3071 + return 3068 case io.ReaderFrom: // Specificity=1 - return 3072 + return 3069 case io.RuneReader: // Specificity=1 - return 3073 + return 3070 case io.Seeker: // Specificity=1 - return 3074 + return 3071 case io.StringWriter: // Specificity=1 - return 3075 + return 3072 case io.Writer: // Specificity=1 - return 3076 + return 3073 case io.WriterAt: // Specificity=1 - return 3077 + return 3074 case io.WriterTo: // Specificity=1 - return 3078 + return 3075 case fs.FS: // Specificity=1 - return 3079 + return 3076 case http.CloseNotifier: // Specificity=1 - return 3080 + return 3077 case http.FileSystem: // Specificity=1 - return 3081 + return 3078 case http.Flusher: // Specificity=1 - return 3082 + return 3079 case http.Handler: // Specificity=1 - return 3083 + return 3080 case http.Hijacker: // Specificity=1 - return 3084 + return 3081 case http.Pusher: // Specificity=1 - return 3085 + return 3082 case http.RoundTripper: // Specificity=1 - return 3086 + return 3083 case syscall.Conn: // Specificity=1 - return 3087 + return 3084 case syscall.Sockaddr: // Specificity=1 - return 3088 + return 3085 case quick.Generator: // Specificity=1 - return 3089 + return 3086 } return -1 } @@ -10486,18 +10480,18 @@ func initNative() { GoMembers{ }) - GoTypesVec[2029] = &info_Format + GoTypesVec[2027] = &info_Format GoTypesVec[9] = &info_PtrTo_Format - GoTypesVec[963] = &info_ArrayOf_Format - GoTypesVec[2030] = &info_Header + GoTypesVec[962] = &info_ArrayOf_Format + GoTypesVec[2028] = &info_Header GoTypesVec[10] = &info_PtrTo_Header - GoTypesVec[964] = &info_ArrayOf_Header - GoTypesVec[2031] = &info_Reader + GoTypesVec[963] = &info_ArrayOf_Header + GoTypesVec[2029] = &info_Reader GoTypesVec[11] = &info_PtrTo_Reader - GoTypesVec[965] = &info_ArrayOf_Reader - GoTypesVec[2032] = &info_Writer + GoTypesVec[964] = &info_ArrayOf_Reader + GoTypesVec[2030] = &info_Writer GoTypesVec[12] = &info_PtrTo_Writer - GoTypesVec[966] = &info_ArrayOf_Writer + GoTypesVec[965] = &info_ArrayOf_Writer EnsureLoaded("go.std.bytes") // E.g. from: C:\Program Files\Go\src\archive\tar\reader.go:8:2 EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\archive\tar\common.go:14:2 EnsureLoaded("go.std.fmt") // E.g. from: C:\Program Files\Go\src\archive\tar\common.go:15:2 @@ -12469,27 +12463,27 @@ func initNative() { GoMembers{ }) - GoTypesVec[2033] = &info_Compressor + GoTypesVec[2031] = &info_Compressor GoTypesVec[13] = &info_PtrTo_Compressor - GoTypesVec[967] = &info_ArrayOf_Compressor - GoTypesVec[2034] = &info_Decompressor + GoTypesVec[966] = &info_ArrayOf_Compressor + GoTypesVec[2032] = &info_Decompressor GoTypesVec[14] = &info_PtrTo_Decompressor - GoTypesVec[968] = &info_ArrayOf_Decompressor - GoTypesVec[2035] = &info_File + GoTypesVec[967] = &info_ArrayOf_Decompressor + GoTypesVec[2033] = &info_File GoTypesVec[15] = &info_PtrTo_File - GoTypesVec[2036] = &info_FileHeader + GoTypesVec[2034] = &info_FileHeader GoTypesVec[16] = &info_PtrTo_FileHeader - GoTypesVec[970] = &info_ArrayOf_FileHeader - GoTypesVec[969] = &info_ArrayOf_File - GoTypesVec[2037] = &info_ReadCloser + GoTypesVec[969] = &info_ArrayOf_FileHeader + GoTypesVec[968] = &info_ArrayOf_File + GoTypesVec[2035] = &info_ReadCloser GoTypesVec[17] = &info_PtrTo_ReadCloser - GoTypesVec[971] = &info_ArrayOf_ReadCloser - GoTypesVec[2038] = &info_Reader + GoTypesVec[970] = &info_ArrayOf_ReadCloser + GoTypesVec[2036] = &info_Reader GoTypesVec[18] = &info_PtrTo_Reader - GoTypesVec[972] = &info_ArrayOf_Reader - GoTypesVec[2039] = &info_Writer + GoTypesVec[971] = &info_ArrayOf_Reader + GoTypesVec[2037] = &info_Writer GoTypesVec[19] = &info_PtrTo_Writer - GoTypesVec[973] = &info_ArrayOf_Writer + GoTypesVec[972] = &info_ArrayOf_Writer EnsureLoaded("go.std.bufio") // E.g. from: C:\Program Files\Go\src\archive\zip\reader.go:8:2 EnsureLoaded("go.std.compress.flate") // E.g. from: C:\Program Files\Go\src\archive\zip\register.go:8:2 EnsureLoaded("go.std.encoding.binary") // E.g. from: C:\Program Files\Go\src\archive\zip\reader.go:9:2 @@ -14544,21 +14538,21 @@ func initNative() { GoMembers{ }) - GoTypesVec[2040] = &info_ReadWriter + GoTypesVec[2038] = &info_ReadWriter GoTypesVec[20] = &info_PtrTo_ReadWriter - GoTypesVec[974] = &info_ArrayOf_ReadWriter - GoTypesVec[2041] = &info_Reader + GoTypesVec[973] = &info_ArrayOf_ReadWriter + GoTypesVec[2039] = &info_Reader GoTypesVec[21] = &info_PtrTo_Reader - GoTypesVec[975] = &info_ArrayOf_Reader - GoTypesVec[2042] = &info_Scanner + GoTypesVec[974] = &info_ArrayOf_Reader + GoTypesVec[2040] = &info_Scanner GoTypesVec[22] = &info_PtrTo_Scanner - GoTypesVec[976] = &info_ArrayOf_Scanner - GoTypesVec[2043] = &info_SplitFunc + GoTypesVec[975] = &info_ArrayOf_Scanner + GoTypesVec[2041] = &info_SplitFunc GoTypesVec[23] = &info_PtrTo_SplitFunc - GoTypesVec[977] = &info_ArrayOf_SplitFunc - GoTypesVec[2044] = &info_Writer + GoTypesVec[976] = &info_ArrayOf_SplitFunc + GoTypesVec[2042] = &info_Writer GoTypesVec[24] = &info_PtrTo_Writer - GoTypesVec[978] = &info_ArrayOf_Writer + GoTypesVec[977] = &info_ArrayOf_Writer EnsureLoaded("go.std.bytes") // E.g. from: C:\Program Files\Go\src\bufio\bufio.go:11:2 EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\bufio\bufio.go:12:2 EnsureLoaded("go.std.io") // E.g. from: C:\Program Files\Go\src\bufio\bufio.go:13:2 @@ -15847,12 +15841,12 @@ func initNative() { GoMembers{ }) - GoTypesVec[2045] = &info_Buffer + GoTypesVec[2043] = &info_Buffer GoTypesVec[25] = &info_PtrTo_Buffer - GoTypesVec[979] = &info_ArrayOf_Buffer - GoTypesVec[2046] = &info_Reader + GoTypesVec[978] = &info_ArrayOf_Buffer + GoTypesVec[2044] = &info_Reader GoTypesVec[26] = &info_PtrTo_Reader - GoTypesVec[980] = &info_ArrayOf_Reader + GoTypesVec[979] = &info_ArrayOf_Reader EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\bytes\buffer.go:10:2 EnsureLoaded("go.std.io") // E.g. from: C:\Program Files\Go\src\bytes\buffer.go:11:2 EnsureLoaded("go.std.unicode") // E.g. from: C:\Program Files\Go\src\bytes\bytes.go:11:2 @@ -16115,9 +16109,9 @@ func initNative() { GoMembers{ }) - GoTypesVec[2049] = &info_StructuralError + GoTypesVec[2047] = &info_StructuralError GoTypesVec[27] = &info_PtrTo_StructuralError - GoTypesVec[981] = &info_ArrayOf_StructuralError + GoTypesVec[980] = &info_ArrayOf_StructuralError EnsureLoaded("go.std.bufio") // E.g. from: C:\Program Files\Go\src\compress\bzip2\bit_reader.go:8:2 EnsureLoaded("go.std.io") // E.g. from: C:\Program Files\Go\src\compress\bzip2\bit_reader.go:9:2 EnsureLoaded("go.std.sort") // E.g. from: C:\Program Files\Go\src\compress\bzip2\huffman.go:7:8 @@ -17696,25 +17690,25 @@ func initNative() { GoMembers{ }) - GoTypesVec[2050] = &info_CorruptInputError + GoTypesVec[2048] = &info_CorruptInputError GoTypesVec[28] = &info_PtrTo_CorruptInputError - GoTypesVec[982] = &info_ArrayOf_CorruptInputError - GoTypesVec[2051] = &info_InternalError + GoTypesVec[981] = &info_ArrayOf_CorruptInputError + GoTypesVec[2049] = &info_InternalError GoTypesVec[29] = &info_PtrTo_InternalError - GoTypesVec[983] = &info_ArrayOf_InternalError - GoTypesVec[2052] = &info_ReadError + GoTypesVec[982] = &info_ArrayOf_InternalError + GoTypesVec[2050] = &info_ReadError GoTypesVec[30] = &info_PtrTo_ReadError - GoTypesVec[984] = &info_ArrayOf_ReadError - GoTypesVec[2982] = &info_Reader - GoTypesVec[985] = &info_ArrayOf_Reader - GoTypesVec[3018] = &info_Resetter - GoTypesVec[986] = &info_ArrayOf_Resetter - GoTypesVec[2053] = &info_WriteError + GoTypesVec[983] = &info_ArrayOf_ReadError + GoTypesVec[2979] = &info_Reader + GoTypesVec[984] = &info_ArrayOf_Reader + GoTypesVec[3015] = &info_Resetter + GoTypesVec[985] = &info_ArrayOf_Resetter + GoTypesVec[2051] = &info_WriteError GoTypesVec[31] = &info_PtrTo_WriteError - GoTypesVec[987] = &info_ArrayOf_WriteError - GoTypesVec[2054] = &info_Writer + GoTypesVec[986] = &info_ArrayOf_WriteError + GoTypesVec[2052] = &info_Writer GoTypesVec[32] = &info_PtrTo_Writer - GoTypesVec[988] = &info_ArrayOf_Writer + GoTypesVec[987] = &info_ArrayOf_Writer EnsureLoaded("go.std.bufio") // E.g. from: C:\Program Files\Go\src\compress\flate\inflate.go:11:2 EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\compress\flate\deflate.go:8:2 EnsureLoaded("go.std.fmt") // E.g. from: C:\Program Files\Go\src\compress\flate\deflate.go:9:2 @@ -18574,15 +18568,15 @@ func initNative() { GoMembers{ }) - GoTypesVec[2055] = &info_Header + GoTypesVec[2053] = &info_Header GoTypesVec[33] = &info_PtrTo_Header - GoTypesVec[989] = &info_ArrayOf_Header - GoTypesVec[2056] = &info_Reader + GoTypesVec[988] = &info_ArrayOf_Header + GoTypesVec[2054] = &info_Reader GoTypesVec[34] = &info_PtrTo_Reader - GoTypesVec[990] = &info_ArrayOf_Reader - GoTypesVec[2057] = &info_Writer + GoTypesVec[989] = &info_ArrayOf_Reader + GoTypesVec[2055] = &info_Writer GoTypesVec[35] = &info_PtrTo_Writer - GoTypesVec[991] = &info_ArrayOf_Writer + GoTypesVec[990] = &info_ArrayOf_Writer EnsureLoaded("go.std.bufio") // E.g. from: C:\Program Files\Go\src\compress\gzip\gunzip.go:10:2 EnsureLoaded("go.std.compress.flate") // E.g. from: C:\Program Files\Go\src\compress\gzip\gunzip.go:11:2 EnsureLoaded("go.std.encoding.binary") // E.g. from: C:\Program Files\Go\src\compress\gzip\gunzip.go:12:2 @@ -19365,15 +19359,15 @@ func initNative() { GoMembers{ }) - GoTypesVec[2058] = &info_Order + GoTypesVec[2056] = &info_Order GoTypesVec[36] = &info_PtrTo_Order - GoTypesVec[992] = &info_ArrayOf_Order - GoTypesVec[2059] = &info_Reader + GoTypesVec[991] = &info_ArrayOf_Order + GoTypesVec[2057] = &info_Reader GoTypesVec[37] = &info_PtrTo_Reader - GoTypesVec[993] = &info_ArrayOf_Reader - GoTypesVec[2060] = &info_Writer + GoTypesVec[992] = &info_ArrayOf_Reader + GoTypesVec[2058] = &info_Writer GoTypesVec[38] = &info_PtrTo_Writer - GoTypesVec[994] = &info_ArrayOf_Writer + GoTypesVec[993] = &info_ArrayOf_Writer EnsureLoaded("go.std.bufio") // E.g. from: C:\Program Files\Go\src\compress\lzw\reader.go:22:2 EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\compress\lzw\reader.go:23:2 EnsureLoaded("go.std.fmt") // E.g. from: C:\Program Files\Go\src\compress\lzw\reader.go:24:2 @@ -19929,11 +19923,11 @@ func initNative() { GoMembers{ }) - GoTypesVec[3019] = &info_Resetter - GoTypesVec[995] = &info_ArrayOf_Resetter - GoTypesVec[2061] = &info_Writer + GoTypesVec[3016] = &info_Resetter + GoTypesVec[994] = &info_ArrayOf_Resetter + GoTypesVec[2059] = &info_Writer GoTypesVec[39] = &info_PtrTo_Writer - GoTypesVec[996] = &info_ArrayOf_Writer + GoTypesVec[995] = &info_ArrayOf_Writer EnsureLoaded("go.std.bufio") // E.g. from: C:\Program Files\Go\src\compress\zlib\reader.go:27:2 EnsureLoaded("go.std.compress.flate") // E.g. from: C:\Program Files\Go\src\compress\zlib\reader.go:28:2 EnsureLoaded("go.std.encoding.binary") // E.g. from: C:\Program Files\Go\src\compress\zlib\writer.go:9:2 @@ -20199,8 +20193,8 @@ func initNative() { GoMembers{ }) - GoTypesVec[2937] = &info_Interface - GoTypesVec[997] = &info_ArrayOf_Interface + GoTypesVec[2934] = &info_Interface + GoTypesVec[996] = &info_ArrayOf_Interface EnsureLoaded("go.std.sort") // E.g. from: C:\Program Files\Go\src\container\heap\heap.go:18:8 } -------- END _tests/gold/go1.19/amd64-windows/joker/std/gostd/go/std/container/heap/heap_native.go. @@ -20822,12 +20816,12 @@ func initNative() { GoMembers{ }) - GoTypesVec[2062] = &info_Element + GoTypesVec[2060] = &info_Element GoTypesVec[40] = &info_PtrTo_Element - GoTypesVec[998] = &info_ArrayOf_Element - GoTypesVec[2063] = &info_List + GoTypesVec[997] = &info_ArrayOf_Element + GoTypesVec[2061] = &info_List GoTypesVec[41] = &info_PtrTo_List - GoTypesVec[999] = &info_ArrayOf_List + GoTypesVec[998] = &info_ArrayOf_List } -------- END _tests/gold/go1.19/amd64-windows/joker/std/gostd/go/std/container/list/list_native.go. -------- BEGIN _tests/gold/go1.19/amd64-windows/joker/std/gostd/go/std/container/ring.joke: @@ -21139,9 +21133,9 @@ func initNative() { GoMembers{ }) - GoTypesVec[2064] = &info_Ring + GoTypesVec[2062] = &info_Ring GoTypesVec[42] = &info_PtrTo_Ring - GoTypesVec[1000] = &info_ArrayOf_Ring + GoTypesVec[999] = &info_ArrayOf_Ring } -------- END _tests/gold/go1.19/amd64-windows/joker/std/gostd/go/std/container/ring/ring_native.go. -------- BEGIN _tests/gold/go1.19/amd64-windows/joker/std/gostd/go/std/context.joke: @@ -21638,11 +21632,11 @@ func initNative() { GoMembers{ }) - GoTypesVec[2065] = &info_CancelFunc + GoTypesVec[2063] = &info_CancelFunc GoTypesVec[43] = &info_PtrTo_CancelFunc - GoTypesVec[1001] = &info_ArrayOf_CancelFunc - GoTypesVec[2941] = &info_Context - GoTypesVec[1002] = &info_ArrayOf_Context + GoTypesVec[1000] = &info_ArrayOf_CancelFunc + GoTypesVec[2938] = &info_Context + GoTypesVec[1001] = &info_ArrayOf_Context EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\context\context.go:51:2 EnsureLoaded("go.std.sync") // E.g. from: C:\Program Files\Go\src\context\context.go:53:2 EnsureLoaded("go.std.sync.atomic") // E.g. from: C:\Program Files\Go\src\context\context.go:54:2 @@ -22193,9 +22187,9 @@ func initNative() { GoMembers{ }) - GoTypesVec[2067] = &info_KeySizeError + GoTypesVec[2065] = &info_KeySizeError GoTypesVec[45] = &info_PtrTo_KeySizeError - GoTypesVec[1010] = &info_ArrayOf_KeySizeError + GoTypesVec[1009] = &info_ArrayOf_KeySizeError EnsureLoaded("go.std.crypto.cipher") // E.g. from: C:\Program Files\Go\src\crypto\aes\aes_gcm.go:10:2 EnsureLoaded("go.std.crypto.subtle") // E.g. from: C:\Program Files\Go\src\crypto\aes\aes_gcm.go:12:2 EnsureLoaded("go.std.encoding.binary") // E.g. from: C:\Program Files\Go\src\crypto\aes\block.go:40:2 @@ -23444,20 +23438,20 @@ func initNative() { GoMembers{ }) - GoTypesVec[2942] = &info_AEAD - GoTypesVec[1011] = &info_ArrayOf_AEAD - GoTypesVec[2960] = &info_Block - GoTypesVec[2985] = &info_BlockMode - GoTypesVec[1013] = &info_ArrayOf_BlockMode - GoTypesVec[1012] = &info_ArrayOf_Block - GoTypesVec[3021] = &info_Stream - GoTypesVec[2068] = &info_StreamReader + GoTypesVec[2939] = &info_AEAD + GoTypesVec[1010] = &info_ArrayOf_AEAD + GoTypesVec[2957] = &info_Block + GoTypesVec[2982] = &info_BlockMode + GoTypesVec[1012] = &info_ArrayOf_BlockMode + GoTypesVec[1011] = &info_ArrayOf_Block + GoTypesVec[3018] = &info_Stream + GoTypesVec[2066] = &info_StreamReader GoTypesVec[46] = &info_PtrTo_StreamReader - GoTypesVec[1015] = &info_ArrayOf_StreamReader - GoTypesVec[2069] = &info_StreamWriter + GoTypesVec[1014] = &info_ArrayOf_StreamReader + GoTypesVec[2067] = &info_StreamWriter GoTypesVec[47] = &info_PtrTo_StreamWriter - GoTypesVec[1016] = &info_ArrayOf_StreamWriter - GoTypesVec[1014] = &info_ArrayOf_Stream + GoTypesVec[1015] = &info_ArrayOf_StreamWriter + GoTypesVec[1013] = &info_ArrayOf_Stream EnsureLoaded("go.std.crypto.subtle") // E.g. from: C:\Program Files\Go\src\crypto\cipher\gcm.go:9:2 EnsureLoaded("go.std.encoding.binary") // E.g. from: C:\Program Files\Go\src\crypto\cipher\gcm.go:10:2 EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\crypto\cipher\gcm.go:11:2 @@ -24524,21 +24518,21 @@ func initNative() { GoMembers{ }) - GoTypesVec[2983] = &info_Decrypter - GoTypesVec[3090] = &info_DecrypterOpts - GoTypesVec[1004] = &info_ArrayOf_DecrypterOpts - GoTypesVec[1003] = &info_ArrayOf_Decrypter - GoTypesVec[2066] = &info_Hash + GoTypesVec[2980] = &info_Decrypter + GoTypesVec[3087] = &info_DecrypterOpts + GoTypesVec[1003] = &info_ArrayOf_DecrypterOpts + GoTypesVec[1002] = &info_ArrayOf_Decrypter + GoTypesVec[2064] = &info_Hash GoTypesVec[44] = &info_PtrTo_Hash - GoTypesVec[1005] = &info_ArrayOf_Hash - GoTypesVec[3091] = &info_PrivateKey - GoTypesVec[1006] = &info_ArrayOf_PrivateKey - GoTypesVec[3092] = &info_PublicKey - GoTypesVec[1007] = &info_ArrayOf_PublicKey - GoTypesVec[2984] = &info_Signer - GoTypesVec[3020] = &info_SignerOpts - GoTypesVec[1009] = &info_ArrayOf_SignerOpts - GoTypesVec[1008] = &info_ArrayOf_Signer + GoTypesVec[1004] = &info_ArrayOf_Hash + GoTypesVec[3088] = &info_PrivateKey + GoTypesVec[1005] = &info_ArrayOf_PrivateKey + GoTypesVec[3089] = &info_PublicKey + GoTypesVec[1006] = &info_ArrayOf_PublicKey + GoTypesVec[2981] = &info_Signer + GoTypesVec[3017] = &info_SignerOpts + GoTypesVec[1008] = &info_ArrayOf_SignerOpts + GoTypesVec[1007] = &info_ArrayOf_Signer EnsureLoaded("go.std.hash") // E.g. from: C:\Program Files\Go\src\crypto\crypto.go:9:2 EnsureLoaded("go.std.io") // E.g. from: C:\Program Files\Go\src\crypto\crypto.go:10:2 EnsureLoaded("go.std.strconv") // E.g. from: C:\Program Files\Go\src\crypto\crypto.go:11:2 @@ -24824,9 +24818,9 @@ func initNative() { GoMembers{ }) - GoTypesVec[2070] = &info_KeySizeError + GoTypesVec[2068] = &info_KeySizeError GoTypesVec[48] = &info_PtrTo_KeySizeError - GoTypesVec[1017] = &info_ArrayOf_KeySizeError + GoTypesVec[1016] = &info_ArrayOf_KeySizeError EnsureLoaded("go.std.crypto.cipher") // E.g. from: C:\Program Files\Go\src\crypto\des\cipher.go:8:2 EnsureLoaded("go.std.encoding.binary") // E.g. from: C:\Program Files\Go\src\crypto\des\block.go:8:2 EnsureLoaded("go.std.strconv") // E.g. from: C:\Program Files\Go\src\crypto\des\cipher.go:11:2 @@ -25802,18 +25796,18 @@ func initNative() { GoMembers{ }) - GoTypesVec[2071] = &info_ParameterSizes + GoTypesVec[2069] = &info_ParameterSizes GoTypesVec[49] = &info_PtrTo_ParameterSizes - GoTypesVec[1018] = &info_ArrayOf_ParameterSizes - GoTypesVec[2072] = &info_Parameters + GoTypesVec[1017] = &info_ArrayOf_ParameterSizes + GoTypesVec[2070] = &info_Parameters GoTypesVec[50] = &info_PtrTo_Parameters - GoTypesVec[1019] = &info_ArrayOf_Parameters - GoTypesVec[2073] = &info_PrivateKey + GoTypesVec[1018] = &info_ArrayOf_Parameters + GoTypesVec[2071] = &info_PrivateKey GoTypesVec[51] = &info_PtrTo_PrivateKey - GoTypesVec[1020] = &info_ArrayOf_PrivateKey - GoTypesVec[2074] = &info_PublicKey + GoTypesVec[1019] = &info_ArrayOf_PrivateKey + GoTypesVec[2072] = &info_PublicKey GoTypesVec[52] = &info_PtrTo_PublicKey - GoTypesVec[1021] = &info_ArrayOf_PublicKey + GoTypesVec[1020] = &info_ArrayOf_PublicKey EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\crypto\dsa\dsa.go:17:2 EnsureLoaded("go.std.io") // E.g. from: C:\Program Files\Go\src\crypto\dsa\dsa.go:18:2 EnsureLoaded("go.std.math.big") // E.g. from: C:\Program Files\Go\src\crypto\dsa\dsa.go:19:2 @@ -26378,12 +26372,12 @@ func initNative() { GoMembers{ }) - GoTypesVec[2075] = &info_PrivateKey + GoTypesVec[2073] = &info_PrivateKey GoTypesVec[53] = &info_PtrTo_PrivateKey - GoTypesVec[1022] = &info_ArrayOf_PrivateKey - GoTypesVec[2076] = &info_PublicKey + GoTypesVec[1021] = &info_ArrayOf_PrivateKey + GoTypesVec[2074] = &info_PublicKey GoTypesVec[54] = &info_PtrTo_PublicKey - GoTypesVec[1023] = &info_ArrayOf_PublicKey + GoTypesVec[1022] = &info_ArrayOf_PublicKey EnsureLoaded("go.std.crypto") // E.g. from: C:\Program Files\Go\src\crypto\ecdsa\ecdsa.go:23:2 EnsureLoaded("go.std.crypto.aes") // E.g. from: C:\Program Files\Go\src\crypto\ecdsa\ecdsa.go:24:2 EnsureLoaded("go.std.crypto.cipher") // E.g. from: C:\Program Files\Go\src\crypto\ecdsa\ecdsa.go:25:2 @@ -26944,12 +26938,12 @@ func initNative() { GoMembers{ }) - GoTypesVec[2077] = &info_PrivateKey + GoTypesVec[2075] = &info_PrivateKey GoTypesVec[55] = &info_PtrTo_PrivateKey - GoTypesVec[1024] = &info_ArrayOf_PrivateKey - GoTypesVec[2078] = &info_PublicKey + GoTypesVec[1023] = &info_ArrayOf_PrivateKey + GoTypesVec[2076] = &info_PublicKey GoTypesVec[56] = &info_PtrTo_PublicKey - GoTypesVec[1025] = &info_ArrayOf_PublicKey + GoTypesVec[1024] = &info_ArrayOf_PublicKey EnsureLoaded("go.std.bytes") // E.g. from: C:\Program Files\Go\src\crypto\ed25519\ed25519.go:16:2 EnsureLoaded("go.std.crypto") // E.g. from: C:\Program Files\Go\src\crypto\ed25519\ed25519.go:17:2 EnsureLoaded("go.std.crypto.rand") // E.g. from: C:\Program Files\Go\src\crypto\ed25519\ed25519.go:19:13 @@ -27698,11 +27692,11 @@ func initNative() { GoMembers{ }) - GoTypesVec[2930] = &info_Curve - GoTypesVec[2079] = &info_CurveParams + GoTypesVec[2927] = &info_Curve + GoTypesVec[2077] = &info_CurveParams GoTypesVec[57] = &info_PtrTo_CurveParams - GoTypesVec[1027] = &info_ArrayOf_CurveParams - GoTypesVec[1026] = &info_ArrayOf_Curve + GoTypesVec[1026] = &info_ArrayOf_CurveParams + GoTypesVec[1025] = &info_ArrayOf_Curve EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\crypto\elliptic\nistec.go:9:2 EnsureLoaded("go.std.io") // E.g. from: C:\Program Files\Go\src\crypto\elliptic\elliptic.go:10:2 EnsureLoaded("go.std.math.big") // E.g. from: C:\Program Files\Go\src\crypto\elliptic\elliptic.go:11:2 @@ -28383,12 +28377,12 @@ func initNative() { GoMembers{ }) - GoTypesVec[2080] = &info_Cipher + GoTypesVec[2078] = &info_Cipher GoTypesVec[58] = &info_PtrTo_Cipher - GoTypesVec[1028] = &info_ArrayOf_Cipher - GoTypesVec[2081] = &info_KeySizeError + GoTypesVec[1027] = &info_ArrayOf_Cipher + GoTypesVec[2079] = &info_KeySizeError GoTypesVec[59] = &info_PtrTo_KeySizeError - GoTypesVec[1029] = &info_ArrayOf_KeySizeError + GoTypesVec[1028] = &info_ArrayOf_KeySizeError EnsureLoaded("go.std.strconv") // E.g. from: C:\Program Files\Go\src\crypto\rc4\rc4.go:14:2 } -------- END _tests/gold/go1.19/amd64-windows/joker/std/gostd/go/std/crypto/rc4/rc4_native.go. @@ -30222,27 +30216,27 @@ func initNative() { GoMembers{ }) - GoTypesVec[2082] = &info_CRTValue + GoTypesVec[2080] = &info_CRTValue GoTypesVec[60] = &info_PtrTo_CRTValue - GoTypesVec[1030] = &info_ArrayOf_CRTValue - GoTypesVec[2083] = &info_OAEPOptions + GoTypesVec[1029] = &info_ArrayOf_CRTValue + GoTypesVec[2081] = &info_OAEPOptions GoTypesVec[61] = &info_PtrTo_OAEPOptions - GoTypesVec[1031] = &info_ArrayOf_OAEPOptions - GoTypesVec[2084] = &info_PKCS1v15DecryptOptions + GoTypesVec[1030] = &info_ArrayOf_OAEPOptions + GoTypesVec[2082] = &info_PKCS1v15DecryptOptions GoTypesVec[62] = &info_PtrTo_PKCS1v15DecryptOptions - GoTypesVec[1032] = &info_ArrayOf_PKCS1v15DecryptOptions - GoTypesVec[2085] = &info_PSSOptions + GoTypesVec[1031] = &info_ArrayOf_PKCS1v15DecryptOptions + GoTypesVec[2083] = &info_PSSOptions GoTypesVec[63] = &info_PtrTo_PSSOptions - GoTypesVec[1033] = &info_ArrayOf_PSSOptions - GoTypesVec[2086] = &info_PrecomputedValues + GoTypesVec[1032] = &info_ArrayOf_PSSOptions + GoTypesVec[2084] = &info_PrecomputedValues GoTypesVec[64] = &info_PtrTo_PrecomputedValues - GoTypesVec[1034] = &info_ArrayOf_PrecomputedValues - GoTypesVec[2087] = &info_PrivateKey + GoTypesVec[1033] = &info_ArrayOf_PrecomputedValues + GoTypesVec[2085] = &info_PrivateKey GoTypesVec[65] = &info_PtrTo_PrivateKey - GoTypesVec[1035] = &info_ArrayOf_PrivateKey - GoTypesVec[2088] = &info_PublicKey + GoTypesVec[1034] = &info_ArrayOf_PrivateKey + GoTypesVec[2086] = &info_PublicKey GoTypesVec[66] = &info_PtrTo_PublicKey - GoTypesVec[1036] = &info_ArrayOf_PublicKey + GoTypesVec[1035] = &info_ArrayOf_PublicKey EnsureLoaded("go.std.bytes") // E.g. from: C:\Program Files\Go\src\crypto\rsa\pss.go:10:2 EnsureLoaded("go.std.crypto") // E.g. from: C:\Program Files\Go\src\crypto\rsa\pkcs1v15.go:8:2 EnsureLoaded("go.std.crypto.rand") // E.g. from: C:\Program Files\Go\src\crypto\rsa\rsa.go:30:2 @@ -34837,50 +34831,50 @@ func initNative() { GoMembers{ }) - GoTypesVec[2089] = &info_Certificate + GoTypesVec[2087] = &info_Certificate GoTypesVec[67] = &info_PtrTo_Certificate - GoTypesVec[2090] = &info_CertificateRequestInfo + GoTypesVec[2088] = &info_CertificateRequestInfo GoTypesVec[68] = &info_PtrTo_CertificateRequestInfo - GoTypesVec[1038] = &info_ArrayOf_CertificateRequestInfo - GoTypesVec[1037] = &info_ArrayOf_Certificate - GoTypesVec[2091] = &info_CipherSuite + GoTypesVec[1037] = &info_ArrayOf_CertificateRequestInfo + GoTypesVec[1036] = &info_ArrayOf_Certificate + GoTypesVec[2089] = &info_CipherSuite GoTypesVec[69] = &info_PtrTo_CipherSuite - GoTypesVec[1039] = &info_ArrayOf_CipherSuite - GoTypesVec[2092] = &info_ClientAuthType + GoTypesVec[1038] = &info_ArrayOf_CipherSuite + GoTypesVec[2090] = &info_ClientAuthType GoTypesVec[70] = &info_PtrTo_ClientAuthType - GoTypesVec[1040] = &info_ArrayOf_ClientAuthType - GoTypesVec[2093] = &info_ClientHelloInfo + GoTypesVec[1039] = &info_ArrayOf_ClientAuthType + GoTypesVec[2091] = &info_ClientHelloInfo GoTypesVec[71] = &info_PtrTo_ClientHelloInfo - GoTypesVec[1041] = &info_ArrayOf_ClientHelloInfo - GoTypesVec[2986] = &info_ClientSessionCache - GoTypesVec[1042] = &info_ArrayOf_ClientSessionCache - GoTypesVec[2094] = &info_ClientSessionState + GoTypesVec[1040] = &info_ArrayOf_ClientHelloInfo + GoTypesVec[2983] = &info_ClientSessionCache + GoTypesVec[1041] = &info_ArrayOf_ClientSessionCache + GoTypesVec[2092] = &info_ClientSessionState GoTypesVec[72] = &info_PtrTo_ClientSessionState - GoTypesVec[1043] = &info_ArrayOf_ClientSessionState - GoTypesVec[2095] = &info_Config + GoTypesVec[1042] = &info_ArrayOf_ClientSessionState + GoTypesVec[2093] = &info_Config GoTypesVec[73] = &info_PtrTo_Config - GoTypesVec[1044] = &info_ArrayOf_Config - GoTypesVec[2096] = &info_Conn + GoTypesVec[1043] = &info_ArrayOf_Config + GoTypesVec[2094] = &info_Conn GoTypesVec[74] = &info_PtrTo_Conn - GoTypesVec[1045] = &info_ArrayOf_Conn - GoTypesVec[2097] = &info_ConnectionState + GoTypesVec[1044] = &info_ArrayOf_Conn + GoTypesVec[2095] = &info_ConnectionState GoTypesVec[75] = &info_PtrTo_ConnectionState - GoTypesVec[1046] = &info_ArrayOf_ConnectionState - GoTypesVec[2098] = &info_CurveID + GoTypesVec[1045] = &info_ArrayOf_ConnectionState + GoTypesVec[2096] = &info_CurveID GoTypesVec[76] = &info_PtrTo_CurveID - GoTypesVec[1047] = &info_ArrayOf_CurveID - GoTypesVec[2099] = &info_Dialer + GoTypesVec[1046] = &info_ArrayOf_CurveID + GoTypesVec[2097] = &info_Dialer GoTypesVec[77] = &info_PtrTo_Dialer - GoTypesVec[1048] = &info_ArrayOf_Dialer - GoTypesVec[2100] = &info_RecordHeaderError + GoTypesVec[1047] = &info_ArrayOf_Dialer + GoTypesVec[2098] = &info_RecordHeaderError GoTypesVec[78] = &info_PtrTo_RecordHeaderError - GoTypesVec[1049] = &info_ArrayOf_RecordHeaderError - GoTypesVec[2101] = &info_RenegotiationSupport + GoTypesVec[1048] = &info_ArrayOf_RecordHeaderError + GoTypesVec[2099] = &info_RenegotiationSupport GoTypesVec[79] = &info_PtrTo_RenegotiationSupport - GoTypesVec[1050] = &info_ArrayOf_RenegotiationSupport - GoTypesVec[2102] = &info_SignatureScheme + GoTypesVec[1049] = &info_ArrayOf_RenegotiationSupport + GoTypesVec[2100] = &info_SignatureScheme GoTypesVec[80] = &info_PtrTo_SignatureScheme - GoTypesVec[1051] = &info_ArrayOf_SignatureScheme + GoTypesVec[1050] = &info_ArrayOf_SignatureScheme EnsureLoaded("go.std.bytes") // E.g. from: C:\Program Files\Go\src\crypto\tls\auth.go:8:2 EnsureLoaded("go.std.container.list") // E.g. from: C:\Program Files\Go\src\crypto\tls\common.go:9:2 EnsureLoaded("go.std.context") // E.g. from: C:\Program Files\Go\src\crypto\tls\common.go:10:2 @@ -38247,36 +38241,36 @@ func initNative() { GoMembers{ }) - GoTypesVec[2121] = &info_AlgorithmIdentifier + GoTypesVec[2119] = &info_AlgorithmIdentifier GoTypesVec[99] = &info_PtrTo_AlgorithmIdentifier - GoTypesVec[1070] = &info_ArrayOf_AlgorithmIdentifier - GoTypesVec[2122] = &info_AttributeTypeAndValue + GoTypesVec[1069] = &info_ArrayOf_AlgorithmIdentifier + GoTypesVec[2120] = &info_AttributeTypeAndValue GoTypesVec[100] = &info_PtrTo_AttributeTypeAndValue - GoTypesVec[2123] = &info_AttributeTypeAndValueSET + GoTypesVec[2121] = &info_AttributeTypeAndValueSET GoTypesVec[101] = &info_PtrTo_AttributeTypeAndValueSET - GoTypesVec[1072] = &info_ArrayOf_AttributeTypeAndValueSET - GoTypesVec[1071] = &info_ArrayOf_AttributeTypeAndValue - GoTypesVec[2124] = &info_CertificateList + GoTypesVec[1071] = &info_ArrayOf_AttributeTypeAndValueSET + GoTypesVec[1070] = &info_ArrayOf_AttributeTypeAndValue + GoTypesVec[2122] = &info_CertificateList GoTypesVec[102] = &info_PtrTo_CertificateList - GoTypesVec[1073] = &info_ArrayOf_CertificateList - GoTypesVec[2125] = &info_Extension + GoTypesVec[1072] = &info_ArrayOf_CertificateList + GoTypesVec[2123] = &info_Extension GoTypesVec[103] = &info_PtrTo_Extension - GoTypesVec[1074] = &info_ArrayOf_Extension - GoTypesVec[2126] = &info_Name + GoTypesVec[1073] = &info_ArrayOf_Extension + GoTypesVec[2124] = &info_Name GoTypesVec[104] = &info_PtrTo_Name - GoTypesVec[1075] = &info_ArrayOf_Name - GoTypesVec[2127] = &info_RDNSequence + GoTypesVec[1074] = &info_ArrayOf_Name + GoTypesVec[2125] = &info_RDNSequence GoTypesVec[105] = &info_PtrTo_RDNSequence - GoTypesVec[1076] = &info_ArrayOf_RDNSequence - GoTypesVec[2128] = &info_RelativeDistinguishedNameSET + GoTypesVec[1075] = &info_ArrayOf_RDNSequence + GoTypesVec[2126] = &info_RelativeDistinguishedNameSET GoTypesVec[106] = &info_PtrTo_RelativeDistinguishedNameSET - GoTypesVec[1077] = &info_ArrayOf_RelativeDistinguishedNameSET - GoTypesVec[2129] = &info_RevokedCertificate + GoTypesVec[1076] = &info_ArrayOf_RelativeDistinguishedNameSET + GoTypesVec[2127] = &info_RevokedCertificate GoTypesVec[107] = &info_PtrTo_RevokedCertificate - GoTypesVec[1078] = &info_ArrayOf_RevokedCertificate - GoTypesVec[2130] = &info_TBSCertificateList + GoTypesVec[1077] = &info_ArrayOf_RevokedCertificate + GoTypesVec[2128] = &info_TBSCertificateList GoTypesVec[108] = &info_PtrTo_TBSCertificateList - GoTypesVec[1079] = &info_ArrayOf_TBSCertificateList + GoTypesVec[1078] = &info_ArrayOf_TBSCertificateList EnsureLoaded("go.std.encoding.asn1") // E.g. from: C:\Program Files\Go\src\crypto\x509\pkix\pkix.go:10:2 EnsureLoaded("go.std.encoding.hex") // E.g. from: C:\Program Files\Go\src\crypto\x509\pkix\pkix.go:11:2 EnsureLoaded("go.std.fmt") // E.g. from: C:\Program Files\Go\src\crypto\x509\pkix\pkix.go:12:2 @@ -42405,60 +42399,60 @@ func initNative() { GoMembers{ }) - GoTypesVec[2103] = &info_CertPool + GoTypesVec[2101] = &info_CertPool GoTypesVec[81] = &info_PtrTo_CertPool - GoTypesVec[1052] = &info_ArrayOf_CertPool - GoTypesVec[2104] = &info_Certificate + GoTypesVec[1051] = &info_ArrayOf_CertPool + GoTypesVec[2102] = &info_Certificate GoTypesVec[82] = &info_PtrTo_Certificate - GoTypesVec[2105] = &info_CertificateInvalidError + GoTypesVec[2103] = &info_CertificateInvalidError GoTypesVec[83] = &info_PtrTo_CertificateInvalidError - GoTypesVec[1054] = &info_ArrayOf_CertificateInvalidError - GoTypesVec[2106] = &info_CertificateRequest + GoTypesVec[1053] = &info_ArrayOf_CertificateInvalidError + GoTypesVec[2104] = &info_CertificateRequest GoTypesVec[84] = &info_PtrTo_CertificateRequest - GoTypesVec[1055] = &info_ArrayOf_CertificateRequest - GoTypesVec[1053] = &info_ArrayOf_Certificate - GoTypesVec[2107] = &info_ConstraintViolationError + GoTypesVec[1054] = &info_ArrayOf_CertificateRequest + GoTypesVec[1052] = &info_ArrayOf_Certificate + GoTypesVec[2105] = &info_ConstraintViolationError GoTypesVec[85] = &info_PtrTo_ConstraintViolationError - GoTypesVec[1056] = &info_ArrayOf_ConstraintViolationError - GoTypesVec[2108] = &info_ExtKeyUsage + GoTypesVec[1055] = &info_ArrayOf_ConstraintViolationError + GoTypesVec[2106] = &info_ExtKeyUsage GoTypesVec[86] = &info_PtrTo_ExtKeyUsage - GoTypesVec[1057] = &info_ArrayOf_ExtKeyUsage - GoTypesVec[2109] = &info_HostnameError + GoTypesVec[1056] = &info_ArrayOf_ExtKeyUsage + GoTypesVec[2107] = &info_HostnameError GoTypesVec[87] = &info_PtrTo_HostnameError - GoTypesVec[1058] = &info_ArrayOf_HostnameError - GoTypesVec[2110] = &info_InsecureAlgorithmError + GoTypesVec[1057] = &info_ArrayOf_HostnameError + GoTypesVec[2108] = &info_InsecureAlgorithmError GoTypesVec[88] = &info_PtrTo_InsecureAlgorithmError - GoTypesVec[1059] = &info_ArrayOf_InsecureAlgorithmError - GoTypesVec[2111] = &info_InvalidReason + GoTypesVec[1058] = &info_ArrayOf_InsecureAlgorithmError + GoTypesVec[2109] = &info_InvalidReason GoTypesVec[89] = &info_PtrTo_InvalidReason - GoTypesVec[1060] = &info_ArrayOf_InvalidReason - GoTypesVec[2112] = &info_KeyUsage + GoTypesVec[1059] = &info_ArrayOf_InvalidReason + GoTypesVec[2110] = &info_KeyUsage GoTypesVec[90] = &info_PtrTo_KeyUsage - GoTypesVec[1061] = &info_ArrayOf_KeyUsage - GoTypesVec[2113] = &info_PEMCipher + GoTypesVec[1060] = &info_ArrayOf_KeyUsage + GoTypesVec[2111] = &info_PEMCipher GoTypesVec[91] = &info_PtrTo_PEMCipher - GoTypesVec[1062] = &info_ArrayOf_PEMCipher - GoTypesVec[2114] = &info_PublicKeyAlgorithm + GoTypesVec[1061] = &info_ArrayOf_PEMCipher + GoTypesVec[2112] = &info_PublicKeyAlgorithm GoTypesVec[92] = &info_PtrTo_PublicKeyAlgorithm - GoTypesVec[1063] = &info_ArrayOf_PublicKeyAlgorithm - GoTypesVec[2115] = &info_RevocationList + GoTypesVec[1062] = &info_ArrayOf_PublicKeyAlgorithm + GoTypesVec[2113] = &info_RevocationList GoTypesVec[93] = &info_PtrTo_RevocationList - GoTypesVec[1064] = &info_ArrayOf_RevocationList - GoTypesVec[2116] = &info_SignatureAlgorithm + GoTypesVec[1063] = &info_ArrayOf_RevocationList + GoTypesVec[2114] = &info_SignatureAlgorithm GoTypesVec[94] = &info_PtrTo_SignatureAlgorithm - GoTypesVec[1065] = &info_ArrayOf_SignatureAlgorithm - GoTypesVec[2117] = &info_SystemRootsError + GoTypesVec[1064] = &info_ArrayOf_SignatureAlgorithm + GoTypesVec[2115] = &info_SystemRootsError GoTypesVec[95] = &info_PtrTo_SystemRootsError - GoTypesVec[1066] = &info_ArrayOf_SystemRootsError - GoTypesVec[2118] = &info_UnhandledCriticalExtension + GoTypesVec[1065] = &info_ArrayOf_SystemRootsError + GoTypesVec[2116] = &info_UnhandledCriticalExtension GoTypesVec[96] = &info_PtrTo_UnhandledCriticalExtension - GoTypesVec[1067] = &info_ArrayOf_UnhandledCriticalExtension - GoTypesVec[2119] = &info_UnknownAuthorityError + GoTypesVec[1066] = &info_ArrayOf_UnhandledCriticalExtension + GoTypesVec[2117] = &info_UnknownAuthorityError GoTypesVec[97] = &info_PtrTo_UnknownAuthorityError - GoTypesVec[1068] = &info_ArrayOf_UnknownAuthorityError - GoTypesVec[2120] = &info_VerifyOptions + GoTypesVec[1067] = &info_ArrayOf_UnknownAuthorityError + GoTypesVec[2118] = &info_VerifyOptions GoTypesVec[98] = &info_PtrTo_VerifyOptions - GoTypesVec[1069] = &info_ArrayOf_VerifyOptions + GoTypesVec[1068] = &info_ArrayOf_VerifyOptions EnsureLoaded("go.std.bytes") // E.g. from: C:\Program Files\Go\src\crypto\x509\cert_pool.go:8:2 EnsureLoaded("go.std.crypto") // E.g. from: C:\Program Files\Go\src\crypto\x509\verify.go:9:2 EnsureLoaded("go.std.crypto.aes") // E.g. from: C:\Program Files\Go\src\crypto\x509\pem_decrypt.go:12:2 @@ -49173,84 +49167,84 @@ func initNative() { GoMembers{ }) - GoTypesVec[3023] = &info_ColumnConverter - GoTypesVec[1103] = &info_ArrayOf_ColumnConverter - GoTypesVec[2961] = &info_Conn - GoTypesVec[3024] = &info_ConnBeginTx - GoTypesVec[1105] = &info_ArrayOf_ConnBeginTx - GoTypesVec[3025] = &info_ConnPrepareContext - GoTypesVec[1106] = &info_ArrayOf_ConnPrepareContext - GoTypesVec[1104] = &info_ArrayOf_Conn - GoTypesVec[2988] = &info_Connector - GoTypesVec[1107] = &info_ArrayOf_Connector - GoTypesVec[3026] = &info_Driver - GoTypesVec[3027] = &info_DriverContext - GoTypesVec[1109] = &info_ArrayOf_DriverContext - GoTypesVec[1108] = &info_ArrayOf_Driver - GoTypesVec[3028] = &info_Execer - GoTypesVec[3029] = &info_ExecerContext - GoTypesVec[1111] = &info_ArrayOf_ExecerContext - GoTypesVec[1110] = &info_ArrayOf_Execer - GoTypesVec[2152] = &info_IsolationLevel + GoTypesVec[3020] = &info_ColumnConverter + GoTypesVec[1102] = &info_ArrayOf_ColumnConverter + GoTypesVec[2958] = &info_Conn + GoTypesVec[3021] = &info_ConnBeginTx + GoTypesVec[1104] = &info_ArrayOf_ConnBeginTx + GoTypesVec[3022] = &info_ConnPrepareContext + GoTypesVec[1105] = &info_ArrayOf_ConnPrepareContext + GoTypesVec[1103] = &info_ArrayOf_Conn + GoTypesVec[2985] = &info_Connector + GoTypesVec[1106] = &info_ArrayOf_Connector + GoTypesVec[3023] = &info_Driver + GoTypesVec[3024] = &info_DriverContext + GoTypesVec[1108] = &info_ArrayOf_DriverContext + GoTypesVec[1107] = &info_ArrayOf_Driver + GoTypesVec[3025] = &info_Execer + GoTypesVec[3026] = &info_ExecerContext + GoTypesVec[1110] = &info_ArrayOf_ExecerContext + GoTypesVec[1109] = &info_ArrayOf_Execer + GoTypesVec[2150] = &info_IsolationLevel GoTypesVec[130] = &info_PtrTo_IsolationLevel - GoTypesVec[1112] = &info_ArrayOf_IsolationLevel - GoTypesVec[2153] = &info_NamedValue + GoTypesVec[1111] = &info_ArrayOf_IsolationLevel + GoTypesVec[2151] = &info_NamedValue GoTypesVec[131] = &info_PtrTo_NamedValue - GoTypesVec[3030] = &info_NamedValueChecker - GoTypesVec[1114] = &info_ArrayOf_NamedValueChecker - GoTypesVec[1113] = &info_ArrayOf_NamedValue - GoTypesVec[2154] = &info_NotNull + GoTypesVec[3027] = &info_NamedValueChecker + GoTypesVec[1113] = &info_ArrayOf_NamedValueChecker + GoTypesVec[1112] = &info_ArrayOf_NamedValue + GoTypesVec[2152] = &info_NotNull GoTypesVec[132] = &info_PtrTo_NotNull - GoTypesVec[1115] = &info_ArrayOf_NotNull - GoTypesVec[2155] = &info_Null + GoTypesVec[1114] = &info_ArrayOf_NotNull + GoTypesVec[2153] = &info_Null GoTypesVec[133] = &info_PtrTo_Null - GoTypesVec[1116] = &info_ArrayOf_Null - GoTypesVec[3031] = &info_Pinger - GoTypesVec[1117] = &info_ArrayOf_Pinger - GoTypesVec[3032] = &info_Queryer - GoTypesVec[3033] = &info_QueryerContext - GoTypesVec[1119] = &info_ArrayOf_QueryerContext - GoTypesVec[1118] = &info_ArrayOf_Queryer - GoTypesVec[2989] = &info_Result - GoTypesVec[1120] = &info_ArrayOf_Result - GoTypesVec[2962] = &info_Rows - GoTypesVec[2156] = &info_RowsAffected + GoTypesVec[1115] = &info_ArrayOf_Null + GoTypesVec[3028] = &info_Pinger + GoTypesVec[1116] = &info_ArrayOf_Pinger + GoTypesVec[3029] = &info_Queryer + GoTypesVec[3030] = &info_QueryerContext + GoTypesVec[1118] = &info_ArrayOf_QueryerContext + GoTypesVec[1117] = &info_ArrayOf_Queryer + GoTypesVec[2986] = &info_Result + GoTypesVec[1119] = &info_ArrayOf_Result + GoTypesVec[2959] = &info_Rows + GoTypesVec[2154] = &info_RowsAffected GoTypesVec[134] = &info_PtrTo_RowsAffected - GoTypesVec[1122] = &info_ArrayOf_RowsAffected - GoTypesVec[2943] = &info_RowsColumnTypeDatabaseTypeName - GoTypesVec[1123] = &info_ArrayOf_RowsColumnTypeDatabaseTypeName - GoTypesVec[2944] = &info_RowsColumnTypeLength - GoTypesVec[1124] = &info_ArrayOf_RowsColumnTypeLength - GoTypesVec[2945] = &info_RowsColumnTypeNullable - GoTypesVec[1125] = &info_ArrayOf_RowsColumnTypeNullable - GoTypesVec[2946] = &info_RowsColumnTypePrecisionScale - GoTypesVec[1126] = &info_ArrayOf_RowsColumnTypePrecisionScale - GoTypesVec[2947] = &info_RowsColumnTypeScanType - GoTypesVec[1127] = &info_ArrayOf_RowsColumnTypeScanType - GoTypesVec[2938] = &info_RowsNextResultSet - GoTypesVec[1128] = &info_ArrayOf_RowsNextResultSet - GoTypesVec[1121] = &info_ArrayOf_Rows - GoTypesVec[3034] = &info_SessionResetter - GoTypesVec[1129] = &info_ArrayOf_SessionResetter - GoTypesVec[2948] = &info_Stmt - GoTypesVec[3035] = &info_StmtExecContext - GoTypesVec[1131] = &info_ArrayOf_StmtExecContext - GoTypesVec[3036] = &info_StmtQueryContext - GoTypesVec[1132] = &info_ArrayOf_StmtQueryContext - GoTypesVec[1130] = &info_ArrayOf_Stmt - GoTypesVec[2990] = &info_Tx - GoTypesVec[2157] = &info_TxOptions + GoTypesVec[1121] = &info_ArrayOf_RowsAffected + GoTypesVec[2940] = &info_RowsColumnTypeDatabaseTypeName + GoTypesVec[1122] = &info_ArrayOf_RowsColumnTypeDatabaseTypeName + GoTypesVec[2941] = &info_RowsColumnTypeLength + GoTypesVec[1123] = &info_ArrayOf_RowsColumnTypeLength + GoTypesVec[2942] = &info_RowsColumnTypeNullable + GoTypesVec[1124] = &info_ArrayOf_RowsColumnTypeNullable + GoTypesVec[2943] = &info_RowsColumnTypePrecisionScale + GoTypesVec[1125] = &info_ArrayOf_RowsColumnTypePrecisionScale + GoTypesVec[2944] = &info_RowsColumnTypeScanType + GoTypesVec[1126] = &info_ArrayOf_RowsColumnTypeScanType + GoTypesVec[2935] = &info_RowsNextResultSet + GoTypesVec[1127] = &info_ArrayOf_RowsNextResultSet + GoTypesVec[1120] = &info_ArrayOf_Rows + GoTypesVec[3031] = &info_SessionResetter + GoTypesVec[1128] = &info_ArrayOf_SessionResetter + GoTypesVec[2945] = &info_Stmt + GoTypesVec[3032] = &info_StmtExecContext + GoTypesVec[1130] = &info_ArrayOf_StmtExecContext + GoTypesVec[3033] = &info_StmtQueryContext + GoTypesVec[1131] = &info_ArrayOf_StmtQueryContext + GoTypesVec[1129] = &info_ArrayOf_Stmt + GoTypesVec[2987] = &info_Tx + GoTypesVec[2155] = &info_TxOptions GoTypesVec[135] = &info_PtrTo_TxOptions - GoTypesVec[1134] = &info_ArrayOf_TxOptions - GoTypesVec[1133] = &info_ArrayOf_Tx - GoTypesVec[3037] = &info_Validator - GoTypesVec[1135] = &info_ArrayOf_Validator - GoTypesVec[3093] = &info_Value - GoTypesVec[3038] = &info_ValueConverter - GoTypesVec[1137] = &info_ArrayOf_ValueConverter - GoTypesVec[1136] = &info_ArrayOf_Value - GoTypesVec[3039] = &info_Valuer - GoTypesVec[1138] = &info_ArrayOf_Valuer + GoTypesVec[1133] = &info_ArrayOf_TxOptions + GoTypesVec[1132] = &info_ArrayOf_Tx + GoTypesVec[3034] = &info_Validator + GoTypesVec[1134] = &info_ArrayOf_Validator + GoTypesVec[3090] = &info_Value + GoTypesVec[3035] = &info_ValueConverter + GoTypesVec[1136] = &info_ArrayOf_ValueConverter + GoTypesVec[1135] = &info_ArrayOf_Value + GoTypesVec[3036] = &info_Valuer + GoTypesVec[1137] = &info_ArrayOf_Valuer EnsureLoaded("go.std.context") // E.g. from: C:\Program Files\Go\src\database\sql\driver\driver.go:41:2 EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\database\sql\driver\driver.go:42:2 EnsureLoaded("go.std.fmt") // E.g. from: C:\Program Files\Go\src\database\sql\driver\types.go:8:2 @@ -54590,73 +54584,73 @@ func initNative() { GoMembers{ }) - GoTypesVec[2131] = &info_ColumnType + GoTypesVec[2129] = &info_ColumnType GoTypesVec[109] = &info_PtrTo_ColumnType - GoTypesVec[1080] = &info_ArrayOf_ColumnType - GoTypesVec[2132] = &info_Conn + GoTypesVec[1079] = &info_ArrayOf_ColumnType + GoTypesVec[2130] = &info_Conn GoTypesVec[110] = &info_PtrTo_Conn - GoTypesVec[1081] = &info_ArrayOf_Conn - GoTypesVec[2133] = &info_DB + GoTypesVec[1080] = &info_ArrayOf_Conn + GoTypesVec[2131] = &info_DB GoTypesVec[111] = &info_PtrTo_DB - GoTypesVec[2134] = &info_DBStats + GoTypesVec[2132] = &info_DBStats GoTypesVec[112] = &info_PtrTo_DBStats - GoTypesVec[1083] = &info_ArrayOf_DBStats - GoTypesVec[1082] = &info_ArrayOf_DB - GoTypesVec[2135] = &info_IsolationLevel + GoTypesVec[1082] = &info_ArrayOf_DBStats + GoTypesVec[1081] = &info_ArrayOf_DB + GoTypesVec[2133] = &info_IsolationLevel GoTypesVec[113] = &info_PtrTo_IsolationLevel - GoTypesVec[1084] = &info_ArrayOf_IsolationLevel - GoTypesVec[2136] = &info_NamedArg + GoTypesVec[1083] = &info_ArrayOf_IsolationLevel + GoTypesVec[2134] = &info_NamedArg GoTypesVec[114] = &info_PtrTo_NamedArg - GoTypesVec[1085] = &info_ArrayOf_NamedArg - GoTypesVec[2137] = &info_NullBool + GoTypesVec[1084] = &info_ArrayOf_NamedArg + GoTypesVec[2135] = &info_NullBool GoTypesVec[115] = &info_PtrTo_NullBool - GoTypesVec[1086] = &info_ArrayOf_NullBool - GoTypesVec[2138] = &info_NullByte + GoTypesVec[1085] = &info_ArrayOf_NullBool + GoTypesVec[2136] = &info_NullByte GoTypesVec[116] = &info_PtrTo_NullByte - GoTypesVec[1087] = &info_ArrayOf_NullByte - GoTypesVec[2139] = &info_NullFloat64 + GoTypesVec[1086] = &info_ArrayOf_NullByte + GoTypesVec[2137] = &info_NullFloat64 GoTypesVec[117] = &info_PtrTo_NullFloat64 - GoTypesVec[1088] = &info_ArrayOf_NullFloat64 - GoTypesVec[2140] = &info_NullInt16 + GoTypesVec[1087] = &info_ArrayOf_NullFloat64 + GoTypesVec[2138] = &info_NullInt16 GoTypesVec[118] = &info_PtrTo_NullInt16 - GoTypesVec[1089] = &info_ArrayOf_NullInt16 - GoTypesVec[2141] = &info_NullInt32 + GoTypesVec[1088] = &info_ArrayOf_NullInt16 + GoTypesVec[2139] = &info_NullInt32 GoTypesVec[119] = &info_PtrTo_NullInt32 - GoTypesVec[1090] = &info_ArrayOf_NullInt32 - GoTypesVec[2142] = &info_NullInt64 + GoTypesVec[1089] = &info_ArrayOf_NullInt32 + GoTypesVec[2140] = &info_NullInt64 GoTypesVec[120] = &info_PtrTo_NullInt64 - GoTypesVec[1091] = &info_ArrayOf_NullInt64 - GoTypesVec[2143] = &info_NullString + GoTypesVec[1090] = &info_ArrayOf_NullInt64 + GoTypesVec[2141] = &info_NullString GoTypesVec[121] = &info_PtrTo_NullString - GoTypesVec[1092] = &info_ArrayOf_NullString - GoTypesVec[2144] = &info_NullTime + GoTypesVec[1091] = &info_ArrayOf_NullString + GoTypesVec[2142] = &info_NullTime GoTypesVec[122] = &info_PtrTo_NullTime - GoTypesVec[1093] = &info_ArrayOf_NullTime - GoTypesVec[2145] = &info_Out + GoTypesVec[1092] = &info_ArrayOf_NullTime + GoTypesVec[2143] = &info_Out GoTypesVec[123] = &info_PtrTo_Out - GoTypesVec[1094] = &info_ArrayOf_Out - GoTypesVec[2146] = &info_RawBytes + GoTypesVec[1093] = &info_ArrayOf_Out + GoTypesVec[2144] = &info_RawBytes GoTypesVec[124] = &info_PtrTo_RawBytes - GoTypesVec[1095] = &info_ArrayOf_RawBytes - GoTypesVec[2987] = &info_Result - GoTypesVec[1096] = &info_ArrayOf_Result - GoTypesVec[2147] = &info_Row + GoTypesVec[1094] = &info_ArrayOf_RawBytes + GoTypesVec[2984] = &info_Result + GoTypesVec[1095] = &info_ArrayOf_Result + GoTypesVec[2145] = &info_Row GoTypesVec[125] = &info_PtrTo_Row - GoTypesVec[1097] = &info_ArrayOf_Row - GoTypesVec[2148] = &info_Rows + GoTypesVec[1096] = &info_ArrayOf_Row + GoTypesVec[2146] = &info_Rows GoTypesVec[126] = &info_PtrTo_Rows - GoTypesVec[1098] = &info_ArrayOf_Rows - GoTypesVec[3022] = &info_Scanner - GoTypesVec[1099] = &info_ArrayOf_Scanner - GoTypesVec[2149] = &info_Stmt + GoTypesVec[1097] = &info_ArrayOf_Rows + GoTypesVec[3019] = &info_Scanner + GoTypesVec[1098] = &info_ArrayOf_Scanner + GoTypesVec[2147] = &info_Stmt GoTypesVec[127] = &info_PtrTo_Stmt - GoTypesVec[1100] = &info_ArrayOf_Stmt - GoTypesVec[2150] = &info_Tx + GoTypesVec[1099] = &info_ArrayOf_Stmt + GoTypesVec[2148] = &info_Tx GoTypesVec[128] = &info_PtrTo_Tx - GoTypesVec[2151] = &info_TxOptions + GoTypesVec[2149] = &info_TxOptions GoTypesVec[129] = &info_PtrTo_TxOptions - GoTypesVec[1102] = &info_ArrayOf_TxOptions - GoTypesVec[1101] = &info_ArrayOf_Tx + GoTypesVec[1101] = &info_ArrayOf_TxOptions + GoTypesVec[1100] = &info_ArrayOf_Tx EnsureLoaded("go.std.context") // E.g. from: C:\Program Files\Go\src\database\sql\ctxutil.go:8:2 EnsureLoaded("go.std.database.sql.driver") // E.g. from: C:\Program Files\Go\src\database\sql\convert.go:10:2 EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\database\sql\convert.go:11:2 @@ -65346,116 +65340,116 @@ func initNative() { GoMembers{ }) - GoTypesVec[2158] = &info_AddrType + GoTypesVec[2156] = &info_AddrType GoTypesVec[136] = &info_PtrTo_AddrType - GoTypesVec[1139] = &info_ArrayOf_AddrType - GoTypesVec[2159] = &info_ArrayType + GoTypesVec[1138] = &info_ArrayOf_AddrType + GoTypesVec[2157] = &info_ArrayType GoTypesVec[137] = &info_PtrTo_ArrayType - GoTypesVec[1140] = &info_ArrayOf_ArrayType - GoTypesVec[2160] = &info_Attr + GoTypesVec[1139] = &info_ArrayOf_ArrayType + GoTypesVec[2158] = &info_Attr GoTypesVec[138] = &info_PtrTo_Attr - GoTypesVec[1141] = &info_ArrayOf_Attr - GoTypesVec[2161] = &info_BasicType + GoTypesVec[1140] = &info_ArrayOf_Attr + GoTypesVec[2159] = &info_BasicType GoTypesVec[139] = &info_PtrTo_BasicType - GoTypesVec[1142] = &info_ArrayOf_BasicType - GoTypesVec[2162] = &info_BoolType + GoTypesVec[1141] = &info_ArrayOf_BasicType + GoTypesVec[2160] = &info_BoolType GoTypesVec[140] = &info_PtrTo_BoolType - GoTypesVec[1143] = &info_ArrayOf_BoolType - GoTypesVec[2163] = &info_CharType + GoTypesVec[1142] = &info_ArrayOf_BoolType + GoTypesVec[2161] = &info_CharType GoTypesVec[141] = &info_PtrTo_CharType - GoTypesVec[1144] = &info_ArrayOf_CharType - GoTypesVec[2164] = &info_Class + GoTypesVec[1143] = &info_ArrayOf_CharType + GoTypesVec[2162] = &info_Class GoTypesVec[142] = &info_PtrTo_Class - GoTypesVec[1145] = &info_ArrayOf_Class - GoTypesVec[2165] = &info_CommonType + GoTypesVec[1144] = &info_ArrayOf_Class + GoTypesVec[2163] = &info_CommonType GoTypesVec[143] = &info_PtrTo_CommonType - GoTypesVec[1146] = &info_ArrayOf_CommonType - GoTypesVec[2166] = &info_ComplexType + GoTypesVec[1145] = &info_ArrayOf_CommonType + GoTypesVec[2164] = &info_ComplexType GoTypesVec[144] = &info_PtrTo_ComplexType - GoTypesVec[1147] = &info_ArrayOf_ComplexType - GoTypesVec[2167] = &info_Data + GoTypesVec[1146] = &info_ArrayOf_ComplexType + GoTypesVec[2165] = &info_Data GoTypesVec[145] = &info_PtrTo_Data - GoTypesVec[1148] = &info_ArrayOf_Data - GoTypesVec[2168] = &info_DecodeError + GoTypesVec[1147] = &info_ArrayOf_Data + GoTypesVec[2166] = &info_DecodeError GoTypesVec[146] = &info_PtrTo_DecodeError - GoTypesVec[1149] = &info_ArrayOf_DecodeError - GoTypesVec[2169] = &info_DotDotDotType + GoTypesVec[1148] = &info_ArrayOf_DecodeError + GoTypesVec[2167] = &info_DotDotDotType GoTypesVec[147] = &info_PtrTo_DotDotDotType - GoTypesVec[1150] = &info_ArrayOf_DotDotDotType - GoTypesVec[2170] = &info_Entry + GoTypesVec[1149] = &info_ArrayOf_DotDotDotType + GoTypesVec[2168] = &info_Entry GoTypesVec[148] = &info_PtrTo_Entry - GoTypesVec[1151] = &info_ArrayOf_Entry - GoTypesVec[2171] = &info_EnumType + GoTypesVec[1150] = &info_ArrayOf_Entry + GoTypesVec[2169] = &info_EnumType GoTypesVec[149] = &info_PtrTo_EnumType - GoTypesVec[1152] = &info_ArrayOf_EnumType - GoTypesVec[2172] = &info_EnumValue + GoTypesVec[1151] = &info_ArrayOf_EnumType + GoTypesVec[2170] = &info_EnumValue GoTypesVec[150] = &info_PtrTo_EnumValue - GoTypesVec[1153] = &info_ArrayOf_EnumValue - GoTypesVec[2173] = &info_Field + GoTypesVec[1152] = &info_ArrayOf_EnumValue + GoTypesVec[2171] = &info_Field GoTypesVec[151] = &info_PtrTo_Field - GoTypesVec[1154] = &info_ArrayOf_Field - GoTypesVec[2174] = &info_FloatType + GoTypesVec[1153] = &info_ArrayOf_Field + GoTypesVec[2172] = &info_FloatType GoTypesVec[152] = &info_PtrTo_FloatType - GoTypesVec[1155] = &info_ArrayOf_FloatType - GoTypesVec[2175] = &info_FuncType + GoTypesVec[1154] = &info_ArrayOf_FloatType + GoTypesVec[2173] = &info_FuncType GoTypesVec[153] = &info_PtrTo_FuncType - GoTypesVec[1156] = &info_ArrayOf_FuncType - GoTypesVec[2176] = &info_IntType + GoTypesVec[1155] = &info_ArrayOf_FuncType + GoTypesVec[2174] = &info_IntType GoTypesVec[154] = &info_PtrTo_IntType - GoTypesVec[1157] = &info_ArrayOf_IntType - GoTypesVec[2177] = &info_LineEntry + GoTypesVec[1156] = &info_ArrayOf_IntType + GoTypesVec[2175] = &info_LineEntry GoTypesVec[155] = &info_PtrTo_LineEntry - GoTypesVec[1158] = &info_ArrayOf_LineEntry - GoTypesVec[2178] = &info_LineFile + GoTypesVec[1157] = &info_ArrayOf_LineEntry + GoTypesVec[2176] = &info_LineFile GoTypesVec[156] = &info_PtrTo_LineFile - GoTypesVec[1159] = &info_ArrayOf_LineFile - GoTypesVec[2179] = &info_LineReader + GoTypesVec[1158] = &info_ArrayOf_LineFile + GoTypesVec[2177] = &info_LineReader GoTypesVec[157] = &info_PtrTo_LineReader - GoTypesVec[2180] = &info_LineReaderPos + GoTypesVec[2178] = &info_LineReaderPos GoTypesVec[158] = &info_PtrTo_LineReaderPos - GoTypesVec[1161] = &info_ArrayOf_LineReaderPos - GoTypesVec[1160] = &info_ArrayOf_LineReader - GoTypesVec[2181] = &info_Offset + GoTypesVec[1160] = &info_ArrayOf_LineReaderPos + GoTypesVec[1159] = &info_ArrayOf_LineReader + GoTypesVec[2179] = &info_Offset GoTypesVec[159] = &info_PtrTo_Offset - GoTypesVec[1162] = &info_ArrayOf_Offset - GoTypesVec[2182] = &info_PtrType + GoTypesVec[1161] = &info_ArrayOf_Offset + GoTypesVec[2180] = &info_PtrType GoTypesVec[160] = &info_PtrTo_PtrType - GoTypesVec[1163] = &info_ArrayOf_PtrType - GoTypesVec[2183] = &info_QualType + GoTypesVec[1162] = &info_ArrayOf_PtrType + GoTypesVec[2181] = &info_QualType GoTypesVec[161] = &info_PtrTo_QualType - GoTypesVec[1164] = &info_ArrayOf_QualType - GoTypesVec[2184] = &info_Reader + GoTypesVec[1163] = &info_ArrayOf_QualType + GoTypesVec[2182] = &info_Reader GoTypesVec[162] = &info_PtrTo_Reader - GoTypesVec[1165] = &info_ArrayOf_Reader - GoTypesVec[2185] = &info_StructField + GoTypesVec[1164] = &info_ArrayOf_Reader + GoTypesVec[2183] = &info_StructField GoTypesVec[163] = &info_PtrTo_StructField - GoTypesVec[1166] = &info_ArrayOf_StructField - GoTypesVec[2186] = &info_StructType + GoTypesVec[1165] = &info_ArrayOf_StructField + GoTypesVec[2184] = &info_StructType GoTypesVec[164] = &info_PtrTo_StructType - GoTypesVec[1167] = &info_ArrayOf_StructType - GoTypesVec[2187] = &info_Tag + GoTypesVec[1166] = &info_ArrayOf_StructType + GoTypesVec[2185] = &info_Tag GoTypesVec[165] = &info_PtrTo_Tag - GoTypesVec[1168] = &info_ArrayOf_Tag - GoTypesVec[2963] = &info_Type - GoTypesVec[1169] = &info_ArrayOf_Type - GoTypesVec[2188] = &info_TypedefType + GoTypesVec[1167] = &info_ArrayOf_Tag + GoTypesVec[2960] = &info_Type + GoTypesVec[1168] = &info_ArrayOf_Type + GoTypesVec[2186] = &info_TypedefType GoTypesVec[166] = &info_PtrTo_TypedefType - GoTypesVec[1170] = &info_ArrayOf_TypedefType - GoTypesVec[2189] = &info_UcharType + GoTypesVec[1169] = &info_ArrayOf_TypedefType + GoTypesVec[2187] = &info_UcharType GoTypesVec[167] = &info_PtrTo_UcharType - GoTypesVec[1171] = &info_ArrayOf_UcharType - GoTypesVec[2190] = &info_UintType + GoTypesVec[1170] = &info_ArrayOf_UcharType + GoTypesVec[2188] = &info_UintType GoTypesVec[168] = &info_PtrTo_UintType - GoTypesVec[1172] = &info_ArrayOf_UintType - GoTypesVec[2191] = &info_UnspecifiedType + GoTypesVec[1171] = &info_ArrayOf_UintType + GoTypesVec[2189] = &info_UnspecifiedType GoTypesVec[169] = &info_PtrTo_UnspecifiedType - GoTypesVec[1173] = &info_ArrayOf_UnspecifiedType - GoTypesVec[2192] = &info_UnsupportedType + GoTypesVec[1172] = &info_ArrayOf_UnspecifiedType + GoTypesVec[2190] = &info_UnsupportedType GoTypesVec[170] = &info_PtrTo_UnsupportedType - GoTypesVec[1174] = &info_ArrayOf_UnsupportedType - GoTypesVec[2193] = &info_VoidType + GoTypesVec[1173] = &info_ArrayOf_UnsupportedType + GoTypesVec[2191] = &info_VoidType GoTypesVec[171] = &info_PtrTo_VoidType - GoTypesVec[1175] = &info_ArrayOf_VoidType + GoTypesVec[1174] = &info_ArrayOf_VoidType EnsureLoaded("go.std.bytes") // E.g. from: C:\Program Files\Go\src\debug\dwarf\buf.go:10:2 EnsureLoaded("go.std.encoding.binary") // E.g. from: C:\Program Files\Go\src\debug\dwarf\buf.go:11:2 EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\debug\dwarf\entry.go:15:2 @@ -89048,171 +89042,171 @@ func initNative() { GoMembers{ }) - GoTypesVec[2194] = &info_Chdr32 + GoTypesVec[2192] = &info_Chdr32 GoTypesVec[172] = &info_PtrTo_Chdr32 - GoTypesVec[1176] = &info_ArrayOf_Chdr32 - GoTypesVec[2195] = &info_Chdr64 + GoTypesVec[1175] = &info_ArrayOf_Chdr32 + GoTypesVec[2193] = &info_Chdr64 GoTypesVec[173] = &info_PtrTo_Chdr64 - GoTypesVec[1177] = &info_ArrayOf_Chdr64 - GoTypesVec[2196] = &info_Class + GoTypesVec[1176] = &info_ArrayOf_Chdr64 + GoTypesVec[2194] = &info_Class GoTypesVec[174] = &info_PtrTo_Class - GoTypesVec[1178] = &info_ArrayOf_Class - GoTypesVec[2197] = &info_CompressionType + GoTypesVec[1177] = &info_ArrayOf_Class + GoTypesVec[2195] = &info_CompressionType GoTypesVec[175] = &info_PtrTo_CompressionType - GoTypesVec[1179] = &info_ArrayOf_CompressionType - GoTypesVec[2198] = &info_Data + GoTypesVec[1178] = &info_ArrayOf_CompressionType + GoTypesVec[2196] = &info_Data GoTypesVec[176] = &info_PtrTo_Data - GoTypesVec[1180] = &info_ArrayOf_Data - GoTypesVec[2199] = &info_Dyn32 + GoTypesVec[1179] = &info_ArrayOf_Data + GoTypesVec[2197] = &info_Dyn32 GoTypesVec[177] = &info_PtrTo_Dyn32 - GoTypesVec[1181] = &info_ArrayOf_Dyn32 - GoTypesVec[2200] = &info_Dyn64 + GoTypesVec[1180] = &info_ArrayOf_Dyn32 + GoTypesVec[2198] = &info_Dyn64 GoTypesVec[178] = &info_PtrTo_Dyn64 - GoTypesVec[1182] = &info_ArrayOf_Dyn64 - GoTypesVec[2201] = &info_DynFlag + GoTypesVec[1181] = &info_ArrayOf_Dyn64 + GoTypesVec[2199] = &info_DynFlag GoTypesVec[179] = &info_PtrTo_DynFlag - GoTypesVec[1183] = &info_ArrayOf_DynFlag - GoTypesVec[2202] = &info_DynTag + GoTypesVec[1182] = &info_ArrayOf_DynFlag + GoTypesVec[2200] = &info_DynTag GoTypesVec[180] = &info_PtrTo_DynTag - GoTypesVec[1184] = &info_ArrayOf_DynTag - GoTypesVec[2203] = &info_File + GoTypesVec[1183] = &info_ArrayOf_DynTag + GoTypesVec[2201] = &info_File GoTypesVec[181] = &info_PtrTo_File - GoTypesVec[2204] = &info_FileHeader + GoTypesVec[2202] = &info_FileHeader GoTypesVec[182] = &info_PtrTo_FileHeader - GoTypesVec[1186] = &info_ArrayOf_FileHeader - GoTypesVec[1185] = &info_ArrayOf_File - GoTypesVec[2205] = &info_FormatError + GoTypesVec[1185] = &info_ArrayOf_FileHeader + GoTypesVec[1184] = &info_ArrayOf_File + GoTypesVec[2203] = &info_FormatError GoTypesVec[183] = &info_PtrTo_FormatError - GoTypesVec[1187] = &info_ArrayOf_FormatError - GoTypesVec[2206] = &info_Header32 + GoTypesVec[1186] = &info_ArrayOf_FormatError + GoTypesVec[2204] = &info_Header32 GoTypesVec[184] = &info_PtrTo_Header32 - GoTypesVec[1188] = &info_ArrayOf_Header32 - GoTypesVec[2207] = &info_Header64 + GoTypesVec[1187] = &info_ArrayOf_Header32 + GoTypesVec[2205] = &info_Header64 GoTypesVec[185] = &info_PtrTo_Header64 - GoTypesVec[1189] = &info_ArrayOf_Header64 - GoTypesVec[2208] = &info_ImportedSymbol + GoTypesVec[1188] = &info_ArrayOf_Header64 + GoTypesVec[2206] = &info_ImportedSymbol GoTypesVec[186] = &info_PtrTo_ImportedSymbol - GoTypesVec[1190] = &info_ArrayOf_ImportedSymbol - GoTypesVec[2209] = &info_Machine + GoTypesVec[1189] = &info_ArrayOf_ImportedSymbol + GoTypesVec[2207] = &info_Machine GoTypesVec[187] = &info_PtrTo_Machine - GoTypesVec[1191] = &info_ArrayOf_Machine - GoTypesVec[2210] = &info_NType + GoTypesVec[1190] = &info_ArrayOf_Machine + GoTypesVec[2208] = &info_NType GoTypesVec[188] = &info_PtrTo_NType - GoTypesVec[1192] = &info_ArrayOf_NType - GoTypesVec[2211] = &info_OSABI + GoTypesVec[1191] = &info_ArrayOf_NType + GoTypesVec[2209] = &info_OSABI GoTypesVec[189] = &info_PtrTo_OSABI - GoTypesVec[1193] = &info_ArrayOf_OSABI - GoTypesVec[2212] = &info_Prog + GoTypesVec[1192] = &info_ArrayOf_OSABI + GoTypesVec[2210] = &info_Prog GoTypesVec[190] = &info_PtrTo_Prog - GoTypesVec[2213] = &info_Prog32 + GoTypesVec[2211] = &info_Prog32 GoTypesVec[191] = &info_PtrTo_Prog32 - GoTypesVec[1195] = &info_ArrayOf_Prog32 - GoTypesVec[2214] = &info_Prog64 + GoTypesVec[1194] = &info_ArrayOf_Prog32 + GoTypesVec[2212] = &info_Prog64 GoTypesVec[192] = &info_PtrTo_Prog64 - GoTypesVec[1196] = &info_ArrayOf_Prog64 - GoTypesVec[2215] = &info_ProgFlag + GoTypesVec[1195] = &info_ArrayOf_Prog64 + GoTypesVec[2213] = &info_ProgFlag GoTypesVec[193] = &info_PtrTo_ProgFlag - GoTypesVec[1197] = &info_ArrayOf_ProgFlag - GoTypesVec[2216] = &info_ProgHeader + GoTypesVec[1196] = &info_ArrayOf_ProgFlag + GoTypesVec[2214] = &info_ProgHeader GoTypesVec[194] = &info_PtrTo_ProgHeader - GoTypesVec[1198] = &info_ArrayOf_ProgHeader - GoTypesVec[2217] = &info_ProgType + GoTypesVec[1197] = &info_ArrayOf_ProgHeader + GoTypesVec[2215] = &info_ProgType GoTypesVec[195] = &info_PtrTo_ProgType - GoTypesVec[1199] = &info_ArrayOf_ProgType - GoTypesVec[1194] = &info_ArrayOf_Prog - GoTypesVec[2218] = &info_R_386 + GoTypesVec[1198] = &info_ArrayOf_ProgType + GoTypesVec[1193] = &info_ArrayOf_Prog + GoTypesVec[2216] = &info_R_386 GoTypesVec[196] = &info_PtrTo_R_386 - GoTypesVec[1200] = &info_ArrayOf_R_386 - GoTypesVec[2219] = &info_R_390 + GoTypesVec[1199] = &info_ArrayOf_R_386 + GoTypesVec[2217] = &info_R_390 GoTypesVec[197] = &info_PtrTo_R_390 - GoTypesVec[1201] = &info_ArrayOf_R_390 - GoTypesVec[2220] = &info_R_AARCH64 + GoTypesVec[1200] = &info_ArrayOf_R_390 + GoTypesVec[2218] = &info_R_AARCH64 GoTypesVec[198] = &info_PtrTo_R_AARCH64 - GoTypesVec[1202] = &info_ArrayOf_R_AARCH64 - GoTypesVec[2221] = &info_R_ALPHA + GoTypesVec[1201] = &info_ArrayOf_R_AARCH64 + GoTypesVec[2219] = &info_R_ALPHA GoTypesVec[199] = &info_PtrTo_R_ALPHA - GoTypesVec[1203] = &info_ArrayOf_R_ALPHA - GoTypesVec[2222] = &info_R_ARM + GoTypesVec[1202] = &info_ArrayOf_R_ALPHA + GoTypesVec[2220] = &info_R_ARM GoTypesVec[200] = &info_PtrTo_R_ARM - GoTypesVec[1204] = &info_ArrayOf_R_ARM - GoTypesVec[2223] = &info_R_LARCH + GoTypesVec[1203] = &info_ArrayOf_R_ARM + GoTypesVec[2221] = &info_R_LARCH GoTypesVec[201] = &info_PtrTo_R_LARCH - GoTypesVec[1205] = &info_ArrayOf_R_LARCH - GoTypesVec[2224] = &info_R_MIPS + GoTypesVec[1204] = &info_ArrayOf_R_LARCH + GoTypesVec[2222] = &info_R_MIPS GoTypesVec[202] = &info_PtrTo_R_MIPS - GoTypesVec[1206] = &info_ArrayOf_R_MIPS - GoTypesVec[2225] = &info_R_PPC + GoTypesVec[1205] = &info_ArrayOf_R_MIPS + GoTypesVec[2223] = &info_R_PPC GoTypesVec[203] = &info_PtrTo_R_PPC - GoTypesVec[2226] = &info_R_PPC64 + GoTypesVec[2224] = &info_R_PPC64 GoTypesVec[204] = &info_PtrTo_R_PPC64 - GoTypesVec[1208] = &info_ArrayOf_R_PPC64 - GoTypesVec[1207] = &info_ArrayOf_R_PPC - GoTypesVec[2227] = &info_R_RISCV + GoTypesVec[1207] = &info_ArrayOf_R_PPC64 + GoTypesVec[1206] = &info_ArrayOf_R_PPC + GoTypesVec[2225] = &info_R_RISCV GoTypesVec[205] = &info_PtrTo_R_RISCV - GoTypesVec[1209] = &info_ArrayOf_R_RISCV - GoTypesVec[2228] = &info_R_SPARC + GoTypesVec[1208] = &info_ArrayOf_R_RISCV + GoTypesVec[2226] = &info_R_SPARC GoTypesVec[206] = &info_PtrTo_R_SPARC - GoTypesVec[1210] = &info_ArrayOf_R_SPARC - GoTypesVec[2229] = &info_R_X86_64 + GoTypesVec[1209] = &info_ArrayOf_R_SPARC + GoTypesVec[2227] = &info_R_X86_64 GoTypesVec[207] = &info_PtrTo_R_X86_64 - GoTypesVec[1211] = &info_ArrayOf_R_X86_64 - GoTypesVec[2230] = &info_Rel32 + GoTypesVec[1210] = &info_ArrayOf_R_X86_64 + GoTypesVec[2228] = &info_Rel32 GoTypesVec[208] = &info_PtrTo_Rel32 - GoTypesVec[1212] = &info_ArrayOf_Rel32 - GoTypesVec[2231] = &info_Rel64 + GoTypesVec[1211] = &info_ArrayOf_Rel32 + GoTypesVec[2229] = &info_Rel64 GoTypesVec[209] = &info_PtrTo_Rel64 - GoTypesVec[1213] = &info_ArrayOf_Rel64 - GoTypesVec[2232] = &info_Rela32 + GoTypesVec[1212] = &info_ArrayOf_Rel64 + GoTypesVec[2230] = &info_Rela32 GoTypesVec[210] = &info_PtrTo_Rela32 - GoTypesVec[1214] = &info_ArrayOf_Rela32 - GoTypesVec[2233] = &info_Rela64 + GoTypesVec[1213] = &info_ArrayOf_Rela32 + GoTypesVec[2231] = &info_Rela64 GoTypesVec[211] = &info_PtrTo_Rela64 - GoTypesVec[1215] = &info_ArrayOf_Rela64 - GoTypesVec[2234] = &info_Section + GoTypesVec[1214] = &info_ArrayOf_Rela64 + GoTypesVec[2232] = &info_Section GoTypesVec[212] = &info_PtrTo_Section - GoTypesVec[2235] = &info_Section32 + GoTypesVec[2233] = &info_Section32 GoTypesVec[213] = &info_PtrTo_Section32 - GoTypesVec[1217] = &info_ArrayOf_Section32 - GoTypesVec[2236] = &info_Section64 + GoTypesVec[1216] = &info_ArrayOf_Section32 + GoTypesVec[2234] = &info_Section64 GoTypesVec[214] = &info_PtrTo_Section64 - GoTypesVec[1218] = &info_ArrayOf_Section64 - GoTypesVec[2237] = &info_SectionFlag + GoTypesVec[1217] = &info_ArrayOf_Section64 + GoTypesVec[2235] = &info_SectionFlag GoTypesVec[215] = &info_PtrTo_SectionFlag - GoTypesVec[1219] = &info_ArrayOf_SectionFlag - GoTypesVec[2238] = &info_SectionHeader + GoTypesVec[1218] = &info_ArrayOf_SectionFlag + GoTypesVec[2236] = &info_SectionHeader GoTypesVec[216] = &info_PtrTo_SectionHeader - GoTypesVec[1220] = &info_ArrayOf_SectionHeader - GoTypesVec[2239] = &info_SectionIndex + GoTypesVec[1219] = &info_ArrayOf_SectionHeader + GoTypesVec[2237] = &info_SectionIndex GoTypesVec[217] = &info_PtrTo_SectionIndex - GoTypesVec[1221] = &info_ArrayOf_SectionIndex - GoTypesVec[2240] = &info_SectionType + GoTypesVec[1220] = &info_ArrayOf_SectionIndex + GoTypesVec[2238] = &info_SectionType GoTypesVec[218] = &info_PtrTo_SectionType - GoTypesVec[1222] = &info_ArrayOf_SectionType - GoTypesVec[1216] = &info_ArrayOf_Section - GoTypesVec[2241] = &info_Sym32 + GoTypesVec[1221] = &info_ArrayOf_SectionType + GoTypesVec[1215] = &info_ArrayOf_Section + GoTypesVec[2239] = &info_Sym32 GoTypesVec[219] = &info_PtrTo_Sym32 - GoTypesVec[1223] = &info_ArrayOf_Sym32 - GoTypesVec[2242] = &info_Sym64 + GoTypesVec[1222] = &info_ArrayOf_Sym32 + GoTypesVec[2240] = &info_Sym64 GoTypesVec[220] = &info_PtrTo_Sym64 - GoTypesVec[1224] = &info_ArrayOf_Sym64 - GoTypesVec[2243] = &info_SymBind + GoTypesVec[1223] = &info_ArrayOf_Sym64 + GoTypesVec[2241] = &info_SymBind GoTypesVec[221] = &info_PtrTo_SymBind - GoTypesVec[1225] = &info_ArrayOf_SymBind - GoTypesVec[2244] = &info_SymType + GoTypesVec[1224] = &info_ArrayOf_SymBind + GoTypesVec[2242] = &info_SymType GoTypesVec[222] = &info_PtrTo_SymType - GoTypesVec[1226] = &info_ArrayOf_SymType - GoTypesVec[2245] = &info_SymVis + GoTypesVec[1225] = &info_ArrayOf_SymType + GoTypesVec[2243] = &info_SymVis GoTypesVec[223] = &info_PtrTo_SymVis - GoTypesVec[1227] = &info_ArrayOf_SymVis - GoTypesVec[2246] = &info_Symbol + GoTypesVec[1226] = &info_ArrayOf_SymVis + GoTypesVec[2244] = &info_Symbol GoTypesVec[224] = &info_PtrTo_Symbol - GoTypesVec[1228] = &info_ArrayOf_Symbol - GoTypesVec[2247] = &info_Type + GoTypesVec[1227] = &info_ArrayOf_Symbol + GoTypesVec[2245] = &info_Type GoTypesVec[225] = &info_PtrTo_Type - GoTypesVec[1229] = &info_ArrayOf_Type - GoTypesVec[2248] = &info_Version + GoTypesVec[1228] = &info_ArrayOf_Type + GoTypesVec[2246] = &info_Version GoTypesVec[226] = &info_PtrTo_Version - GoTypesVec[1230] = &info_ArrayOf_Version + GoTypesVec[1229] = &info_ArrayOf_Version EnsureLoaded("go.std.bytes") // E.g. from: C:\Program Files\Go\src\debug\elf\file.go:9:2 EnsureLoaded("go.std.compress.zlib") // E.g. from: C:\Program Files\Go\src\debug\elf\file.go:10:2 EnsureLoaded("go.std.debug.dwarf") // E.g. from: C:\Program Files\Go\src\debug\elf\file.go:11:2 @@ -91291,30 +91285,30 @@ func initNative() { GoMembers{ }) - GoTypesVec[2249] = &info_DecodingError + GoTypesVec[2247] = &info_DecodingError GoTypesVec[227] = &info_PtrTo_DecodingError - GoTypesVec[1231] = &info_ArrayOf_DecodingError - GoTypesVec[2250] = &info_Func + GoTypesVec[1230] = &info_ArrayOf_DecodingError + GoTypesVec[2248] = &info_Func GoTypesVec[228] = &info_PtrTo_Func - GoTypesVec[1232] = &info_ArrayOf_Func - GoTypesVec[2251] = &info_LineTable + GoTypesVec[1231] = &info_ArrayOf_Func + GoTypesVec[2249] = &info_LineTable GoTypesVec[229] = &info_PtrTo_LineTable - GoTypesVec[1233] = &info_ArrayOf_LineTable - GoTypesVec[2252] = &info_Obj + GoTypesVec[1232] = &info_ArrayOf_LineTable + GoTypesVec[2250] = &info_Obj GoTypesVec[230] = &info_PtrTo_Obj - GoTypesVec[1234] = &info_ArrayOf_Obj - GoTypesVec[2253] = &info_Sym + GoTypesVec[1233] = &info_ArrayOf_Obj + GoTypesVec[2251] = &info_Sym GoTypesVec[231] = &info_PtrTo_Sym - GoTypesVec[1235] = &info_ArrayOf_Sym - GoTypesVec[2254] = &info_Table + GoTypesVec[1234] = &info_ArrayOf_Sym + GoTypesVec[2252] = &info_Table GoTypesVec[232] = &info_PtrTo_Table - GoTypesVec[1236] = &info_ArrayOf_Table - GoTypesVec[2255] = &info_UnknownFileError + GoTypesVec[1235] = &info_ArrayOf_Table + GoTypesVec[2253] = &info_UnknownFileError GoTypesVec[233] = &info_PtrTo_UnknownFileError - GoTypesVec[1237] = &info_ArrayOf_UnknownFileError - GoTypesVec[2256] = &info_UnknownLineError + GoTypesVec[1236] = &info_ArrayOf_UnknownFileError + GoTypesVec[2254] = &info_UnknownLineError GoTypesVec[234] = &info_PtrTo_UnknownLineError - GoTypesVec[1238] = &info_ArrayOf_UnknownLineError + GoTypesVec[1237] = &info_ArrayOf_UnknownLineError EnsureLoaded("go.std.bytes") // E.g. from: C:\Program Files\Go\src\debug\gosym\pclntab.go:12:2 EnsureLoaded("go.std.encoding.binary") // E.g. from: C:\Program Files\Go\src\debug\gosym\pclntab.go:13:2 EnsureLoaded("go.std.fmt") // E.g. from: C:\Program Files\Go\src\debug\gosym\symtab.go:13:2 @@ -100940,119 +100934,119 @@ func initNative() { GoMembers{ }) - GoTypesVec[2257] = &info_Cpu + GoTypesVec[2255] = &info_Cpu GoTypesVec[235] = &info_PtrTo_Cpu - GoTypesVec[1239] = &info_ArrayOf_Cpu - GoTypesVec[2258] = &info_Dylib + GoTypesVec[1238] = &info_ArrayOf_Cpu + GoTypesVec[2256] = &info_Dylib GoTypesVec[236] = &info_PtrTo_Dylib - GoTypesVec[2259] = &info_DylibCmd + GoTypesVec[2257] = &info_DylibCmd GoTypesVec[237] = &info_PtrTo_DylibCmd - GoTypesVec[1241] = &info_ArrayOf_DylibCmd - GoTypesVec[1240] = &info_ArrayOf_Dylib - GoTypesVec[2260] = &info_Dysymtab + GoTypesVec[1240] = &info_ArrayOf_DylibCmd + GoTypesVec[1239] = &info_ArrayOf_Dylib + GoTypesVec[2258] = &info_Dysymtab GoTypesVec[238] = &info_PtrTo_Dysymtab - GoTypesVec[2261] = &info_DysymtabCmd + GoTypesVec[2259] = &info_DysymtabCmd GoTypesVec[239] = &info_PtrTo_DysymtabCmd - GoTypesVec[1243] = &info_ArrayOf_DysymtabCmd - GoTypesVec[1242] = &info_ArrayOf_Dysymtab - GoTypesVec[2262] = &info_FatArch + GoTypesVec[1242] = &info_ArrayOf_DysymtabCmd + GoTypesVec[1241] = &info_ArrayOf_Dysymtab + GoTypesVec[2260] = &info_FatArch GoTypesVec[240] = &info_PtrTo_FatArch - GoTypesVec[2263] = &info_FatArchHeader + GoTypesVec[2261] = &info_FatArchHeader GoTypesVec[241] = &info_PtrTo_FatArchHeader - GoTypesVec[1245] = &info_ArrayOf_FatArchHeader - GoTypesVec[1244] = &info_ArrayOf_FatArch - GoTypesVec[2264] = &info_FatFile + GoTypesVec[1244] = &info_ArrayOf_FatArchHeader + GoTypesVec[1243] = &info_ArrayOf_FatArch + GoTypesVec[2262] = &info_FatFile GoTypesVec[242] = &info_PtrTo_FatFile - GoTypesVec[1246] = &info_ArrayOf_FatFile - GoTypesVec[2265] = &info_File + GoTypesVec[1245] = &info_ArrayOf_FatFile + GoTypesVec[2263] = &info_File GoTypesVec[243] = &info_PtrTo_File - GoTypesVec[2266] = &info_FileHeader + GoTypesVec[2264] = &info_FileHeader GoTypesVec[244] = &info_PtrTo_FileHeader - GoTypesVec[1248] = &info_ArrayOf_FileHeader - GoTypesVec[1247] = &info_ArrayOf_File - GoTypesVec[2267] = &info_FormatError + GoTypesVec[1247] = &info_ArrayOf_FileHeader + GoTypesVec[1246] = &info_ArrayOf_File + GoTypesVec[2265] = &info_FormatError GoTypesVec[245] = &info_PtrTo_FormatError - GoTypesVec[1249] = &info_ArrayOf_FormatError - GoTypesVec[3040] = &info_Load - GoTypesVec[2268] = &info_LoadBytes + GoTypesVec[1248] = &info_ArrayOf_FormatError + GoTypesVec[3037] = &info_Load + GoTypesVec[2266] = &info_LoadBytes GoTypesVec[246] = &info_PtrTo_LoadBytes - GoTypesVec[1251] = &info_ArrayOf_LoadBytes - GoTypesVec[2269] = &info_LoadCmd + GoTypesVec[1250] = &info_ArrayOf_LoadBytes + GoTypesVec[2267] = &info_LoadCmd GoTypesVec[247] = &info_PtrTo_LoadCmd - GoTypesVec[1252] = &info_ArrayOf_LoadCmd - GoTypesVec[1250] = &info_ArrayOf_Load - GoTypesVec[2270] = &info_Nlist32 + GoTypesVec[1251] = &info_ArrayOf_LoadCmd + GoTypesVec[1249] = &info_ArrayOf_Load + GoTypesVec[2268] = &info_Nlist32 GoTypesVec[248] = &info_PtrTo_Nlist32 - GoTypesVec[1253] = &info_ArrayOf_Nlist32 - GoTypesVec[2271] = &info_Nlist64 + GoTypesVec[1252] = &info_ArrayOf_Nlist32 + GoTypesVec[2269] = &info_Nlist64 GoTypesVec[249] = &info_PtrTo_Nlist64 - GoTypesVec[1254] = &info_ArrayOf_Nlist64 - GoTypesVec[2272] = &info_Regs386 + GoTypesVec[1253] = &info_ArrayOf_Nlist64 + GoTypesVec[2270] = &info_Regs386 GoTypesVec[250] = &info_PtrTo_Regs386 - GoTypesVec[1255] = &info_ArrayOf_Regs386 - GoTypesVec[2273] = &info_RegsAMD64 + GoTypesVec[1254] = &info_ArrayOf_Regs386 + GoTypesVec[2271] = &info_RegsAMD64 GoTypesVec[251] = &info_PtrTo_RegsAMD64 - GoTypesVec[1256] = &info_ArrayOf_RegsAMD64 - GoTypesVec[2274] = &info_Reloc + GoTypesVec[1255] = &info_ArrayOf_RegsAMD64 + GoTypesVec[2272] = &info_Reloc GoTypesVec[252] = &info_PtrTo_Reloc - GoTypesVec[2275] = &info_RelocTypeARM + GoTypesVec[2273] = &info_RelocTypeARM GoTypesVec[253] = &info_PtrTo_RelocTypeARM - GoTypesVec[2276] = &info_RelocTypeARM64 + GoTypesVec[2274] = &info_RelocTypeARM64 GoTypesVec[254] = &info_PtrTo_RelocTypeARM64 - GoTypesVec[1259] = &info_ArrayOf_RelocTypeARM64 - GoTypesVec[1258] = &info_ArrayOf_RelocTypeARM - GoTypesVec[2277] = &info_RelocTypeGeneric + GoTypesVec[1258] = &info_ArrayOf_RelocTypeARM64 + GoTypesVec[1257] = &info_ArrayOf_RelocTypeARM + GoTypesVec[2275] = &info_RelocTypeGeneric GoTypesVec[255] = &info_PtrTo_RelocTypeGeneric - GoTypesVec[1260] = &info_ArrayOf_RelocTypeGeneric - GoTypesVec[2278] = &info_RelocTypeX86_64 + GoTypesVec[1259] = &info_ArrayOf_RelocTypeGeneric + GoTypesVec[2276] = &info_RelocTypeX86_64 GoTypesVec[256] = &info_PtrTo_RelocTypeX86_64 - GoTypesVec[1261] = &info_ArrayOf_RelocTypeX86_64 - GoTypesVec[1257] = &info_ArrayOf_Reloc - GoTypesVec[2279] = &info_Rpath + GoTypesVec[1260] = &info_ArrayOf_RelocTypeX86_64 + GoTypesVec[1256] = &info_ArrayOf_Reloc + GoTypesVec[2277] = &info_Rpath GoTypesVec[257] = &info_PtrTo_Rpath - GoTypesVec[2280] = &info_RpathCmd + GoTypesVec[2278] = &info_RpathCmd GoTypesVec[258] = &info_PtrTo_RpathCmd - GoTypesVec[1263] = &info_ArrayOf_RpathCmd - GoTypesVec[1262] = &info_ArrayOf_Rpath - GoTypesVec[2281] = &info_Section + GoTypesVec[1262] = &info_ArrayOf_RpathCmd + GoTypesVec[1261] = &info_ArrayOf_Rpath + GoTypesVec[2279] = &info_Section GoTypesVec[259] = &info_PtrTo_Section - GoTypesVec[2282] = &info_Section32 + GoTypesVec[2280] = &info_Section32 GoTypesVec[260] = &info_PtrTo_Section32 - GoTypesVec[1265] = &info_ArrayOf_Section32 - GoTypesVec[2283] = &info_Section64 + GoTypesVec[1264] = &info_ArrayOf_Section32 + GoTypesVec[2281] = &info_Section64 GoTypesVec[261] = &info_PtrTo_Section64 - GoTypesVec[1266] = &info_ArrayOf_Section64 - GoTypesVec[2284] = &info_SectionHeader + GoTypesVec[1265] = &info_ArrayOf_Section64 + GoTypesVec[2282] = &info_SectionHeader GoTypesVec[262] = &info_PtrTo_SectionHeader - GoTypesVec[1267] = &info_ArrayOf_SectionHeader - GoTypesVec[1264] = &info_ArrayOf_Section - GoTypesVec[2285] = &info_Segment + GoTypesVec[1266] = &info_ArrayOf_SectionHeader + GoTypesVec[1263] = &info_ArrayOf_Section + GoTypesVec[2283] = &info_Segment GoTypesVec[263] = &info_PtrTo_Segment - GoTypesVec[2286] = &info_Segment32 + GoTypesVec[2284] = &info_Segment32 GoTypesVec[264] = &info_PtrTo_Segment32 - GoTypesVec[1269] = &info_ArrayOf_Segment32 - GoTypesVec[2287] = &info_Segment64 + GoTypesVec[1268] = &info_ArrayOf_Segment32 + GoTypesVec[2285] = &info_Segment64 GoTypesVec[265] = &info_PtrTo_Segment64 - GoTypesVec[1270] = &info_ArrayOf_Segment64 - GoTypesVec[2288] = &info_SegmentHeader + GoTypesVec[1269] = &info_ArrayOf_Segment64 + GoTypesVec[2286] = &info_SegmentHeader GoTypesVec[266] = &info_PtrTo_SegmentHeader - GoTypesVec[1271] = &info_ArrayOf_SegmentHeader - GoTypesVec[1268] = &info_ArrayOf_Segment - GoTypesVec[2289] = &info_Symbol + GoTypesVec[1270] = &info_ArrayOf_SegmentHeader + GoTypesVec[1267] = &info_ArrayOf_Segment + GoTypesVec[2287] = &info_Symbol GoTypesVec[267] = &info_PtrTo_Symbol - GoTypesVec[1272] = &info_ArrayOf_Symbol - GoTypesVec[2290] = &info_Symtab + GoTypesVec[1271] = &info_ArrayOf_Symbol + GoTypesVec[2288] = &info_Symtab GoTypesVec[268] = &info_PtrTo_Symtab - GoTypesVec[2291] = &info_SymtabCmd + GoTypesVec[2289] = &info_SymtabCmd GoTypesVec[269] = &info_PtrTo_SymtabCmd - GoTypesVec[1274] = &info_ArrayOf_SymtabCmd - GoTypesVec[1273] = &info_ArrayOf_Symtab - GoTypesVec[2292] = &info_Thread + GoTypesVec[1273] = &info_ArrayOf_SymtabCmd + GoTypesVec[1272] = &info_ArrayOf_Symtab + GoTypesVec[2290] = &info_Thread GoTypesVec[270] = &info_PtrTo_Thread - GoTypesVec[1275] = &info_ArrayOf_Thread - GoTypesVec[2293] = &info_Type + GoTypesVec[1274] = &info_ArrayOf_Thread + GoTypesVec[2291] = &info_Type GoTypesVec[271] = &info_PtrTo_Type - GoTypesVec[1276] = &info_ArrayOf_Type + GoTypesVec[1275] = &info_ArrayOf_Type EnsureLoaded("go.std.bytes") // E.g. from: C:\Program Files\Go\src\debug\macho\file.go:11:2 EnsureLoaded("go.std.compress.zlib") // E.g. from: C:\Program Files\Go\src\debug\macho\file.go:12:2 EnsureLoaded("go.std.debug.dwarf") // E.g. from: C:\Program Files\Go\src\debug\macho\file.go:13:2 @@ -105516,51 +105510,51 @@ func initNative() { GoMembers{ }) - GoTypesVec[2294] = &info_COFFSymbol + GoTypesVec[2292] = &info_COFFSymbol GoTypesVec[272] = &info_PtrTo_COFFSymbol - GoTypesVec[2295] = &info_COFFSymbolAuxFormat5 + GoTypesVec[2293] = &info_COFFSymbolAuxFormat5 GoTypesVec[273] = &info_PtrTo_COFFSymbolAuxFormat5 - GoTypesVec[1278] = &info_ArrayOf_COFFSymbolAuxFormat5 - GoTypesVec[1277] = &info_ArrayOf_COFFSymbol - GoTypesVec[2296] = &info_DataDirectory + GoTypesVec[1277] = &info_ArrayOf_COFFSymbolAuxFormat5 + GoTypesVec[1276] = &info_ArrayOf_COFFSymbol + GoTypesVec[2294] = &info_DataDirectory GoTypesVec[274] = &info_PtrTo_DataDirectory - GoTypesVec[1279] = &info_ArrayOf_DataDirectory - GoTypesVec[2297] = &info_File + GoTypesVec[1278] = &info_ArrayOf_DataDirectory + GoTypesVec[2295] = &info_File GoTypesVec[275] = &info_PtrTo_File - GoTypesVec[2298] = &info_FileHeader + GoTypesVec[2296] = &info_FileHeader GoTypesVec[276] = &info_PtrTo_FileHeader - GoTypesVec[1281] = &info_ArrayOf_FileHeader - GoTypesVec[1280] = &info_ArrayOf_File - GoTypesVec[2299] = &info_FormatError + GoTypesVec[1280] = &info_ArrayOf_FileHeader + GoTypesVec[1279] = &info_ArrayOf_File + GoTypesVec[2297] = &info_FormatError GoTypesVec[277] = &info_PtrTo_FormatError - GoTypesVec[1282] = &info_ArrayOf_FormatError - GoTypesVec[2300] = &info_ImportDirectory + GoTypesVec[1281] = &info_ArrayOf_FormatError + GoTypesVec[2298] = &info_ImportDirectory GoTypesVec[278] = &info_PtrTo_ImportDirectory - GoTypesVec[1283] = &info_ArrayOf_ImportDirectory - GoTypesVec[2301] = &info_OptionalHeader32 + GoTypesVec[1282] = &info_ArrayOf_ImportDirectory + GoTypesVec[2299] = &info_OptionalHeader32 GoTypesVec[279] = &info_PtrTo_OptionalHeader32 - GoTypesVec[1284] = &info_ArrayOf_OptionalHeader32 - GoTypesVec[2302] = &info_OptionalHeader64 + GoTypesVec[1283] = &info_ArrayOf_OptionalHeader32 + GoTypesVec[2300] = &info_OptionalHeader64 GoTypesVec[280] = &info_PtrTo_OptionalHeader64 - GoTypesVec[1285] = &info_ArrayOf_OptionalHeader64 - GoTypesVec[2303] = &info_Reloc + GoTypesVec[1284] = &info_ArrayOf_OptionalHeader64 + GoTypesVec[2301] = &info_Reloc GoTypesVec[281] = &info_PtrTo_Reloc - GoTypesVec[1286] = &info_ArrayOf_Reloc - GoTypesVec[2304] = &info_Section + GoTypesVec[1285] = &info_ArrayOf_Reloc + GoTypesVec[2302] = &info_Section GoTypesVec[282] = &info_PtrTo_Section - GoTypesVec[2305] = &info_SectionHeader + GoTypesVec[2303] = &info_SectionHeader GoTypesVec[283] = &info_PtrTo_SectionHeader - GoTypesVec[2306] = &info_SectionHeader32 + GoTypesVec[2304] = &info_SectionHeader32 GoTypesVec[284] = &info_PtrTo_SectionHeader32 - GoTypesVec[1289] = &info_ArrayOf_SectionHeader32 - GoTypesVec[1288] = &info_ArrayOf_SectionHeader - GoTypesVec[1287] = &info_ArrayOf_Section - GoTypesVec[2307] = &info_StringTable + GoTypesVec[1288] = &info_ArrayOf_SectionHeader32 + GoTypesVec[1287] = &info_ArrayOf_SectionHeader + GoTypesVec[1286] = &info_ArrayOf_Section + GoTypesVec[2305] = &info_StringTable GoTypesVec[285] = &info_PtrTo_StringTable - GoTypesVec[1290] = &info_ArrayOf_StringTable - GoTypesVec[2308] = &info_Symbol + GoTypesVec[1289] = &info_ArrayOf_StringTable + GoTypesVec[2306] = &info_Symbol GoTypesVec[286] = &info_PtrTo_Symbol - GoTypesVec[1291] = &info_ArrayOf_Symbol + GoTypesVec[1290] = &info_ArrayOf_Symbol EnsureLoaded("go.std.bytes") // E.g. from: C:\Program Files\Go\src\debug\pe\file.go:9:2 EnsureLoaded("go.std.compress.zlib") // E.g. from: C:\Program Files\Go\src\debug\pe\file.go:10:2 EnsureLoaded("go.std.debug.dwarf") // E.g. from: C:\Program Files\Go\src\debug\pe\file.go:11:2 @@ -106865,21 +106859,21 @@ func initNative() { GoMembers{ }) - GoTypesVec[2309] = &info_File + GoTypesVec[2307] = &info_File GoTypesVec[287] = &info_PtrTo_File - GoTypesVec[2310] = &info_FileHeader + GoTypesVec[2308] = &info_FileHeader GoTypesVec[288] = &info_PtrTo_FileHeader - GoTypesVec[1293] = &info_ArrayOf_FileHeader - GoTypesVec[1292] = &info_ArrayOf_File - GoTypesVec[2311] = &info_Section + GoTypesVec[1292] = &info_ArrayOf_FileHeader + GoTypesVec[1291] = &info_ArrayOf_File + GoTypesVec[2309] = &info_Section GoTypesVec[289] = &info_PtrTo_Section - GoTypesVec[2312] = &info_SectionHeader + GoTypesVec[2310] = &info_SectionHeader GoTypesVec[290] = &info_PtrTo_SectionHeader - GoTypesVec[1295] = &info_ArrayOf_SectionHeader - GoTypesVec[1294] = &info_ArrayOf_Section - GoTypesVec[2313] = &info_Sym + GoTypesVec[1294] = &info_ArrayOf_SectionHeader + GoTypesVec[1293] = &info_ArrayOf_Section + GoTypesVec[2311] = &info_Sym GoTypesVec[291] = &info_PtrTo_Sym - GoTypesVec[1296] = &info_ArrayOf_Sym + GoTypesVec[1295] = &info_ArrayOf_Sym EnsureLoaded("go.std.encoding.binary") // E.g. from: C:\Program Files\Go\src\debug\plan9obj\file.go:9:2 EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\debug\plan9obj\file.go:10:2 EnsureLoaded("go.std.fmt") // E.g. from: C:\Program Files\Go\src\debug\plan9obj\file.go:11:2 @@ -107160,9 +107154,9 @@ func initNative() { GoMembers{ }) - GoTypesVec[2314] = &info_FS + GoTypesVec[2312] = &info_FS GoTypesVec[292] = &info_PtrTo_FS - GoTypesVec[1297] = &info_ArrayOf_FS + GoTypesVec[1296] = &info_ArrayOf_FS EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\embed\embed.go:132:2 EnsureLoaded("go.std.io") // E.g. from: C:\Program Files\Go\src\embed\embed.go:133:2 EnsureLoaded("go.std.io.fs") // E.g. from: C:\Program Files\Go\src\embed\embed.go:134:2 @@ -107532,9 +107526,9 @@ func initNative() { GoMembers{ }) - GoTypesVec[2315] = &info_CorruptInputError + GoTypesVec[2313] = &info_CorruptInputError GoTypesVec[293] = &info_PtrTo_CorruptInputError - GoTypesVec[1302] = &info_ArrayOf_CorruptInputError + GoTypesVec[1301] = &info_ArrayOf_CorruptInputError EnsureLoaded("go.std.io") // E.g. from: C:\Program Files\Go\src\encoding\ascii85\ascii85.go:10:2 EnsureLoaded("go.std.strconv") // E.g. from: C:\Program Files\Go\src\encoding\ascii85\ascii85.go:11:2 } @@ -109570,30 +109564,30 @@ func initNative() { GoMembers{ }) - GoTypesVec[2316] = &info_BitString + GoTypesVec[2314] = &info_BitString GoTypesVec[294] = &info_PtrTo_BitString - GoTypesVec[1303] = &info_ArrayOf_BitString - GoTypesVec[2317] = &info_Enumerated + GoTypesVec[1302] = &info_ArrayOf_BitString + GoTypesVec[2315] = &info_Enumerated GoTypesVec[295] = &info_PtrTo_Enumerated - GoTypesVec[1304] = &info_ArrayOf_Enumerated - GoTypesVec[2318] = &info_Flag + GoTypesVec[1303] = &info_ArrayOf_Enumerated + GoTypesVec[2316] = &info_Flag GoTypesVec[296] = &info_PtrTo_Flag - GoTypesVec[1305] = &info_ArrayOf_Flag - GoTypesVec[2319] = &info_ObjectIdentifier + GoTypesVec[1304] = &info_ArrayOf_Flag + GoTypesVec[2317] = &info_ObjectIdentifier GoTypesVec[297] = &info_PtrTo_ObjectIdentifier - GoTypesVec[1306] = &info_ArrayOf_ObjectIdentifier - GoTypesVec[2320] = &info_RawContent + GoTypesVec[1305] = &info_ArrayOf_ObjectIdentifier + GoTypesVec[2318] = &info_RawContent GoTypesVec[298] = &info_PtrTo_RawContent - GoTypesVec[1307] = &info_ArrayOf_RawContent - GoTypesVec[2321] = &info_RawValue + GoTypesVec[1306] = &info_ArrayOf_RawContent + GoTypesVec[2319] = &info_RawValue GoTypesVec[299] = &info_PtrTo_RawValue - GoTypesVec[1308] = &info_ArrayOf_RawValue - GoTypesVec[2322] = &info_StructuralError + GoTypesVec[1307] = &info_ArrayOf_RawValue + GoTypesVec[2320] = &info_StructuralError GoTypesVec[300] = &info_PtrTo_StructuralError - GoTypesVec[1309] = &info_ArrayOf_StructuralError - GoTypesVec[2323] = &info_SyntaxError + GoTypesVec[1308] = &info_ArrayOf_StructuralError + GoTypesVec[2321] = &info_SyntaxError GoTypesVec[301] = &info_PtrTo_SyntaxError - GoTypesVec[1310] = &info_ArrayOf_SyntaxError + GoTypesVec[1309] = &info_ArrayOf_SyntaxError EnsureLoaded("go.std.bytes") // E.g. from: C:\Program Files\Go\src\encoding\asn1\marshal.go:8:2 EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\encoding\asn1\asn1.go:23:2 EnsureLoaded("go.std.fmt") // E.g. from: C:\Program Files\Go\src\encoding\asn1\asn1.go:24:2 @@ -110204,12 +110198,12 @@ func initNative() { GoMembers{ }) - GoTypesVec[2324] = &info_CorruptInputError + GoTypesVec[2322] = &info_CorruptInputError GoTypesVec[302] = &info_PtrTo_CorruptInputError - GoTypesVec[1311] = &info_ArrayOf_CorruptInputError - GoTypesVec[2325] = &info_Encoding + GoTypesVec[1310] = &info_ArrayOf_CorruptInputError + GoTypesVec[2323] = &info_Encoding GoTypesVec[303] = &info_PtrTo_Encoding - GoTypesVec[1312] = &info_ArrayOf_Encoding + GoTypesVec[1311] = &info_ArrayOf_Encoding EnsureLoaded("go.std.io") // E.g. from: C:\Program Files\Go\src\encoding\base32\base32.go:9:2 EnsureLoaded("go.std.strconv") // E.g. from: C:\Program Files\Go\src\encoding\base32\base32.go:10:2 } @@ -110832,12 +110826,12 @@ func initNative() { GoMembers{ }) - GoTypesVec[2326] = &info_CorruptInputError + GoTypesVec[2324] = &info_CorruptInputError GoTypesVec[304] = &info_PtrTo_CorruptInputError - GoTypesVec[1313] = &info_ArrayOf_CorruptInputError - GoTypesVec[2327] = &info_Encoding + GoTypesVec[1312] = &info_ArrayOf_CorruptInputError + GoTypesVec[2325] = &info_Encoding GoTypesVec[305] = &info_PtrTo_Encoding - GoTypesVec[1314] = &info_ArrayOf_Encoding + GoTypesVec[1313] = &info_ArrayOf_Encoding EnsureLoaded("go.std.encoding.binary") // E.g. from: C:\Program Files\Go\src\encoding\base64\base64.go:9:2 EnsureLoaded("go.std.io") // E.g. from: C:\Program Files\Go\src\encoding\base64\base64.go:10:2 EnsureLoaded("go.std.strconv") // E.g. from: C:\Program Files\Go\src\encoding\base64\base64.go:11:2 @@ -111383,10 +111377,10 @@ func initNative() { GoMembers{ }) - GoTypesVec[2949] = &info_AppendByteOrder - GoTypesVec[1315] = &info_ArrayOf_AppendByteOrder - GoTypesVec[2928] = &info_ByteOrder - GoTypesVec[1316] = &info_ArrayOf_ByteOrder + GoTypesVec[2946] = &info_AppendByteOrder + GoTypesVec[1314] = &info_ArrayOf_AppendByteOrder + GoTypesVec[2925] = &info_ByteOrder + GoTypesVec[1315] = &info_ArrayOf_ByteOrder EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\encoding\binary\binary.go:25:2 EnsureLoaded("go.std.io") // E.g. from: C:\Program Files\Go\src\encoding\binary\binary.go:26:2 EnsureLoaded("go.std.math") // E.g. from: C:\Program Files\Go\src\encoding\binary\binary.go:27:2 @@ -112224,15 +112218,15 @@ func initNative() { GoMembers{ }) - GoTypesVec[2328] = &info_ParseError + GoTypesVec[2326] = &info_ParseError GoTypesVec[306] = &info_PtrTo_ParseError - GoTypesVec[1317] = &info_ArrayOf_ParseError - GoTypesVec[2329] = &info_Reader + GoTypesVec[1316] = &info_ArrayOf_ParseError + GoTypesVec[2327] = &info_Reader GoTypesVec[307] = &info_PtrTo_Reader - GoTypesVec[1318] = &info_ArrayOf_Reader - GoTypesVec[2330] = &info_Writer + GoTypesVec[1317] = &info_ArrayOf_Reader + GoTypesVec[2328] = &info_Writer GoTypesVec[308] = &info_PtrTo_Writer - GoTypesVec[1319] = &info_ArrayOf_Writer + GoTypesVec[1318] = &info_ArrayOf_Writer EnsureLoaded("go.std.bufio") // E.g. from: C:\Program Files\Go\src\encoding\csv\reader.go:55:2 EnsureLoaded("go.std.bytes") // E.g. from: C:\Program Files\Go\src\encoding\csv\reader.go:56:2 EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\encoding\csv\reader.go:57:2 @@ -112774,14 +112768,14 @@ func initNative() { GoMembers{ }) - GoTypesVec[3041] = &info_BinaryMarshaler - GoTypesVec[1298] = &info_ArrayOf_BinaryMarshaler - GoTypesVec[3042] = &info_BinaryUnmarshaler - GoTypesVec[1299] = &info_ArrayOf_BinaryUnmarshaler - GoTypesVec[3043] = &info_TextMarshaler - GoTypesVec[1300] = &info_ArrayOf_TextMarshaler - GoTypesVec[3044] = &info_TextUnmarshaler - GoTypesVec[1301] = &info_ArrayOf_TextUnmarshaler + GoTypesVec[3038] = &info_BinaryMarshaler + GoTypesVec[1297] = &info_ArrayOf_BinaryMarshaler + GoTypesVec[3039] = &info_BinaryUnmarshaler + GoTypesVec[1298] = &info_ArrayOf_BinaryUnmarshaler + GoTypesVec[3040] = &info_TextMarshaler + GoTypesVec[1299] = &info_ArrayOf_TextMarshaler + GoTypesVec[3041] = &info_TextUnmarshaler + GoTypesVec[1300] = &info_ArrayOf_TextUnmarshaler } -------- END _tests/gold/go1.19/amd64-windows/joker/std/gostd/go/std/encoding/encoding_native.go. -------- BEGIN _tests/gold/go1.19/amd64-windows/joker/std/gostd/go/std/encoding/gob.joke: @@ -113830,19 +113824,19 @@ func initNative() { GoMembers{ }) - GoTypesVec[2331] = &info_CommonType + GoTypesVec[2329] = &info_CommonType GoTypesVec[309] = &info_PtrTo_CommonType - GoTypesVec[1320] = &info_ArrayOf_CommonType - GoTypesVec[2332] = &info_Decoder + GoTypesVec[1319] = &info_ArrayOf_CommonType + GoTypesVec[2330] = &info_Decoder GoTypesVec[310] = &info_PtrTo_Decoder - GoTypesVec[1321] = &info_ArrayOf_Decoder - GoTypesVec[2333] = &info_Encoder + GoTypesVec[1320] = &info_ArrayOf_Decoder + GoTypesVec[2331] = &info_Encoder GoTypesVec[311] = &info_PtrTo_Encoder - GoTypesVec[1322] = &info_ArrayOf_Encoder - GoTypesVec[3045] = &info_GobDecoder - GoTypesVec[1323] = &info_ArrayOf_GobDecoder - GoTypesVec[3046] = &info_GobEncoder - GoTypesVec[1324] = &info_ArrayOf_GobEncoder + GoTypesVec[1321] = &info_ArrayOf_Encoder + GoTypesVec[3042] = &info_GobDecoder + GoTypesVec[1322] = &info_ArrayOf_GobDecoder + GoTypesVec[3043] = &info_GobEncoder + GoTypesVec[1323] = &info_ArrayOf_GobEncoder EnsureLoaded("go.std.bufio") // E.g. from: C:\Program Files\Go\src\encoding\gob\decoder.go:8:2 EnsureLoaded("go.std.encoding") // E.g. from: C:\Program Files\Go\src\encoding\gob\decode.go:10:2 EnsureLoaded("go.std.encoding.binary") // E.g. from: C:\Program Files\Go\src\encoding\gob\encode.go:11:2 @@ -114202,9 +114196,9 @@ func initNative() { GoMembers{ }) - GoTypesVec[2334] = &info_InvalidByteError + GoTypesVec[2332] = &info_InvalidByteError GoTypesVec[312] = &info_PtrTo_InvalidByteError - GoTypesVec[1325] = &info_ArrayOf_InvalidByteError + GoTypesVec[1324] = &info_ArrayOf_InvalidByteError EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\encoding\hex\hex.go:9:2 EnsureLoaded("go.std.fmt") // E.g. from: C:\Program Files\Go\src\encoding\hex\hex.go:10:2 EnsureLoaded("go.std.io") // E.g. from: C:\Program Files\Go\src\encoding\hex\hex.go:11:2 @@ -117801,51 +117795,51 @@ func initNative() { GoMembers{ }) - GoTypesVec[2335] = &info_Decoder + GoTypesVec[2333] = &info_Decoder GoTypesVec[313] = &info_PtrTo_Decoder - GoTypesVec[1326] = &info_ArrayOf_Decoder - GoTypesVec[2336] = &info_Delim + GoTypesVec[1325] = &info_ArrayOf_Decoder + GoTypesVec[2334] = &info_Delim GoTypesVec[314] = &info_PtrTo_Delim - GoTypesVec[1327] = &info_ArrayOf_Delim - GoTypesVec[2337] = &info_Encoder + GoTypesVec[1326] = &info_ArrayOf_Delim + GoTypesVec[2335] = &info_Encoder GoTypesVec[315] = &info_PtrTo_Encoder - GoTypesVec[1328] = &info_ArrayOf_Encoder - GoTypesVec[2338] = &info_InvalidUTF8Error + GoTypesVec[1327] = &info_ArrayOf_Encoder + GoTypesVec[2336] = &info_InvalidUTF8Error GoTypesVec[316] = &info_PtrTo_InvalidUTF8Error - GoTypesVec[1329] = &info_ArrayOf_InvalidUTF8Error - GoTypesVec[2339] = &info_InvalidUnmarshalError + GoTypesVec[1328] = &info_ArrayOf_InvalidUTF8Error + GoTypesVec[2337] = &info_InvalidUnmarshalError GoTypesVec[317] = &info_PtrTo_InvalidUnmarshalError - GoTypesVec[1330] = &info_ArrayOf_InvalidUnmarshalError - GoTypesVec[3047] = &info_Marshaler - GoTypesVec[2340] = &info_MarshalerError + GoTypesVec[1329] = &info_ArrayOf_InvalidUnmarshalError + GoTypesVec[3044] = &info_Marshaler + GoTypesVec[2338] = &info_MarshalerError GoTypesVec[318] = &info_PtrTo_MarshalerError - GoTypesVec[1332] = &info_ArrayOf_MarshalerError - GoTypesVec[1331] = &info_ArrayOf_Marshaler - GoTypesVec[2341] = &info_Number + GoTypesVec[1331] = &info_ArrayOf_MarshalerError + GoTypesVec[1330] = &info_ArrayOf_Marshaler + GoTypesVec[2339] = &info_Number GoTypesVec[319] = &info_PtrTo_Number - GoTypesVec[1333] = &info_ArrayOf_Number - GoTypesVec[2342] = &info_RawMessage + GoTypesVec[1332] = &info_ArrayOf_Number + GoTypesVec[2340] = &info_RawMessage GoTypesVec[320] = &info_PtrTo_RawMessage - GoTypesVec[1334] = &info_ArrayOf_RawMessage - GoTypesVec[2343] = &info_SyntaxError + GoTypesVec[1333] = &info_ArrayOf_RawMessage + GoTypesVec[2341] = &info_SyntaxError GoTypesVec[321] = &info_PtrTo_SyntaxError - GoTypesVec[1335] = &info_ArrayOf_SyntaxError - GoTypesVec[3094] = &info_Token - GoTypesVec[1336] = &info_ArrayOf_Token - GoTypesVec[2344] = &info_UnmarshalFieldError + GoTypesVec[1334] = &info_ArrayOf_SyntaxError + GoTypesVec[3091] = &info_Token + GoTypesVec[1335] = &info_ArrayOf_Token + GoTypesVec[2342] = &info_UnmarshalFieldError GoTypesVec[322] = &info_PtrTo_UnmarshalFieldError - GoTypesVec[1337] = &info_ArrayOf_UnmarshalFieldError - GoTypesVec[2345] = &info_UnmarshalTypeError + GoTypesVec[1336] = &info_ArrayOf_UnmarshalFieldError + GoTypesVec[2343] = &info_UnmarshalTypeError GoTypesVec[323] = &info_PtrTo_UnmarshalTypeError - GoTypesVec[1338] = &info_ArrayOf_UnmarshalTypeError - GoTypesVec[3048] = &info_Unmarshaler - GoTypesVec[1339] = &info_ArrayOf_Unmarshaler - GoTypesVec[2346] = &info_UnsupportedTypeError + GoTypesVec[1337] = &info_ArrayOf_UnmarshalTypeError + GoTypesVec[3045] = &info_Unmarshaler + GoTypesVec[1338] = &info_ArrayOf_Unmarshaler + GoTypesVec[2344] = &info_UnsupportedTypeError GoTypesVec[324] = &info_PtrTo_UnsupportedTypeError - GoTypesVec[1340] = &info_ArrayOf_UnsupportedTypeError - GoTypesVec[2347] = &info_UnsupportedValueError + GoTypesVec[1339] = &info_ArrayOf_UnsupportedTypeError + GoTypesVec[2345] = &info_UnsupportedValueError GoTypesVec[325] = &info_PtrTo_UnsupportedValueError - GoTypesVec[1341] = &info_ArrayOf_UnsupportedValueError + GoTypesVec[1340] = &info_ArrayOf_UnsupportedValueError EnsureLoaded("go.std.bytes") // E.g. from: C:\Program Files\Go\src\encoding\json\encode.go:14:2 EnsureLoaded("go.std.encoding") // E.g. from: C:\Program Files\Go\src\encoding\json\decode.go:11:2 EnsureLoaded("go.std.encoding.base64") // E.g. from: C:\Program Files\Go\src\encoding\json\decode.go:12:2 @@ -118135,9 +118129,9 @@ func initNative() { GoMembers{ }) - GoTypesVec[2348] = &info_Block + GoTypesVec[2346] = &info_Block GoTypesVec[326] = &info_PtrTo_Block - GoTypesVec[1342] = &info_ArrayOf_Block + GoTypesVec[1341] = &info_ArrayOf_Block EnsureLoaded("go.std.bytes") // E.g. from: C:\Program Files\Go\src\encoding\pem\pem.go:11:2 EnsureLoaded("go.std.encoding.base64") // E.g. from: C:\Program Files\Go\src\encoding\pem\pem.go:12:2 EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\encoding\pem\pem.go:13:2 @@ -122373,60 +122367,60 @@ func initNative() { GoMembers{ }) - GoTypesVec[2349] = &info_Attr + GoTypesVec[2347] = &info_Attr GoTypesVec[327] = &info_PtrTo_Attr - GoTypesVec[1343] = &info_ArrayOf_Attr - GoTypesVec[2350] = &info_CharData + GoTypesVec[1342] = &info_ArrayOf_Attr + GoTypesVec[2348] = &info_CharData GoTypesVec[328] = &info_PtrTo_CharData - GoTypesVec[1344] = &info_ArrayOf_CharData - GoTypesVec[2351] = &info_Comment + GoTypesVec[1343] = &info_ArrayOf_CharData + GoTypesVec[2349] = &info_Comment GoTypesVec[329] = &info_PtrTo_Comment - GoTypesVec[1345] = &info_ArrayOf_Comment - GoTypesVec[2352] = &info_Decoder + GoTypesVec[1344] = &info_ArrayOf_Comment + GoTypesVec[2350] = &info_Decoder GoTypesVec[330] = &info_PtrTo_Decoder - GoTypesVec[1346] = &info_ArrayOf_Decoder - GoTypesVec[2353] = &info_Directive + GoTypesVec[1345] = &info_ArrayOf_Decoder + GoTypesVec[2351] = &info_Directive GoTypesVec[331] = &info_PtrTo_Directive - GoTypesVec[1347] = &info_ArrayOf_Directive - GoTypesVec[2354] = &info_Encoder + GoTypesVec[1346] = &info_ArrayOf_Directive + GoTypesVec[2352] = &info_Encoder GoTypesVec[332] = &info_PtrTo_Encoder - GoTypesVec[1348] = &info_ArrayOf_Encoder - GoTypesVec[2355] = &info_EndElement + GoTypesVec[1347] = &info_ArrayOf_Encoder + GoTypesVec[2353] = &info_EndElement GoTypesVec[333] = &info_PtrTo_EndElement - GoTypesVec[1349] = &info_ArrayOf_EndElement - GoTypesVec[3049] = &info_Marshaler - GoTypesVec[3050] = &info_MarshalerAttr - GoTypesVec[1351] = &info_ArrayOf_MarshalerAttr - GoTypesVec[1350] = &info_ArrayOf_Marshaler - GoTypesVec[2356] = &info_Name + GoTypesVec[1348] = &info_ArrayOf_EndElement + GoTypesVec[3046] = &info_Marshaler + GoTypesVec[3047] = &info_MarshalerAttr + GoTypesVec[1350] = &info_ArrayOf_MarshalerAttr + GoTypesVec[1349] = &info_ArrayOf_Marshaler + GoTypesVec[2354] = &info_Name GoTypesVec[334] = &info_PtrTo_Name - GoTypesVec[1352] = &info_ArrayOf_Name - GoTypesVec[2357] = &info_ProcInst + GoTypesVec[1351] = &info_ArrayOf_Name + GoTypesVec[2355] = &info_ProcInst GoTypesVec[335] = &info_PtrTo_ProcInst - GoTypesVec[1353] = &info_ArrayOf_ProcInst - GoTypesVec[2358] = &info_StartElement + GoTypesVec[1352] = &info_ArrayOf_ProcInst + GoTypesVec[2356] = &info_StartElement GoTypesVec[336] = &info_PtrTo_StartElement - GoTypesVec[1354] = &info_ArrayOf_StartElement - GoTypesVec[2359] = &info_SyntaxError + GoTypesVec[1353] = &info_ArrayOf_StartElement + GoTypesVec[2357] = &info_SyntaxError GoTypesVec[337] = &info_PtrTo_SyntaxError - GoTypesVec[1355] = &info_ArrayOf_SyntaxError - GoTypesVec[2360] = &info_TagPathError + GoTypesVec[1354] = &info_ArrayOf_SyntaxError + GoTypesVec[2358] = &info_TagPathError GoTypesVec[338] = &info_PtrTo_TagPathError - GoTypesVec[1356] = &info_ArrayOf_TagPathError - GoTypesVec[3095] = &info_Token - GoTypesVec[3051] = &info_TokenReader - GoTypesVec[1358] = &info_ArrayOf_TokenReader - GoTypesVec[1357] = &info_ArrayOf_Token - GoTypesVec[2361] = &info_UnmarshalError + GoTypesVec[1355] = &info_ArrayOf_TagPathError + GoTypesVec[3092] = &info_Token + GoTypesVec[3048] = &info_TokenReader + GoTypesVec[1357] = &info_ArrayOf_TokenReader + GoTypesVec[1356] = &info_ArrayOf_Token + GoTypesVec[2359] = &info_UnmarshalError GoTypesVec[339] = &info_PtrTo_UnmarshalError - GoTypesVec[1359] = &info_ArrayOf_UnmarshalError - GoTypesVec[3052] = &info_Unmarshaler - GoTypesVec[3053] = &info_UnmarshalerAttr - GoTypesVec[1361] = &info_ArrayOf_UnmarshalerAttr - GoTypesVec[1360] = &info_ArrayOf_Unmarshaler - GoTypesVec[2362] = &info_UnsupportedTypeError + GoTypesVec[1358] = &info_ArrayOf_UnmarshalError + GoTypesVec[3049] = &info_Unmarshaler + GoTypesVec[3050] = &info_UnmarshalerAttr + GoTypesVec[1360] = &info_ArrayOf_UnmarshalerAttr + GoTypesVec[1359] = &info_ArrayOf_Unmarshaler + GoTypesVec[2360] = &info_UnsupportedTypeError GoTypesVec[340] = &info_PtrTo_UnsupportedTypeError - GoTypesVec[1362] = &info_ArrayOf_UnsupportedTypeError + GoTypesVec[1361] = &info_ArrayOf_UnsupportedTypeError EnsureLoaded("go.std.bufio") // E.g. from: C:\Program Files\Go\src\encoding\xml\marshal.go:8:2 EnsureLoaded("go.std.bytes") // E.g. from: C:\Program Files\Go\src\encoding\xml\marshal.go:9:2 EnsureLoaded("go.std.encoding") // E.g. from: C:\Program Files\Go\src\encoding\xml\marshal.go:10:2 @@ -124206,26 +124200,26 @@ func initNative() { GoMembers{ }) - GoTypesVec[2363] = &info_Float + GoTypesVec[2361] = &info_Float GoTypesVec[341] = &info_PtrTo_Float - GoTypesVec[1363] = &info_ArrayOf_Float - GoTypesVec[2364] = &info_Func + GoTypesVec[1362] = &info_ArrayOf_Float + GoTypesVec[2362] = &info_Func GoTypesVec[342] = &info_PtrTo_Func - GoTypesVec[1364] = &info_ArrayOf_Func - GoTypesVec[2365] = &info_Int + GoTypesVec[1363] = &info_ArrayOf_Func + GoTypesVec[2363] = &info_Int GoTypesVec[343] = &info_PtrTo_Int - GoTypesVec[1365] = &info_ArrayOf_Int - GoTypesVec[2366] = &info_KeyValue + GoTypesVec[1364] = &info_ArrayOf_Int + GoTypesVec[2364] = &info_KeyValue GoTypesVec[344] = &info_PtrTo_KeyValue - GoTypesVec[1366] = &info_ArrayOf_KeyValue - GoTypesVec[2367] = &info_Map + GoTypesVec[1365] = &info_ArrayOf_KeyValue + GoTypesVec[2365] = &info_Map GoTypesVec[345] = &info_PtrTo_Map - GoTypesVec[1367] = &info_ArrayOf_Map - GoTypesVec[2368] = &info_String + GoTypesVec[1366] = &info_ArrayOf_Map + GoTypesVec[2366] = &info_String GoTypesVec[346] = &info_PtrTo_String - GoTypesVec[1368] = &info_ArrayOf_String - GoTypesVec[3054] = &info_Var - GoTypesVec[1369] = &info_ArrayOf_Var + GoTypesVec[1367] = &info_ArrayOf_String + GoTypesVec[3051] = &info_Var + GoTypesVec[1368] = &info_ArrayOf_Var EnsureLoaded("go.std.encoding.json") // E.g. from: C:\Program Files\Go\src\expvar\expvar.go:25:2 EnsureLoaded("go.std.fmt") // E.g. from: C:\Program Files\Go\src\expvar\expvar.go:26:2 EnsureLoaded("go.std.log") // E.g. from: C:\Program Files\Go\src\expvar\expvar.go:27:2 @@ -125955,19 +125949,19 @@ func initNative() { GoMembers{ }) - GoTypesVec[2369] = &info_ErrorHandling + GoTypesVec[2367] = &info_ErrorHandling GoTypesVec[347] = &info_PtrTo_ErrorHandling - GoTypesVec[1370] = &info_ArrayOf_ErrorHandling - GoTypesVec[2370] = &info_Flag + GoTypesVec[1369] = &info_ArrayOf_ErrorHandling + GoTypesVec[2368] = &info_Flag GoTypesVec[348] = &info_PtrTo_Flag - GoTypesVec[2371] = &info_FlagSet + GoTypesVec[2369] = &info_FlagSet GoTypesVec[349] = &info_PtrTo_FlagSet - GoTypesVec[1372] = &info_ArrayOf_FlagSet - GoTypesVec[1371] = &info_ArrayOf_Flag - GoTypesVec[2964] = &info_Getter - GoTypesVec[1373] = &info_ArrayOf_Getter - GoTypesVec[2991] = &info_Value - GoTypesVec[1374] = &info_ArrayOf_Value + GoTypesVec[1371] = &info_ArrayOf_FlagSet + GoTypesVec[1370] = &info_ArrayOf_Flag + GoTypesVec[2961] = &info_Getter + GoTypesVec[1372] = &info_ArrayOf_Getter + GoTypesVec[2988] = &info_Value + GoTypesVec[1373] = &info_ArrayOf_Value EnsureLoaded("go.std.encoding") // E.g. from: C:\Program Files\Go\src\flag\flag.go:86:2 EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\flag\flag.go:87:2 EnsureLoaded("go.std.fmt") // E.g. from: C:\Program Files\Go\src\flag\flag.go:88:2 @@ -127220,18 +127214,18 @@ func initNative() { GoMembers{ }) - GoTypesVec[3055] = &info_Formatter - GoTypesVec[1375] = &info_ArrayOf_Formatter - GoTypesVec[3056] = &info_GoStringer - GoTypesVec[1376] = &info_ArrayOf_GoStringer - GoTypesVec[2931] = &info_ScanState - GoTypesVec[1377] = &info_ArrayOf_ScanState - GoTypesVec[3057] = &info_Scanner - GoTypesVec[1378] = &info_ArrayOf_Scanner - GoTypesVec[2950] = &info_State - GoTypesVec[1379] = &info_ArrayOf_State - GoTypesVec[3058] = &info_Stringer - GoTypesVec[1380] = &info_ArrayOf_Stringer + GoTypesVec[3052] = &info_Formatter + GoTypesVec[1374] = &info_ArrayOf_Formatter + GoTypesVec[3053] = &info_GoStringer + GoTypesVec[1375] = &info_ArrayOf_GoStringer + GoTypesVec[2928] = &info_ScanState + GoTypesVec[1376] = &info_ArrayOf_ScanState + GoTypesVec[3054] = &info_Scanner + GoTypesVec[1377] = &info_ArrayOf_Scanner + GoTypesVec[2947] = &info_State + GoTypesVec[1378] = &info_ArrayOf_State + GoTypesVec[3055] = &info_Stringer + GoTypesVec[1379] = &info_ArrayOf_Stringer EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\fmt\errors.go:7:8 EnsureLoaded("go.std.io") // E.g. from: C:\Program Files\Go\src\fmt\print.go:9:2 EnsureLoaded("go.std.math") // E.g. from: C:\Program Files\Go\src\fmt\scan.go:10:2 @@ -144061,213 +144055,213 @@ func initNative() { GoMembers{ }) - GoTypesVec[2372] = &info_ArrayType + GoTypesVec[2370] = &info_ArrayType GoTypesVec[350] = &info_PtrTo_ArrayType - GoTypesVec[1381] = &info_ArrayOf_ArrayType - GoTypesVec[2373] = &info_AssignStmt + GoTypesVec[1380] = &info_ArrayOf_ArrayType + GoTypesVec[2371] = &info_AssignStmt GoTypesVec[351] = &info_PtrTo_AssignStmt - GoTypesVec[1382] = &info_ArrayOf_AssignStmt - GoTypesVec[2374] = &info_BadDecl + GoTypesVec[1381] = &info_ArrayOf_AssignStmt + GoTypesVec[2372] = &info_BadDecl GoTypesVec[352] = &info_PtrTo_BadDecl - GoTypesVec[1383] = &info_ArrayOf_BadDecl - GoTypesVec[2375] = &info_BadExpr + GoTypesVec[1382] = &info_ArrayOf_BadDecl + GoTypesVec[2373] = &info_BadExpr GoTypesVec[353] = &info_PtrTo_BadExpr - GoTypesVec[1384] = &info_ArrayOf_BadExpr - GoTypesVec[2376] = &info_BadStmt + GoTypesVec[1383] = &info_ArrayOf_BadExpr + GoTypesVec[2374] = &info_BadStmt GoTypesVec[354] = &info_PtrTo_BadStmt - GoTypesVec[1385] = &info_ArrayOf_BadStmt - GoTypesVec[2377] = &info_BasicLit + GoTypesVec[1384] = &info_ArrayOf_BadStmt + GoTypesVec[2375] = &info_BasicLit GoTypesVec[355] = &info_PtrTo_BasicLit - GoTypesVec[1386] = &info_ArrayOf_BasicLit - GoTypesVec[2378] = &info_BinaryExpr + GoTypesVec[1385] = &info_ArrayOf_BasicLit + GoTypesVec[2376] = &info_BinaryExpr GoTypesVec[356] = &info_PtrTo_BinaryExpr - GoTypesVec[1387] = &info_ArrayOf_BinaryExpr - GoTypesVec[2379] = &info_BlockStmt + GoTypesVec[1386] = &info_ArrayOf_BinaryExpr + GoTypesVec[2377] = &info_BlockStmt GoTypesVec[357] = &info_PtrTo_BlockStmt - GoTypesVec[1388] = &info_ArrayOf_BlockStmt - GoTypesVec[2380] = &info_BranchStmt + GoTypesVec[1387] = &info_ArrayOf_BlockStmt + GoTypesVec[2378] = &info_BranchStmt GoTypesVec[358] = &info_PtrTo_BranchStmt - GoTypesVec[1389] = &info_ArrayOf_BranchStmt - GoTypesVec[2381] = &info_CallExpr + GoTypesVec[1388] = &info_ArrayOf_BranchStmt + GoTypesVec[2379] = &info_CallExpr GoTypesVec[359] = &info_PtrTo_CallExpr - GoTypesVec[1390] = &info_ArrayOf_CallExpr - GoTypesVec[2382] = &info_CaseClause + GoTypesVec[1389] = &info_ArrayOf_CallExpr + GoTypesVec[2380] = &info_CaseClause GoTypesVec[360] = &info_PtrTo_CaseClause - GoTypesVec[1391] = &info_ArrayOf_CaseClause - GoTypesVec[2383] = &info_ChanDir + GoTypesVec[1390] = &info_ArrayOf_CaseClause + GoTypesVec[2381] = &info_ChanDir GoTypesVec[361] = &info_PtrTo_ChanDir - GoTypesVec[1392] = &info_ArrayOf_ChanDir - GoTypesVec[2384] = &info_ChanType + GoTypesVec[1391] = &info_ArrayOf_ChanDir + GoTypesVec[2382] = &info_ChanType GoTypesVec[362] = &info_PtrTo_ChanType - GoTypesVec[1393] = &info_ArrayOf_ChanType - GoTypesVec[2385] = &info_CommClause + GoTypesVec[1392] = &info_ArrayOf_ChanType + GoTypesVec[2383] = &info_CommClause GoTypesVec[363] = &info_PtrTo_CommClause - GoTypesVec[1394] = &info_ArrayOf_CommClause - GoTypesVec[2386] = &info_Comment + GoTypesVec[1393] = &info_ArrayOf_CommClause + GoTypesVec[2384] = &info_Comment GoTypesVec[364] = &info_PtrTo_Comment - GoTypesVec[2387] = &info_CommentGroup + GoTypesVec[2385] = &info_CommentGroup GoTypesVec[365] = &info_PtrTo_CommentGroup - GoTypesVec[1396] = &info_ArrayOf_CommentGroup - GoTypesVec[2388] = &info_CommentMap + GoTypesVec[1395] = &info_ArrayOf_CommentGroup + GoTypesVec[2386] = &info_CommentMap GoTypesVec[366] = &info_PtrTo_CommentMap - GoTypesVec[1397] = &info_ArrayOf_CommentMap - GoTypesVec[1395] = &info_ArrayOf_Comment - GoTypesVec[2389] = &info_CompositeLit + GoTypesVec[1396] = &info_ArrayOf_CommentMap + GoTypesVec[1394] = &info_ArrayOf_Comment + GoTypesVec[2387] = &info_CompositeLit GoTypesVec[367] = &info_PtrTo_CompositeLit - GoTypesVec[1398] = &info_ArrayOf_CompositeLit - GoTypesVec[2965] = &info_Decl - GoTypesVec[2390] = &info_DeclStmt + GoTypesVec[1397] = &info_ArrayOf_CompositeLit + GoTypesVec[2962] = &info_Decl + GoTypesVec[2388] = &info_DeclStmt GoTypesVec[368] = &info_PtrTo_DeclStmt - GoTypesVec[1400] = &info_ArrayOf_DeclStmt - GoTypesVec[1399] = &info_ArrayOf_Decl - GoTypesVec[2391] = &info_DeferStmt + GoTypesVec[1399] = &info_ArrayOf_DeclStmt + GoTypesVec[1398] = &info_ArrayOf_Decl + GoTypesVec[2389] = &info_DeferStmt GoTypesVec[369] = &info_PtrTo_DeferStmt - GoTypesVec[1401] = &info_ArrayOf_DeferStmt - GoTypesVec[2392] = &info_Ellipsis + GoTypesVec[1400] = &info_ArrayOf_DeferStmt + GoTypesVec[2390] = &info_Ellipsis GoTypesVec[370] = &info_PtrTo_Ellipsis - GoTypesVec[1402] = &info_ArrayOf_Ellipsis - GoTypesVec[2393] = &info_EmptyStmt + GoTypesVec[1401] = &info_ArrayOf_Ellipsis + GoTypesVec[2391] = &info_EmptyStmt GoTypesVec[371] = &info_PtrTo_EmptyStmt - GoTypesVec[1403] = &info_ArrayOf_EmptyStmt - GoTypesVec[2966] = &info_Expr - GoTypesVec[2394] = &info_ExprStmt + GoTypesVec[1402] = &info_ArrayOf_EmptyStmt + GoTypesVec[2963] = &info_Expr + GoTypesVec[2392] = &info_ExprStmt GoTypesVec[372] = &info_PtrTo_ExprStmt - GoTypesVec[1405] = &info_ArrayOf_ExprStmt - GoTypesVec[1404] = &info_ArrayOf_Expr - GoTypesVec[2395] = &info_Field + GoTypesVec[1404] = &info_ArrayOf_ExprStmt + GoTypesVec[1403] = &info_ArrayOf_Expr + GoTypesVec[2393] = &info_Field GoTypesVec[373] = &info_PtrTo_Field - GoTypesVec[2396] = &info_FieldFilter + GoTypesVec[2394] = &info_FieldFilter GoTypesVec[374] = &info_PtrTo_FieldFilter - GoTypesVec[1407] = &info_ArrayOf_FieldFilter - GoTypesVec[2397] = &info_FieldList + GoTypesVec[1406] = &info_ArrayOf_FieldFilter + GoTypesVec[2395] = &info_FieldList GoTypesVec[375] = &info_PtrTo_FieldList - GoTypesVec[1408] = &info_ArrayOf_FieldList - GoTypesVec[1406] = &info_ArrayOf_Field - GoTypesVec[2398] = &info_File + GoTypesVec[1407] = &info_ArrayOf_FieldList + GoTypesVec[1405] = &info_ArrayOf_Field + GoTypesVec[2396] = &info_File GoTypesVec[376] = &info_PtrTo_File - GoTypesVec[1409] = &info_ArrayOf_File - GoTypesVec[2399] = &info_Filter + GoTypesVec[1408] = &info_ArrayOf_File + GoTypesVec[2397] = &info_Filter GoTypesVec[377] = &info_PtrTo_Filter - GoTypesVec[1410] = &info_ArrayOf_Filter - GoTypesVec[2400] = &info_ForStmt + GoTypesVec[1409] = &info_ArrayOf_Filter + GoTypesVec[2398] = &info_ForStmt GoTypesVec[378] = &info_PtrTo_ForStmt - GoTypesVec[1411] = &info_ArrayOf_ForStmt - GoTypesVec[2401] = &info_FuncDecl + GoTypesVec[1410] = &info_ArrayOf_ForStmt + GoTypesVec[2399] = &info_FuncDecl GoTypesVec[379] = &info_PtrTo_FuncDecl - GoTypesVec[1412] = &info_ArrayOf_FuncDecl - GoTypesVec[2402] = &info_FuncLit + GoTypesVec[1411] = &info_ArrayOf_FuncDecl + GoTypesVec[2400] = &info_FuncLit GoTypesVec[380] = &info_PtrTo_FuncLit - GoTypesVec[1413] = &info_ArrayOf_FuncLit - GoTypesVec[2403] = &info_FuncType + GoTypesVec[1412] = &info_ArrayOf_FuncLit + GoTypesVec[2401] = &info_FuncType GoTypesVec[381] = &info_PtrTo_FuncType - GoTypesVec[1414] = &info_ArrayOf_FuncType - GoTypesVec[2404] = &info_GenDecl + GoTypesVec[1413] = &info_ArrayOf_FuncType + GoTypesVec[2402] = &info_GenDecl GoTypesVec[382] = &info_PtrTo_GenDecl - GoTypesVec[1415] = &info_ArrayOf_GenDecl - GoTypesVec[2405] = &info_GoStmt + GoTypesVec[1414] = &info_ArrayOf_GenDecl + GoTypesVec[2403] = &info_GoStmt GoTypesVec[383] = &info_PtrTo_GoStmt - GoTypesVec[1416] = &info_ArrayOf_GoStmt - GoTypesVec[2406] = &info_Ident + GoTypesVec[1415] = &info_ArrayOf_GoStmt + GoTypesVec[2404] = &info_Ident GoTypesVec[384] = &info_PtrTo_Ident - GoTypesVec[1417] = &info_ArrayOf_Ident - GoTypesVec[2407] = &info_IfStmt + GoTypesVec[1416] = &info_ArrayOf_Ident + GoTypesVec[2405] = &info_IfStmt GoTypesVec[385] = &info_PtrTo_IfStmt - GoTypesVec[1418] = &info_ArrayOf_IfStmt - GoTypesVec[2408] = &info_ImportSpec + GoTypesVec[1417] = &info_ArrayOf_IfStmt + GoTypesVec[2406] = &info_ImportSpec GoTypesVec[386] = &info_PtrTo_ImportSpec - GoTypesVec[1419] = &info_ArrayOf_ImportSpec - GoTypesVec[2409] = &info_Importer + GoTypesVec[1418] = &info_ArrayOf_ImportSpec + GoTypesVec[2407] = &info_Importer GoTypesVec[387] = &info_PtrTo_Importer - GoTypesVec[1420] = &info_ArrayOf_Importer - GoTypesVec[2410] = &info_IncDecStmt + GoTypesVec[1419] = &info_ArrayOf_Importer + GoTypesVec[2408] = &info_IncDecStmt GoTypesVec[388] = &info_PtrTo_IncDecStmt - GoTypesVec[1421] = &info_ArrayOf_IncDecStmt - GoTypesVec[2411] = &info_IndexExpr + GoTypesVec[1420] = &info_ArrayOf_IncDecStmt + GoTypesVec[2409] = &info_IndexExpr GoTypesVec[389] = &info_PtrTo_IndexExpr - GoTypesVec[1422] = &info_ArrayOf_IndexExpr - GoTypesVec[2412] = &info_IndexListExpr + GoTypesVec[1421] = &info_ArrayOf_IndexExpr + GoTypesVec[2410] = &info_IndexListExpr GoTypesVec[390] = &info_PtrTo_IndexListExpr - GoTypesVec[1423] = &info_ArrayOf_IndexListExpr - GoTypesVec[2413] = &info_InterfaceType + GoTypesVec[1422] = &info_ArrayOf_IndexListExpr + GoTypesVec[2411] = &info_InterfaceType GoTypesVec[391] = &info_PtrTo_InterfaceType - GoTypesVec[1424] = &info_ArrayOf_InterfaceType - GoTypesVec[2414] = &info_KeyValueExpr + GoTypesVec[1423] = &info_ArrayOf_InterfaceType + GoTypesVec[2412] = &info_KeyValueExpr GoTypesVec[392] = &info_PtrTo_KeyValueExpr - GoTypesVec[1425] = &info_ArrayOf_KeyValueExpr - GoTypesVec[2415] = &info_LabeledStmt + GoTypesVec[1424] = &info_ArrayOf_KeyValueExpr + GoTypesVec[2413] = &info_LabeledStmt GoTypesVec[393] = &info_PtrTo_LabeledStmt - GoTypesVec[1426] = &info_ArrayOf_LabeledStmt - GoTypesVec[2416] = &info_MapType + GoTypesVec[1425] = &info_ArrayOf_LabeledStmt + GoTypesVec[2414] = &info_MapType GoTypesVec[394] = &info_PtrTo_MapType - GoTypesVec[1427] = &info_ArrayOf_MapType - GoTypesVec[2417] = &info_MergeMode + GoTypesVec[1426] = &info_ArrayOf_MapType + GoTypesVec[2415] = &info_MergeMode GoTypesVec[395] = &info_PtrTo_MergeMode - GoTypesVec[1428] = &info_ArrayOf_MergeMode - GoTypesVec[2992] = &info_Node - GoTypesVec[1429] = &info_ArrayOf_Node - GoTypesVec[2418] = &info_ObjKind + GoTypesVec[1427] = &info_ArrayOf_MergeMode + GoTypesVec[2989] = &info_Node + GoTypesVec[1428] = &info_ArrayOf_Node + GoTypesVec[2416] = &info_ObjKind GoTypesVec[396] = &info_PtrTo_ObjKind - GoTypesVec[1430] = &info_ArrayOf_ObjKind - GoTypesVec[2419] = &info_Object + GoTypesVec[1429] = &info_ArrayOf_ObjKind + GoTypesVec[2417] = &info_Object GoTypesVec[397] = &info_PtrTo_Object - GoTypesVec[1431] = &info_ArrayOf_Object - GoTypesVec[2420] = &info_Package + GoTypesVec[1430] = &info_ArrayOf_Object + GoTypesVec[2418] = &info_Package GoTypesVec[398] = &info_PtrTo_Package - GoTypesVec[1432] = &info_ArrayOf_Package - GoTypesVec[2421] = &info_ParenExpr + GoTypesVec[1431] = &info_ArrayOf_Package + GoTypesVec[2419] = &info_ParenExpr GoTypesVec[399] = &info_PtrTo_ParenExpr - GoTypesVec[1433] = &info_ArrayOf_ParenExpr - GoTypesVec[2422] = &info_RangeStmt + GoTypesVec[1432] = &info_ArrayOf_ParenExpr + GoTypesVec[2420] = &info_RangeStmt GoTypesVec[400] = &info_PtrTo_RangeStmt - GoTypesVec[1434] = &info_ArrayOf_RangeStmt - GoTypesVec[2423] = &info_ReturnStmt + GoTypesVec[1433] = &info_ArrayOf_RangeStmt + GoTypesVec[2421] = &info_ReturnStmt GoTypesVec[401] = &info_PtrTo_ReturnStmt - GoTypesVec[1435] = &info_ArrayOf_ReturnStmt - GoTypesVec[2424] = &info_Scope + GoTypesVec[1434] = &info_ArrayOf_ReturnStmt + GoTypesVec[2422] = &info_Scope GoTypesVec[402] = &info_PtrTo_Scope - GoTypesVec[1436] = &info_ArrayOf_Scope - GoTypesVec[2425] = &info_SelectStmt + GoTypesVec[1435] = &info_ArrayOf_Scope + GoTypesVec[2423] = &info_SelectStmt GoTypesVec[403] = &info_PtrTo_SelectStmt - GoTypesVec[1437] = &info_ArrayOf_SelectStmt - GoTypesVec[2426] = &info_SelectorExpr + GoTypesVec[1436] = &info_ArrayOf_SelectStmt + GoTypesVec[2424] = &info_SelectorExpr GoTypesVec[404] = &info_PtrTo_SelectorExpr - GoTypesVec[1438] = &info_ArrayOf_SelectorExpr - GoTypesVec[2427] = &info_SendStmt + GoTypesVec[1437] = &info_ArrayOf_SelectorExpr + GoTypesVec[2425] = &info_SendStmt GoTypesVec[405] = &info_PtrTo_SendStmt - GoTypesVec[1439] = &info_ArrayOf_SendStmt - GoTypesVec[2428] = &info_SliceExpr + GoTypesVec[1438] = &info_ArrayOf_SendStmt + GoTypesVec[2426] = &info_SliceExpr GoTypesVec[406] = &info_PtrTo_SliceExpr - GoTypesVec[1440] = &info_ArrayOf_SliceExpr - GoTypesVec[2967] = &info_Spec - GoTypesVec[1441] = &info_ArrayOf_Spec - GoTypesVec[2429] = &info_StarExpr + GoTypesVec[1439] = &info_ArrayOf_SliceExpr + GoTypesVec[2964] = &info_Spec + GoTypesVec[1440] = &info_ArrayOf_Spec + GoTypesVec[2427] = &info_StarExpr GoTypesVec[407] = &info_PtrTo_StarExpr - GoTypesVec[1442] = &info_ArrayOf_StarExpr - GoTypesVec[2968] = &info_Stmt - GoTypesVec[1443] = &info_ArrayOf_Stmt - GoTypesVec[2430] = &info_StructType + GoTypesVec[1441] = &info_ArrayOf_StarExpr + GoTypesVec[2965] = &info_Stmt + GoTypesVec[1442] = &info_ArrayOf_Stmt + GoTypesVec[2428] = &info_StructType GoTypesVec[408] = &info_PtrTo_StructType - GoTypesVec[1444] = &info_ArrayOf_StructType - GoTypesVec[2431] = &info_SwitchStmt + GoTypesVec[1443] = &info_ArrayOf_StructType + GoTypesVec[2429] = &info_SwitchStmt GoTypesVec[409] = &info_PtrTo_SwitchStmt - GoTypesVec[1445] = &info_ArrayOf_SwitchStmt - GoTypesVec[2432] = &info_TypeAssertExpr + GoTypesVec[1444] = &info_ArrayOf_SwitchStmt + GoTypesVec[2430] = &info_TypeAssertExpr GoTypesVec[410] = &info_PtrTo_TypeAssertExpr - GoTypesVec[1446] = &info_ArrayOf_TypeAssertExpr - GoTypesVec[2433] = &info_TypeSpec + GoTypesVec[1445] = &info_ArrayOf_TypeAssertExpr + GoTypesVec[2431] = &info_TypeSpec GoTypesVec[411] = &info_PtrTo_TypeSpec - GoTypesVec[1447] = &info_ArrayOf_TypeSpec - GoTypesVec[2434] = &info_TypeSwitchStmt + GoTypesVec[1446] = &info_ArrayOf_TypeSpec + GoTypesVec[2432] = &info_TypeSwitchStmt GoTypesVec[412] = &info_PtrTo_TypeSwitchStmt - GoTypesVec[1448] = &info_ArrayOf_TypeSwitchStmt - GoTypesVec[2435] = &info_UnaryExpr + GoTypesVec[1447] = &info_ArrayOf_TypeSwitchStmt + GoTypesVec[2433] = &info_UnaryExpr GoTypesVec[413] = &info_PtrTo_UnaryExpr - GoTypesVec[1449] = &info_ArrayOf_UnaryExpr - GoTypesVec[2436] = &info_ValueSpec + GoTypesVec[1448] = &info_ArrayOf_UnaryExpr + GoTypesVec[2434] = &info_ValueSpec GoTypesVec[414] = &info_PtrTo_ValueSpec - GoTypesVec[1450] = &info_ArrayOf_ValueSpec - GoTypesVec[3059] = &info_Visitor - GoTypesVec[1451] = &info_ArrayOf_Visitor + GoTypesVec[1449] = &info_ArrayOf_ValueSpec + GoTypesVec[3056] = &info_Visitor + GoTypesVec[1450] = &info_ArrayOf_Visitor EnsureLoaded("go.std.bytes") // E.g. from: C:\Program Files\Go\src\go\ast\commentmap.go:8:2 EnsureLoaded("go.std.fmt") // E.g. from: C:\Program Files\Go\src\go\ast\commentmap.go:9:2 EnsureLoaded("go.std.go.scanner") // E.g. from: C:\Program Files\Go\src\go\ast\resolve.go:11:2 @@ -145626,21 +145620,21 @@ func initNative() { GoMembers{ }) - GoTypesVec[2437] = &info_Context + GoTypesVec[2435] = &info_Context GoTypesVec[415] = &info_PtrTo_Context - GoTypesVec[1452] = &info_ArrayOf_Context - GoTypesVec[2438] = &info_ImportMode + GoTypesVec[1451] = &info_ArrayOf_Context + GoTypesVec[2436] = &info_ImportMode GoTypesVec[416] = &info_PtrTo_ImportMode - GoTypesVec[1453] = &info_ArrayOf_ImportMode - GoTypesVec[2439] = &info_MultiplePackageError + GoTypesVec[1452] = &info_ArrayOf_ImportMode + GoTypesVec[2437] = &info_MultiplePackageError GoTypesVec[417] = &info_PtrTo_MultiplePackageError - GoTypesVec[1454] = &info_ArrayOf_MultiplePackageError - GoTypesVec[2440] = &info_NoGoError + GoTypesVec[1453] = &info_ArrayOf_MultiplePackageError + GoTypesVec[2438] = &info_NoGoError GoTypesVec[418] = &info_PtrTo_NoGoError - GoTypesVec[1455] = &info_ArrayOf_NoGoError - GoTypesVec[2441] = &info_Package + GoTypesVec[1454] = &info_ArrayOf_NoGoError + GoTypesVec[2439] = &info_Package GoTypesVec[419] = &info_PtrTo_Package - GoTypesVec[1456] = &info_ArrayOf_Package + GoTypesVec[1455] = &info_ArrayOf_Package EnsureLoaded("go.std.bufio") // E.g. from: C:\Program Files\Go\src\go\build\read.go:8:2 EnsureLoaded("go.std.bytes") // E.g. from: C:\Program Files\Go\src\go\build\build.go:8:2 EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\go\build\build.go:9:2 @@ -147045,23 +147039,23 @@ func initNative() { GoMembers{ }) - GoTypesVec[2442] = &info_AndExpr + GoTypesVec[2440] = &info_AndExpr GoTypesVec[420] = &info_PtrTo_AndExpr - GoTypesVec[1457] = &info_ArrayOf_AndExpr - GoTypesVec[2969] = &info_Expr - GoTypesVec[1458] = &info_ArrayOf_Expr - GoTypesVec[2443] = &info_NotExpr + GoTypesVec[1456] = &info_ArrayOf_AndExpr + GoTypesVec[2966] = &info_Expr + GoTypesVec[1457] = &info_ArrayOf_Expr + GoTypesVec[2441] = &info_NotExpr GoTypesVec[421] = &info_PtrTo_NotExpr - GoTypesVec[1459] = &info_ArrayOf_NotExpr - GoTypesVec[2444] = &info_OrExpr + GoTypesVec[1458] = &info_ArrayOf_NotExpr + GoTypesVec[2442] = &info_OrExpr GoTypesVec[422] = &info_PtrTo_OrExpr - GoTypesVec[1460] = &info_ArrayOf_OrExpr - GoTypesVec[2445] = &info_SyntaxError + GoTypesVec[1459] = &info_ArrayOf_OrExpr + GoTypesVec[2443] = &info_SyntaxError GoTypesVec[423] = &info_PtrTo_SyntaxError - GoTypesVec[1461] = &info_ArrayOf_SyntaxError - GoTypesVec[2446] = &info_TagExpr + GoTypesVec[1460] = &info_ArrayOf_SyntaxError + GoTypesVec[2444] = &info_TagExpr GoTypesVec[424] = &info_PtrTo_TagExpr - GoTypesVec[1462] = &info_ArrayOf_TagExpr + GoTypesVec[1461] = &info_ArrayOf_TagExpr EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\go\build\constraint\expr.go:13:2 EnsureLoaded("go.std.strings") // E.g. from: C:\Program Files\Go\src\go\build\constraint\expr.go:14:2 EnsureLoaded("go.std.unicode") // E.g. from: C:\Program Files\Go\src\go\build\constraint\expr.go:15:2 @@ -147848,11 +147842,11 @@ func initNative() { GoMembers{ }) - GoTypesVec[2447] = &info_Kind + GoTypesVec[2445] = &info_Kind GoTypesVec[425] = &info_PtrTo_Kind - GoTypesVec[1463] = &info_ArrayOf_Kind - GoTypesVec[2951] = &info_Value - GoTypesVec[1464] = &info_ArrayOf_Value + GoTypesVec[1462] = &info_ArrayOf_Kind + GoTypesVec[2948] = &info_Value + GoTypesVec[1463] = &info_ArrayOf_Value EnsureLoaded("go.std.fmt") // E.g. from: C:\Program Files\Go\src\go\constant\value.go:15:2 EnsureLoaded("go.std.go.token") // E.g. from: C:\Program Files\Go\src\go\constant\value.go:16:2 EnsureLoaded("go.std.math") // E.g. from: C:\Program Files\Go\src\go\constant\value.go:17:2 @@ -151466,49 +151460,49 @@ func initNative() { GoMembers{ }) - GoTypesVec[3060] = &info_Block - GoTypesVec[1473] = &info_ArrayOf_Block - GoTypesVec[2456] = &info_Code + GoTypesVec[3057] = &info_Block + GoTypesVec[1472] = &info_ArrayOf_Block + GoTypesVec[2454] = &info_Code GoTypesVec[434] = &info_PtrTo_Code - GoTypesVec[1474] = &info_ArrayOf_Code - GoTypesVec[2457] = &info_Doc + GoTypesVec[1473] = &info_ArrayOf_Code + GoTypesVec[2455] = &info_Doc GoTypesVec[435] = &info_PtrTo_Doc - GoTypesVec[2458] = &info_DocLink + GoTypesVec[2456] = &info_DocLink GoTypesVec[436] = &info_PtrTo_DocLink - GoTypesVec[1476] = &info_ArrayOf_DocLink - GoTypesVec[1475] = &info_ArrayOf_Doc - GoTypesVec[2459] = &info_Heading + GoTypesVec[1475] = &info_ArrayOf_DocLink + GoTypesVec[1474] = &info_ArrayOf_Doc + GoTypesVec[2457] = &info_Heading GoTypesVec[437] = &info_PtrTo_Heading - GoTypesVec[1477] = &info_ArrayOf_Heading - GoTypesVec[2460] = &info_Italic + GoTypesVec[1476] = &info_ArrayOf_Heading + GoTypesVec[2458] = &info_Italic GoTypesVec[438] = &info_PtrTo_Italic - GoTypesVec[1478] = &info_ArrayOf_Italic - GoTypesVec[2461] = &info_Link + GoTypesVec[1477] = &info_ArrayOf_Italic + GoTypesVec[2459] = &info_Link GoTypesVec[439] = &info_PtrTo_Link - GoTypesVec[2462] = &info_LinkDef + GoTypesVec[2460] = &info_LinkDef GoTypesVec[440] = &info_PtrTo_LinkDef - GoTypesVec[1480] = &info_ArrayOf_LinkDef - GoTypesVec[1479] = &info_ArrayOf_Link - GoTypesVec[2463] = &info_List + GoTypesVec[1479] = &info_ArrayOf_LinkDef + GoTypesVec[1478] = &info_ArrayOf_Link + GoTypesVec[2461] = &info_List GoTypesVec[441] = &info_PtrTo_List - GoTypesVec[2464] = &info_ListItem + GoTypesVec[2462] = &info_ListItem GoTypesVec[442] = &info_PtrTo_ListItem - GoTypesVec[1482] = &info_ArrayOf_ListItem - GoTypesVec[1481] = &info_ArrayOf_List - GoTypesVec[2465] = &info_Paragraph + GoTypesVec[1481] = &info_ArrayOf_ListItem + GoTypesVec[1480] = &info_ArrayOf_List + GoTypesVec[2463] = &info_Paragraph GoTypesVec[443] = &info_PtrTo_Paragraph - GoTypesVec[1483] = &info_ArrayOf_Paragraph - GoTypesVec[2466] = &info_Parser + GoTypesVec[1482] = &info_ArrayOf_Paragraph + GoTypesVec[2464] = &info_Parser GoTypesVec[444] = &info_PtrTo_Parser - GoTypesVec[1484] = &info_ArrayOf_Parser - GoTypesVec[2467] = &info_Plain + GoTypesVec[1483] = &info_ArrayOf_Parser + GoTypesVec[2465] = &info_Plain GoTypesVec[445] = &info_PtrTo_Plain - GoTypesVec[1485] = &info_ArrayOf_Plain - GoTypesVec[2468] = &info_Printer + GoTypesVec[1484] = &info_ArrayOf_Plain + GoTypesVec[2466] = &info_Printer GoTypesVec[446] = &info_PtrTo_Printer - GoTypesVec[1486] = &info_ArrayOf_Printer - GoTypesVec[3061] = &info_Text - GoTypesVec[1487] = &info_ArrayOf_Text + GoTypesVec[1485] = &info_ArrayOf_Printer + GoTypesVec[3058] = &info_Text + GoTypesVec[1486] = &info_ArrayOf_Text EnsureLoaded("go.std.bytes") // E.g. from: C:\Program Files\Go\src\go\doc\comment\html.go:8:2 EnsureLoaded("go.std.fmt") // E.g. from: C:\Program Files\Go\src\go\doc\comment\html.go:9:2 EnsureLoaded("go.std.sort") // E.g. from: C:\Program Files\Go\src\go\doc\comment\parse.go:8:2 @@ -153499,30 +153493,30 @@ func initNative() { GoMembers{ }) - GoTypesVec[2448] = &info_Example + GoTypesVec[2446] = &info_Example GoTypesVec[426] = &info_PtrTo_Example - GoTypesVec[1465] = &info_ArrayOf_Example - GoTypesVec[2449] = &info_Filter + GoTypesVec[1464] = &info_ArrayOf_Example + GoTypesVec[2447] = &info_Filter GoTypesVec[427] = &info_PtrTo_Filter - GoTypesVec[1466] = &info_ArrayOf_Filter - GoTypesVec[2450] = &info_Func + GoTypesVec[1465] = &info_ArrayOf_Filter + GoTypesVec[2448] = &info_Func GoTypesVec[428] = &info_PtrTo_Func - GoTypesVec[1467] = &info_ArrayOf_Func - GoTypesVec[2451] = &info_Mode + GoTypesVec[1466] = &info_ArrayOf_Func + GoTypesVec[2449] = &info_Mode GoTypesVec[429] = &info_PtrTo_Mode - GoTypesVec[1468] = &info_ArrayOf_Mode - GoTypesVec[2452] = &info_Note + GoTypesVec[1467] = &info_ArrayOf_Mode + GoTypesVec[2450] = &info_Note GoTypesVec[430] = &info_PtrTo_Note - GoTypesVec[1469] = &info_ArrayOf_Note - GoTypesVec[2453] = &info_Package + GoTypesVec[1468] = &info_ArrayOf_Note + GoTypesVec[2451] = &info_Package GoTypesVec[431] = &info_PtrTo_Package - GoTypesVec[1470] = &info_ArrayOf_Package - GoTypesVec[2454] = &info_Type + GoTypesVec[1469] = &info_ArrayOf_Package + GoTypesVec[2452] = &info_Type GoTypesVec[432] = &info_PtrTo_Type - GoTypesVec[1471] = &info_ArrayOf_Type - GoTypesVec[2455] = &info_Value + GoTypesVec[1470] = &info_ArrayOf_Type + GoTypesVec[2453] = &info_Value GoTypesVec[433] = &info_PtrTo_Value - GoTypesVec[1472] = &info_ArrayOf_Value + GoTypesVec[1471] = &info_ArrayOf_Value EnsureLoaded("go.std.fmt") // E.g. from: C:\Program Files\Go\src\go\doc\doc.go:9:2 EnsureLoaded("go.std.go.ast") // E.g. from: C:\Program Files\Go\src\go\doc\doc.go:10:2 EnsureLoaded("go.std.go.doc.comment") // E.g. from: C:\Program Files\Go\src\go\doc\comment.go:8:2 @@ -153841,9 +153835,9 @@ func initNative() { GoMembers{ }) - GoTypesVec[2469] = &info_Lookup + GoTypesVec[2467] = &info_Lookup GoTypesVec[447] = &info_PtrTo_Lookup - GoTypesVec[1488] = &info_ArrayOf_Lookup + GoTypesVec[1487] = &info_ArrayOf_Lookup EnsureLoaded("go.std.go.build") // E.g. from: C:\Program Files\Go\src\go\importer\importer.go:9:2 EnsureLoaded("go.std.go.token") // E.g. from: C:\Program Files\Go\src\go\importer\importer.go:13:2 EnsureLoaded("go.std.go.types") // E.g. from: C:\Program Files\Go\src\go\importer\importer.go:14:2 @@ -154208,9 +154202,9 @@ func initNative() { GoMembers{ }) - GoTypesVec[2470] = &info_Mode + GoTypesVec[2468] = &info_Mode GoTypesVec[448] = &info_PtrTo_Mode - GoTypesVec[1489] = &info_ArrayOf_Mode + GoTypesVec[1488] = &info_ArrayOf_Mode EnsureLoaded("go.std.bytes") // E.g. from: C:\Program Files\Go\src\go\parser\interface.go:10:2 EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\go\parser\interface.go:11:2 EnsureLoaded("go.std.fmt") // E.g. from: C:\Program Files\Go\src\go\parser\parser.go:19:2 @@ -154955,15 +154949,15 @@ func initNative() { GoMembers{ }) - GoTypesVec[2471] = &info_CommentedNode + GoTypesVec[2469] = &info_CommentedNode GoTypesVec[449] = &info_PtrTo_CommentedNode - GoTypesVec[1490] = &info_ArrayOf_CommentedNode - GoTypesVec[2472] = &info_Config + GoTypesVec[1489] = &info_ArrayOf_CommentedNode + GoTypesVec[2470] = &info_Config GoTypesVec[450] = &info_PtrTo_Config - GoTypesVec[1491] = &info_ArrayOf_Config - GoTypesVec[2473] = &info_Mode + GoTypesVec[1490] = &info_ArrayOf_Config + GoTypesVec[2471] = &info_Mode GoTypesVec[451] = &info_PtrTo_Mode - GoTypesVec[1492] = &info_ArrayOf_Mode + GoTypesVec[1491] = &info_ArrayOf_Mode EnsureLoaded("go.std.bytes") // E.g. from: C:\Program Files\Go\src\go\printer\nodes.go:12:2 EnsureLoaded("go.std.fmt") // E.g. from: C:\Program Files\Go\src\go\printer\printer.go:9:2 EnsureLoaded("go.std.go.ast") // E.g. from: C:\Program Files\Go\src\go\printer\comment.go:8:2 @@ -156244,21 +156238,21 @@ func initNative() { GoMembers{ }) - GoTypesVec[2474] = &info_Error + GoTypesVec[2472] = &info_Error GoTypesVec[452] = &info_PtrTo_Error - GoTypesVec[2475] = &info_ErrorHandler + GoTypesVec[2473] = &info_ErrorHandler GoTypesVec[453] = &info_PtrTo_ErrorHandler - GoTypesVec[1494] = &info_ArrayOf_ErrorHandler - GoTypesVec[2476] = &info_ErrorList + GoTypesVec[1493] = &info_ArrayOf_ErrorHandler + GoTypesVec[2474] = &info_ErrorList GoTypesVec[454] = &info_PtrTo_ErrorList - GoTypesVec[1495] = &info_ArrayOf_ErrorList - GoTypesVec[1493] = &info_ArrayOf_Error - GoTypesVec[2477] = &info_Mode + GoTypesVec[1494] = &info_ArrayOf_ErrorList + GoTypesVec[1492] = &info_ArrayOf_Error + GoTypesVec[2475] = &info_Mode GoTypesVec[455] = &info_PtrTo_Mode - GoTypesVec[1496] = &info_ArrayOf_Mode - GoTypesVec[2478] = &info_Scanner + GoTypesVec[1495] = &info_ArrayOf_Mode + GoTypesVec[2476] = &info_Scanner GoTypesVec[456] = &info_PtrTo_Scanner - GoTypesVec[1497] = &info_ArrayOf_Scanner + GoTypesVec[1496] = &info_ArrayOf_Scanner EnsureLoaded("go.std.bytes") // E.g. from: C:\Program Files\Go\src\go\scanner\scanner.go:11:2 EnsureLoaded("go.std.fmt") // E.g. from: C:\Program Files\Go\src\go\scanner\errors.go:8:2 EnsureLoaded("go.std.go.token") // E.g. from: C:\Program Files\Go\src\go\scanner\errors.go:9:2 @@ -158387,21 +158381,21 @@ func initNative() { GoMembers{ }) - GoTypesVec[2479] = &info_File + GoTypesVec[2477] = &info_File GoTypesVec[457] = &info_PtrTo_File - GoTypesVec[2480] = &info_FileSet + GoTypesVec[2478] = &info_FileSet GoTypesVec[458] = &info_PtrTo_FileSet - GoTypesVec[1499] = &info_ArrayOf_FileSet - GoTypesVec[1498] = &info_ArrayOf_File - GoTypesVec[2481] = &info_Pos + GoTypesVec[1498] = &info_ArrayOf_FileSet + GoTypesVec[1497] = &info_ArrayOf_File + GoTypesVec[2479] = &info_Pos GoTypesVec[459] = &info_PtrTo_Pos - GoTypesVec[1500] = &info_ArrayOf_Pos - GoTypesVec[2482] = &info_Position + GoTypesVec[1499] = &info_ArrayOf_Pos + GoTypesVec[2480] = &info_Position GoTypesVec[460] = &info_PtrTo_Position - GoTypesVec[1501] = &info_ArrayOf_Position - GoTypesVec[2483] = &info_Token + GoTypesVec[1500] = &info_ArrayOf_Position + GoTypesVec[2481] = &info_Token GoTypesVec[461] = &info_PtrTo_Token - GoTypesVec[1502] = &info_ArrayOf_Token + GoTypesVec[1501] = &info_ArrayOf_Token EnsureLoaded("go.std.fmt") // E.g. from: C:\Program Files\Go\src\go\token\position.go:8:2 EnsureLoaded("go.std.sort") // E.g. from: C:\Program Files\Go\src\go\token\position.go:9:2 EnsureLoaded("go.std.strconv") // E.g. from: C:\Program Files\Go\src\go\token\token.go:10:2 @@ -171854,148 +171848,148 @@ func initNative() { GoMembers{ }) - GoTypesVec[2484] = &info_ArgumentError + GoTypesVec[2482] = &info_ArgumentError GoTypesVec[462] = &info_PtrTo_ArgumentError - GoTypesVec[1503] = &info_ArrayOf_ArgumentError - GoTypesVec[2485] = &info_Array + GoTypesVec[1502] = &info_ArrayOf_ArgumentError + GoTypesVec[2483] = &info_Array GoTypesVec[463] = &info_PtrTo_Array - GoTypesVec[1504] = &info_ArrayOf_Array - GoTypesVec[2486] = &info_Basic + GoTypesVec[1503] = &info_ArrayOf_Array + GoTypesVec[2484] = &info_Basic GoTypesVec[464] = &info_PtrTo_Basic - GoTypesVec[2487] = &info_BasicInfo + GoTypesVec[2485] = &info_BasicInfo GoTypesVec[465] = &info_PtrTo_BasicInfo - GoTypesVec[1506] = &info_ArrayOf_BasicInfo - GoTypesVec[2488] = &info_BasicKind + GoTypesVec[1505] = &info_ArrayOf_BasicInfo + GoTypesVec[2486] = &info_BasicKind GoTypesVec[466] = &info_PtrTo_BasicKind - GoTypesVec[1507] = &info_ArrayOf_BasicKind - GoTypesVec[1505] = &info_ArrayOf_Basic - GoTypesVec[2489] = &info_Builtin + GoTypesVec[1506] = &info_ArrayOf_BasicKind + GoTypesVec[1504] = &info_ArrayOf_Basic + GoTypesVec[2487] = &info_Builtin GoTypesVec[467] = &info_PtrTo_Builtin - GoTypesVec[1508] = &info_ArrayOf_Builtin - GoTypesVec[2490] = &info_Chan + GoTypesVec[1507] = &info_ArrayOf_Builtin + GoTypesVec[2488] = &info_Chan GoTypesVec[468] = &info_PtrTo_Chan - GoTypesVec[2491] = &info_ChanDir + GoTypesVec[2489] = &info_ChanDir GoTypesVec[469] = &info_PtrTo_ChanDir - GoTypesVec[1510] = &info_ArrayOf_ChanDir - GoTypesVec[1509] = &info_ArrayOf_Chan - GoTypesVec[2492] = &info_Checker + GoTypesVec[1509] = &info_ArrayOf_ChanDir + GoTypesVec[1508] = &info_ArrayOf_Chan + GoTypesVec[2490] = &info_Checker GoTypesVec[470] = &info_PtrTo_Checker - GoTypesVec[1511] = &info_ArrayOf_Checker - GoTypesVec[2493] = &info_Config + GoTypesVec[1510] = &info_ArrayOf_Checker + GoTypesVec[2491] = &info_Config GoTypesVec[471] = &info_PtrTo_Config - GoTypesVec[1512] = &info_ArrayOf_Config - GoTypesVec[2494] = &info_Const + GoTypesVec[1511] = &info_ArrayOf_Config + GoTypesVec[2492] = &info_Const GoTypesVec[472] = &info_PtrTo_Const - GoTypesVec[1513] = &info_ArrayOf_Const - GoTypesVec[2495] = &info_Context + GoTypesVec[1512] = &info_ArrayOf_Const + GoTypesVec[2493] = &info_Context GoTypesVec[473] = &info_PtrTo_Context - GoTypesVec[1514] = &info_ArrayOf_Context - GoTypesVec[2496] = &info_Error + GoTypesVec[1513] = &info_ArrayOf_Context + GoTypesVec[2494] = &info_Error GoTypesVec[474] = &info_PtrTo_Error - GoTypesVec[1515] = &info_ArrayOf_Error - GoTypesVec[2497] = &info_Func + GoTypesVec[1514] = &info_ArrayOf_Error + GoTypesVec[2495] = &info_Func GoTypesVec[475] = &info_PtrTo_Func - GoTypesVec[1516] = &info_ArrayOf_Func - GoTypesVec[2498] = &info_ImportMode + GoTypesVec[1515] = &info_ArrayOf_Func + GoTypesVec[2496] = &info_ImportMode GoTypesVec[476] = &info_PtrTo_ImportMode - GoTypesVec[1517] = &info_ArrayOf_ImportMode - GoTypesVec[3062] = &info_Importer - GoTypesVec[2993] = &info_ImporterFrom - GoTypesVec[1519] = &info_ArrayOf_ImporterFrom - GoTypesVec[1518] = &info_ArrayOf_Importer - GoTypesVec[2499] = &info_Info + GoTypesVec[1516] = &info_ArrayOf_ImportMode + GoTypesVec[3059] = &info_Importer + GoTypesVec[2990] = &info_ImporterFrom + GoTypesVec[1518] = &info_ArrayOf_ImporterFrom + GoTypesVec[1517] = &info_ArrayOf_Importer + GoTypesVec[2497] = &info_Info GoTypesVec[477] = &info_PtrTo_Info - GoTypesVec[1520] = &info_ArrayOf_Info - GoTypesVec[2500] = &info_Initializer + GoTypesVec[1519] = &info_ArrayOf_Info + GoTypesVec[2498] = &info_Initializer GoTypesVec[478] = &info_PtrTo_Initializer - GoTypesVec[1521] = &info_ArrayOf_Initializer - GoTypesVec[2501] = &info_Instance + GoTypesVec[1520] = &info_ArrayOf_Initializer + GoTypesVec[2499] = &info_Instance GoTypesVec[479] = &info_PtrTo_Instance - GoTypesVec[1522] = &info_ArrayOf_Instance - GoTypesVec[2502] = &info_Interface + GoTypesVec[1521] = &info_ArrayOf_Instance + GoTypesVec[2500] = &info_Interface GoTypesVec[480] = &info_PtrTo_Interface - GoTypesVec[1523] = &info_ArrayOf_Interface - GoTypesVec[2503] = &info_Label + GoTypesVec[1522] = &info_ArrayOf_Interface + GoTypesVec[2501] = &info_Label GoTypesVec[481] = &info_PtrTo_Label - GoTypesVec[1524] = &info_ArrayOf_Label - GoTypesVec[2504] = &info_Map + GoTypesVec[1523] = &info_ArrayOf_Label + GoTypesVec[2502] = &info_Map GoTypesVec[482] = &info_PtrTo_Map - GoTypesVec[1525] = &info_ArrayOf_Map - GoTypesVec[2505] = &info_MethodSet + GoTypesVec[1524] = &info_ArrayOf_Map + GoTypesVec[2503] = &info_MethodSet GoTypesVec[483] = &info_PtrTo_MethodSet - GoTypesVec[1526] = &info_ArrayOf_MethodSet - GoTypesVec[2506] = &info_Named + GoTypesVec[1525] = &info_ArrayOf_MethodSet + GoTypesVec[2504] = &info_Named GoTypesVec[484] = &info_PtrTo_Named - GoTypesVec[1527] = &info_ArrayOf_Named - GoTypesVec[2507] = &info_Nil + GoTypesVec[1526] = &info_ArrayOf_Named + GoTypesVec[2505] = &info_Nil GoTypesVec[485] = &info_PtrTo_Nil - GoTypesVec[1528] = &info_ArrayOf_Nil - GoTypesVec[2926] = &info_Object - GoTypesVec[1529] = &info_ArrayOf_Object - GoTypesVec[2508] = &info_Package + GoTypesVec[1527] = &info_ArrayOf_Nil + GoTypesVec[2923] = &info_Object + GoTypesVec[1528] = &info_ArrayOf_Object + GoTypesVec[2506] = &info_Package GoTypesVec[486] = &info_PtrTo_Package - GoTypesVec[1530] = &info_ArrayOf_Package - GoTypesVec[2509] = &info_PkgName + GoTypesVec[1529] = &info_ArrayOf_Package + GoTypesVec[2507] = &info_PkgName GoTypesVec[487] = &info_PtrTo_PkgName - GoTypesVec[1531] = &info_ArrayOf_PkgName - GoTypesVec[2510] = &info_Pointer + GoTypesVec[1530] = &info_ArrayOf_PkgName + GoTypesVec[2508] = &info_Pointer GoTypesVec[488] = &info_PtrTo_Pointer - GoTypesVec[1532] = &info_ArrayOf_Pointer - GoTypesVec[2511] = &info_Qualifier + GoTypesVec[1531] = &info_ArrayOf_Pointer + GoTypesVec[2509] = &info_Qualifier GoTypesVec[489] = &info_PtrTo_Qualifier - GoTypesVec[1533] = &info_ArrayOf_Qualifier - GoTypesVec[2512] = &info_Scope + GoTypesVec[1532] = &info_ArrayOf_Qualifier + GoTypesVec[2510] = &info_Scope GoTypesVec[490] = &info_PtrTo_Scope - GoTypesVec[1534] = &info_ArrayOf_Scope - GoTypesVec[2513] = &info_Selection + GoTypesVec[1533] = &info_ArrayOf_Scope + GoTypesVec[2511] = &info_Selection GoTypesVec[491] = &info_PtrTo_Selection - GoTypesVec[2514] = &info_SelectionKind + GoTypesVec[2512] = &info_SelectionKind GoTypesVec[492] = &info_PtrTo_SelectionKind - GoTypesVec[1536] = &info_ArrayOf_SelectionKind - GoTypesVec[1535] = &info_ArrayOf_Selection - GoTypesVec[2515] = &info_Signature + GoTypesVec[1535] = &info_ArrayOf_SelectionKind + GoTypesVec[1534] = &info_ArrayOf_Selection + GoTypesVec[2513] = &info_Signature GoTypesVec[493] = &info_PtrTo_Signature - GoTypesVec[1537] = &info_ArrayOf_Signature - GoTypesVec[2970] = &info_Sizes - GoTypesVec[1538] = &info_ArrayOf_Sizes - GoTypesVec[2516] = &info_Slice + GoTypesVec[1536] = &info_ArrayOf_Signature + GoTypesVec[2967] = &info_Sizes + GoTypesVec[1537] = &info_ArrayOf_Sizes + GoTypesVec[2514] = &info_Slice GoTypesVec[494] = &info_PtrTo_Slice - GoTypesVec[1539] = &info_ArrayOf_Slice - GoTypesVec[2517] = &info_StdSizes + GoTypesVec[1538] = &info_ArrayOf_Slice + GoTypesVec[2515] = &info_StdSizes GoTypesVec[495] = &info_PtrTo_StdSizes - GoTypesVec[1540] = &info_ArrayOf_StdSizes - GoTypesVec[2518] = &info_Struct + GoTypesVec[1539] = &info_ArrayOf_StdSizes + GoTypesVec[2516] = &info_Struct GoTypesVec[496] = &info_PtrTo_Struct - GoTypesVec[1541] = &info_ArrayOf_Struct - GoTypesVec[2519] = &info_Term + GoTypesVec[1540] = &info_ArrayOf_Struct + GoTypesVec[2517] = &info_Term GoTypesVec[497] = &info_PtrTo_Term - GoTypesVec[1542] = &info_ArrayOf_Term - GoTypesVec[2520] = &info_Tuple + GoTypesVec[1541] = &info_ArrayOf_Term + GoTypesVec[2518] = &info_Tuple GoTypesVec[498] = &info_PtrTo_Tuple - GoTypesVec[1543] = &info_ArrayOf_Tuple - GoTypesVec[2994] = &info_Type - GoTypesVec[2521] = &info_TypeAndValue + GoTypesVec[1542] = &info_ArrayOf_Tuple + GoTypesVec[2991] = &info_Type + GoTypesVec[2519] = &info_TypeAndValue GoTypesVec[499] = &info_PtrTo_TypeAndValue - GoTypesVec[1545] = &info_ArrayOf_TypeAndValue - GoTypesVec[2522] = &info_TypeList + GoTypesVec[1544] = &info_ArrayOf_TypeAndValue + GoTypesVec[2520] = &info_TypeList GoTypesVec[500] = &info_PtrTo_TypeList - GoTypesVec[1546] = &info_ArrayOf_TypeList - GoTypesVec[2523] = &info_TypeName + GoTypesVec[1545] = &info_ArrayOf_TypeList + GoTypesVec[2521] = &info_TypeName GoTypesVec[501] = &info_PtrTo_TypeName - GoTypesVec[1547] = &info_ArrayOf_TypeName - GoTypesVec[2524] = &info_TypeParam + GoTypesVec[1546] = &info_ArrayOf_TypeName + GoTypesVec[2522] = &info_TypeParam GoTypesVec[502] = &info_PtrTo_TypeParam - GoTypesVec[2525] = &info_TypeParamList + GoTypesVec[2523] = &info_TypeParamList GoTypesVec[503] = &info_PtrTo_TypeParamList - GoTypesVec[1549] = &info_ArrayOf_TypeParamList - GoTypesVec[1548] = &info_ArrayOf_TypeParam - GoTypesVec[1544] = &info_ArrayOf_Type - GoTypesVec[2526] = &info_Union + GoTypesVec[1548] = &info_ArrayOf_TypeParamList + GoTypesVec[1547] = &info_ArrayOf_TypeParam + GoTypesVec[1543] = &info_ArrayOf_Type + GoTypesVec[2524] = &info_Union GoTypesVec[504] = &info_PtrTo_Union - GoTypesVec[1550] = &info_ArrayOf_Union - GoTypesVec[2527] = &info_Var + GoTypesVec[1549] = &info_ArrayOf_Union + GoTypesVec[2525] = &info_Var GoTypesVec[505] = &info_PtrTo_Var - GoTypesVec[1551] = &info_ArrayOf_Var + GoTypesVec[1550] = &info_ArrayOf_Var EnsureLoaded("go.std.bytes") // E.g. from: C:\Program Files\Go\src\go\types\api.go:29:2 EnsureLoaded("go.std.container.heap") // E.g. from: C:\Program Files\Go\src\go\types\initorder.go:8:2 EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\go\types\check.go:10:2 @@ -172561,9 +172555,9 @@ func initNative() { GoMembers{ }) - GoTypesVec[2528] = &info_Table + GoTypesVec[2526] = &info_Table GoTypesVec[506] = &info_PtrTo_Table - GoTypesVec[1555] = &info_ArrayOf_Table + GoTypesVec[1554] = &info_ArrayOf_Table EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\hash\crc32\crc32.go:16:2 EnsureLoaded("go.std.hash") // E.g. from: C:\Program Files\Go\src\hash\crc32\crc32.go:17:2 EnsureLoaded("go.std.sync") // E.g. from: C:\Program Files\Go\src\hash\crc32\crc32.go:18:2 @@ -172860,9 +172854,9 @@ func initNative() { GoMembers{ }) - GoTypesVec[2529] = &info_Table + GoTypesVec[2527] = &info_Table GoTypesVec[507] = &info_PtrTo_Table - GoTypesVec[1556] = &info_ArrayOf_Table + GoTypesVec[1555] = &info_ArrayOf_Table EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\hash\crc64\crc64.go:11:2 EnsureLoaded("go.std.hash") // E.g. from: C:\Program Files\Go\src\hash\crc64\crc64.go:12:2 EnsureLoaded("go.std.sync") // E.g. from: C:\Program Files\Go\src\hash\crc64\crc64.go:13:2 @@ -173481,12 +173475,12 @@ func initNative() { GoMembers{ }) - GoTypesVec[2939] = &info_Hash - GoTypesVec[2932] = &info_Hash32 - GoTypesVec[1553] = &info_ArrayOf_Hash32 - GoTypesVec[2933] = &info_Hash64 - GoTypesVec[1554] = &info_ArrayOf_Hash64 - GoTypesVec[1552] = &info_ArrayOf_Hash + GoTypesVec[2936] = &info_Hash + GoTypesVec[2929] = &info_Hash32 + GoTypesVec[1552] = &info_ArrayOf_Hash32 + GoTypesVec[2930] = &info_Hash64 + GoTypesVec[1553] = &info_ArrayOf_Hash64 + GoTypesVec[1551] = &info_ArrayOf_Hash EnsureLoaded("go.std.io") // E.g. from: C:\Program Files\Go\src\hash\hash.go:8:8 } -------- END _tests/gold/go1.19/amd64-windows/joker/std/gostd/go/std/hash/hash_native.go. @@ -174068,12 +174062,12 @@ func initNative() { GoMembers{ }) - GoTypesVec[2530] = &info_Hash + GoTypesVec[2528] = &info_Hash GoTypesVec[508] = &info_PtrTo_Hash - GoTypesVec[1557] = &info_ArrayOf_Hash - GoTypesVec[2531] = &info_Seed + GoTypesVec[1556] = &info_ArrayOf_Hash + GoTypesVec[2529] = &info_Seed GoTypesVec[509] = &info_PtrTo_Seed - GoTypesVec[1558] = &info_ArrayOf_Seed + GoTypesVec[1557] = &info_ArrayOf_Seed EnsureLoaded("go.std.unsafe") // E.g. from: C:\Program Files\Go\src\hash\maphash\maphash.go:17:2 } -------- END _tests/gold/go1.19/amd64-windows/joker/std/gostd/go/std/hash/maphash/maphash_native.go. @@ -176762,36 +176756,36 @@ func initNative() { GoMembers{ }) - GoTypesVec[2532] = &info_CSS + GoTypesVec[2530] = &info_CSS GoTypesVec[510] = &info_PtrTo_CSS - GoTypesVec[1559] = &info_ArrayOf_CSS - GoTypesVec[2533] = &info_Error + GoTypesVec[1558] = &info_ArrayOf_CSS + GoTypesVec[2531] = &info_Error GoTypesVec[511] = &info_PtrTo_Error - GoTypesVec[2534] = &info_ErrorCode + GoTypesVec[2532] = &info_ErrorCode GoTypesVec[512] = &info_PtrTo_ErrorCode - GoTypesVec[1561] = &info_ArrayOf_ErrorCode - GoTypesVec[1560] = &info_ArrayOf_Error - GoTypesVec[2535] = &info_HTML + GoTypesVec[1560] = &info_ArrayOf_ErrorCode + GoTypesVec[1559] = &info_ArrayOf_Error + GoTypesVec[2533] = &info_HTML GoTypesVec[513] = &info_PtrTo_HTML - GoTypesVec[2536] = &info_HTMLAttr + GoTypesVec[2534] = &info_HTMLAttr GoTypesVec[514] = &info_PtrTo_HTMLAttr - GoTypesVec[1563] = &info_ArrayOf_HTMLAttr - GoTypesVec[1562] = &info_ArrayOf_HTML - GoTypesVec[2537] = &info_JS + GoTypesVec[1562] = &info_ArrayOf_HTMLAttr + GoTypesVec[1561] = &info_ArrayOf_HTML + GoTypesVec[2535] = &info_JS GoTypesVec[515] = &info_PtrTo_JS - GoTypesVec[2538] = &info_JSStr + GoTypesVec[2536] = &info_JSStr GoTypesVec[516] = &info_PtrTo_JSStr - GoTypesVec[1565] = &info_ArrayOf_JSStr - GoTypesVec[1564] = &info_ArrayOf_JS - GoTypesVec[2539] = &info_Srcset + GoTypesVec[1564] = &info_ArrayOf_JSStr + GoTypesVec[1563] = &info_ArrayOf_JS + GoTypesVec[2537] = &info_Srcset GoTypesVec[517] = &info_PtrTo_Srcset - GoTypesVec[1566] = &info_ArrayOf_Srcset - GoTypesVec[2540] = &info_Template + GoTypesVec[1565] = &info_ArrayOf_Srcset + GoTypesVec[2538] = &info_Template GoTypesVec[518] = &info_PtrTo_Template - GoTypesVec[1567] = &info_ArrayOf_Template - GoTypesVec[2541] = &info_URL + GoTypesVec[1566] = &info_ArrayOf_Template + GoTypesVec[2539] = &info_URL GoTypesVec[519] = &info_PtrTo_URL - GoTypesVec[1568] = &info_ArrayOf_URL + GoTypesVec[1567] = &info_ArrayOf_URL EnsureLoaded("go.std.bytes") // E.g. from: C:\Program Files\Go\src\html\template\css.go:8:2 EnsureLoaded("go.std.encoding.json") // E.g. from: C:\Program Files\Go\src\html\template\js.go:9:2 EnsureLoaded("go.std.fmt") // E.g. from: C:\Program Files\Go\src\html\template\content.go:8:2 @@ -180704,46 +180698,46 @@ func initNative() { GoMembers{ }) - GoTypesVec[2559] = &info_Alpha + GoTypesVec[2557] = &info_Alpha GoTypesVec[537] = &info_PtrTo_Alpha - GoTypesVec[2560] = &info_Alpha16 + GoTypesVec[2558] = &info_Alpha16 GoTypesVec[538] = &info_PtrTo_Alpha16 - GoTypesVec[1590] = &info_ArrayOf_Alpha16 - GoTypesVec[1589] = &info_ArrayOf_Alpha - GoTypesVec[2561] = &info_CMYK + GoTypesVec[1589] = &info_ArrayOf_Alpha16 + GoTypesVec[1588] = &info_ArrayOf_Alpha + GoTypesVec[2559] = &info_CMYK GoTypesVec[539] = &info_PtrTo_CMYK - GoTypesVec[1591] = &info_ArrayOf_CMYK - GoTypesVec[3063] = &info_Color - GoTypesVec[1592] = &info_ArrayOf_Color - GoTypesVec[2562] = &info_Gray + GoTypesVec[1590] = &info_ArrayOf_CMYK + GoTypesVec[3060] = &info_Color + GoTypesVec[1591] = &info_ArrayOf_Color + GoTypesVec[2560] = &info_Gray GoTypesVec[540] = &info_PtrTo_Gray - GoTypesVec[2563] = &info_Gray16 + GoTypesVec[2561] = &info_Gray16 GoTypesVec[541] = &info_PtrTo_Gray16 - GoTypesVec[1594] = &info_ArrayOf_Gray16 - GoTypesVec[1593] = &info_ArrayOf_Gray - GoTypesVec[3064] = &info_Model - GoTypesVec[1595] = &info_ArrayOf_Model - GoTypesVec[2564] = &info_NRGBA + GoTypesVec[1593] = &info_ArrayOf_Gray16 + GoTypesVec[1592] = &info_ArrayOf_Gray + GoTypesVec[3061] = &info_Model + GoTypesVec[1594] = &info_ArrayOf_Model + GoTypesVec[2562] = &info_NRGBA GoTypesVec[542] = &info_PtrTo_NRGBA - GoTypesVec[2565] = &info_NRGBA64 + GoTypesVec[2563] = &info_NRGBA64 GoTypesVec[543] = &info_PtrTo_NRGBA64 - GoTypesVec[1597] = &info_ArrayOf_NRGBA64 - GoTypesVec[1596] = &info_ArrayOf_NRGBA - GoTypesVec[2566] = &info_NYCbCrA + GoTypesVec[1596] = &info_ArrayOf_NRGBA64 + GoTypesVec[1595] = &info_ArrayOf_NRGBA + GoTypesVec[2564] = &info_NYCbCrA GoTypesVec[544] = &info_PtrTo_NYCbCrA - GoTypesVec[1598] = &info_ArrayOf_NYCbCrA - GoTypesVec[2567] = &info_Palette + GoTypesVec[1597] = &info_ArrayOf_NYCbCrA + GoTypesVec[2565] = &info_Palette GoTypesVec[545] = &info_PtrTo_Palette - GoTypesVec[1599] = &info_ArrayOf_Palette - GoTypesVec[2568] = &info_RGBA + GoTypesVec[1598] = &info_ArrayOf_Palette + GoTypesVec[2566] = &info_RGBA GoTypesVec[546] = &info_PtrTo_RGBA - GoTypesVec[2569] = &info_RGBA64 + GoTypesVec[2567] = &info_RGBA64 GoTypesVec[547] = &info_PtrTo_RGBA64 - GoTypesVec[1601] = &info_ArrayOf_RGBA64 - GoTypesVec[1600] = &info_ArrayOf_RGBA - GoTypesVec[2570] = &info_YCbCr + GoTypesVec[1600] = &info_ArrayOf_RGBA64 + GoTypesVec[1599] = &info_ArrayOf_RGBA + GoTypesVec[2568] = &info_YCbCr GoTypesVec[548] = &info_PtrTo_YCbCr - GoTypesVec[1602] = &info_ArrayOf_YCbCr + GoTypesVec[1601] = &info_ArrayOf_YCbCr } -------- END _tests/gold/go1.19/amd64-windows/joker/std/gostd/go/std/image/color/color_native.go. -------- BEGIN _tests/gold/go1.19/amd64-windows/joker/std/gostd/go/std/image/color/palette.joke: @@ -181735,17 +181729,17 @@ func initNative() { GoMembers{ }) - GoTypesVec[3065] = &info_Drawer - GoTypesVec[1603] = &info_ArrayOf_Drawer - GoTypesVec[2954] = &info_Image - GoTypesVec[1604] = &info_ArrayOf_Image - GoTypesVec[2571] = &info_Op + GoTypesVec[3062] = &info_Drawer + GoTypesVec[1602] = &info_ArrayOf_Drawer + GoTypesVec[2951] = &info_Image + GoTypesVec[1603] = &info_ArrayOf_Image + GoTypesVec[2569] = &info_Op GoTypesVec[549] = &info_PtrTo_Op - GoTypesVec[1605] = &info_ArrayOf_Op - GoTypesVec[3066] = &info_Quantizer - GoTypesVec[1606] = &info_ArrayOf_Quantizer - GoTypesVec[2934] = &info_RGBA64Image - GoTypesVec[1607] = &info_ArrayOf_RGBA64Image + GoTypesVec[1604] = &info_ArrayOf_Op + GoTypesVec[3063] = &info_Quantizer + GoTypesVec[1605] = &info_ArrayOf_Quantizer + GoTypesVec[2931] = &info_RGBA64Image + GoTypesVec[1606] = &info_ArrayOf_RGBA64Image EnsureLoaded("go.std.image") // E.g. from: C:\Program Files\Go\src\image\draw\draw.go:12:2 EnsureLoaded("go.std.image.color") // E.g. from: C:\Program Files\Go\src\image\draw\draw.go:13:2 } @@ -182295,12 +182289,12 @@ func initNative() { GoMembers{ }) - GoTypesVec[2572] = &info_GIF + GoTypesVec[2570] = &info_GIF GoTypesVec[550] = &info_PtrTo_GIF - GoTypesVec[1608] = &info_ArrayOf_GIF - GoTypesVec[2573] = &info_Options + GoTypesVec[1607] = &info_ArrayOf_GIF + GoTypesVec[2571] = &info_Options GoTypesVec[551] = &info_PtrTo_Options - GoTypesVec[1609] = &info_ArrayOf_Options + GoTypesVec[1608] = &info_ArrayOf_Options EnsureLoaded("go.std.bufio") // E.g. from: C:\Program Files\Go\src\image\gif\reader.go:11:2 EnsureLoaded("go.std.bytes") // E.g. from: C:\Program Files\Go\src\image\gif\writer.go:9:2 EnsureLoaded("go.std.compress.lzw") // E.g. from: C:\Program Files\Go\src\image\gif\reader.go:12:2 @@ -187859,63 +187853,63 @@ func initNative() { GoMembers{ }) - GoTypesVec[2542] = &info_Alpha + GoTypesVec[2540] = &info_Alpha GoTypesVec[520] = &info_PtrTo_Alpha - GoTypesVec[2543] = &info_Alpha16 + GoTypesVec[2541] = &info_Alpha16 GoTypesVec[521] = &info_PtrTo_Alpha16 - GoTypesVec[1570] = &info_ArrayOf_Alpha16 - GoTypesVec[1569] = &info_ArrayOf_Alpha - GoTypesVec[2544] = &info_CMYK + GoTypesVec[1569] = &info_ArrayOf_Alpha16 + GoTypesVec[1568] = &info_ArrayOf_Alpha + GoTypesVec[2542] = &info_CMYK GoTypesVec[522] = &info_PtrTo_CMYK - GoTypesVec[1571] = &info_ArrayOf_CMYK - GoTypesVec[2545] = &info_Config + GoTypesVec[1570] = &info_ArrayOf_CMYK + GoTypesVec[2543] = &info_Config GoTypesVec[523] = &info_PtrTo_Config - GoTypesVec[1572] = &info_ArrayOf_Config - GoTypesVec[2546] = &info_Gray + GoTypesVec[1571] = &info_ArrayOf_Config + GoTypesVec[2544] = &info_Gray GoTypesVec[524] = &info_PtrTo_Gray - GoTypesVec[2547] = &info_Gray16 + GoTypesVec[2545] = &info_Gray16 GoTypesVec[525] = &info_PtrTo_Gray16 - GoTypesVec[1574] = &info_ArrayOf_Gray16 - GoTypesVec[1573] = &info_ArrayOf_Gray - GoTypesVec[2971] = &info_Image - GoTypesVec[1575] = &info_ArrayOf_Image - GoTypesVec[2548] = &info_NRGBA + GoTypesVec[1573] = &info_ArrayOf_Gray16 + GoTypesVec[1572] = &info_ArrayOf_Gray + GoTypesVec[2968] = &info_Image + GoTypesVec[1574] = &info_ArrayOf_Image + GoTypesVec[2546] = &info_NRGBA GoTypesVec[526] = &info_PtrTo_NRGBA - GoTypesVec[2549] = &info_NRGBA64 + GoTypesVec[2547] = &info_NRGBA64 GoTypesVec[527] = &info_PtrTo_NRGBA64 - GoTypesVec[1577] = &info_ArrayOf_NRGBA64 - GoTypesVec[1576] = &info_ArrayOf_NRGBA - GoTypesVec[2550] = &info_NYCbCrA + GoTypesVec[1576] = &info_ArrayOf_NRGBA64 + GoTypesVec[1575] = &info_ArrayOf_NRGBA + GoTypesVec[2548] = &info_NYCbCrA GoTypesVec[528] = &info_PtrTo_NYCbCrA - GoTypesVec[1578] = &info_ArrayOf_NYCbCrA - GoTypesVec[2551] = &info_Paletted + GoTypesVec[1577] = &info_ArrayOf_NYCbCrA + GoTypesVec[2549] = &info_Paletted GoTypesVec[529] = &info_PtrTo_Paletted - GoTypesVec[2952] = &info_PalettedImage - GoTypesVec[1580] = &info_ArrayOf_PalettedImage - GoTypesVec[1579] = &info_ArrayOf_Paletted - GoTypesVec[2552] = &info_Point + GoTypesVec[2949] = &info_PalettedImage + GoTypesVec[1579] = &info_ArrayOf_PalettedImage + GoTypesVec[1578] = &info_ArrayOf_Paletted + GoTypesVec[2550] = &info_Point GoTypesVec[530] = &info_PtrTo_Point - GoTypesVec[1581] = &info_ArrayOf_Point - GoTypesVec[2553] = &info_RGBA + GoTypesVec[1580] = &info_ArrayOf_Point + GoTypesVec[2551] = &info_RGBA GoTypesVec[531] = &info_PtrTo_RGBA - GoTypesVec[2554] = &info_RGBA64 + GoTypesVec[2552] = &info_RGBA64 GoTypesVec[532] = &info_PtrTo_RGBA64 - GoTypesVec[2953] = &info_RGBA64Image - GoTypesVec[1584] = &info_ArrayOf_RGBA64Image - GoTypesVec[1583] = &info_ArrayOf_RGBA64 - GoTypesVec[1582] = &info_ArrayOf_RGBA - GoTypesVec[2555] = &info_Rectangle + GoTypesVec[2950] = &info_RGBA64Image + GoTypesVec[1583] = &info_ArrayOf_RGBA64Image + GoTypesVec[1582] = &info_ArrayOf_RGBA64 + GoTypesVec[1581] = &info_ArrayOf_RGBA + GoTypesVec[2553] = &info_Rectangle GoTypesVec[533] = &info_PtrTo_Rectangle - GoTypesVec[1585] = &info_ArrayOf_Rectangle - GoTypesVec[2556] = &info_Uniform + GoTypesVec[1584] = &info_ArrayOf_Rectangle + GoTypesVec[2554] = &info_Uniform GoTypesVec[534] = &info_PtrTo_Uniform - GoTypesVec[1586] = &info_ArrayOf_Uniform - GoTypesVec[2557] = &info_YCbCr + GoTypesVec[1585] = &info_ArrayOf_Uniform + GoTypesVec[2555] = &info_YCbCr GoTypesVec[535] = &info_PtrTo_YCbCr - GoTypesVec[2558] = &info_YCbCrSubsampleRatio + GoTypesVec[2556] = &info_YCbCrSubsampleRatio GoTypesVec[536] = &info_PtrTo_YCbCrSubsampleRatio - GoTypesVec[1588] = &info_ArrayOf_YCbCrSubsampleRatio - GoTypesVec[1587] = &info_ArrayOf_YCbCr + GoTypesVec[1587] = &info_ArrayOf_YCbCrSubsampleRatio + GoTypesVec[1586] = &info_ArrayOf_YCbCr EnsureLoaded("go.std.bufio") // E.g. from: C:\Program Files\Go\src\image\format.go:8:2 EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\image\format.go:9:2 EnsureLoaded("go.std.image.color") // E.g. from: C:\Program Files\Go\src\image\geom.go:8:2 @@ -188814,17 +188808,17 @@ func initNative() { GoMembers{ }) - GoTypesVec[2574] = &info_FormatError + GoTypesVec[2572] = &info_FormatError GoTypesVec[552] = &info_PtrTo_FormatError - GoTypesVec[1610] = &info_ArrayOf_FormatError - GoTypesVec[2575] = &info_Options + GoTypesVec[1609] = &info_ArrayOf_FormatError + GoTypesVec[2573] = &info_Options GoTypesVec[553] = &info_PtrTo_Options - GoTypesVec[1611] = &info_ArrayOf_Options - GoTypesVec[2995] = &info_Reader - GoTypesVec[1612] = &info_ArrayOf_Reader - GoTypesVec[2576] = &info_UnsupportedError + GoTypesVec[1610] = &info_ArrayOf_Options + GoTypesVec[2992] = &info_Reader + GoTypesVec[1611] = &info_ArrayOf_Reader + GoTypesVec[2574] = &info_UnsupportedError GoTypesVec[554] = &info_PtrTo_UnsupportedError - GoTypesVec[1613] = &info_ArrayOf_UnsupportedError + GoTypesVec[1612] = &info_ArrayOf_UnsupportedError EnsureLoaded("go.std.bufio") // E.g. from: C:\Program Files\Go\src\image\jpeg\writer.go:8:2 EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\image\jpeg\writer.go:9:2 EnsureLoaded("go.std.image") // E.g. from: C:\Program Files\Go\src\image\jpeg\reader.go:11:2 @@ -190168,23 +190162,23 @@ func initNative() { GoMembers{ }) - GoTypesVec[2577] = &info_CompressionLevel + GoTypesVec[2575] = &info_CompressionLevel GoTypesVec[555] = &info_PtrTo_CompressionLevel - GoTypesVec[1614] = &info_ArrayOf_CompressionLevel - GoTypesVec[2578] = &info_Encoder + GoTypesVec[1613] = &info_ArrayOf_CompressionLevel + GoTypesVec[2576] = &info_Encoder GoTypesVec[556] = &info_PtrTo_Encoder - GoTypesVec[2579] = &info_EncoderBuffer + GoTypesVec[2577] = &info_EncoderBuffer GoTypesVec[557] = &info_PtrTo_EncoderBuffer - GoTypesVec[2996] = &info_EncoderBufferPool - GoTypesVec[1617] = &info_ArrayOf_EncoderBufferPool - GoTypesVec[1616] = &info_ArrayOf_EncoderBuffer - GoTypesVec[1615] = &info_ArrayOf_Encoder - GoTypesVec[2580] = &info_FormatError + GoTypesVec[2993] = &info_EncoderBufferPool + GoTypesVec[1616] = &info_ArrayOf_EncoderBufferPool + GoTypesVec[1615] = &info_ArrayOf_EncoderBuffer + GoTypesVec[1614] = &info_ArrayOf_Encoder + GoTypesVec[2578] = &info_FormatError GoTypesVec[558] = &info_PtrTo_FormatError - GoTypesVec[1618] = &info_ArrayOf_FormatError - GoTypesVec[2581] = &info_UnsupportedError + GoTypesVec[1617] = &info_ArrayOf_FormatError + GoTypesVec[2579] = &info_UnsupportedError GoTypesVec[559] = &info_PtrTo_UnsupportedError - GoTypesVec[1619] = &info_ArrayOf_UnsupportedError + GoTypesVec[1618] = &info_ArrayOf_UnsupportedError EnsureLoaded("go.std.bufio") // E.g. from: C:\Program Files\Go\src\image\png\writer.go:8:2 EnsureLoaded("go.std.compress.zlib") // E.g. from: C:\Program Files\Go\src\image\png\reader.go:11:2 EnsureLoaded("go.std.encoding.binary") // E.g. from: C:\Program Files\Go\src\image\png\reader.go:12:2 @@ -190493,9 +190487,9 @@ func initNative() { GoMembers{ }) - GoTypesVec[2582] = &info_Index + GoTypesVec[2580] = &info_Index GoTypesVec[560] = &info_PtrTo_Index - GoTypesVec[1620] = &info_ArrayOf_Index + GoTypesVec[1619] = &info_ArrayOf_Index EnsureLoaded("go.std.bytes") // E.g. from: C:\Program Files\Go\src\index\suffixarray\suffixarray.go:19:2 EnsureLoaded("go.std.encoding.binary") // E.g. from: C:\Program Files\Go\src\index\suffixarray\suffixarray.go:20:2 EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\index\suffixarray\suffixarray.go:21:2 @@ -193701,35 +193695,35 @@ func initNative() { GoMembers{ }) - GoTypesVec[2955] = &info_DirEntry - GoTypesVec[1647] = &info_ArrayOf_DirEntry - GoTypesVec[3079] = &info_FS - GoTypesVec[1648] = &info_ArrayOf_FS - GoTypesVec[2975] = &info_File - GoTypesVec[2935] = &info_FileInfo - GoTypesVec[1650] = &info_ArrayOf_FileInfo - GoTypesVec[2587] = &info_FileMode + GoTypesVec[2952] = &info_DirEntry + GoTypesVec[1646] = &info_ArrayOf_DirEntry + GoTypesVec[3076] = &info_FS + GoTypesVec[1647] = &info_ArrayOf_FS + GoTypesVec[2972] = &info_File + GoTypesVec[2932] = &info_FileInfo + GoTypesVec[1649] = &info_ArrayOf_FileInfo + GoTypesVec[2585] = &info_FileMode GoTypesVec[565] = &info_PtrTo_FileMode - GoTypesVec[1651] = &info_ArrayOf_FileMode - GoTypesVec[1649] = &info_ArrayOf_File - GoTypesVec[3004] = &info_GlobFS - GoTypesVec[1652] = &info_ArrayOf_GlobFS - GoTypesVec[2588] = &info_PathError + GoTypesVec[1650] = &info_ArrayOf_FileMode + GoTypesVec[1648] = &info_ArrayOf_File + GoTypesVec[3001] = &info_GlobFS + GoTypesVec[1651] = &info_ArrayOf_GlobFS + GoTypesVec[2586] = &info_PathError GoTypesVec[566] = &info_PtrTo_PathError - GoTypesVec[1653] = &info_ArrayOf_PathError - GoTypesVec[3005] = &info_ReadDirFS - GoTypesVec[1654] = &info_ArrayOf_ReadDirFS - GoTypesVec[2956] = &info_ReadDirFile - GoTypesVec[1655] = &info_ArrayOf_ReadDirFile - GoTypesVec[3006] = &info_ReadFileFS - GoTypesVec[1656] = &info_ArrayOf_ReadFileFS - GoTypesVec[3007] = &info_StatFS - GoTypesVec[1657] = &info_ArrayOf_StatFS - GoTypesVec[3008] = &info_SubFS - GoTypesVec[1658] = &info_ArrayOf_SubFS - GoTypesVec[2589] = &info_WalkDirFunc + GoTypesVec[1652] = &info_ArrayOf_PathError + GoTypesVec[3002] = &info_ReadDirFS + GoTypesVec[1653] = &info_ArrayOf_ReadDirFS + GoTypesVec[2953] = &info_ReadDirFile + GoTypesVec[1654] = &info_ArrayOf_ReadDirFile + GoTypesVec[3003] = &info_ReadFileFS + GoTypesVec[1655] = &info_ArrayOf_ReadFileFS + GoTypesVec[3004] = &info_StatFS + GoTypesVec[1656] = &info_ArrayOf_StatFS + GoTypesVec[3005] = &info_SubFS + GoTypesVec[1657] = &info_ArrayOf_SubFS + GoTypesVec[2587] = &info_WalkDirFunc GoTypesVec[567] = &info_PtrTo_WalkDirFunc - GoTypesVec[1659] = &info_ArrayOf_WalkDirFunc + GoTypesVec[1658] = &info_ArrayOf_WalkDirFunc EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\io\fs\readdir.go:8:2 EnsureLoaded("go.std.io") // E.g. from: C:\Program Files\Go\src\io\fs\readfile.go:7:8 EnsureLoaded("go.std.path") // E.g. from: C:\Program Files\Go\src\io\fs\glob.go:8:2 @@ -197780,62 +197774,62 @@ func initNative() { GoMembers{ }) - GoTypesVec[3067] = &info_ByteReader - GoTypesVec[1621] = &info_ArrayOf_ByteReader - GoTypesVec[2997] = &info_ByteScanner - GoTypesVec[1622] = &info_ArrayOf_ByteScanner - GoTypesVec[3068] = &info_ByteWriter - GoTypesVec[1623] = &info_ArrayOf_ByteWriter - GoTypesVec[3069] = &info_Closer - GoTypesVec[1624] = &info_ArrayOf_Closer - GoTypesVec[2583] = &info_LimitedReader + GoTypesVec[3064] = &info_ByteReader + GoTypesVec[1620] = &info_ArrayOf_ByteReader + GoTypesVec[2994] = &info_ByteScanner + GoTypesVec[1621] = &info_ArrayOf_ByteScanner + GoTypesVec[3065] = &info_ByteWriter + GoTypesVec[1622] = &info_ArrayOf_ByteWriter + GoTypesVec[3066] = &info_Closer + GoTypesVec[1623] = &info_ArrayOf_Closer + GoTypesVec[2581] = &info_LimitedReader GoTypesVec[561] = &info_PtrTo_LimitedReader - GoTypesVec[1625] = &info_ArrayOf_LimitedReader - GoTypesVec[2584] = &info_PipeReader + GoTypesVec[1624] = &info_ArrayOf_LimitedReader + GoTypesVec[2582] = &info_PipeReader GoTypesVec[562] = &info_PtrTo_PipeReader - GoTypesVec[1626] = &info_ArrayOf_PipeReader - GoTypesVec[2585] = &info_PipeWriter + GoTypesVec[1625] = &info_ArrayOf_PipeReader + GoTypesVec[2583] = &info_PipeWriter GoTypesVec[563] = &info_PtrTo_PipeWriter - GoTypesVec[1627] = &info_ArrayOf_PipeWriter - GoTypesVec[2998] = &info_ReadCloser - GoTypesVec[1628] = &info_ArrayOf_ReadCloser - GoTypesVec[2972] = &info_ReadSeekCloser - GoTypesVec[1629] = &info_ArrayOf_ReadSeekCloser - GoTypesVec[2999] = &info_ReadSeeker - GoTypesVec[1630] = &info_ArrayOf_ReadSeeker - GoTypesVec[2973] = &info_ReadWriteCloser - GoTypesVec[1631] = &info_ArrayOf_ReadWriteCloser - GoTypesVec[2974] = &info_ReadWriteSeeker - GoTypesVec[1632] = &info_ArrayOf_ReadWriteSeeker - GoTypesVec[3000] = &info_ReadWriter - GoTypesVec[1633] = &info_ArrayOf_ReadWriter - GoTypesVec[3070] = &info_Reader - GoTypesVec[3071] = &info_ReaderAt - GoTypesVec[1635] = &info_ArrayOf_ReaderAt - GoTypesVec[3072] = &info_ReaderFrom - GoTypesVec[1636] = &info_ArrayOf_ReaderFrom - GoTypesVec[1634] = &info_ArrayOf_Reader - GoTypesVec[3073] = &info_RuneReader - GoTypesVec[1637] = &info_ArrayOf_RuneReader - GoTypesVec[3001] = &info_RuneScanner - GoTypesVec[1638] = &info_ArrayOf_RuneScanner - GoTypesVec[2586] = &info_SectionReader + GoTypesVec[1626] = &info_ArrayOf_PipeWriter + GoTypesVec[2995] = &info_ReadCloser + GoTypesVec[1627] = &info_ArrayOf_ReadCloser + GoTypesVec[2969] = &info_ReadSeekCloser + GoTypesVec[1628] = &info_ArrayOf_ReadSeekCloser + GoTypesVec[2996] = &info_ReadSeeker + GoTypesVec[1629] = &info_ArrayOf_ReadSeeker + GoTypesVec[2970] = &info_ReadWriteCloser + GoTypesVec[1630] = &info_ArrayOf_ReadWriteCloser + GoTypesVec[2971] = &info_ReadWriteSeeker + GoTypesVec[1631] = &info_ArrayOf_ReadWriteSeeker + GoTypesVec[2997] = &info_ReadWriter + GoTypesVec[1632] = &info_ArrayOf_ReadWriter + GoTypesVec[3067] = &info_Reader + GoTypesVec[3068] = &info_ReaderAt + GoTypesVec[1634] = &info_ArrayOf_ReaderAt + GoTypesVec[3069] = &info_ReaderFrom + GoTypesVec[1635] = &info_ArrayOf_ReaderFrom + GoTypesVec[1633] = &info_ArrayOf_Reader + GoTypesVec[3070] = &info_RuneReader + GoTypesVec[1636] = &info_ArrayOf_RuneReader + GoTypesVec[2998] = &info_RuneScanner + GoTypesVec[1637] = &info_ArrayOf_RuneScanner + GoTypesVec[2584] = &info_SectionReader GoTypesVec[564] = &info_PtrTo_SectionReader - GoTypesVec[1639] = &info_ArrayOf_SectionReader - GoTypesVec[3074] = &info_Seeker - GoTypesVec[1640] = &info_ArrayOf_Seeker - GoTypesVec[3075] = &info_StringWriter - GoTypesVec[1641] = &info_ArrayOf_StringWriter - GoTypesVec[3002] = &info_WriteCloser - GoTypesVec[1642] = &info_ArrayOf_WriteCloser - GoTypesVec[3003] = &info_WriteSeeker - GoTypesVec[1643] = &info_ArrayOf_WriteSeeker - GoTypesVec[3076] = &info_Writer - GoTypesVec[3077] = &info_WriterAt - GoTypesVec[1645] = &info_ArrayOf_WriterAt - GoTypesVec[3078] = &info_WriterTo - GoTypesVec[1646] = &info_ArrayOf_WriterTo - GoTypesVec[1644] = &info_ArrayOf_Writer + GoTypesVec[1638] = &info_ArrayOf_SectionReader + GoTypesVec[3071] = &info_Seeker + GoTypesVec[1639] = &info_ArrayOf_Seeker + GoTypesVec[3072] = &info_StringWriter + GoTypesVec[1640] = &info_ArrayOf_StringWriter + GoTypesVec[2999] = &info_WriteCloser + GoTypesVec[1641] = &info_ArrayOf_WriteCloser + GoTypesVec[3000] = &info_WriteSeeker + GoTypesVec[1642] = &info_ArrayOf_WriteSeeker + GoTypesVec[3073] = &info_Writer + GoTypesVec[3074] = &info_WriterAt + GoTypesVec[1644] = &info_ArrayOf_WriterAt + GoTypesVec[3075] = &info_WriterTo + GoTypesVec[1645] = &info_ArrayOf_WriterTo + GoTypesVec[1643] = &info_ArrayOf_Writer EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\io\io.go:16:2 EnsureLoaded("go.std.sync") // E.g. from: C:\Program Files\Go\src\io\io.go:17:2 } @@ -198592,9 +198586,9 @@ func initNative() { GoMembers{ }) - GoTypesVec[2590] = &info_Logger + GoTypesVec[2588] = &info_Logger GoTypesVec[568] = &info_PtrTo_Logger - GoTypesVec[1660] = &info_ArrayOf_Logger + GoTypesVec[1659] = &info_ArrayOf_Logger EnsureLoaded("go.std.fmt") // E.g. from: C:\Program Files\Go\src\log\log.go:18:2 EnsureLoaded("go.std.io") // E.g. from: C:\Program Files\Go\src\log\log.go:19:2 EnsureLoaded("go.std.os") // E.g. from: C:\Program Files\Go\src\log\log.go:20:2 @@ -202304,27 +202298,27 @@ func initNative() { GoMembers{ }) - GoTypesVec[2591] = &info_Accuracy + GoTypesVec[2589] = &info_Accuracy GoTypesVec[569] = &info_PtrTo_Accuracy - GoTypesVec[1661] = &info_ArrayOf_Accuracy - GoTypesVec[2592] = &info_ErrNaN + GoTypesVec[1660] = &info_ArrayOf_Accuracy + GoTypesVec[2590] = &info_ErrNaN GoTypesVec[570] = &info_PtrTo_ErrNaN - GoTypesVec[1662] = &info_ArrayOf_ErrNaN - GoTypesVec[2593] = &info_Float + GoTypesVec[1661] = &info_ArrayOf_ErrNaN + GoTypesVec[2591] = &info_Float GoTypesVec[571] = &info_PtrTo_Float - GoTypesVec[1663] = &info_ArrayOf_Float - GoTypesVec[2594] = &info_Int + GoTypesVec[1662] = &info_ArrayOf_Float + GoTypesVec[2592] = &info_Int GoTypesVec[572] = &info_PtrTo_Int - GoTypesVec[1664] = &info_ArrayOf_Int - GoTypesVec[2595] = &info_Rat + GoTypesVec[1663] = &info_ArrayOf_Int + GoTypesVec[2593] = &info_Rat GoTypesVec[573] = &info_PtrTo_Rat - GoTypesVec[1665] = &info_ArrayOf_Rat - GoTypesVec[2596] = &info_RoundingMode + GoTypesVec[1664] = &info_ArrayOf_Rat + GoTypesVec[2594] = &info_RoundingMode GoTypesVec[574] = &info_PtrTo_RoundingMode - GoTypesVec[1666] = &info_ArrayOf_RoundingMode - GoTypesVec[2597] = &info_Word + GoTypesVec[1665] = &info_ArrayOf_RoundingMode + GoTypesVec[2595] = &info_Word GoTypesVec[575] = &info_PtrTo_Word - GoTypesVec[1667] = &info_ArrayOf_Word + GoTypesVec[1666] = &info_ArrayOf_Word EnsureLoaded("go.std.bytes") // E.g. from: C:\Program Files\Go\src\math\big\ftoa.go:12:2 EnsureLoaded("go.std.encoding.binary") // E.g. from: C:\Program Files\Go\src\math\big\floatmarsh.go:10:2 EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\math\big\floatmarsh.go:11:2 @@ -204010,16 +204004,16 @@ func initNative() { GoMembers{ }) - GoTypesVec[2598] = &info_Rand + GoTypesVec[2596] = &info_Rand GoTypesVec[576] = &info_PtrTo_Rand - GoTypesVec[1668] = &info_ArrayOf_Rand - GoTypesVec[3009] = &info_Source - GoTypesVec[2976] = &info_Source64 - GoTypesVec[1670] = &info_ArrayOf_Source64 - GoTypesVec[1669] = &info_ArrayOf_Source - GoTypesVec[2599] = &info_Zipf + GoTypesVec[1667] = &info_ArrayOf_Rand + GoTypesVec[3006] = &info_Source + GoTypesVec[2973] = &info_Source64 + GoTypesVec[1669] = &info_ArrayOf_Source64 + GoTypesVec[1668] = &info_ArrayOf_Source + GoTypesVec[2597] = &info_Zipf GoTypesVec[577] = &info_PtrTo_Zipf - GoTypesVec[1671] = &info_ArrayOf_Zipf + GoTypesVec[1670] = &info_ArrayOf_Zipf EnsureLoaded("go.std.math") // E.g. from: C:\Program Files\Go\src\math\rand\exp.go:8:2 EnsureLoaded("go.std.sync") // E.g. from: C:\Program Files\Go\src\math\rand\rand.go:20:8 } @@ -204588,12 +204582,12 @@ func initNative() { GoMembers{ }) - GoTypesVec[2600] = &info_WordDecoder + GoTypesVec[2598] = &info_WordDecoder GoTypesVec[578] = &info_PtrTo_WordDecoder - GoTypesVec[1672] = &info_ArrayOf_WordDecoder - GoTypesVec[2601] = &info_WordEncoder + GoTypesVec[1671] = &info_ArrayOf_WordDecoder + GoTypesVec[2599] = &info_WordEncoder GoTypesVec[579] = &info_PtrTo_WordEncoder - GoTypesVec[1673] = &info_ArrayOf_WordEncoder + GoTypesVec[1672] = &info_ArrayOf_WordEncoder EnsureLoaded("go.std.bytes") // E.g. from: C:\Program Files\Go\src\mime\encodedword.go:8:2 EnsureLoaded("go.std.encoding.base64") // E.g. from: C:\Program Files\Go\src\mime\encodedword.go:9:2 EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\mime\encodedword.go:10:2 @@ -206156,23 +206150,23 @@ func initNative() { GoMembers{ }) - GoTypesVec[2957] = &info_File - GoTypesVec[2602] = &info_FileHeader + GoTypesVec[2954] = &info_File + GoTypesVec[2600] = &info_FileHeader GoTypesVec[580] = &info_PtrTo_FileHeader - GoTypesVec[1675] = &info_ArrayOf_FileHeader - GoTypesVec[1674] = &info_ArrayOf_File - GoTypesVec[2603] = &info_Form + GoTypesVec[1674] = &info_ArrayOf_FileHeader + GoTypesVec[1673] = &info_ArrayOf_File + GoTypesVec[2601] = &info_Form GoTypesVec[581] = &info_PtrTo_Form - GoTypesVec[1676] = &info_ArrayOf_Form - GoTypesVec[2604] = &info_Part + GoTypesVec[1675] = &info_ArrayOf_Form + GoTypesVec[2602] = &info_Part GoTypesVec[582] = &info_PtrTo_Part - GoTypesVec[1677] = &info_ArrayOf_Part - GoTypesVec[2605] = &info_Reader + GoTypesVec[1676] = &info_ArrayOf_Part + GoTypesVec[2603] = &info_Reader GoTypesVec[583] = &info_PtrTo_Reader - GoTypesVec[1678] = &info_ArrayOf_Reader - GoTypesVec[2606] = &info_Writer + GoTypesVec[1677] = &info_ArrayOf_Reader + GoTypesVec[2604] = &info_Writer GoTypesVec[584] = &info_PtrTo_Writer - GoTypesVec[1679] = &info_ArrayOf_Writer + GoTypesVec[1678] = &info_ArrayOf_Writer EnsureLoaded("go.std.bufio") // E.g. from: C:\Program Files\Go\src\mime\multipart\multipart.go:16:2 EnsureLoaded("go.std.bytes") // E.g. from: C:\Program Files\Go\src\mime\multipart\formdata.go:8:2 EnsureLoaded("go.std.crypto.rand") // E.g. from: C:\Program Files\Go\src\mime\multipart\writer.go:9:2 @@ -206700,12 +206694,12 @@ func initNative() { GoMembers{ }) - GoTypesVec[2607] = &info_Reader + GoTypesVec[2605] = &info_Reader GoTypesVec[585] = &info_PtrTo_Reader - GoTypesVec[1680] = &info_ArrayOf_Reader - GoTypesVec[2608] = &info_Writer + GoTypesVec[1679] = &info_ArrayOf_Reader + GoTypesVec[2606] = &info_Writer GoTypesVec[586] = &info_PtrTo_Writer - GoTypesVec[1681] = &info_ArrayOf_Writer + GoTypesVec[1680] = &info_ArrayOf_Writer EnsureLoaded("go.std.bufio") // E.g. from: C:\Program Files\Go\src\mime\quotedprintable\reader.go:10:2 EnsureLoaded("go.std.bytes") // E.g. from: C:\Program Files\Go\src\mime\quotedprintable\reader.go:11:2 EnsureLoaded("go.std.fmt") // E.g. from: C:\Program Files\Go\src\mime\quotedprintable\reader.go:12:2 @@ -209698,9 +209692,9 @@ func initNative() { GoMembers{ }) - GoTypesVec[2654] = &info_Handler + GoTypesVec[2652] = &info_Handler GoTypesVec[632] = &info_PtrTo_Handler - GoTypesVec[1742] = &info_ArrayOf_Handler + GoTypesVec[1741] = &info_ArrayOf_Handler EnsureLoaded("go.std.bufio") // E.g. from: C:\Program Files\Go\src\net\http\cgi\child.go:11:2 EnsureLoaded("go.std.crypto.tls") // E.g. from: C:\Program Files\Go\src\net\http\cgi\child.go:12:2 EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\net\http\cgi\child.go:13:2 @@ -210364,14 +210358,14 @@ func initNative() { GoMembers{ }) - GoTypesVec[2655] = &info_Jar + GoTypesVec[2653] = &info_Jar GoTypesVec[633] = &info_PtrTo_Jar - GoTypesVec[1743] = &info_ArrayOf_Jar - GoTypesVec[2656] = &info_Options + GoTypesVec[1742] = &info_ArrayOf_Jar + GoTypesVec[2654] = &info_Options GoTypesVec[634] = &info_PtrTo_Options - GoTypesVec[1744] = &info_ArrayOf_Options - GoTypesVec[3012] = &info_PublicSuffixList - GoTypesVec[1745] = &info_ArrayOf_PublicSuffixList + GoTypesVec[1743] = &info_ArrayOf_Options + GoTypesVec[3009] = &info_PublicSuffixList + GoTypesVec[1744] = &info_ArrayOf_PublicSuffixList EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\net\http\cookiejar\jar.go:9:2 EnsureLoaded("go.std.fmt") // E.g. from: C:\Program Files\Go\src\net\http\cookiejar\jar.go:10:2 EnsureLoaded("go.std.net") // E.g. from: C:\Program Files\Go\src\net\http\cookiejar\jar.go:11:2 @@ -215692,71 +215686,71 @@ func initNative() { GoMembers{ }) - GoTypesVec[2639] = &info_Client + GoTypesVec[2637] = &info_Client GoTypesVec[617] = &info_PtrTo_Client - GoTypesVec[1717] = &info_ArrayOf_Client - GoTypesVec[3080] = &info_CloseNotifier - GoTypesVec[1718] = &info_ArrayOf_CloseNotifier - GoTypesVec[2640] = &info_ConnState + GoTypesVec[1716] = &info_ArrayOf_Client + GoTypesVec[3077] = &info_CloseNotifier + GoTypesVec[1717] = &info_ArrayOf_CloseNotifier + GoTypesVec[2638] = &info_ConnState GoTypesVec[618] = &info_PtrTo_ConnState - GoTypesVec[1719] = &info_ArrayOf_ConnState - GoTypesVec[2641] = &info_Cookie + GoTypesVec[1718] = &info_ArrayOf_ConnState + GoTypesVec[2639] = &info_Cookie GoTypesVec[619] = &info_PtrTo_Cookie - GoTypesVec[3011] = &info_CookieJar - GoTypesVec[1721] = &info_ArrayOf_CookieJar - GoTypesVec[1720] = &info_ArrayOf_Cookie - GoTypesVec[2642] = &info_Dir + GoTypesVec[3008] = &info_CookieJar + GoTypesVec[1720] = &info_ArrayOf_CookieJar + GoTypesVec[1719] = &info_ArrayOf_Cookie + GoTypesVec[2640] = &info_Dir GoTypesVec[620] = &info_PtrTo_Dir - GoTypesVec[1722] = &info_ArrayOf_Dir - GoTypesVec[2940] = &info_File - GoTypesVec[3081] = &info_FileSystem - GoTypesVec[1724] = &info_ArrayOf_FileSystem - GoTypesVec[1723] = &info_ArrayOf_File - GoTypesVec[3082] = &info_Flusher - GoTypesVec[1725] = &info_ArrayOf_Flusher - GoTypesVec[3083] = &info_Handler - GoTypesVec[2643] = &info_HandlerFunc + GoTypesVec[1721] = &info_ArrayOf_Dir + GoTypesVec[2937] = &info_File + GoTypesVec[3078] = &info_FileSystem + GoTypesVec[1723] = &info_ArrayOf_FileSystem + GoTypesVec[1722] = &info_ArrayOf_File + GoTypesVec[3079] = &info_Flusher + GoTypesVec[1724] = &info_ArrayOf_Flusher + GoTypesVec[3080] = &info_Handler + GoTypesVec[2641] = &info_HandlerFunc GoTypesVec[621] = &info_PtrTo_HandlerFunc - GoTypesVec[1727] = &info_ArrayOf_HandlerFunc - GoTypesVec[1726] = &info_ArrayOf_Handler - GoTypesVec[2644] = &info_Header + GoTypesVec[1726] = &info_ArrayOf_HandlerFunc + GoTypesVec[1725] = &info_ArrayOf_Handler + GoTypesVec[2642] = &info_Header GoTypesVec[622] = &info_PtrTo_Header - GoTypesVec[1728] = &info_ArrayOf_Header - GoTypesVec[3084] = &info_Hijacker - GoTypesVec[1729] = &info_ArrayOf_Hijacker - GoTypesVec[2645] = &info_MaxBytesError + GoTypesVec[1727] = &info_ArrayOf_Header + GoTypesVec[3081] = &info_Hijacker + GoTypesVec[1728] = &info_ArrayOf_Hijacker + GoTypesVec[2643] = &info_MaxBytesError GoTypesVec[623] = &info_PtrTo_MaxBytesError - GoTypesVec[1730] = &info_ArrayOf_MaxBytesError - GoTypesVec[2646] = &info_ProtocolError + GoTypesVec[1729] = &info_ArrayOf_MaxBytesError + GoTypesVec[2644] = &info_ProtocolError GoTypesVec[624] = &info_PtrTo_ProtocolError - GoTypesVec[1731] = &info_ArrayOf_ProtocolError - GoTypesVec[2647] = &info_PushOptions + GoTypesVec[1730] = &info_ArrayOf_ProtocolError + GoTypesVec[2645] = &info_PushOptions GoTypesVec[625] = &info_PtrTo_PushOptions - GoTypesVec[1732] = &info_ArrayOf_PushOptions - GoTypesVec[3085] = &info_Pusher - GoTypesVec[1733] = &info_ArrayOf_Pusher - GoTypesVec[2648] = &info_Request + GoTypesVec[1731] = &info_ArrayOf_PushOptions + GoTypesVec[3082] = &info_Pusher + GoTypesVec[1732] = &info_ArrayOf_Pusher + GoTypesVec[2646] = &info_Request GoTypesVec[626] = &info_PtrTo_Request - GoTypesVec[1734] = &info_ArrayOf_Request - GoTypesVec[2649] = &info_Response + GoTypesVec[1733] = &info_ArrayOf_Request + GoTypesVec[2647] = &info_Response GoTypesVec[627] = &info_PtrTo_Response - GoTypesVec[2979] = &info_ResponseWriter - GoTypesVec[1736] = &info_ArrayOf_ResponseWriter - GoTypesVec[1735] = &info_ArrayOf_Response - GoTypesVec[3086] = &info_RoundTripper - GoTypesVec[1737] = &info_ArrayOf_RoundTripper - GoTypesVec[2650] = &info_SameSite + GoTypesVec[2976] = &info_ResponseWriter + GoTypesVec[1735] = &info_ArrayOf_ResponseWriter + GoTypesVec[1734] = &info_ArrayOf_Response + GoTypesVec[3083] = &info_RoundTripper + GoTypesVec[1736] = &info_ArrayOf_RoundTripper + GoTypesVec[2648] = &info_SameSite GoTypesVec[628] = &info_PtrTo_SameSite - GoTypesVec[1738] = &info_ArrayOf_SameSite - GoTypesVec[2651] = &info_ServeMux + GoTypesVec[1737] = &info_ArrayOf_SameSite + GoTypesVec[2649] = &info_ServeMux GoTypesVec[629] = &info_PtrTo_ServeMux - GoTypesVec[1739] = &info_ArrayOf_ServeMux - GoTypesVec[2652] = &info_Server + GoTypesVec[1738] = &info_ArrayOf_ServeMux + GoTypesVec[2650] = &info_Server GoTypesVec[630] = &info_PtrTo_Server - GoTypesVec[1740] = &info_ArrayOf_Server - GoTypesVec[2653] = &info_Transport + GoTypesVec[1739] = &info_ArrayOf_Server + GoTypesVec[2651] = &info_Transport GoTypesVec[631] = &info_PtrTo_Transport - GoTypesVec[1741] = &info_ArrayOf_Transport + GoTypesVec[1740] = &info_ArrayOf_Transport EnsureLoaded("go.std.bufio") // E.g. from: C:\Program Files\Go\src\net\http\h2_bundle.go:23:2 EnsureLoaded("go.std.bytes") // E.g. from: C:\Program Files\Go\src\net\http\h2_bundle.go:24:2 EnsureLoaded("go.std.compress.gzip") // E.g. from: C:\Program Files\Go\src\net\http\h2_bundle.go:25:2 @@ -216436,12 +216430,12 @@ func initNative() { GoMembers{ }) - GoTypesVec[2657] = &info_ResponseRecorder + GoTypesVec[2655] = &info_ResponseRecorder GoTypesVec[635] = &info_PtrTo_ResponseRecorder - GoTypesVec[1746] = &info_ArrayOf_ResponseRecorder - GoTypesVec[2658] = &info_Server + GoTypesVec[1745] = &info_ArrayOf_ResponseRecorder + GoTypesVec[2656] = &info_Server GoTypesVec[636] = &info_PtrTo_Server - GoTypesVec[1747] = &info_ArrayOf_Server + GoTypesVec[1746] = &info_ArrayOf_Server EnsureLoaded("go.std.bufio") // E.g. from: C:\Program Files\Go\src\net\http\httptest\httptest.go:9:2 EnsureLoaded("go.std.bytes") // E.g. from: C:\Program Files\Go\src\net\http\httptest\httptest.go:10:2 EnsureLoaded("go.std.crypto.tls") // E.g. from: C:\Program Files\Go\src\net\http\httptest\httptest.go:11:2 @@ -217621,21 +217615,21 @@ func initNative() { GoMembers{ }) - GoTypesVec[2659] = &info_ClientTrace + GoTypesVec[2657] = &info_ClientTrace GoTypesVec[637] = &info_PtrTo_ClientTrace - GoTypesVec[1748] = &info_ArrayOf_ClientTrace - GoTypesVec[2660] = &info_DNSDoneInfo + GoTypesVec[1747] = &info_ArrayOf_ClientTrace + GoTypesVec[2658] = &info_DNSDoneInfo GoTypesVec[638] = &info_PtrTo_DNSDoneInfo - GoTypesVec[1749] = &info_ArrayOf_DNSDoneInfo - GoTypesVec[2661] = &info_DNSStartInfo + GoTypesVec[1748] = &info_ArrayOf_DNSDoneInfo + GoTypesVec[2659] = &info_DNSStartInfo GoTypesVec[639] = &info_PtrTo_DNSStartInfo - GoTypesVec[1750] = &info_ArrayOf_DNSStartInfo - GoTypesVec[2662] = &info_GotConnInfo + GoTypesVec[1749] = &info_ArrayOf_DNSStartInfo + GoTypesVec[2660] = &info_GotConnInfo GoTypesVec[640] = &info_PtrTo_GotConnInfo - GoTypesVec[1751] = &info_ArrayOf_GotConnInfo - GoTypesVec[2663] = &info_WroteRequestInfo + GoTypesVec[1750] = &info_ArrayOf_GotConnInfo + GoTypesVec[2661] = &info_WroteRequestInfo GoTypesVec[641] = &info_PtrTo_WroteRequestInfo - GoTypesVec[1752] = &info_ArrayOf_WroteRequestInfo + GoTypesVec[1751] = &info_ArrayOf_WroteRequestInfo EnsureLoaded("go.std.context") // E.g. from: C:\Program Files\Go\src\net\http\httptrace\trace.go:10:2 EnsureLoaded("go.std.crypto.tls") // E.g. from: C:\Program Files\Go\src\net\http\httptrace\trace.go:11:2 EnsureLoaded("go.std.net") // E.g. from: C:\Program Files\Go\src\net\http\httptrace\trace.go:13:2 @@ -218735,17 +218729,17 @@ func initNative() { GoMembers{ }) - GoTypesVec[3013] = &info_BufferPool - GoTypesVec[1753] = &info_ArrayOf_BufferPool - GoTypesVec[2664] = &info_ClientConn + GoTypesVec[3010] = &info_BufferPool + GoTypesVec[1752] = &info_ArrayOf_BufferPool + GoTypesVec[2662] = &info_ClientConn GoTypesVec[642] = &info_PtrTo_ClientConn - GoTypesVec[1754] = &info_ArrayOf_ClientConn - GoTypesVec[2665] = &info_ReverseProxy + GoTypesVec[1753] = &info_ArrayOf_ClientConn + GoTypesVec[2663] = &info_ReverseProxy GoTypesVec[643] = &info_PtrTo_ReverseProxy - GoTypesVec[1755] = &info_ArrayOf_ReverseProxy - GoTypesVec[2666] = &info_ServerConn + GoTypesVec[1754] = &info_ArrayOf_ReverseProxy + GoTypesVec[2664] = &info_ServerConn GoTypesVec[644] = &info_PtrTo_ServerConn - GoTypesVec[1756] = &info_ArrayOf_ServerConn + GoTypesVec[1755] = &info_ArrayOf_ServerConn EnsureLoaded("go.std.bufio") // E.g. from: C:\Program Files\Go\src\net\http\httputil\dump.go:8:2 EnsureLoaded("go.std.bytes") // E.g. from: C:\Program Files\Go\src\net\http\httputil\dump.go:9:2 EnsureLoaded("go.std.context") // E.g. from: C:\Program Files\Go\src\net\http\httputil\reverseproxy.go:10:2 @@ -219947,18 +219941,18 @@ func initNative() { GoMembers{ }) - GoTypesVec[2667] = &info_Address + GoTypesVec[2665] = &info_Address GoTypesVec[645] = &info_PtrTo_Address - GoTypesVec[2668] = &info_AddressParser + GoTypesVec[2666] = &info_AddressParser GoTypesVec[646] = &info_PtrTo_AddressParser - GoTypesVec[1758] = &info_ArrayOf_AddressParser - GoTypesVec[1757] = &info_ArrayOf_Address - GoTypesVec[2669] = &info_Header + GoTypesVec[1757] = &info_ArrayOf_AddressParser + GoTypesVec[1756] = &info_ArrayOf_Address + GoTypesVec[2667] = &info_Header GoTypesVec[647] = &info_PtrTo_Header - GoTypesVec[1759] = &info_ArrayOf_Header - GoTypesVec[2670] = &info_Message + GoTypesVec[1758] = &info_ArrayOf_Header + GoTypesVec[2668] = &info_Message GoTypesVec[648] = &info_PtrTo_Message - GoTypesVec[1760] = &info_ArrayOf_Message + GoTypesVec[1759] = &info_ArrayOf_Message EnsureLoaded("go.std.bufio") // E.g. from: C:\Program Files\Go\src\net\mail\message.go:21:2 EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\net\mail\message.go:22:2 EnsureLoaded("go.std.fmt") // E.g. from: C:\Program Files\Go\src\net\mail\message.go:23:2 @@ -228943,106 +228937,106 @@ func initNative() { GoMembers{ }) - GoTypesVec[3010] = &info_Addr - GoTypesVec[2609] = &info_AddrError + GoTypesVec[3007] = &info_Addr + GoTypesVec[2607] = &info_AddrError GoTypesVec[587] = &info_PtrTo_AddrError - GoTypesVec[1683] = &info_ArrayOf_AddrError - GoTypesVec[1682] = &info_ArrayOf_Addr - GoTypesVec[2610] = &info_Buffers + GoTypesVec[1682] = &info_ArrayOf_AddrError + GoTypesVec[1681] = &info_ArrayOf_Addr + GoTypesVec[2608] = &info_Buffers GoTypesVec[588] = &info_PtrTo_Buffers - GoTypesVec[1684] = &info_ArrayOf_Buffers - GoTypesVec[2927] = &info_Conn - GoTypesVec[1685] = &info_ArrayOf_Conn - GoTypesVec[2611] = &info_DNSConfigError + GoTypesVec[1683] = &info_ArrayOf_Buffers + GoTypesVec[2924] = &info_Conn + GoTypesVec[1684] = &info_ArrayOf_Conn + GoTypesVec[2609] = &info_DNSConfigError GoTypesVec[589] = &info_PtrTo_DNSConfigError - GoTypesVec[1686] = &info_ArrayOf_DNSConfigError - GoTypesVec[2612] = &info_DNSError + GoTypesVec[1685] = &info_ArrayOf_DNSConfigError + GoTypesVec[2610] = &info_DNSError GoTypesVec[590] = &info_PtrTo_DNSError - GoTypesVec[1687] = &info_ArrayOf_DNSError - GoTypesVec[2613] = &info_Dialer + GoTypesVec[1686] = &info_ArrayOf_DNSError + GoTypesVec[2611] = &info_Dialer GoTypesVec[591] = &info_PtrTo_Dialer - GoTypesVec[1688] = &info_ArrayOf_Dialer - GoTypesVec[2977] = &info_Error - GoTypesVec[1689] = &info_ArrayOf_Error - GoTypesVec[2614] = &info_Flags + GoTypesVec[1687] = &info_ArrayOf_Dialer + GoTypesVec[2974] = &info_Error + GoTypesVec[1688] = &info_ArrayOf_Error + GoTypesVec[2612] = &info_Flags GoTypesVec[592] = &info_PtrTo_Flags - GoTypesVec[1690] = &info_ArrayOf_Flags - GoTypesVec[2615] = &info_HardwareAddr + GoTypesVec[1689] = &info_ArrayOf_Flags + GoTypesVec[2613] = &info_HardwareAddr GoTypesVec[593] = &info_PtrTo_HardwareAddr - GoTypesVec[1691] = &info_ArrayOf_HardwareAddr - GoTypesVec[2616] = &info_IP + GoTypesVec[1690] = &info_ArrayOf_HardwareAddr + GoTypesVec[2614] = &info_IP GoTypesVec[594] = &info_PtrTo_IP - GoTypesVec[2617] = &info_IPAddr + GoTypesVec[2615] = &info_IPAddr GoTypesVec[595] = &info_PtrTo_IPAddr - GoTypesVec[1693] = &info_ArrayOf_IPAddr - GoTypesVec[2618] = &info_IPConn + GoTypesVec[1692] = &info_ArrayOf_IPAddr + GoTypesVec[2616] = &info_IPConn GoTypesVec[596] = &info_PtrTo_IPConn - GoTypesVec[1694] = &info_ArrayOf_IPConn - GoTypesVec[2619] = &info_IPMask + GoTypesVec[1693] = &info_ArrayOf_IPConn + GoTypesVec[2617] = &info_IPMask GoTypesVec[597] = &info_PtrTo_IPMask - GoTypesVec[1695] = &info_ArrayOf_IPMask - GoTypesVec[2620] = &info_IPNet + GoTypesVec[1694] = &info_ArrayOf_IPMask + GoTypesVec[2618] = &info_IPNet GoTypesVec[598] = &info_PtrTo_IPNet - GoTypesVec[1696] = &info_ArrayOf_IPNet - GoTypesVec[1692] = &info_ArrayOf_IP - GoTypesVec[2621] = &info_Interface + GoTypesVec[1695] = &info_ArrayOf_IPNet + GoTypesVec[1691] = &info_ArrayOf_IP + GoTypesVec[2619] = &info_Interface GoTypesVec[599] = &info_PtrTo_Interface - GoTypesVec[1697] = &info_ArrayOf_Interface - GoTypesVec[2622] = &info_InvalidAddrError + GoTypesVec[1696] = &info_ArrayOf_Interface + GoTypesVec[2620] = &info_InvalidAddrError GoTypesVec[600] = &info_PtrTo_InvalidAddrError - GoTypesVec[1698] = &info_ArrayOf_InvalidAddrError - GoTypesVec[2623] = &info_ListenConfig + GoTypesVec[1697] = &info_ArrayOf_InvalidAddrError + GoTypesVec[2621] = &info_ListenConfig GoTypesVec[601] = &info_PtrTo_ListenConfig - GoTypesVec[1699] = &info_ArrayOf_ListenConfig - GoTypesVec[2978] = &info_Listener - GoTypesVec[1700] = &info_ArrayOf_Listener - GoTypesVec[2624] = &info_MX + GoTypesVec[1698] = &info_ArrayOf_ListenConfig + GoTypesVec[2975] = &info_Listener + GoTypesVec[1699] = &info_ArrayOf_Listener + GoTypesVec[2622] = &info_MX GoTypesVec[602] = &info_PtrTo_MX - GoTypesVec[1701] = &info_ArrayOf_MX - GoTypesVec[2625] = &info_NS + GoTypesVec[1700] = &info_ArrayOf_MX + GoTypesVec[2623] = &info_NS GoTypesVec[603] = &info_PtrTo_NS - GoTypesVec[1702] = &info_ArrayOf_NS - GoTypesVec[2626] = &info_OpError + GoTypesVec[1701] = &info_ArrayOf_NS + GoTypesVec[2624] = &info_OpError GoTypesVec[604] = &info_PtrTo_OpError - GoTypesVec[1703] = &info_ArrayOf_OpError - GoTypesVec[2929] = &info_PacketConn - GoTypesVec[1704] = &info_ArrayOf_PacketConn - GoTypesVec[2627] = &info_ParseError + GoTypesVec[1702] = &info_ArrayOf_OpError + GoTypesVec[2926] = &info_PacketConn + GoTypesVec[1703] = &info_ArrayOf_PacketConn + GoTypesVec[2625] = &info_ParseError GoTypesVec[605] = &info_PtrTo_ParseError - GoTypesVec[1705] = &info_ArrayOf_ParseError - GoTypesVec[2628] = &info_Resolver + GoTypesVec[1704] = &info_ArrayOf_ParseError + GoTypesVec[2626] = &info_Resolver GoTypesVec[606] = &info_PtrTo_Resolver - GoTypesVec[1706] = &info_ArrayOf_Resolver - GoTypesVec[2629] = &info_SRV + GoTypesVec[1705] = &info_ArrayOf_Resolver + GoTypesVec[2627] = &info_SRV GoTypesVec[607] = &info_PtrTo_SRV - GoTypesVec[1707] = &info_ArrayOf_SRV - GoTypesVec[2630] = &info_TCPAddr + GoTypesVec[1706] = &info_ArrayOf_SRV + GoTypesVec[2628] = &info_TCPAddr GoTypesVec[608] = &info_PtrTo_TCPAddr - GoTypesVec[1708] = &info_ArrayOf_TCPAddr - GoTypesVec[2631] = &info_TCPConn + GoTypesVec[1707] = &info_ArrayOf_TCPAddr + GoTypesVec[2629] = &info_TCPConn GoTypesVec[609] = &info_PtrTo_TCPConn - GoTypesVec[1709] = &info_ArrayOf_TCPConn - GoTypesVec[2632] = &info_TCPListener + GoTypesVec[1708] = &info_ArrayOf_TCPConn + GoTypesVec[2630] = &info_TCPListener GoTypesVec[610] = &info_PtrTo_TCPListener - GoTypesVec[1710] = &info_ArrayOf_TCPListener - GoTypesVec[2633] = &info_UDPAddr + GoTypesVec[1709] = &info_ArrayOf_TCPListener + GoTypesVec[2631] = &info_UDPAddr GoTypesVec[611] = &info_PtrTo_UDPAddr - GoTypesVec[1711] = &info_ArrayOf_UDPAddr - GoTypesVec[2634] = &info_UDPConn + GoTypesVec[1710] = &info_ArrayOf_UDPAddr + GoTypesVec[2632] = &info_UDPConn GoTypesVec[612] = &info_PtrTo_UDPConn - GoTypesVec[1712] = &info_ArrayOf_UDPConn - GoTypesVec[2635] = &info_UnixAddr + GoTypesVec[1711] = &info_ArrayOf_UDPConn + GoTypesVec[2633] = &info_UnixAddr GoTypesVec[613] = &info_PtrTo_UnixAddr - GoTypesVec[1713] = &info_ArrayOf_UnixAddr - GoTypesVec[2636] = &info_UnixConn + GoTypesVec[1712] = &info_ArrayOf_UnixAddr + GoTypesVec[2634] = &info_UnixConn GoTypesVec[614] = &info_PtrTo_UnixConn - GoTypesVec[1714] = &info_ArrayOf_UnixConn - GoTypesVec[2637] = &info_UnixListener + GoTypesVec[1713] = &info_ArrayOf_UnixConn + GoTypesVec[2635] = &info_UnixListener GoTypesVec[615] = &info_PtrTo_UnixListener - GoTypesVec[1715] = &info_ArrayOf_UnixListener - GoTypesVec[2638] = &info_UnknownNetworkError + GoTypesVec[1714] = &info_ArrayOf_UnixListener + GoTypesVec[2636] = &info_UnknownNetworkError GoTypesVec[616] = &info_PtrTo_UnknownNetworkError - GoTypesVec[1716] = &info_ArrayOf_UnknownNetworkError + GoTypesVec[1715] = &info_ArrayOf_UnknownNetworkError EnsureLoaded("go.std.context") // E.g. from: C:\Program Files\Go\src\net\dial.go:8:2 EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\net\dnsclient_unix.go:19:2 EnsureLoaded("go.std.golang.org.x.net.dns.dnsmessage") // E.g. from: C:\Program Files\Go\src\net\dnsclient.go:12:2 @@ -230355,15 +230349,15 @@ func initNative() { GoMembers{ }) - GoTypesVec[2671] = &info_Addr + GoTypesVec[2669] = &info_Addr GoTypesVec[649] = &info_PtrTo_Addr - GoTypesVec[2672] = &info_AddrPort + GoTypesVec[2670] = &info_AddrPort GoTypesVec[650] = &info_PtrTo_AddrPort - GoTypesVec[1762] = &info_ArrayOf_AddrPort - GoTypesVec[1761] = &info_ArrayOf_Addr - GoTypesVec[2673] = &info_Prefix + GoTypesVec[1761] = &info_ArrayOf_AddrPort + GoTypesVec[1760] = &info_ArrayOf_Addr + GoTypesVec[2671] = &info_Prefix GoTypesVec[651] = &info_PtrTo_Prefix - GoTypesVec[1763] = &info_ArrayOf_Prefix + GoTypesVec[1762] = &info_ArrayOf_Prefix EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\net\netip\netip.go:16:2 EnsureLoaded("go.std.math") // E.g. from: C:\Program Files\Go\src\net\netip\netip.go:17:2 EnsureLoaded("go.std.math.bits") // E.g. from: C:\Program Files\Go\src\net\netip\uint128.go:7:8 @@ -232475,28 +232469,28 @@ func initNative() { GoMembers{ }) - GoTypesVec[2674] = &info_Call + GoTypesVec[2672] = &info_Call GoTypesVec[652] = &info_PtrTo_Call - GoTypesVec[1764] = &info_ArrayOf_Call - GoTypesVec[2675] = &info_Client + GoTypesVec[1763] = &info_ArrayOf_Call + GoTypesVec[2673] = &info_Client GoTypesVec[653] = &info_PtrTo_Client - GoTypesVec[2958] = &info_ClientCodec - GoTypesVec[1766] = &info_ArrayOf_ClientCodec - GoTypesVec[1765] = &info_ArrayOf_Client - GoTypesVec[2676] = &info_Request + GoTypesVec[2955] = &info_ClientCodec + GoTypesVec[1765] = &info_ArrayOf_ClientCodec + GoTypesVec[1764] = &info_ArrayOf_Client + GoTypesVec[2674] = &info_Request GoTypesVec[654] = &info_PtrTo_Request - GoTypesVec[1767] = &info_ArrayOf_Request - GoTypesVec[2677] = &info_Response + GoTypesVec[1766] = &info_ArrayOf_Request + GoTypesVec[2675] = &info_Response GoTypesVec[655] = &info_PtrTo_Response - GoTypesVec[1768] = &info_ArrayOf_Response - GoTypesVec[2678] = &info_Server + GoTypesVec[1767] = &info_ArrayOf_Response + GoTypesVec[2676] = &info_Server GoTypesVec[656] = &info_PtrTo_Server - GoTypesVec[2959] = &info_ServerCodec - GoTypesVec[1770] = &info_ArrayOf_ServerCodec - GoTypesVec[2679] = &info_ServerError + GoTypesVec[2956] = &info_ServerCodec + GoTypesVec[1769] = &info_ArrayOf_ServerCodec + GoTypesVec[2677] = &info_ServerError GoTypesVec[657] = &info_PtrTo_ServerError - GoTypesVec[1771] = &info_ArrayOf_ServerError - GoTypesVec[1769] = &info_ArrayOf_Server + GoTypesVec[1770] = &info_ArrayOf_ServerError + GoTypesVec[1768] = &info_ArrayOf_Server EnsureLoaded("go.std.bufio") // E.g. from: C:\Program Files\Go\src\net\rpc\client.go:8:2 EnsureLoaded("go.std.encoding.gob") // E.g. from: C:\Program Files\Go\src\net\rpc\client.go:9:2 EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\net\rpc\client.go:10:2 @@ -233313,14 +233307,14 @@ func initNative() { GoMembers{ }) - GoTypesVec[3014] = &info_Auth - GoTypesVec[1772] = &info_ArrayOf_Auth - GoTypesVec[2680] = &info_Client + GoTypesVec[3011] = &info_Auth + GoTypesVec[1771] = &info_ArrayOf_Auth + GoTypesVec[2678] = &info_Client GoTypesVec[658] = &info_PtrTo_Client - GoTypesVec[1773] = &info_ArrayOf_Client - GoTypesVec[2681] = &info_ServerInfo + GoTypesVec[1772] = &info_ArrayOf_Client + GoTypesVec[2679] = &info_ServerInfo GoTypesVec[659] = &info_PtrTo_ServerInfo - GoTypesVec[1774] = &info_ArrayOf_ServerInfo + GoTypesVec[1773] = &info_ArrayOf_ServerInfo EnsureLoaded("go.std.crypto.hmac") // E.g. from: C:\Program Files\Go\src\net\smtp\auth.go:8:2 EnsureLoaded("go.std.crypto.md5") // E.g. from: C:\Program Files\Go\src\net\smtp\auth.go:9:2 EnsureLoaded("go.std.crypto.tls") // E.g. from: C:\Program Files\Go\src\net\smtp\smtp.go:21:2 @@ -235377,27 +235371,27 @@ func initNative() { GoMembers{ }) - GoTypesVec[2682] = &info_Conn + GoTypesVec[2680] = &info_Conn GoTypesVec[660] = &info_PtrTo_Conn - GoTypesVec[1775] = &info_ArrayOf_Conn - GoTypesVec[2683] = &info_Error + GoTypesVec[1774] = &info_ArrayOf_Conn + GoTypesVec[2681] = &info_Error GoTypesVec[661] = &info_PtrTo_Error - GoTypesVec[1776] = &info_ArrayOf_Error - GoTypesVec[2684] = &info_MIMEHeader + GoTypesVec[1775] = &info_ArrayOf_Error + GoTypesVec[2682] = &info_MIMEHeader GoTypesVec[662] = &info_PtrTo_MIMEHeader - GoTypesVec[1777] = &info_ArrayOf_MIMEHeader - GoTypesVec[2685] = &info_Pipeline + GoTypesVec[1776] = &info_ArrayOf_MIMEHeader + GoTypesVec[2683] = &info_Pipeline GoTypesVec[663] = &info_PtrTo_Pipeline - GoTypesVec[1778] = &info_ArrayOf_Pipeline - GoTypesVec[2686] = &info_ProtocolError + GoTypesVec[1777] = &info_ArrayOf_Pipeline + GoTypesVec[2684] = &info_ProtocolError GoTypesVec[664] = &info_PtrTo_ProtocolError - GoTypesVec[1779] = &info_ArrayOf_ProtocolError - GoTypesVec[2687] = &info_Reader + GoTypesVec[1778] = &info_ArrayOf_ProtocolError + GoTypesVec[2685] = &info_Reader GoTypesVec[665] = &info_PtrTo_Reader - GoTypesVec[1780] = &info_ArrayOf_Reader - GoTypesVec[2688] = &info_Writer + GoTypesVec[1779] = &info_ArrayOf_Reader + GoTypesVec[2686] = &info_Writer GoTypesVec[666] = &info_PtrTo_Writer - GoTypesVec[1781] = &info_ArrayOf_Writer + GoTypesVec[1780] = &info_ArrayOf_Writer EnsureLoaded("go.std.bufio") // E.g. from: C:\Program Files\Go\src\net\textproto\reader.go:8:2 EnsureLoaded("go.std.bytes") // E.g. from: C:\Program Files\Go\src\net\textproto\reader.go:9:2 EnsureLoaded("go.std.fmt") // E.g. from: C:\Program Files\Go\src\net\textproto\reader.go:10:2 @@ -237165,24 +237159,24 @@ func initNative() { GoMembers{ }) - GoTypesVec[2689] = &info_Error + GoTypesVec[2687] = &info_Error GoTypesVec[667] = &info_PtrTo_Error - GoTypesVec[1782] = &info_ArrayOf_Error - GoTypesVec[2690] = &info_EscapeError + GoTypesVec[1781] = &info_ArrayOf_Error + GoTypesVec[2688] = &info_EscapeError GoTypesVec[668] = &info_PtrTo_EscapeError - GoTypesVec[1783] = &info_ArrayOf_EscapeError - GoTypesVec[2691] = &info_InvalidHostError + GoTypesVec[1782] = &info_ArrayOf_EscapeError + GoTypesVec[2689] = &info_InvalidHostError GoTypesVec[669] = &info_PtrTo_InvalidHostError - GoTypesVec[1784] = &info_ArrayOf_InvalidHostError - GoTypesVec[2692] = &info_URL + GoTypesVec[1783] = &info_ArrayOf_InvalidHostError + GoTypesVec[2690] = &info_URL GoTypesVec[670] = &info_PtrTo_URL - GoTypesVec[1785] = &info_ArrayOf_URL - GoTypesVec[2693] = &info_Userinfo + GoTypesVec[1784] = &info_ArrayOf_URL + GoTypesVec[2691] = &info_Userinfo GoTypesVec[671] = &info_PtrTo_Userinfo - GoTypesVec[1786] = &info_ArrayOf_Userinfo - GoTypesVec[2694] = &info_Values + GoTypesVec[1785] = &info_ArrayOf_Userinfo + GoTypesVec[2692] = &info_Values GoTypesVec[672] = &info_PtrTo_Values - GoTypesVec[1787] = &info_ArrayOf_Values + GoTypesVec[1786] = &info_ArrayOf_Values EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\net\url\url.go:14:2 EnsureLoaded("go.std.fmt") // E.g. from: C:\Program Files\Go\src\net\url\url.go:15:2 EnsureLoaded("go.std.path") // E.g. from: C:\Program Files\Go\src\net\url\url.go:16:2 @@ -239034,15 +239028,15 @@ func initNative() { GoMembers{ }) - GoTypesVec[2701] = &info_Cmd + GoTypesVec[2699] = &info_Cmd GoTypesVec[679] = &info_PtrTo_Cmd - GoTypesVec[1795] = &info_ArrayOf_Cmd - GoTypesVec[2702] = &info_Error + GoTypesVec[1794] = &info_ArrayOf_Cmd + GoTypesVec[2700] = &info_Error GoTypesVec[680] = &info_PtrTo_Error - GoTypesVec[1796] = &info_ArrayOf_Error - GoTypesVec[2703] = &info_ExitError + GoTypesVec[1795] = &info_ArrayOf_Error + GoTypesVec[2701] = &info_ExitError GoTypesVec[681] = &info_PtrTo_ExitError - GoTypesVec[1797] = &info_ArrayOf_ExitError + GoTypesVec[1796] = &info_ArrayOf_ExitError EnsureLoaded("go.std.bytes") // E.g. from: C:\Program Files\Go\src\os\exec\exec.go:94:2 EnsureLoaded("go.std.context") // E.g. from: C:\Program Files\Go\src\os\exec\exec.go:95:2 EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\os\exec\exec.go:96:2 @@ -241096,26 +241090,26 @@ func initNative() { GoMembers{ }) - GoTypesVec[2695] = &info_File + GoTypesVec[2693] = &info_File GoTypesVec[673] = &info_PtrTo_File - GoTypesVec[1788] = &info_ArrayOf_File - GoTypesVec[2696] = &info_LinkError + GoTypesVec[1787] = &info_ArrayOf_File + GoTypesVec[2694] = &info_LinkError GoTypesVec[674] = &info_PtrTo_LinkError - GoTypesVec[1789] = &info_ArrayOf_LinkError - GoTypesVec[2697] = &info_ProcAttr + GoTypesVec[1788] = &info_ArrayOf_LinkError + GoTypesVec[2695] = &info_ProcAttr GoTypesVec[675] = &info_PtrTo_ProcAttr - GoTypesVec[1790] = &info_ArrayOf_ProcAttr - GoTypesVec[2698] = &info_Process + GoTypesVec[1789] = &info_ArrayOf_ProcAttr + GoTypesVec[2696] = &info_Process GoTypesVec[676] = &info_PtrTo_Process - GoTypesVec[2699] = &info_ProcessState + GoTypesVec[2697] = &info_ProcessState GoTypesVec[677] = &info_PtrTo_ProcessState - GoTypesVec[1792] = &info_ArrayOf_ProcessState - GoTypesVec[1791] = &info_ArrayOf_Process - GoTypesVec[3015] = &info_Signal - GoTypesVec[1793] = &info_ArrayOf_Signal - GoTypesVec[2700] = &info_SyscallError + GoTypesVec[1791] = &info_ArrayOf_ProcessState + GoTypesVec[1790] = &info_ArrayOf_Process + GoTypesVec[3012] = &info_Signal + GoTypesVec[1792] = &info_ArrayOf_Signal + GoTypesVec[2698] = &info_SyscallError GoTypesVec[678] = &info_PtrTo_SyscallError - GoTypesVec[1794] = &info_ArrayOf_SyscallError + GoTypesVec[1793] = &info_ArrayOf_SyscallError EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\os\exec.go:8:2 EnsureLoaded("go.std.io") // E.g. from: C:\Program Files\Go\src\os\dir_windows.go:8:2 EnsureLoaded("go.std.io.fs") // E.g. from: C:\Program Files\Go\src\os\dir.go:8:2 @@ -242661,24 +242655,24 @@ func initNative() { GoMembers{ }) - GoTypesVec[2704] = &info_Group + GoTypesVec[2702] = &info_Group GoTypesVec[682] = &info_PtrTo_Group - GoTypesVec[1798] = &info_ArrayOf_Group - GoTypesVec[2705] = &info_UnknownGroupError + GoTypesVec[1797] = &info_ArrayOf_Group + GoTypesVec[2703] = &info_UnknownGroupError GoTypesVec[683] = &info_PtrTo_UnknownGroupError - GoTypesVec[1799] = &info_ArrayOf_UnknownGroupError - GoTypesVec[2706] = &info_UnknownGroupIdError + GoTypesVec[1798] = &info_ArrayOf_UnknownGroupError + GoTypesVec[2704] = &info_UnknownGroupIdError GoTypesVec[684] = &info_PtrTo_UnknownGroupIdError - GoTypesVec[1800] = &info_ArrayOf_UnknownGroupIdError - GoTypesVec[2707] = &info_UnknownUserError + GoTypesVec[1799] = &info_ArrayOf_UnknownGroupIdError + GoTypesVec[2705] = &info_UnknownUserError GoTypesVec[685] = &info_PtrTo_UnknownUserError - GoTypesVec[1801] = &info_ArrayOf_UnknownUserError - GoTypesVec[2708] = &info_UnknownUserIdError + GoTypesVec[1800] = &info_ArrayOf_UnknownUserError + GoTypesVec[2706] = &info_UnknownUserIdError GoTypesVec[686] = &info_PtrTo_UnknownUserIdError - GoTypesVec[1802] = &info_ArrayOf_UnknownUserIdError - GoTypesVec[2709] = &info_User + GoTypesVec[1801] = &info_ArrayOf_UnknownUserIdError + GoTypesVec[2707] = &info_User GoTypesVec[687] = &info_PtrTo_User - GoTypesVec[1803] = &info_ArrayOf_User + GoTypesVec[1802] = &info_ArrayOf_User EnsureLoaded("go.std.fmt") // E.g. from: C:\Program Files\Go\src\os\user\lookup_windows.go:8:2 EnsureLoaded("go.std.strconv") // E.g. from: C:\Program Files\Go\src\os\user\user.go:22:2 EnsureLoaded("go.std.sync") // E.g. from: C:\Program Files\Go\src\os\user\lookup.go:7:8 @@ -243168,9 +243162,9 @@ func initNative() { GoMembers{ }) - GoTypesVec[2710] = &info_WalkFunc + GoTypesVec[2708] = &info_WalkFunc GoTypesVec[688] = &info_PtrTo_WalkFunc - GoTypesVec[1804] = &info_ArrayOf_WalkFunc + GoTypesVec[1803] = &info_ArrayOf_WalkFunc EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\path\filepath\match.go:8:2 EnsureLoaded("go.std.io.fs") // E.g. from: C:\Program Files\Go\src\path\filepath\path.go:16:2 EnsureLoaded("go.std.os") // E.g. from: C:\Program Files\Go\src\path\filepath\match.go:9:2 @@ -243622,11 +243616,11 @@ func initNative() { GoMembers{ }) - GoTypesVec[2711] = &info_Plugin + GoTypesVec[2709] = &info_Plugin GoTypesVec[689] = &info_PtrTo_Plugin - GoTypesVec[1805] = &info_ArrayOf_Plugin - GoTypesVec[3096] = &info_Symbol - GoTypesVec[1806] = &info_ArrayOf_Symbol + GoTypesVec[1804] = &info_ArrayOf_Plugin + GoTypesVec[3093] = &info_Symbol + GoTypesVec[1805] = &info_ArrayOf_Symbol EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\plugin\plugin_stubs.go:9:8 } -------- END _tests/gold/go1.19/amd64-windows/joker/std/gostd/go/std/plugin/plugin_native.go. @@ -247875,44 +247869,44 @@ func initNative() { GoMembers{ }) - GoTypesVec[2712] = &info_ChanDir + GoTypesVec[2710] = &info_ChanDir GoTypesVec[690] = &info_PtrTo_ChanDir - GoTypesVec[1807] = &info_ArrayOf_ChanDir - GoTypesVec[2713] = &info_Kind + GoTypesVec[1806] = &info_ArrayOf_ChanDir + GoTypesVec[2711] = &info_Kind GoTypesVec[691] = &info_PtrTo_Kind - GoTypesVec[1808] = &info_ArrayOf_Kind - GoTypesVec[2714] = &info_MapIter + GoTypesVec[1807] = &info_ArrayOf_Kind + GoTypesVec[2712] = &info_MapIter GoTypesVec[692] = &info_PtrTo_MapIter - GoTypesVec[1809] = &info_ArrayOf_MapIter - GoTypesVec[2715] = &info_Method + GoTypesVec[1808] = &info_ArrayOf_MapIter + GoTypesVec[2713] = &info_Method GoTypesVec[693] = &info_PtrTo_Method - GoTypesVec[1810] = &info_ArrayOf_Method - GoTypesVec[2716] = &info_SelectCase + GoTypesVec[1809] = &info_ArrayOf_Method + GoTypesVec[2714] = &info_SelectCase GoTypesVec[694] = &info_PtrTo_SelectCase - GoTypesVec[1811] = &info_ArrayOf_SelectCase - GoTypesVec[2717] = &info_SelectDir + GoTypesVec[1810] = &info_ArrayOf_SelectCase + GoTypesVec[2715] = &info_SelectDir GoTypesVec[695] = &info_PtrTo_SelectDir - GoTypesVec[1812] = &info_ArrayOf_SelectDir - GoTypesVec[2718] = &info_SliceHeader + GoTypesVec[1811] = &info_ArrayOf_SelectDir + GoTypesVec[2716] = &info_SliceHeader GoTypesVec[696] = &info_PtrTo_SliceHeader - GoTypesVec[1813] = &info_ArrayOf_SliceHeader - GoTypesVec[2719] = &info_StringHeader + GoTypesVec[1812] = &info_ArrayOf_SliceHeader + GoTypesVec[2717] = &info_StringHeader GoTypesVec[697] = &info_PtrTo_StringHeader - GoTypesVec[1814] = &info_ArrayOf_StringHeader - GoTypesVec[2720] = &info_StructField + GoTypesVec[1813] = &info_ArrayOf_StringHeader + GoTypesVec[2718] = &info_StructField GoTypesVec[698] = &info_PtrTo_StructField - GoTypesVec[1815] = &info_ArrayOf_StructField - GoTypesVec[2721] = &info_StructTag + GoTypesVec[1814] = &info_ArrayOf_StructField + GoTypesVec[2719] = &info_StructTag GoTypesVec[699] = &info_PtrTo_StructTag - GoTypesVec[1816] = &info_ArrayOf_StructTag - GoTypesVec[2924] = &info_Type - GoTypesVec[1817] = &info_ArrayOf_Type - GoTypesVec[2722] = &info_Value + GoTypesVec[1815] = &info_ArrayOf_StructTag + GoTypesVec[2921] = &info_Type + GoTypesVec[1816] = &info_ArrayOf_Type + GoTypesVec[2720] = &info_Value GoTypesVec[700] = &info_PtrTo_Value - GoTypesVec[2723] = &info_ValueError + GoTypesVec[2721] = &info_ValueError GoTypesVec[701] = &info_PtrTo_ValueError - GoTypesVec[1819] = &info_ArrayOf_ValueError - GoTypesVec[1818] = &info_ArrayOf_Value + GoTypesVec[1818] = &info_ArrayOf_ValueError + GoTypesVec[1817] = &info_ArrayOf_Value EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\reflect\value.go:8:2 EnsureLoaded("go.std.math") // E.g. from: C:\Program Files\Go\src\reflect\value.go:13:2 EnsureLoaded("go.std.runtime") // E.g. from: C:\Program Files\Go\src\reflect\value.go:14:2 @@ -248609,9 +248603,9 @@ func initNative() { GoMembers{ }) - GoTypesVec[2724] = &info_Regexp + GoTypesVec[2722] = &info_Regexp GoTypesVec[702] = &info_PtrTo_Regexp - GoTypesVec[1820] = &info_ArrayOf_Regexp + GoTypesVec[1819] = &info_ArrayOf_Regexp EnsureLoaded("go.std.bytes") // E.g. from: C:\Program Files\Go\src\regexp\regexp.go:73:2 EnsureLoaded("go.std.io") // E.g. from: C:\Program Files\Go\src\regexp\exec.go:8:2 EnsureLoaded("go.std.regexp.syntax") // E.g. from: C:\Program Files\Go\src\regexp\backtrack.go:18:2 @@ -251417,33 +251411,33 @@ func initNative() { GoMembers{ }) - GoTypesVec[2725] = &info_EmptyOp + GoTypesVec[2723] = &info_EmptyOp GoTypesVec[703] = &info_PtrTo_EmptyOp - GoTypesVec[1821] = &info_ArrayOf_EmptyOp - GoTypesVec[2726] = &info_Error + GoTypesVec[1820] = &info_ArrayOf_EmptyOp + GoTypesVec[2724] = &info_Error GoTypesVec[704] = &info_PtrTo_Error - GoTypesVec[2727] = &info_ErrorCode + GoTypesVec[2725] = &info_ErrorCode GoTypesVec[705] = &info_PtrTo_ErrorCode - GoTypesVec[1823] = &info_ArrayOf_ErrorCode - GoTypesVec[1822] = &info_ArrayOf_Error - GoTypesVec[2728] = &info_Flags + GoTypesVec[1822] = &info_ArrayOf_ErrorCode + GoTypesVec[1821] = &info_ArrayOf_Error + GoTypesVec[2726] = &info_Flags GoTypesVec[706] = &info_PtrTo_Flags - GoTypesVec[1824] = &info_ArrayOf_Flags - GoTypesVec[2729] = &info_Inst + GoTypesVec[1823] = &info_ArrayOf_Flags + GoTypesVec[2727] = &info_Inst GoTypesVec[707] = &info_PtrTo_Inst - GoTypesVec[2730] = &info_InstOp + GoTypesVec[2728] = &info_InstOp GoTypesVec[708] = &info_PtrTo_InstOp - GoTypesVec[1826] = &info_ArrayOf_InstOp - GoTypesVec[1825] = &info_ArrayOf_Inst - GoTypesVec[2731] = &info_Op + GoTypesVec[1825] = &info_ArrayOf_InstOp + GoTypesVec[1824] = &info_ArrayOf_Inst + GoTypesVec[2729] = &info_Op GoTypesVec[709] = &info_PtrTo_Op - GoTypesVec[1827] = &info_ArrayOf_Op - GoTypesVec[2732] = &info_Prog + GoTypesVec[1826] = &info_ArrayOf_Op + GoTypesVec[2730] = &info_Prog GoTypesVec[710] = &info_PtrTo_Prog - GoTypesVec[1828] = &info_ArrayOf_Prog - GoTypesVec[2733] = &info_Regexp + GoTypesVec[1827] = &info_ArrayOf_Prog + GoTypesVec[2731] = &info_Regexp GoTypesVec[711] = &info_PtrTo_Regexp - GoTypesVec[1829] = &info_ArrayOf_Regexp + GoTypesVec[1828] = &info_ArrayOf_Regexp EnsureLoaded("go.std.sort") // E.g. from: C:\Program Files\Go\src\regexp\syntax\parse.go:8:2 EnsureLoaded("go.std.strconv") // E.g. from: C:\Program Files\Go\src\regexp\syntax\op_string.go:5:8 EnsureLoaded("go.std.strings") // E.g. from: C:\Program Files\Go\src\regexp\syntax\parse.go:9:2 @@ -252135,9 +252129,9 @@ func initNative() { GoMembers{ }) - GoTypesVec[2742] = &info_Handle + GoTypesVec[2740] = &info_Handle GoTypesVec[720] = &info_PtrTo_Handle - GoTypesVec[1839] = &info_ArrayOf_Handle + GoTypesVec[1838] = &info_ArrayOf_Handle EnsureLoaded("go.std.sync") // E.g. from: C:\Program Files\Go\src\runtime\cgo\handle.go:8:2 EnsureLoaded("go.std.sync.atomic") // E.g. from: C:\Program Files\Go\src\runtime\cgo\handle.go:9:2 EnsureLoaded("go.std.unsafe") // E.g. from: C:\Program Files\Go\src\runtime\cgo\callbacks.go:7:8 @@ -253245,18 +253239,18 @@ func initNative() { GoMembers{ }) - GoTypesVec[2743] = &info_BuildInfo + GoTypesVec[2741] = &info_BuildInfo GoTypesVec[721] = &info_PtrTo_BuildInfo - GoTypesVec[1840] = &info_ArrayOf_BuildInfo - GoTypesVec[2744] = &info_BuildSetting + GoTypesVec[1839] = &info_ArrayOf_BuildInfo + GoTypesVec[2742] = &info_BuildSetting GoTypesVec[722] = &info_PtrTo_BuildSetting - GoTypesVec[1841] = &info_ArrayOf_BuildSetting - GoTypesVec[2745] = &info_GCStats + GoTypesVec[1840] = &info_ArrayOf_BuildSetting + GoTypesVec[2743] = &info_GCStats GoTypesVec[723] = &info_PtrTo_GCStats - GoTypesVec[1842] = &info_ArrayOf_GCStats - GoTypesVec[2746] = &info_Module + GoTypesVec[1841] = &info_ArrayOf_GCStats + GoTypesVec[2744] = &info_Module GoTypesVec[724] = &info_PtrTo_Module - GoTypesVec[1843] = &info_ArrayOf_Module + GoTypesVec[1842] = &info_ArrayOf_Module EnsureLoaded("go.std.fmt") // E.g. from: C:\Program Files\Go\src\runtime\debug\mod.go:8:2 EnsureLoaded("go.std.os") // E.g. from: C:\Program Files\Go\src\runtime\debug\stack.go:10:2 EnsureLoaded("go.std.runtime") // E.g. from: C:\Program Files\Go\src\runtime\debug\garbage.go:8:2 @@ -254467,21 +254461,21 @@ func initNative() { GoMembers{ }) - GoTypesVec[2747] = &info_Description + GoTypesVec[2745] = &info_Description GoTypesVec[725] = &info_PtrTo_Description - GoTypesVec[1844] = &info_ArrayOf_Description - GoTypesVec[2748] = &info_Float64Histogram + GoTypesVec[1843] = &info_ArrayOf_Description + GoTypesVec[2746] = &info_Float64Histogram GoTypesVec[726] = &info_PtrTo_Float64Histogram - GoTypesVec[1845] = &info_ArrayOf_Float64Histogram - GoTypesVec[2749] = &info_Sample + GoTypesVec[1844] = &info_ArrayOf_Float64Histogram + GoTypesVec[2747] = &info_Sample GoTypesVec[727] = &info_PtrTo_Sample - GoTypesVec[1846] = &info_ArrayOf_Sample - GoTypesVec[2750] = &info_Value + GoTypesVec[1845] = &info_ArrayOf_Sample + GoTypesVec[2748] = &info_Value GoTypesVec[728] = &info_PtrTo_Value - GoTypesVec[2751] = &info_ValueKind + GoTypesVec[2749] = &info_ValueKind GoTypesVec[729] = &info_PtrTo_ValueKind - GoTypesVec[1848] = &info_ArrayOf_ValueKind - GoTypesVec[1847] = &info_ArrayOf_Value + GoTypesVec[1847] = &info_ArrayOf_ValueKind + GoTypesVec[1846] = &info_ArrayOf_Value EnsureLoaded("go.std.math") // E.g. from: C:\Program Files\Go\src\runtime\metrics\value.go:8:2 EnsureLoaded("go.std.runtime") // E.g. from: C:\Program Files\Go\src\runtime\metrics\sample.go:8:4 EnsureLoaded("go.std.unsafe") // E.g. from: C:\Program Files\Go\src\runtime\metrics\sample.go:9:2 @@ -255168,12 +255162,12 @@ func initNative() { GoMembers{ }) - GoTypesVec[2752] = &info_LabelSet + GoTypesVec[2750] = &info_LabelSet GoTypesVec[730] = &info_PtrTo_LabelSet - GoTypesVec[1849] = &info_ArrayOf_LabelSet - GoTypesVec[2753] = &info_Profile + GoTypesVec[1848] = &info_ArrayOf_LabelSet + GoTypesVec[2751] = &info_Profile GoTypesVec[731] = &info_PtrTo_Profile - GoTypesVec[1850] = &info_ArrayOf_Profile + GoTypesVec[1849] = &info_ArrayOf_Profile EnsureLoaded("go.std.bufio") // E.g. from: C:\Program Files\Go\src\runtime\pprof\pprof.go:76:2 EnsureLoaded("go.std.bytes") // E.g. from: C:\Program Files\Go\src\runtime\pprof\pprof.go:77:2 EnsureLoaded("go.std.compress.gzip") // E.g. from: C:\Program Files\Go\src\runtime\pprof\proto.go:9:2 @@ -257196,32 +257190,32 @@ func initNative() { GoMembers{ }) - GoTypesVec[2734] = &info_BlockProfileRecord + GoTypesVec[2732] = &info_BlockProfileRecord GoTypesVec[712] = &info_PtrTo_BlockProfileRecord - GoTypesVec[1830] = &info_ArrayOf_BlockProfileRecord - GoTypesVec[3016] = &info_Error - GoTypesVec[1831] = &info_ArrayOf_Error - GoTypesVec[2735] = &info_Frame + GoTypesVec[1829] = &info_ArrayOf_BlockProfileRecord + GoTypesVec[3013] = &info_Error + GoTypesVec[1830] = &info_ArrayOf_Error + GoTypesVec[2733] = &info_Frame GoTypesVec[713] = &info_PtrTo_Frame - GoTypesVec[1832] = &info_ArrayOf_Frame - GoTypesVec[2736] = &info_Frames + GoTypesVec[1831] = &info_ArrayOf_Frame + GoTypesVec[2734] = &info_Frames GoTypesVec[714] = &info_PtrTo_Frames - GoTypesVec[1833] = &info_ArrayOf_Frames - GoTypesVec[2737] = &info_Func + GoTypesVec[1832] = &info_ArrayOf_Frames + GoTypesVec[2735] = &info_Func GoTypesVec[715] = &info_PtrTo_Func - GoTypesVec[1834] = &info_ArrayOf_Func - GoTypesVec[2738] = &info_MemProfileRecord + GoTypesVec[1833] = &info_ArrayOf_Func + GoTypesVec[2736] = &info_MemProfileRecord GoTypesVec[716] = &info_PtrTo_MemProfileRecord - GoTypesVec[1835] = &info_ArrayOf_MemProfileRecord - GoTypesVec[2739] = &info_MemStats + GoTypesVec[1834] = &info_ArrayOf_MemProfileRecord + GoTypesVec[2737] = &info_MemStats GoTypesVec[717] = &info_PtrTo_MemStats - GoTypesVec[1836] = &info_ArrayOf_MemStats - GoTypesVec[2740] = &info_StackRecord + GoTypesVec[1835] = &info_ArrayOf_MemStats + GoTypesVec[2738] = &info_StackRecord GoTypesVec[718] = &info_PtrTo_StackRecord - GoTypesVec[1837] = &info_ArrayOf_StackRecord - GoTypesVec[2741] = &info_TypeAssertionError + GoTypesVec[1836] = &info_ArrayOf_StackRecord + GoTypesVec[2739] = &info_TypeAssertionError GoTypesVec[719] = &info_PtrTo_TypeAssertionError - GoTypesVec[1838] = &info_ArrayOf_TypeAssertionError + GoTypesVec[1837] = &info_ArrayOf_TypeAssertionError EnsureLoaded("go.std.unsafe") // E.g. from: C:\Program Files\Go\src\runtime\alg.go:10:2 } -------- END _tests/gold/go1.19/amd64-windows/joker/std/gostd/go/std/runtime/runtime_native.go. @@ -257777,12 +257771,12 @@ func initNative() { GoMembers{ }) - GoTypesVec[2754] = &info_Region + GoTypesVec[2752] = &info_Region GoTypesVec[732] = &info_PtrTo_Region - GoTypesVec[1851] = &info_ArrayOf_Region - GoTypesVec[2755] = &info_Task + GoTypesVec[1850] = &info_ArrayOf_Region + GoTypesVec[2753] = &info_Task GoTypesVec[733] = &info_PtrTo_Task - GoTypesVec[1852] = &info_ArrayOf_Task + GoTypesVec[1851] = &info_ArrayOf_Task EnsureLoaded("go.std.context") // E.g. from: C:\Program Files\Go\src\runtime\trace\annotation.go:8:2 EnsureLoaded("go.std.fmt") // E.g. from: C:\Program Files\Go\src\runtime\trace\annotation.go:9:2 EnsureLoaded("go.std.io") // E.g. from: C:\Program Files\Go\src\runtime\trace\trace.go:112:2 @@ -258879,17 +258873,17 @@ func initNative() { GoMembers{ }) - GoTypesVec[2756] = &info_Float64Slice + GoTypesVec[2754] = &info_Float64Slice GoTypesVec[734] = &info_PtrTo_Float64Slice - GoTypesVec[1853] = &info_ArrayOf_Float64Slice - GoTypesVec[2757] = &info_IntSlice + GoTypesVec[1852] = &info_ArrayOf_Float64Slice + GoTypesVec[2755] = &info_IntSlice GoTypesVec[735] = &info_PtrTo_IntSlice - GoTypesVec[1854] = &info_ArrayOf_IntSlice - GoTypesVec[2980] = &info_Interface - GoTypesVec[1855] = &info_ArrayOf_Interface - GoTypesVec[2758] = &info_StringSlice + GoTypesVec[1853] = &info_ArrayOf_IntSlice + GoTypesVec[2977] = &info_Interface + GoTypesVec[1854] = &info_ArrayOf_Interface + GoTypesVec[2756] = &info_StringSlice GoTypesVec[736] = &info_PtrTo_StringSlice - GoTypesVec[1856] = &info_ArrayOf_StringSlice + GoTypesVec[1855] = &info_ArrayOf_StringSlice EnsureLoaded("go.std.math.bits") // E.g. from: C:\Program Files\Go\src\sort\slice.go:7:8 } -------- END _tests/gold/go1.19/amd64-windows/joker/std/gostd/go/std/sort/sort_native.go. @@ -259505,9 +259499,9 @@ func initNative() { GoMembers{ }) - GoTypesVec[2759] = &info_NumError + GoTypesVec[2757] = &info_NumError GoTypesVec[737] = &info_PtrTo_NumError - GoTypesVec[1857] = &info_ArrayOf_NumError + GoTypesVec[1856] = &info_ArrayOf_NumError EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\strconv\atoi.go:7:8 EnsureLoaded("go.std.math") // E.g. from: C:\Program Files\Go\src\strconv\atof.go:13:8 EnsureLoaded("go.std.math.bits") // E.g. from: C:\Program Files\Go\src\strconv\eisel_lemire.go:22:2 @@ -260781,15 +260775,15 @@ func initNative() { GoMembers{ }) - GoTypesVec[2760] = &info_Builder + GoTypesVec[2758] = &info_Builder GoTypesVec[738] = &info_PtrTo_Builder - GoTypesVec[1858] = &info_ArrayOf_Builder - GoTypesVec[2761] = &info_Reader + GoTypesVec[1857] = &info_ArrayOf_Builder + GoTypesVec[2759] = &info_Reader GoTypesVec[739] = &info_PtrTo_Reader - GoTypesVec[1859] = &info_ArrayOf_Reader - GoTypesVec[2762] = &info_Replacer + GoTypesVec[1858] = &info_ArrayOf_Reader + GoTypesVec[2760] = &info_Replacer GoTypesVec[740] = &info_PtrTo_Replacer - GoTypesVec[1860] = &info_ArrayOf_Replacer + GoTypesVec[1859] = &info_ArrayOf_Replacer EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\strings\reader.go:8:2 EnsureLoaded("go.std.io") // E.g. from: C:\Program Files\Go\src\strings\reader.go:9:2 EnsureLoaded("go.std.sync") // E.g. from: C:\Program Files\Go\src\strings\replace.go:9:2 @@ -261221,27 +261215,6 @@ func initNative() { :go "&info_ArrayOf_Int64"} arrayOfInt64) -(def - ^{:doc "A Pointer is an atomic pointer of type *T. The zero value is a nil *T.\n" - :added "1.0" - :tag "Type" - :go "&info_Pointer"} - Pointer) - -(def - ^{:doc "A Pointer is an atomic pointer of type *T. The zero value is a nil *T.\n" - :added "1.0" - :tag "Type" - :go "&info_PtrTo_Pointer"} - *Pointer) - -(def - ^{:doc "A Pointer is an atomic pointer of type *T. The zero value is a nil *T.\n" - :added "1.0" - :tag "Type" - :go "&info_ArrayOf_Pointer"} - arrayOfPointer) - (def ^{:doc "An Uint32 is an atomic uint32. The zero value is zero.\n" :added "1.0" @@ -261501,61 +261474,6 @@ func ReceiverArgAs_ns_arrayOfInt64_s(name, rcvr string, args *ArraySeq, n int) [ return vec } -func MaybeIs_ns_arrayOfPointer(o Object) ([]atomic.Pointer, bool) { - switch o := o.(type) { - case GoObject: - switch r := o.O.(type) { - case []atomic.Pointer: - return r, true - } - } - return []atomic.Pointer{}, false -} - -func Extract_ns_arrayOfPointer(args []Object, index int) []atomic.Pointer { - a := args[index] - if res, ok := MaybeIs_ns_arrayOfPointer(a); ok { - return res - } - panic(RT.NewArgTypeError(index, a, "GoObject[[]sync/atomic.Pointer]")) -} - -func Extract_ns_arrayOfPointer_s(args []Object, index int) [][]atomic.Pointer { - vec := make([][]atomic.Pointer, 0) - for i := index; i < len(args); i++ { - vec = append(vec, Extract_ns_arrayOfPointer(args, i)) - } - return vec -} - -func FieldAs_ns_arrayOfPointer(o Map, k string) []atomic.Pointer { - ok, v := o.Get(MakeKeyword(k)) - if !ok || v.Equals(NIL) { - return []atomic.Pointer{} - } - if res, ok := MaybeIs_ns_arrayOfPointer(v); ok { - return res - } - panic(FailObject(v, "GoObject[[]sync/atomic.Pointer]", "")) -} - -func ReceiverArgAs_ns_arrayOfPointer(name, rcvr string, args *ArraySeq, n int) []atomic.Pointer { - a := SeqNth(args, n) - if res, ok := MaybeIs_ns_arrayOfPointer(a); ok { - return res - } - panic(RT.NewReceiverArgTypeError(n, name, rcvr, a, "GoObject[[]sync/atomic.Pointer]")) -} - -func ReceiverArgAs_ns_arrayOfPointer_s(name, rcvr string, args *ArraySeq, n int) [][]atomic.Pointer { - vec := make([][]atomic.Pointer, 0) - count := SeqCount(args) - for i := n; i < count; i++ { - vec = append(vec, ReceiverArgAs_ns_arrayOfPointer(name, rcvr, args, i)) - } - return vec -} - func MaybeIs_ns_arrayOfUint32(o Object) ([]atomic.Uint32, bool) { switch o := o.(type) { case GoObject: @@ -262154,132 +262072,6 @@ func _Wrapped_Ctor_refToInt64(_o Object) Object { return MakeGoObjectIfNeeded(_Ctor_refToInt64(_o)) } -func MaybeIs_ns_Pointer(o Object) (*atomic.Pointer, bool) { - switch o := o.(type) { - case GoObject: - switch r := o.O.(type) { - case *atomic.Pointer: - return r, true - } - } - return nil, false -} - -func Extract_ns_Pointer(args []Object, index int) *atomic.Pointer { - a := args[index] - if res, ok := MaybeIs_ns_Pointer(a); ok { - return res - } - panic(RT.NewArgTypeError(index, a, "GoObject[sync/atomic.Pointer]")) -} - -func Extract_ns_Pointer_s(args []Object, index int) []*atomic.Pointer { - vec := make([]*atomic.Pointer, 0) - for i := index; i < len(args); i++ { - vec = append(vec, Extract_ns_Pointer(args, i)) - } - return vec -} - -func FieldAs_ns_Pointer(o Map, k string) *atomic.Pointer { - ok, v := o.Get(MakeKeyword(k)) - if !ok || v.Equals(NIL) { - return nil - } - if res, ok := MaybeIs_ns_Pointer(v); ok { - return res - } - panic(FailObject(v, "GoObject[sync/atomic.Pointer]", "")) -} - -func ReceiverArgAs_ns_Pointer(name, rcvr string, args *ArraySeq, n int) *atomic.Pointer { - a := SeqNth(args, n) - if res, ok := MaybeIs_ns_Pointer(a); ok { - return res - } - panic(RT.NewReceiverArgTypeError(n, name, rcvr, a, "GoObject[sync/atomic.Pointer]")) -} - -func ReceiverArgAs_ns_Pointer_s(name, rcvr string, args *ArraySeq, n int) []*atomic.Pointer { - vec := make([]*atomic.Pointer, 0) - count := SeqCount(args) - for i := n; i < count; i++ { - vec = append(vec, ReceiverArgAs_ns_Pointer(name, rcvr, args, i)) - } - return vec -} - -func MaybeIs_ns_refToPointer(o Object) (*atomic.Pointer, bool) { - switch o := o.(type) { - case GoObject: - switch r := o.O.(type) { - case *atomic.Pointer: - return r, true - } - } - return nil, false -} - -func Extract_ns_refToPointer(args []Object, index int) *atomic.Pointer { - a := args[index] - if res, ok := MaybeIs_ns_refToPointer(a); ok { - return res - } - panic(RT.NewArgTypeError(index, a, "GoObject[*sync/atomic.Pointer]")) -} - -func Extract_ns_refToPointer_s(args []Object, index int) []*atomic.Pointer { - vec := make([]*atomic.Pointer, 0) - for i := index; i < len(args); i++ { - vec = append(vec, Extract_ns_refToPointer(args, i)) - } - return vec -} - -func FieldAs_ns_refToPointer(o Map, k string) *atomic.Pointer { - ok, v := o.Get(MakeKeyword(k)) - if !ok || v.Equals(NIL) { - return nil - } - if res, ok := MaybeIs_ns_refToPointer(v); ok { - return res - } - panic(FailObject(v, "GoObject[*sync/atomic.Pointer]", "")) -} - -func ReceiverArgAs_ns_refToPointer(name, rcvr string, args *ArraySeq, n int) *atomic.Pointer { - a := SeqNth(args, n) - if res, ok := MaybeIs_ns_refToPointer(a); ok { - return res - } - panic(RT.NewReceiverArgTypeError(n, name, rcvr, a, "GoObject[*sync/atomic.Pointer]")) -} - -func ReceiverArgAs_ns_refToPointer_s(name, rcvr string, args *ArraySeq, n int) []*atomic.Pointer { - vec := make([]*atomic.Pointer, 0) - count := SeqCount(args) - for i := n; i < count; i++ { - vec = append(vec, ReceiverArgAs_ns_refToPointer(name, rcvr, args, i)) - } - return vec -} - -func _mapTo_refToPointer(o Map) *atomic.Pointer { - return &atomic.Pointer{} -} - -func _Ctor_refToPointer(_v Object) *atomic.Pointer { - switch _o := _v.(type) { - case *ArrayMap, *HashMap: - return _mapTo_refToPointer(_o.(Map)) - } - panic(RT.NewArgTypeError(0, _v, "GoObject[*atomic.Pointer] or: Map")) -} - -func _Wrapped_Ctor_refToPointer(_o Object) Object { - return MakeGoObjectIfNeeded(_Ctor_refToPointer(_o)) -} - func MaybeIs_ns_Uint32(o Object) (*atomic.Uint32, bool) { switch o := o.(type) { case GoObject: @@ -263225,9 +263017,6 @@ var info_ArrayOf_Int32 Type var info_Int64 Type var info_PtrTo_Int64 Type var info_ArrayOf_Int64 Type -var info_Pointer Type -var info_PtrTo_Pointer Type -var info_ArrayOf_Pointer Type var info_Uint32 Type var info_PtrTo_Uint32 Type var info_ArrayOf_Uint32 Type @@ -263292,18 +263081,6 @@ func initNative() { GoMembers{ }) - info_Pointer = MakeType("go.std.sync.atomic/Pointer", _Wrapped_Ctor_refToPointer, - GoMembers{ - }) - - info_PtrTo_Pointer = MakeType("go.std.sync.atomic/*Pointer", _Wrapped_Ctor_refToPointer, - GoMembers{ - }) - - info_ArrayOf_Pointer = MakeType("go.std.sync.atomic/arrayOfPointer", nil, - GoMembers{ - }) - info_Uint32 = MakeType("go.std.sync.atomic/Uint32", _Wrapped_Ctor_refToUint32, GoMembers{ }) @@ -263371,30 +263148,27 @@ func initNative() { GoMembers{ }) - GoTypesVec[2770] = &info_Bool + GoTypesVec[2768] = &info_Bool GoTypesVec[748] = &info_PtrTo_Bool - GoTypesVec[1869] = &info_ArrayOf_Bool - GoTypesVec[2771] = &info_Int32 + GoTypesVec[1868] = &info_ArrayOf_Bool + GoTypesVec[2769] = &info_Int32 GoTypesVec[749] = &info_PtrTo_Int32 - GoTypesVec[1870] = &info_ArrayOf_Int32 - GoTypesVec[2772] = &info_Int64 + GoTypesVec[1869] = &info_ArrayOf_Int32 + GoTypesVec[2770] = &info_Int64 GoTypesVec[750] = &info_PtrTo_Int64 - GoTypesVec[1871] = &info_ArrayOf_Int64 - GoTypesVec[2773] = &info_Pointer - GoTypesVec[751] = &info_PtrTo_Pointer - GoTypesVec[1872] = &info_ArrayOf_Pointer - GoTypesVec[2774] = &info_Uint32 - GoTypesVec[752] = &info_PtrTo_Uint32 - GoTypesVec[1873] = &info_ArrayOf_Uint32 - GoTypesVec[2775] = &info_Uint64 - GoTypesVec[753] = &info_PtrTo_Uint64 - GoTypesVec[1874] = &info_ArrayOf_Uint64 - GoTypesVec[2776] = &info_Uintptr - GoTypesVec[754] = &info_PtrTo_Uintptr - GoTypesVec[1875] = &info_ArrayOf_Uintptr - GoTypesVec[2777] = &info_Value - GoTypesVec[755] = &info_PtrTo_Value - GoTypesVec[1876] = &info_ArrayOf_Value + GoTypesVec[1870] = &info_ArrayOf_Int64 + GoTypesVec[2771] = &info_Uint32 + GoTypesVec[751] = &info_PtrTo_Uint32 + GoTypesVec[1871] = &info_ArrayOf_Uint32 + GoTypesVec[2772] = &info_Uint64 + GoTypesVec[752] = &info_PtrTo_Uint64 + GoTypesVec[1872] = &info_ArrayOf_Uint64 + GoTypesVec[2773] = &info_Uintptr + GoTypesVec[753] = &info_PtrTo_Uintptr + GoTypesVec[1873] = &info_ArrayOf_Uintptr + GoTypesVec[2774] = &info_Value + GoTypesVec[754] = &info_PtrTo_Value + GoTypesVec[1874] = &info_ArrayOf_Value EnsureLoaded("go.std.unsafe") // E.g. from: C:\Program Files\Go\src\sync\atomic\doc.go:50:2 } -------- END _tests/gold/go1.19/amd64-windows/joker/std/gostd/go/std/sync/atomic/atomic_native.go. @@ -265145,29 +264919,29 @@ func initNative() { GoMembers{ }) - GoTypesVec[2763] = &info_Cond + GoTypesVec[2761] = &info_Cond GoTypesVec[741] = &info_PtrTo_Cond - GoTypesVec[1861] = &info_ArrayOf_Cond - GoTypesVec[3017] = &info_Locker - GoTypesVec[1862] = &info_ArrayOf_Locker - GoTypesVec[2764] = &info_Map + GoTypesVec[1860] = &info_ArrayOf_Cond + GoTypesVec[3014] = &info_Locker + GoTypesVec[1861] = &info_ArrayOf_Locker + GoTypesVec[2762] = &info_Map GoTypesVec[742] = &info_PtrTo_Map - GoTypesVec[1863] = &info_ArrayOf_Map - GoTypesVec[2765] = &info_Mutex + GoTypesVec[1862] = &info_ArrayOf_Map + GoTypesVec[2763] = &info_Mutex GoTypesVec[743] = &info_PtrTo_Mutex - GoTypesVec[1864] = &info_ArrayOf_Mutex - GoTypesVec[2766] = &info_Once + GoTypesVec[1863] = &info_ArrayOf_Mutex + GoTypesVec[2764] = &info_Once GoTypesVec[744] = &info_PtrTo_Once - GoTypesVec[1865] = &info_ArrayOf_Once - GoTypesVec[2767] = &info_Pool + GoTypesVec[1864] = &info_ArrayOf_Once + GoTypesVec[2765] = &info_Pool GoTypesVec[745] = &info_PtrTo_Pool - GoTypesVec[1866] = &info_ArrayOf_Pool - GoTypesVec[2768] = &info_RWMutex + GoTypesVec[1865] = &info_ArrayOf_Pool + GoTypesVec[2766] = &info_RWMutex GoTypesVec[746] = &info_PtrTo_RWMutex - GoTypesVec[1867] = &info_ArrayOf_RWMutex - GoTypesVec[2769] = &info_WaitGroup + GoTypesVec[1866] = &info_ArrayOf_RWMutex + GoTypesVec[2767] = &info_WaitGroup GoTypesVec[747] = &info_PtrTo_WaitGroup - GoTypesVec[1868] = &info_ArrayOf_WaitGroup + GoTypesVec[1867] = &info_ArrayOf_WaitGroup EnsureLoaded("go.std.runtime") // E.g. from: C:\Program Files\Go\src\sync\pool.go:9:2 EnsureLoaded("go.std.sync.atomic") // E.g. from: C:\Program Files\Go\src\sync\cond.go:8:2 EnsureLoaded("go.std.unsafe") // E.g. from: C:\Program Files\Go\src\sync\cond.go:9:2 @@ -292376,258 +292150,258 @@ func initNative() { GoMembers{ }) - GoTypesVec[2778] = &info_AddrinfoW - GoTypesVec[756] = &info_PtrTo_AddrinfoW - GoTypesVec[1877] = &info_ArrayOf_AddrinfoW - GoTypesVec[2779] = &info_ByHandleFileInformation - GoTypesVec[757] = &info_PtrTo_ByHandleFileInformation - GoTypesVec[1878] = &info_ArrayOf_ByHandleFileInformation - GoTypesVec[2780] = &info_CertChainContext - GoTypesVec[758] = &info_PtrTo_CertChainContext - GoTypesVec[1879] = &info_ArrayOf_CertChainContext - GoTypesVec[2781] = &info_CertChainElement - GoTypesVec[759] = &info_PtrTo_CertChainElement - GoTypesVec[1880] = &info_ArrayOf_CertChainElement - GoTypesVec[2782] = &info_CertChainPara - GoTypesVec[760] = &info_PtrTo_CertChainPara - GoTypesVec[1881] = &info_ArrayOf_CertChainPara - GoTypesVec[2783] = &info_CertChainPolicyPara - GoTypesVec[761] = &info_PtrTo_CertChainPolicyPara - GoTypesVec[1882] = &info_ArrayOf_CertChainPolicyPara - GoTypesVec[2784] = &info_CertChainPolicyStatus - GoTypesVec[762] = &info_PtrTo_CertChainPolicyStatus - GoTypesVec[1883] = &info_ArrayOf_CertChainPolicyStatus - GoTypesVec[2785] = &info_CertContext - GoTypesVec[763] = &info_PtrTo_CertContext - GoTypesVec[1884] = &info_ArrayOf_CertContext - GoTypesVec[2786] = &info_CertEnhKeyUsage - GoTypesVec[764] = &info_PtrTo_CertEnhKeyUsage - GoTypesVec[1885] = &info_ArrayOf_CertEnhKeyUsage - GoTypesVec[2787] = &info_CertInfo - GoTypesVec[765] = &info_PtrTo_CertInfo - GoTypesVec[1886] = &info_ArrayOf_CertInfo - GoTypesVec[2788] = &info_CertRevocationCrlInfo - GoTypesVec[766] = &info_PtrTo_CertRevocationCrlInfo - GoTypesVec[1887] = &info_ArrayOf_CertRevocationCrlInfo - GoTypesVec[2789] = &info_CertRevocationInfo - GoTypesVec[767] = &info_PtrTo_CertRevocationInfo - GoTypesVec[1888] = &info_ArrayOf_CertRevocationInfo - GoTypesVec[2790] = &info_CertSimpleChain - GoTypesVec[768] = &info_PtrTo_CertSimpleChain - GoTypesVec[1889] = &info_ArrayOf_CertSimpleChain - GoTypesVec[2791] = &info_CertTrustListInfo - GoTypesVec[769] = &info_PtrTo_CertTrustListInfo - GoTypesVec[1890] = &info_ArrayOf_CertTrustListInfo - GoTypesVec[2792] = &info_CertTrustStatus - GoTypesVec[770] = &info_PtrTo_CertTrustStatus - GoTypesVec[1891] = &info_ArrayOf_CertTrustStatus - GoTypesVec[2793] = &info_CertUsageMatch - GoTypesVec[771] = &info_PtrTo_CertUsageMatch - GoTypesVec[1892] = &info_ArrayOf_CertUsageMatch - GoTypesVec[3087] = &info_Conn - GoTypesVec[1893] = &info_ArrayOf_Conn - GoTypesVec[2794] = &info_DLL - GoTypesVec[772] = &info_PtrTo_DLL - GoTypesVec[2795] = &info_DLLError - GoTypesVec[773] = &info_PtrTo_DLLError - GoTypesVec[1895] = &info_ArrayOf_DLLError - GoTypesVec[1894] = &info_ArrayOf_DLL - GoTypesVec[2796] = &info_DNSMXData - GoTypesVec[774] = &info_PtrTo_DNSMXData - GoTypesVec[1896] = &info_ArrayOf_DNSMXData - GoTypesVec[2797] = &info_DNSPTRData - GoTypesVec[775] = &info_PtrTo_DNSPTRData - GoTypesVec[1897] = &info_ArrayOf_DNSPTRData - GoTypesVec[2798] = &info_DNSRecord - GoTypesVec[776] = &info_PtrTo_DNSRecord - GoTypesVec[1898] = &info_ArrayOf_DNSRecord - GoTypesVec[2799] = &info_DNSSRVData - GoTypesVec[777] = &info_PtrTo_DNSSRVData - GoTypesVec[1899] = &info_ArrayOf_DNSSRVData - GoTypesVec[2800] = &info_DNSTXTData - GoTypesVec[778] = &info_PtrTo_DNSTXTData - GoTypesVec[1900] = &info_ArrayOf_DNSTXTData - GoTypesVec[2801] = &info_Errno - GoTypesVec[779] = &info_PtrTo_Errno - GoTypesVec[1901] = &info_ArrayOf_Errno - GoTypesVec[2802] = &info_FileNotifyInformation - GoTypesVec[780] = &info_PtrTo_FileNotifyInformation - GoTypesVec[1902] = &info_ArrayOf_FileNotifyInformation - GoTypesVec[2803] = &info_Filetime - GoTypesVec[781] = &info_PtrTo_Filetime - GoTypesVec[1903] = &info_ArrayOf_Filetime - GoTypesVec[2804] = &info_GUID - GoTypesVec[782] = &info_PtrTo_GUID - GoTypesVec[1904] = &info_ArrayOf_GUID - GoTypesVec[2805] = &info_Handle - GoTypesVec[783] = &info_PtrTo_Handle - GoTypesVec[1905] = &info_ArrayOf_Handle - GoTypesVec[2806] = &info_Hostent - GoTypesVec[784] = &info_PtrTo_Hostent - GoTypesVec[1906] = &info_ArrayOf_Hostent - GoTypesVec[2807] = &info_IPMreq - GoTypesVec[785] = &info_PtrTo_IPMreq - GoTypesVec[1907] = &info_ArrayOf_IPMreq - GoTypesVec[2808] = &info_IPv6Mreq - GoTypesVec[786] = &info_PtrTo_IPv6Mreq - GoTypesVec[1908] = &info_ArrayOf_IPv6Mreq - GoTypesVec[2809] = &info_InterfaceInfo - GoTypesVec[787] = &info_PtrTo_InterfaceInfo - GoTypesVec[1909] = &info_ArrayOf_InterfaceInfo - GoTypesVec[2810] = &info_IpAdapterInfo - GoTypesVec[788] = &info_PtrTo_IpAdapterInfo - GoTypesVec[1910] = &info_ArrayOf_IpAdapterInfo - GoTypesVec[2811] = &info_IpAddrString - GoTypesVec[789] = &info_PtrTo_IpAddrString - GoTypesVec[1911] = &info_ArrayOf_IpAddrString - GoTypesVec[2812] = &info_IpAddressString - GoTypesVec[790] = &info_PtrTo_IpAddressString - GoTypesVec[1912] = &info_ArrayOf_IpAddressString - GoTypesVec[2813] = &info_IpMaskString - GoTypesVec[791] = &info_PtrTo_IpMaskString - GoTypesVec[1913] = &info_ArrayOf_IpMaskString - GoTypesVec[2814] = &info_LazyDLL - GoTypesVec[792] = &info_PtrTo_LazyDLL - GoTypesVec[1914] = &info_ArrayOf_LazyDLL - GoTypesVec[2815] = &info_LazyProc - GoTypesVec[793] = &info_PtrTo_LazyProc - GoTypesVec[1915] = &info_ArrayOf_LazyProc - GoTypesVec[2816] = &info_Linger - GoTypesVec[794] = &info_PtrTo_Linger - GoTypesVec[1916] = &info_ArrayOf_Linger - GoTypesVec[2817] = &info_MibIfRow - GoTypesVec[795] = &info_PtrTo_MibIfRow - GoTypesVec[1917] = &info_ArrayOf_MibIfRow - GoTypesVec[2818] = &info_Overlapped - GoTypesVec[796] = &info_PtrTo_Overlapped - GoTypesVec[1918] = &info_ArrayOf_Overlapped - GoTypesVec[2819] = &info_Pointer - GoTypesVec[797] = &info_PtrTo_Pointer - GoTypesVec[1919] = &info_ArrayOf_Pointer - GoTypesVec[2820] = &info_Proc - GoTypesVec[798] = &info_PtrTo_Proc - GoTypesVec[2821] = &info_ProcAttr - GoTypesVec[799] = &info_PtrTo_ProcAttr - GoTypesVec[1921] = &info_ArrayOf_ProcAttr - GoTypesVec[1920] = &info_ArrayOf_Proc - GoTypesVec[2822] = &info_ProcessEntry32 - GoTypesVec[800] = &info_PtrTo_ProcessEntry32 - GoTypesVec[1922] = &info_ArrayOf_ProcessEntry32 - GoTypesVec[2823] = &info_ProcessInformation - GoTypesVec[801] = &info_PtrTo_ProcessInformation - GoTypesVec[1923] = &info_ArrayOf_ProcessInformation - GoTypesVec[2824] = &info_Protoent - GoTypesVec[802] = &info_PtrTo_Protoent - GoTypesVec[1924] = &info_ArrayOf_Protoent - GoTypesVec[2981] = &info_RawConn - GoTypesVec[1925] = &info_ArrayOf_RawConn - GoTypesVec[2825] = &info_RawSockaddr - GoTypesVec[803] = &info_PtrTo_RawSockaddr - GoTypesVec[2826] = &info_RawSockaddrAny - GoTypesVec[804] = &info_PtrTo_RawSockaddrAny - GoTypesVec[1927] = &info_ArrayOf_RawSockaddrAny - GoTypesVec[2827] = &info_RawSockaddrInet4 - GoTypesVec[805] = &info_PtrTo_RawSockaddrInet4 - GoTypesVec[1928] = &info_ArrayOf_RawSockaddrInet4 - GoTypesVec[2828] = &info_RawSockaddrInet6 - GoTypesVec[806] = &info_PtrTo_RawSockaddrInet6 - GoTypesVec[1929] = &info_ArrayOf_RawSockaddrInet6 - GoTypesVec[2829] = &info_RawSockaddrUnix - GoTypesVec[807] = &info_PtrTo_RawSockaddrUnix - GoTypesVec[1930] = &info_ArrayOf_RawSockaddrUnix - GoTypesVec[1926] = &info_ArrayOf_RawSockaddr - GoTypesVec[2830] = &info_Rusage - GoTypesVec[808] = &info_PtrTo_Rusage - GoTypesVec[1931] = &info_ArrayOf_Rusage - GoTypesVec[2831] = &info_SID - GoTypesVec[809] = &info_PtrTo_SID - GoTypesVec[2832] = &info_SIDAndAttributes - GoTypesVec[810] = &info_PtrTo_SIDAndAttributes - GoTypesVec[1933] = &info_ArrayOf_SIDAndAttributes - GoTypesVec[1932] = &info_ArrayOf_SID - GoTypesVec[2833] = &info_SSLExtraCertChainPolicyPara - GoTypesVec[811] = &info_PtrTo_SSLExtraCertChainPolicyPara - GoTypesVec[1934] = &info_ArrayOf_SSLExtraCertChainPolicyPara - GoTypesVec[2834] = &info_SecurityAttributes - GoTypesVec[812] = &info_PtrTo_SecurityAttributes - GoTypesVec[1935] = &info_ArrayOf_SecurityAttributes - GoTypesVec[2835] = &info_Servent - GoTypesVec[813] = &info_PtrTo_Servent - GoTypesVec[1936] = &info_ArrayOf_Servent - GoTypesVec[2836] = &info_Signal - GoTypesVec[814] = &info_PtrTo_Signal - GoTypesVec[1937] = &info_ArrayOf_Signal - GoTypesVec[3088] = &info_Sockaddr - GoTypesVec[2837] = &info_SockaddrGen - GoTypesVec[815] = &info_PtrTo_SockaddrGen - GoTypesVec[1939] = &info_ArrayOf_SockaddrGen - GoTypesVec[2838] = &info_SockaddrInet4 - GoTypesVec[816] = &info_PtrTo_SockaddrInet4 - GoTypesVec[1940] = &info_ArrayOf_SockaddrInet4 - GoTypesVec[2839] = &info_SockaddrInet6 - GoTypesVec[817] = &info_PtrTo_SockaddrInet6 - GoTypesVec[1941] = &info_ArrayOf_SockaddrInet6 - GoTypesVec[2840] = &info_SockaddrUnix - GoTypesVec[818] = &info_PtrTo_SockaddrUnix - GoTypesVec[1942] = &info_ArrayOf_SockaddrUnix - GoTypesVec[1938] = &info_ArrayOf_Sockaddr - GoTypesVec[2841] = &info_StartupInfo - GoTypesVec[819] = &info_PtrTo_StartupInfo - GoTypesVec[1943] = &info_ArrayOf_StartupInfo - GoTypesVec[2842] = &info_SysProcAttr - GoTypesVec[820] = &info_PtrTo_SysProcAttr - GoTypesVec[1944] = &info_ArrayOf_SysProcAttr - GoTypesVec[2843] = &info_Systemtime - GoTypesVec[821] = &info_PtrTo_Systemtime - GoTypesVec[1945] = &info_ArrayOf_Systemtime - GoTypesVec[2844] = &info_TCPKeepalive - GoTypesVec[822] = &info_PtrTo_TCPKeepalive - GoTypesVec[1946] = &info_ArrayOf_TCPKeepalive - GoTypesVec[2845] = &info_Timespec - GoTypesVec[823] = &info_PtrTo_Timespec - GoTypesVec[1947] = &info_ArrayOf_Timespec - GoTypesVec[2846] = &info_Timeval - GoTypesVec[824] = &info_PtrTo_Timeval - GoTypesVec[1948] = &info_ArrayOf_Timeval - GoTypesVec[2847] = &info_Timezoneinformation - GoTypesVec[825] = &info_PtrTo_Timezoneinformation - GoTypesVec[1949] = &info_ArrayOf_Timezoneinformation - GoTypesVec[2848] = &info_Token - GoTypesVec[826] = &info_PtrTo_Token - GoTypesVec[1950] = &info_ArrayOf_Token - GoTypesVec[2849] = &info_Tokenprimarygroup - GoTypesVec[827] = &info_PtrTo_Tokenprimarygroup - GoTypesVec[1951] = &info_ArrayOf_Tokenprimarygroup - GoTypesVec[2850] = &info_Tokenuser - GoTypesVec[828] = &info_PtrTo_Tokenuser - GoTypesVec[1952] = &info_ArrayOf_Tokenuser - GoTypesVec[2851] = &info_TransmitFileBuffers - GoTypesVec[829] = &info_PtrTo_TransmitFileBuffers - GoTypesVec[1953] = &info_ArrayOf_TransmitFileBuffers - GoTypesVec[2852] = &info_UserInfo10 - GoTypesVec[830] = &info_PtrTo_UserInfo10 - GoTypesVec[1954] = &info_ArrayOf_UserInfo10 - GoTypesVec[2853] = &info_WSABuf - GoTypesVec[831] = &info_PtrTo_WSABuf - GoTypesVec[1955] = &info_ArrayOf_WSABuf - GoTypesVec[2854] = &info_WSAData - GoTypesVec[832] = &info_PtrTo_WSAData - GoTypesVec[1956] = &info_ArrayOf_WSAData - GoTypesVec[2855] = &info_WSAProtocolChain - GoTypesVec[833] = &info_PtrTo_WSAProtocolChain - GoTypesVec[1957] = &info_ArrayOf_WSAProtocolChain - GoTypesVec[2856] = &info_WSAProtocolInfo - GoTypesVec[834] = &info_PtrTo_WSAProtocolInfo - GoTypesVec[1958] = &info_ArrayOf_WSAProtocolInfo - GoTypesVec[2857] = &info_WaitStatus - GoTypesVec[835] = &info_PtrTo_WaitStatus - GoTypesVec[1959] = &info_ArrayOf_WaitStatus - GoTypesVec[2858] = &info_Win32FileAttributeData - GoTypesVec[836] = &info_PtrTo_Win32FileAttributeData - GoTypesVec[1960] = &info_ArrayOf_Win32FileAttributeData - GoTypesVec[2859] = &info_Win32finddata - GoTypesVec[837] = &info_PtrTo_Win32finddata - GoTypesVec[1961] = &info_ArrayOf_Win32finddata + GoTypesVec[2775] = &info_AddrinfoW + GoTypesVec[755] = &info_PtrTo_AddrinfoW + GoTypesVec[1875] = &info_ArrayOf_AddrinfoW + GoTypesVec[2776] = &info_ByHandleFileInformation + GoTypesVec[756] = &info_PtrTo_ByHandleFileInformation + GoTypesVec[1876] = &info_ArrayOf_ByHandleFileInformation + GoTypesVec[2777] = &info_CertChainContext + GoTypesVec[757] = &info_PtrTo_CertChainContext + GoTypesVec[1877] = &info_ArrayOf_CertChainContext + GoTypesVec[2778] = &info_CertChainElement + GoTypesVec[758] = &info_PtrTo_CertChainElement + GoTypesVec[1878] = &info_ArrayOf_CertChainElement + GoTypesVec[2779] = &info_CertChainPara + GoTypesVec[759] = &info_PtrTo_CertChainPara + GoTypesVec[1879] = &info_ArrayOf_CertChainPara + GoTypesVec[2780] = &info_CertChainPolicyPara + GoTypesVec[760] = &info_PtrTo_CertChainPolicyPara + GoTypesVec[1880] = &info_ArrayOf_CertChainPolicyPara + GoTypesVec[2781] = &info_CertChainPolicyStatus + GoTypesVec[761] = &info_PtrTo_CertChainPolicyStatus + GoTypesVec[1881] = &info_ArrayOf_CertChainPolicyStatus + GoTypesVec[2782] = &info_CertContext + GoTypesVec[762] = &info_PtrTo_CertContext + GoTypesVec[1882] = &info_ArrayOf_CertContext + GoTypesVec[2783] = &info_CertEnhKeyUsage + GoTypesVec[763] = &info_PtrTo_CertEnhKeyUsage + GoTypesVec[1883] = &info_ArrayOf_CertEnhKeyUsage + GoTypesVec[2784] = &info_CertInfo + GoTypesVec[764] = &info_PtrTo_CertInfo + GoTypesVec[1884] = &info_ArrayOf_CertInfo + GoTypesVec[2785] = &info_CertRevocationCrlInfo + GoTypesVec[765] = &info_PtrTo_CertRevocationCrlInfo + GoTypesVec[1885] = &info_ArrayOf_CertRevocationCrlInfo + GoTypesVec[2786] = &info_CertRevocationInfo + GoTypesVec[766] = &info_PtrTo_CertRevocationInfo + GoTypesVec[1886] = &info_ArrayOf_CertRevocationInfo + GoTypesVec[2787] = &info_CertSimpleChain + GoTypesVec[767] = &info_PtrTo_CertSimpleChain + GoTypesVec[1887] = &info_ArrayOf_CertSimpleChain + GoTypesVec[2788] = &info_CertTrustListInfo + GoTypesVec[768] = &info_PtrTo_CertTrustListInfo + GoTypesVec[1888] = &info_ArrayOf_CertTrustListInfo + GoTypesVec[2789] = &info_CertTrustStatus + GoTypesVec[769] = &info_PtrTo_CertTrustStatus + GoTypesVec[1889] = &info_ArrayOf_CertTrustStatus + GoTypesVec[2790] = &info_CertUsageMatch + GoTypesVec[770] = &info_PtrTo_CertUsageMatch + GoTypesVec[1890] = &info_ArrayOf_CertUsageMatch + GoTypesVec[3084] = &info_Conn + GoTypesVec[1891] = &info_ArrayOf_Conn + GoTypesVec[2791] = &info_DLL + GoTypesVec[771] = &info_PtrTo_DLL + GoTypesVec[2792] = &info_DLLError + GoTypesVec[772] = &info_PtrTo_DLLError + GoTypesVec[1893] = &info_ArrayOf_DLLError + GoTypesVec[1892] = &info_ArrayOf_DLL + GoTypesVec[2793] = &info_DNSMXData + GoTypesVec[773] = &info_PtrTo_DNSMXData + GoTypesVec[1894] = &info_ArrayOf_DNSMXData + GoTypesVec[2794] = &info_DNSPTRData + GoTypesVec[774] = &info_PtrTo_DNSPTRData + GoTypesVec[1895] = &info_ArrayOf_DNSPTRData + GoTypesVec[2795] = &info_DNSRecord + GoTypesVec[775] = &info_PtrTo_DNSRecord + GoTypesVec[1896] = &info_ArrayOf_DNSRecord + GoTypesVec[2796] = &info_DNSSRVData + GoTypesVec[776] = &info_PtrTo_DNSSRVData + GoTypesVec[1897] = &info_ArrayOf_DNSSRVData + GoTypesVec[2797] = &info_DNSTXTData + GoTypesVec[777] = &info_PtrTo_DNSTXTData + GoTypesVec[1898] = &info_ArrayOf_DNSTXTData + GoTypesVec[2798] = &info_Errno + GoTypesVec[778] = &info_PtrTo_Errno + GoTypesVec[1899] = &info_ArrayOf_Errno + GoTypesVec[2799] = &info_FileNotifyInformation + GoTypesVec[779] = &info_PtrTo_FileNotifyInformation + GoTypesVec[1900] = &info_ArrayOf_FileNotifyInformation + GoTypesVec[2800] = &info_Filetime + GoTypesVec[780] = &info_PtrTo_Filetime + GoTypesVec[1901] = &info_ArrayOf_Filetime + GoTypesVec[2801] = &info_GUID + GoTypesVec[781] = &info_PtrTo_GUID + GoTypesVec[1902] = &info_ArrayOf_GUID + GoTypesVec[2802] = &info_Handle + GoTypesVec[782] = &info_PtrTo_Handle + GoTypesVec[1903] = &info_ArrayOf_Handle + GoTypesVec[2803] = &info_Hostent + GoTypesVec[783] = &info_PtrTo_Hostent + GoTypesVec[1904] = &info_ArrayOf_Hostent + GoTypesVec[2804] = &info_IPMreq + GoTypesVec[784] = &info_PtrTo_IPMreq + GoTypesVec[1905] = &info_ArrayOf_IPMreq + GoTypesVec[2805] = &info_IPv6Mreq + GoTypesVec[785] = &info_PtrTo_IPv6Mreq + GoTypesVec[1906] = &info_ArrayOf_IPv6Mreq + GoTypesVec[2806] = &info_InterfaceInfo + GoTypesVec[786] = &info_PtrTo_InterfaceInfo + GoTypesVec[1907] = &info_ArrayOf_InterfaceInfo + GoTypesVec[2807] = &info_IpAdapterInfo + GoTypesVec[787] = &info_PtrTo_IpAdapterInfo + GoTypesVec[1908] = &info_ArrayOf_IpAdapterInfo + GoTypesVec[2808] = &info_IpAddrString + GoTypesVec[788] = &info_PtrTo_IpAddrString + GoTypesVec[1909] = &info_ArrayOf_IpAddrString + GoTypesVec[2809] = &info_IpAddressString + GoTypesVec[789] = &info_PtrTo_IpAddressString + GoTypesVec[1910] = &info_ArrayOf_IpAddressString + GoTypesVec[2810] = &info_IpMaskString + GoTypesVec[790] = &info_PtrTo_IpMaskString + GoTypesVec[1911] = &info_ArrayOf_IpMaskString + GoTypesVec[2811] = &info_LazyDLL + GoTypesVec[791] = &info_PtrTo_LazyDLL + GoTypesVec[1912] = &info_ArrayOf_LazyDLL + GoTypesVec[2812] = &info_LazyProc + GoTypesVec[792] = &info_PtrTo_LazyProc + GoTypesVec[1913] = &info_ArrayOf_LazyProc + GoTypesVec[2813] = &info_Linger + GoTypesVec[793] = &info_PtrTo_Linger + GoTypesVec[1914] = &info_ArrayOf_Linger + GoTypesVec[2814] = &info_MibIfRow + GoTypesVec[794] = &info_PtrTo_MibIfRow + GoTypesVec[1915] = &info_ArrayOf_MibIfRow + GoTypesVec[2815] = &info_Overlapped + GoTypesVec[795] = &info_PtrTo_Overlapped + GoTypesVec[1916] = &info_ArrayOf_Overlapped + GoTypesVec[2816] = &info_Pointer + GoTypesVec[796] = &info_PtrTo_Pointer + GoTypesVec[1917] = &info_ArrayOf_Pointer + GoTypesVec[2817] = &info_Proc + GoTypesVec[797] = &info_PtrTo_Proc + GoTypesVec[2818] = &info_ProcAttr + GoTypesVec[798] = &info_PtrTo_ProcAttr + GoTypesVec[1919] = &info_ArrayOf_ProcAttr + GoTypesVec[1918] = &info_ArrayOf_Proc + GoTypesVec[2819] = &info_ProcessEntry32 + GoTypesVec[799] = &info_PtrTo_ProcessEntry32 + GoTypesVec[1920] = &info_ArrayOf_ProcessEntry32 + GoTypesVec[2820] = &info_ProcessInformation + GoTypesVec[800] = &info_PtrTo_ProcessInformation + GoTypesVec[1921] = &info_ArrayOf_ProcessInformation + GoTypesVec[2821] = &info_Protoent + GoTypesVec[801] = &info_PtrTo_Protoent + GoTypesVec[1922] = &info_ArrayOf_Protoent + GoTypesVec[2978] = &info_RawConn + GoTypesVec[1923] = &info_ArrayOf_RawConn + GoTypesVec[2822] = &info_RawSockaddr + GoTypesVec[802] = &info_PtrTo_RawSockaddr + GoTypesVec[2823] = &info_RawSockaddrAny + GoTypesVec[803] = &info_PtrTo_RawSockaddrAny + GoTypesVec[1925] = &info_ArrayOf_RawSockaddrAny + GoTypesVec[2824] = &info_RawSockaddrInet4 + GoTypesVec[804] = &info_PtrTo_RawSockaddrInet4 + GoTypesVec[1926] = &info_ArrayOf_RawSockaddrInet4 + GoTypesVec[2825] = &info_RawSockaddrInet6 + GoTypesVec[805] = &info_PtrTo_RawSockaddrInet6 + GoTypesVec[1927] = &info_ArrayOf_RawSockaddrInet6 + GoTypesVec[2826] = &info_RawSockaddrUnix + GoTypesVec[806] = &info_PtrTo_RawSockaddrUnix + GoTypesVec[1928] = &info_ArrayOf_RawSockaddrUnix + GoTypesVec[1924] = &info_ArrayOf_RawSockaddr + GoTypesVec[2827] = &info_Rusage + GoTypesVec[807] = &info_PtrTo_Rusage + GoTypesVec[1929] = &info_ArrayOf_Rusage + GoTypesVec[2828] = &info_SID + GoTypesVec[808] = &info_PtrTo_SID + GoTypesVec[2829] = &info_SIDAndAttributes + GoTypesVec[809] = &info_PtrTo_SIDAndAttributes + GoTypesVec[1931] = &info_ArrayOf_SIDAndAttributes + GoTypesVec[1930] = &info_ArrayOf_SID + GoTypesVec[2830] = &info_SSLExtraCertChainPolicyPara + GoTypesVec[810] = &info_PtrTo_SSLExtraCertChainPolicyPara + GoTypesVec[1932] = &info_ArrayOf_SSLExtraCertChainPolicyPara + GoTypesVec[2831] = &info_SecurityAttributes + GoTypesVec[811] = &info_PtrTo_SecurityAttributes + GoTypesVec[1933] = &info_ArrayOf_SecurityAttributes + GoTypesVec[2832] = &info_Servent + GoTypesVec[812] = &info_PtrTo_Servent + GoTypesVec[1934] = &info_ArrayOf_Servent + GoTypesVec[2833] = &info_Signal + GoTypesVec[813] = &info_PtrTo_Signal + GoTypesVec[1935] = &info_ArrayOf_Signal + GoTypesVec[3085] = &info_Sockaddr + GoTypesVec[2834] = &info_SockaddrGen + GoTypesVec[814] = &info_PtrTo_SockaddrGen + GoTypesVec[1937] = &info_ArrayOf_SockaddrGen + GoTypesVec[2835] = &info_SockaddrInet4 + GoTypesVec[815] = &info_PtrTo_SockaddrInet4 + GoTypesVec[1938] = &info_ArrayOf_SockaddrInet4 + GoTypesVec[2836] = &info_SockaddrInet6 + GoTypesVec[816] = &info_PtrTo_SockaddrInet6 + GoTypesVec[1939] = &info_ArrayOf_SockaddrInet6 + GoTypesVec[2837] = &info_SockaddrUnix + GoTypesVec[817] = &info_PtrTo_SockaddrUnix + GoTypesVec[1940] = &info_ArrayOf_SockaddrUnix + GoTypesVec[1936] = &info_ArrayOf_Sockaddr + GoTypesVec[2838] = &info_StartupInfo + GoTypesVec[818] = &info_PtrTo_StartupInfo + GoTypesVec[1941] = &info_ArrayOf_StartupInfo + GoTypesVec[2839] = &info_SysProcAttr + GoTypesVec[819] = &info_PtrTo_SysProcAttr + GoTypesVec[1942] = &info_ArrayOf_SysProcAttr + GoTypesVec[2840] = &info_Systemtime + GoTypesVec[820] = &info_PtrTo_Systemtime + GoTypesVec[1943] = &info_ArrayOf_Systemtime + GoTypesVec[2841] = &info_TCPKeepalive + GoTypesVec[821] = &info_PtrTo_TCPKeepalive + GoTypesVec[1944] = &info_ArrayOf_TCPKeepalive + GoTypesVec[2842] = &info_Timespec + GoTypesVec[822] = &info_PtrTo_Timespec + GoTypesVec[1945] = &info_ArrayOf_Timespec + GoTypesVec[2843] = &info_Timeval + GoTypesVec[823] = &info_PtrTo_Timeval + GoTypesVec[1946] = &info_ArrayOf_Timeval + GoTypesVec[2844] = &info_Timezoneinformation + GoTypesVec[824] = &info_PtrTo_Timezoneinformation + GoTypesVec[1947] = &info_ArrayOf_Timezoneinformation + GoTypesVec[2845] = &info_Token + GoTypesVec[825] = &info_PtrTo_Token + GoTypesVec[1948] = &info_ArrayOf_Token + GoTypesVec[2846] = &info_Tokenprimarygroup + GoTypesVec[826] = &info_PtrTo_Tokenprimarygroup + GoTypesVec[1949] = &info_ArrayOf_Tokenprimarygroup + GoTypesVec[2847] = &info_Tokenuser + GoTypesVec[827] = &info_PtrTo_Tokenuser + GoTypesVec[1950] = &info_ArrayOf_Tokenuser + GoTypesVec[2848] = &info_TransmitFileBuffers + GoTypesVec[828] = &info_PtrTo_TransmitFileBuffers + GoTypesVec[1951] = &info_ArrayOf_TransmitFileBuffers + GoTypesVec[2849] = &info_UserInfo10 + GoTypesVec[829] = &info_PtrTo_UserInfo10 + GoTypesVec[1952] = &info_ArrayOf_UserInfo10 + GoTypesVec[2850] = &info_WSABuf + GoTypesVec[830] = &info_PtrTo_WSABuf + GoTypesVec[1953] = &info_ArrayOf_WSABuf + GoTypesVec[2851] = &info_WSAData + GoTypesVec[831] = &info_PtrTo_WSAData + GoTypesVec[1954] = &info_ArrayOf_WSAData + GoTypesVec[2852] = &info_WSAProtocolChain + GoTypesVec[832] = &info_PtrTo_WSAProtocolChain + GoTypesVec[1955] = &info_ArrayOf_WSAProtocolChain + GoTypesVec[2853] = &info_WSAProtocolInfo + GoTypesVec[833] = &info_PtrTo_WSAProtocolInfo + GoTypesVec[1956] = &info_ArrayOf_WSAProtocolInfo + GoTypesVec[2854] = &info_WaitStatus + GoTypesVec[834] = &info_PtrTo_WaitStatus + GoTypesVec[1957] = &info_ArrayOf_WaitStatus + GoTypesVec[2855] = &info_Win32FileAttributeData + GoTypesVec[835] = &info_PtrTo_Win32FileAttributeData + GoTypesVec[1958] = &info_ArrayOf_Win32FileAttributeData + GoTypesVec[2856] = &info_Win32finddata + GoTypesVec[836] = &info_PtrTo_Win32finddata + GoTypesVec[1959] = &info_ArrayOf_Win32finddata EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\syscall\syscall_windows.go:10:12 EnsureLoaded("go.std.runtime") // E.g. from: C:\Program Files\Go\src\syscall\exec_windows.go:11:2 EnsureLoaded("go.std.sync") // E.g. from: C:\Program Files\Go\src\syscall\dll_windows.go:9:2 @@ -293525,12 +293299,12 @@ func initNative() { GoMembers{ }) - GoTypesVec[2872] = &info_MapFS - GoTypesVec[850] = &info_PtrTo_MapFS - GoTypesVec[1975] = &info_ArrayOf_MapFS - GoTypesVec[2873] = &info_MapFile - GoTypesVec[851] = &info_PtrTo_MapFile - GoTypesVec[1976] = &info_ArrayOf_MapFile + GoTypesVec[2869] = &info_MapFS + GoTypesVec[849] = &info_PtrTo_MapFS + GoTypesVec[1973] = &info_ArrayOf_MapFS + GoTypesVec[2870] = &info_MapFile + GoTypesVec[850] = &info_PtrTo_MapFile + GoTypesVec[1974] = &info_ArrayOf_MapFile EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\testing\fstest\testfs.go:9:2 EnsureLoaded("go.std.fmt") // E.g. from: C:\Program Files\Go\src\testing\fstest\testfs.go:10:2 EnsureLoaded("go.std.io") // E.g. from: C:\Program Files\Go\src\testing\fstest\mapfs.go:8:2 @@ -294768,20 +294542,20 @@ func initNative() { GoMembers{ }) - GoTypesVec[2874] = &info_CheckEqualError - GoTypesVec[852] = &info_PtrTo_CheckEqualError - GoTypesVec[1977] = &info_ArrayOf_CheckEqualError - GoTypesVec[2875] = &info_CheckError - GoTypesVec[853] = &info_PtrTo_CheckError - GoTypesVec[1978] = &info_ArrayOf_CheckError - GoTypesVec[2876] = &info_Config - GoTypesVec[854] = &info_PtrTo_Config - GoTypesVec[1979] = &info_ArrayOf_Config - GoTypesVec[3089] = &info_Generator - GoTypesVec[1980] = &info_ArrayOf_Generator - GoTypesVec[2877] = &info_SetupError - GoTypesVec[855] = &info_PtrTo_SetupError - GoTypesVec[1981] = &info_ArrayOf_SetupError + GoTypesVec[2871] = &info_CheckEqualError + GoTypesVec[851] = &info_PtrTo_CheckEqualError + GoTypesVec[1975] = &info_ArrayOf_CheckEqualError + GoTypesVec[2872] = &info_CheckError + GoTypesVec[852] = &info_PtrTo_CheckError + GoTypesVec[1976] = &info_ArrayOf_CheckError + GoTypesVec[2873] = &info_Config + GoTypesVec[853] = &info_PtrTo_Config + GoTypesVec[1977] = &info_ArrayOf_Config + GoTypesVec[3086] = &info_Generator + GoTypesVec[1978] = &info_ArrayOf_Generator + GoTypesVec[2874] = &info_SetupError + GoTypesVec[854] = &info_PtrTo_SetupError + GoTypesVec[1979] = &info_ArrayOf_SetupError EnsureLoaded("go.std.flag") // E.g. from: C:\Program Files\Go\src\testing\quick\quick.go:11:2 EnsureLoaded("go.std.fmt") // E.g. from: C:\Program Files\Go\src\testing\quick\quick.go:12:2 EnsureLoaded("go.std.math") // E.g. from: C:\Program Files\Go\src\testing\quick\quick.go:13:2 @@ -298163,44 +297937,44 @@ func initNative() { GoMembers{ }) - GoTypesVec[2860] = &info_B - GoTypesVec[838] = &info_PtrTo_B - GoTypesVec[1962] = &info_ArrayOf_B - GoTypesVec[2861] = &info_BenchmarkResult - GoTypesVec[839] = &info_PtrTo_BenchmarkResult - GoTypesVec[1963] = &info_ArrayOf_BenchmarkResult - GoTypesVec[2862] = &info_Cover - GoTypesVec[840] = &info_PtrTo_Cover - GoTypesVec[2863] = &info_CoverBlock - GoTypesVec[841] = &info_PtrTo_CoverBlock - GoTypesVec[1965] = &info_ArrayOf_CoverBlock - GoTypesVec[1964] = &info_ArrayOf_Cover - GoTypesVec[2864] = &info_F - GoTypesVec[842] = &info_PtrTo_F - GoTypesVec[1966] = &info_ArrayOf_F - GoTypesVec[2865] = &info_InternalBenchmark - GoTypesVec[843] = &info_PtrTo_InternalBenchmark - GoTypesVec[1967] = &info_ArrayOf_InternalBenchmark - GoTypesVec[2866] = &info_InternalExample - GoTypesVec[844] = &info_PtrTo_InternalExample - GoTypesVec[1968] = &info_ArrayOf_InternalExample - GoTypesVec[2867] = &info_InternalFuzzTarget - GoTypesVec[845] = &info_PtrTo_InternalFuzzTarget - GoTypesVec[1969] = &info_ArrayOf_InternalFuzzTarget - GoTypesVec[2868] = &info_InternalTest - GoTypesVec[846] = &info_PtrTo_InternalTest - GoTypesVec[1970] = &info_ArrayOf_InternalTest - GoTypesVec[2869] = &info_M - GoTypesVec[847] = &info_PtrTo_M - GoTypesVec[1971] = &info_ArrayOf_M - GoTypesVec[2870] = &info_PB - GoTypesVec[848] = &info_PtrTo_PB - GoTypesVec[1972] = &info_ArrayOf_PB - GoTypesVec[2871] = &info_T - GoTypesVec[849] = &info_PtrTo_T - GoTypesVec[2925] = &info_TB - GoTypesVec[1974] = &info_ArrayOf_TB - GoTypesVec[1973] = &info_ArrayOf_T + GoTypesVec[2857] = &info_B + GoTypesVec[837] = &info_PtrTo_B + GoTypesVec[1960] = &info_ArrayOf_B + GoTypesVec[2858] = &info_BenchmarkResult + GoTypesVec[838] = &info_PtrTo_BenchmarkResult + GoTypesVec[1961] = &info_ArrayOf_BenchmarkResult + GoTypesVec[2859] = &info_Cover + GoTypesVec[839] = &info_PtrTo_Cover + GoTypesVec[2860] = &info_CoverBlock + GoTypesVec[840] = &info_PtrTo_CoverBlock + GoTypesVec[1963] = &info_ArrayOf_CoverBlock + GoTypesVec[1962] = &info_ArrayOf_Cover + GoTypesVec[2861] = &info_F + GoTypesVec[841] = &info_PtrTo_F + GoTypesVec[1964] = &info_ArrayOf_F + GoTypesVec[2862] = &info_InternalBenchmark + GoTypesVec[842] = &info_PtrTo_InternalBenchmark + GoTypesVec[1965] = &info_ArrayOf_InternalBenchmark + GoTypesVec[2863] = &info_InternalExample + GoTypesVec[843] = &info_PtrTo_InternalExample + GoTypesVec[1966] = &info_ArrayOf_InternalExample + GoTypesVec[2864] = &info_InternalFuzzTarget + GoTypesVec[844] = &info_PtrTo_InternalFuzzTarget + GoTypesVec[1967] = &info_ArrayOf_InternalFuzzTarget + GoTypesVec[2865] = &info_InternalTest + GoTypesVec[845] = &info_PtrTo_InternalTest + GoTypesVec[1968] = &info_ArrayOf_InternalTest + GoTypesVec[2866] = &info_M + GoTypesVec[846] = &info_PtrTo_M + GoTypesVec[1969] = &info_ArrayOf_M + GoTypesVec[2867] = &info_PB + GoTypesVec[847] = &info_PtrTo_PB + GoTypesVec[1970] = &info_ArrayOf_PB + GoTypesVec[2868] = &info_T + GoTypesVec[848] = &info_PtrTo_T + GoTypesVec[2922] = &info_TB + GoTypesVec[1972] = &info_ArrayOf_TB + GoTypesVec[1971] = &info_ArrayOf_T EnsureLoaded("go.std.bytes") // E.g. from: C:\Program Files\Go\src\testing\fuzz.go:8:2 EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\testing\fuzz.go:9:2 EnsureLoaded("go.std.flag") // E.g. from: C:\Program Files\Go\src\testing\benchmark.go:8:2 @@ -298930,12 +298704,12 @@ func initNative() { GoMembers{ }) - GoTypesVec[2878] = &info_Position - GoTypesVec[856] = &info_PtrTo_Position - GoTypesVec[1982] = &info_ArrayOf_Position - GoTypesVec[2879] = &info_Scanner - GoTypesVec[857] = &info_PtrTo_Scanner - GoTypesVec[1983] = &info_ArrayOf_Scanner + GoTypesVec[2875] = &info_Position + GoTypesVec[855] = &info_PtrTo_Position + GoTypesVec[1980] = &info_ArrayOf_Position + GoTypesVec[2876] = &info_Scanner + GoTypesVec[856] = &info_PtrTo_Scanner + GoTypesVec[1981] = &info_ArrayOf_Scanner EnsureLoaded("go.std.bytes") // E.g. from: C:\Program Files\Go\src\text\scanner\scanner.go:18:2 EnsureLoaded("go.std.fmt") // E.g. from: C:\Program Files\Go\src\text\scanner\scanner.go:19:2 EnsureLoaded("go.std.io") // E.g. from: C:\Program Files\Go\src\text\scanner\scanner.go:20:2 @@ -299284,9 +299058,9 @@ func initNative() { GoMembers{ }) - GoTypesVec[2880] = &info_Writer - GoTypesVec[858] = &info_PtrTo_Writer - GoTypesVec[1984] = &info_ArrayOf_Writer + GoTypesVec[2877] = &info_Writer + GoTypesVec[857] = &info_PtrTo_Writer + GoTypesVec[1982] = &info_ArrayOf_Writer EnsureLoaded("go.std.io") // E.g. from: C:\Program Files\Go\src\text\tabwriter\tabwriter.go:15:2 EnsureLoaded("go.std.unicode.utf8") // E.g. from: C:\Program Files\Go\src\text\tabwriter\tabwriter.go:16:2 } @@ -306699,86 +306473,86 @@ func initNative() { GoMembers{ }) - GoTypesVec[2884] = &info_ActionNode - GoTypesVec[862] = &info_PtrTo_ActionNode - GoTypesVec[1988] = &info_ArrayOf_ActionNode - GoTypesVec[2885] = &info_BoolNode - GoTypesVec[863] = &info_PtrTo_BoolNode - GoTypesVec[1989] = &info_ArrayOf_BoolNode - GoTypesVec[2886] = &info_BranchNode - GoTypesVec[864] = &info_PtrTo_BranchNode - GoTypesVec[1990] = &info_ArrayOf_BranchNode - GoTypesVec[2887] = &info_BreakNode - GoTypesVec[865] = &info_PtrTo_BreakNode - GoTypesVec[1991] = &info_ArrayOf_BreakNode - GoTypesVec[2888] = &info_ChainNode - GoTypesVec[866] = &info_PtrTo_ChainNode - GoTypesVec[1992] = &info_ArrayOf_ChainNode - GoTypesVec[2889] = &info_CommandNode - GoTypesVec[867] = &info_PtrTo_CommandNode - GoTypesVec[1993] = &info_ArrayOf_CommandNode - GoTypesVec[2890] = &info_CommentNode - GoTypesVec[868] = &info_PtrTo_CommentNode - GoTypesVec[1994] = &info_ArrayOf_CommentNode - GoTypesVec[2891] = &info_ContinueNode - GoTypesVec[869] = &info_PtrTo_ContinueNode - GoTypesVec[1995] = &info_ArrayOf_ContinueNode - GoTypesVec[2892] = &info_DotNode - GoTypesVec[870] = &info_PtrTo_DotNode - GoTypesVec[1996] = &info_ArrayOf_DotNode - GoTypesVec[2893] = &info_FieldNode - GoTypesVec[871] = &info_PtrTo_FieldNode - GoTypesVec[1997] = &info_ArrayOf_FieldNode - GoTypesVec[2894] = &info_IdentifierNode - GoTypesVec[872] = &info_PtrTo_IdentifierNode - GoTypesVec[1998] = &info_ArrayOf_IdentifierNode - GoTypesVec[2895] = &info_IfNode - GoTypesVec[873] = &info_PtrTo_IfNode - GoTypesVec[1999] = &info_ArrayOf_IfNode - GoTypesVec[2896] = &info_ListNode - GoTypesVec[874] = &info_PtrTo_ListNode - GoTypesVec[2000] = &info_ArrayOf_ListNode - GoTypesVec[2897] = &info_Mode - GoTypesVec[875] = &info_PtrTo_Mode - GoTypesVec[2001] = &info_ArrayOf_Mode - GoTypesVec[2898] = &info_NilNode - GoTypesVec[876] = &info_PtrTo_NilNode - GoTypesVec[2002] = &info_ArrayOf_NilNode - GoTypesVec[2936] = &info_Node - GoTypesVec[2899] = &info_NodeType - GoTypesVec[877] = &info_PtrTo_NodeType - GoTypesVec[2004] = &info_ArrayOf_NodeType - GoTypesVec[2003] = &info_ArrayOf_Node - GoTypesVec[2900] = &info_NumberNode - GoTypesVec[878] = &info_PtrTo_NumberNode - GoTypesVec[2005] = &info_ArrayOf_NumberNode - GoTypesVec[2901] = &info_PipeNode - GoTypesVec[879] = &info_PtrTo_PipeNode - GoTypesVec[2006] = &info_ArrayOf_PipeNode - GoTypesVec[2902] = &info_Pos - GoTypesVec[880] = &info_PtrTo_Pos - GoTypesVec[2007] = &info_ArrayOf_Pos - GoTypesVec[2903] = &info_RangeNode - GoTypesVec[881] = &info_PtrTo_RangeNode - GoTypesVec[2008] = &info_ArrayOf_RangeNode - GoTypesVec[2904] = &info_StringNode - GoTypesVec[882] = &info_PtrTo_StringNode - GoTypesVec[2009] = &info_ArrayOf_StringNode - GoTypesVec[2905] = &info_TemplateNode - GoTypesVec[883] = &info_PtrTo_TemplateNode - GoTypesVec[2010] = &info_ArrayOf_TemplateNode - GoTypesVec[2906] = &info_TextNode - GoTypesVec[884] = &info_PtrTo_TextNode - GoTypesVec[2011] = &info_ArrayOf_TextNode - GoTypesVec[2907] = &info_Tree - GoTypesVec[885] = &info_PtrTo_Tree - GoTypesVec[2012] = &info_ArrayOf_Tree - GoTypesVec[2908] = &info_VariableNode - GoTypesVec[886] = &info_PtrTo_VariableNode - GoTypesVec[2013] = &info_ArrayOf_VariableNode - GoTypesVec[2909] = &info_WithNode - GoTypesVec[887] = &info_PtrTo_WithNode - GoTypesVec[2014] = &info_ArrayOf_WithNode + GoTypesVec[2881] = &info_ActionNode + GoTypesVec[861] = &info_PtrTo_ActionNode + GoTypesVec[1986] = &info_ArrayOf_ActionNode + GoTypesVec[2882] = &info_BoolNode + GoTypesVec[862] = &info_PtrTo_BoolNode + GoTypesVec[1987] = &info_ArrayOf_BoolNode + GoTypesVec[2883] = &info_BranchNode + GoTypesVec[863] = &info_PtrTo_BranchNode + GoTypesVec[1988] = &info_ArrayOf_BranchNode + GoTypesVec[2884] = &info_BreakNode + GoTypesVec[864] = &info_PtrTo_BreakNode + GoTypesVec[1989] = &info_ArrayOf_BreakNode + GoTypesVec[2885] = &info_ChainNode + GoTypesVec[865] = &info_PtrTo_ChainNode + GoTypesVec[1990] = &info_ArrayOf_ChainNode + GoTypesVec[2886] = &info_CommandNode + GoTypesVec[866] = &info_PtrTo_CommandNode + GoTypesVec[1991] = &info_ArrayOf_CommandNode + GoTypesVec[2887] = &info_CommentNode + GoTypesVec[867] = &info_PtrTo_CommentNode + GoTypesVec[1992] = &info_ArrayOf_CommentNode + GoTypesVec[2888] = &info_ContinueNode + GoTypesVec[868] = &info_PtrTo_ContinueNode + GoTypesVec[1993] = &info_ArrayOf_ContinueNode + GoTypesVec[2889] = &info_DotNode + GoTypesVec[869] = &info_PtrTo_DotNode + GoTypesVec[1994] = &info_ArrayOf_DotNode + GoTypesVec[2890] = &info_FieldNode + GoTypesVec[870] = &info_PtrTo_FieldNode + GoTypesVec[1995] = &info_ArrayOf_FieldNode + GoTypesVec[2891] = &info_IdentifierNode + GoTypesVec[871] = &info_PtrTo_IdentifierNode + GoTypesVec[1996] = &info_ArrayOf_IdentifierNode + GoTypesVec[2892] = &info_IfNode + GoTypesVec[872] = &info_PtrTo_IfNode + GoTypesVec[1997] = &info_ArrayOf_IfNode + GoTypesVec[2893] = &info_ListNode + GoTypesVec[873] = &info_PtrTo_ListNode + GoTypesVec[1998] = &info_ArrayOf_ListNode + GoTypesVec[2894] = &info_Mode + GoTypesVec[874] = &info_PtrTo_Mode + GoTypesVec[1999] = &info_ArrayOf_Mode + GoTypesVec[2895] = &info_NilNode + GoTypesVec[875] = &info_PtrTo_NilNode + GoTypesVec[2000] = &info_ArrayOf_NilNode + GoTypesVec[2933] = &info_Node + GoTypesVec[2896] = &info_NodeType + GoTypesVec[876] = &info_PtrTo_NodeType + GoTypesVec[2002] = &info_ArrayOf_NodeType + GoTypesVec[2001] = &info_ArrayOf_Node + GoTypesVec[2897] = &info_NumberNode + GoTypesVec[877] = &info_PtrTo_NumberNode + GoTypesVec[2003] = &info_ArrayOf_NumberNode + GoTypesVec[2898] = &info_PipeNode + GoTypesVec[878] = &info_PtrTo_PipeNode + GoTypesVec[2004] = &info_ArrayOf_PipeNode + GoTypesVec[2899] = &info_Pos + GoTypesVec[879] = &info_PtrTo_Pos + GoTypesVec[2005] = &info_ArrayOf_Pos + GoTypesVec[2900] = &info_RangeNode + GoTypesVec[880] = &info_PtrTo_RangeNode + GoTypesVec[2006] = &info_ArrayOf_RangeNode + GoTypesVec[2901] = &info_StringNode + GoTypesVec[881] = &info_PtrTo_StringNode + GoTypesVec[2007] = &info_ArrayOf_StringNode + GoTypesVec[2902] = &info_TemplateNode + GoTypesVec[882] = &info_PtrTo_TemplateNode + GoTypesVec[2008] = &info_ArrayOf_TemplateNode + GoTypesVec[2903] = &info_TextNode + GoTypesVec[883] = &info_PtrTo_TextNode + GoTypesVec[2009] = &info_ArrayOf_TextNode + GoTypesVec[2904] = &info_Tree + GoTypesVec[884] = &info_PtrTo_Tree + GoTypesVec[2010] = &info_ArrayOf_Tree + GoTypesVec[2905] = &info_VariableNode + GoTypesVec[885] = &info_PtrTo_VariableNode + GoTypesVec[2011] = &info_ArrayOf_VariableNode + GoTypesVec[2906] = &info_WithNode + GoTypesVec[886] = &info_PtrTo_WithNode + GoTypesVec[2012] = &info_ArrayOf_WithNode EnsureLoaded("go.std.bytes") // E.g. from: C:\Program Files\Go\src\text\template\parse\parse.go:12:2 EnsureLoaded("go.std.fmt") // E.g. from: C:\Program Files\Go\src\text\template\parse\lex.go:8:2 EnsureLoaded("go.std.runtime") // E.g. from: C:\Program Files\Go\src\text\template\parse\parse.go:14:2 @@ -307718,15 +307492,15 @@ func initNative() { GoMembers{ }) - GoTypesVec[2881] = &info_ExecError - GoTypesVec[859] = &info_PtrTo_ExecError - GoTypesVec[1985] = &info_ArrayOf_ExecError - GoTypesVec[2882] = &info_FuncMap - GoTypesVec[860] = &info_PtrTo_FuncMap - GoTypesVec[1986] = &info_ArrayOf_FuncMap - GoTypesVec[2883] = &info_Template - GoTypesVec[861] = &info_PtrTo_Template - GoTypesVec[1987] = &info_ArrayOf_Template + GoTypesVec[2878] = &info_ExecError + GoTypesVec[858] = &info_PtrTo_ExecError + GoTypesVec[1983] = &info_ArrayOf_ExecError + GoTypesVec[2879] = &info_FuncMap + GoTypesVec[859] = &info_PtrTo_FuncMap + GoTypesVec[1984] = &info_ArrayOf_FuncMap + GoTypesVec[2880] = &info_Template + GoTypesVec[860] = &info_PtrTo_Template + GoTypesVec[1985] = &info_ArrayOf_Template EnsureLoaded("go.std.bytes") // E.g. from: C:\Program Files\Go\src\text\template\funcs.go:8:2 EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\text\template\exec.go:8:2 EnsureLoaded("go.std.fmt") // E.g. from: C:\Program Files\Go\src\text\template\exec.go:9:2 @@ -310676,30 +310450,30 @@ func initNative() { GoMembers{ }) - GoTypesVec[2910] = &info_Duration - GoTypesVec[888] = &info_PtrTo_Duration - GoTypesVec[2015] = &info_ArrayOf_Duration - GoTypesVec[2911] = &info_Location - GoTypesVec[889] = &info_PtrTo_Location - GoTypesVec[2016] = &info_ArrayOf_Location - GoTypesVec[2912] = &info_Month - GoTypesVec[890] = &info_PtrTo_Month - GoTypesVec[2017] = &info_ArrayOf_Month - GoTypesVec[2913] = &info_ParseError - GoTypesVec[891] = &info_PtrTo_ParseError - GoTypesVec[2018] = &info_ArrayOf_ParseError - GoTypesVec[2914] = &info_Ticker - GoTypesVec[892] = &info_PtrTo_Ticker - GoTypesVec[2019] = &info_ArrayOf_Ticker - GoTypesVec[2915] = &info_Time - GoTypesVec[893] = &info_PtrTo_Time - GoTypesVec[2020] = &info_ArrayOf_Time - GoTypesVec[2916] = &info_Timer - GoTypesVec[894] = &info_PtrTo_Timer - GoTypesVec[2021] = &info_ArrayOf_Timer - GoTypesVec[2917] = &info_Weekday - GoTypesVec[895] = &info_PtrTo_Weekday - GoTypesVec[2022] = &info_ArrayOf_Weekday + GoTypesVec[2907] = &info_Duration + GoTypesVec[887] = &info_PtrTo_Duration + GoTypesVec[2013] = &info_ArrayOf_Duration + GoTypesVec[2908] = &info_Location + GoTypesVec[888] = &info_PtrTo_Location + GoTypesVec[2014] = &info_ArrayOf_Location + GoTypesVec[2909] = &info_Month + GoTypesVec[889] = &info_PtrTo_Month + GoTypesVec[2015] = &info_ArrayOf_Month + GoTypesVec[2910] = &info_ParseError + GoTypesVec[890] = &info_PtrTo_ParseError + GoTypesVec[2016] = &info_ArrayOf_ParseError + GoTypesVec[2911] = &info_Ticker + GoTypesVec[891] = &info_PtrTo_Ticker + GoTypesVec[2017] = &info_ArrayOf_Ticker + GoTypesVec[2912] = &info_Time + GoTypesVec[892] = &info_PtrTo_Time + GoTypesVec[2018] = &info_ArrayOf_Time + GoTypesVec[2913] = &info_Timer + GoTypesVec[893] = &info_PtrTo_Timer + GoTypesVec[2019] = &info_ArrayOf_Timer + GoTypesVec[2914] = &info_Weekday + GoTypesVec[894] = &info_PtrTo_Weekday + GoTypesVec[2020] = &info_ArrayOf_Weekday EnsureLoaded("go.std.errors") // E.g. from: C:\Program Files\Go\src\time\format.go:7:8 EnsureLoaded("go.std.runtime") // E.g. from: C:\Program Files\Go\src\time\zoneinfo_read.go:14:2 EnsureLoaded("go.std.sync") // E.g. from: C:\Program Files\Go\src\time\zoneinfo.go:9:2 @@ -313861,21 +313635,21 @@ func initNative() { GoMembers{ }) - GoTypesVec[2918] = &info_CaseRange - GoTypesVec[896] = &info_PtrTo_CaseRange - GoTypesVec[2023] = &info_ArrayOf_CaseRange - GoTypesVec[2919] = &info_Range16 - GoTypesVec[897] = &info_PtrTo_Range16 - GoTypesVec[2024] = &info_ArrayOf_Range16 - GoTypesVec[2920] = &info_Range32 - GoTypesVec[898] = &info_PtrTo_Range32 - GoTypesVec[2025] = &info_ArrayOf_Range32 - GoTypesVec[2921] = &info_RangeTable - GoTypesVec[899] = &info_PtrTo_RangeTable - GoTypesVec[2026] = &info_ArrayOf_RangeTable - GoTypesVec[2922] = &info_SpecialCase - GoTypesVec[900] = &info_PtrTo_SpecialCase - GoTypesVec[2027] = &info_ArrayOf_SpecialCase + GoTypesVec[2915] = &info_CaseRange + GoTypesVec[895] = &info_PtrTo_CaseRange + GoTypesVec[2021] = &info_ArrayOf_CaseRange + GoTypesVec[2916] = &info_Range16 + GoTypesVec[896] = &info_PtrTo_Range16 + GoTypesVec[2022] = &info_ArrayOf_Range16 + GoTypesVec[2917] = &info_Range32 + GoTypesVec[897] = &info_PtrTo_Range32 + GoTypesVec[2023] = &info_ArrayOf_Range32 + GoTypesVec[2918] = &info_RangeTable + GoTypesVec[898] = &info_PtrTo_RangeTable + GoTypesVec[2024] = &info_ArrayOf_RangeTable + GoTypesVec[2919] = &info_SpecialCase + GoTypesVec[899] = &info_PtrTo_SpecialCase + GoTypesVec[2025] = &info_ArrayOf_SpecialCase } -------- END _tests/gold/go1.19/amd64-windows/joker/std/gostd/go/std/unicode/unicode_native.go. -------- BEGIN _tests/gold/go1.19/amd64-windows/joker/std/gostd/go/std/unicode/utf16.joke: @@ -314355,8 +314129,8 @@ func initNative() { GoMembers{ }) - GoTypesVec[2923] = &info_Pointer - GoTypesVec[901] = &info_PtrTo_Pointer - GoTypesVec[2028] = &info_ArrayOf_Pointer + GoTypesVec[2920] = &info_Pointer + GoTypesVec[900] = &info_PtrTo_Pointer + GoTypesVec[2026] = &info_ArrayOf_Pointer } -------- END _tests/gold/go1.19/amd64-windows/joker/std/gostd/go/std/unsafe/unsafe_native.go.